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 * 26 * This file contains initiator IO related functions in TD layer 27 * 28 */ 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 #include <dev/pms/config.h> 32 33 #include <dev/pms/freebsd/driver/common/osenv.h> 34 #include <dev/pms/freebsd/driver/common/ostypes.h> 35 #include <dev/pms/freebsd/driver/common/osdebug.h> 36 37 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 38 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 39 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 40 41 #include <dev/pms/RefTisa/tisa/api/titypes.h> 42 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 43 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 44 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 45 46 #ifdef FDS_SM 47 #include <dev/pms/RefTisa/sat/api/sm.h> 48 #include <dev/pms/RefTisa/sat/api/smapi.h> 49 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 50 #endif 51 52 #ifdef FDS_DM 53 #include <dev/pms/RefTisa/discovery/api/dm.h> 54 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 55 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 56 #endif 57 58 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 59 #include <dev/pms/freebsd/driver/common/osstring.h> 60 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h> 61 62 #ifdef INITIATOR_DRIVER 63 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h> 65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h> 66 #endif 67 68 #ifdef TARGET_DRIVER 69 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h> 70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h> 71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h> 72 #endif 73 74 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 75 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 76 77 /***************************************************************************** 78 *! \brief tiINIIOStart 79 * 80 * Purpose: This routine is called to initiate a new SCSI request. 81 * 82 * \param tiRoot: Pointer to initiator driver/port instance. 83 * \param tiIORequest: Pointer to the I/O request context for this I/O. 84 * \param tiDeviceHandle: Pointer to device handle for this I/O. 85 * \param tiScsiRequest: Pointer to the SCSI-3 I/O request and SGL list. 86 * \param tiRequestBody: Pointer to the OS Specific module allocated storage 87 * to be used by the TD layer for executing this I/O. 88 * \param interruptContext: The interrupt context within which this function 89 * is called. 90 * \return: 91 * 92 * tiSuccess: I/O request successfully initiated. 93 * tiBusy: No resources available, try again later. 94 * tiIONoDevice: Invalid device handle. 95 * tiError: Other errors that prevent the I/O request to be started. 96 * 97 * 98 *****************************************************************************/ 99 osGLOBAL bit32 100 tiINIIOStart( 101 tiRoot_t *tiRoot, 102 tiIORequest_t *tiIORequest, 103 tiDeviceHandle_t *tiDeviceHandle, 104 tiScsiInitiatorRequest_t *tiScsiRequest, 105 void *tiRequestBody, 106 bit32 interruptContext 107 ) 108 { 109 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 110 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 111 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 112 tdsaDeviceData_t *oneDeviceData; 113 agsaRoot_t *agRoot = agNULL; 114 agsaIORequest_t *agIORequest = agNULL; 115 agsaDevHandle_t *agDevHandle = agNULL; 116 bit32 agRequestType; 117 agsaSASRequestBody_t *agSASRequestBody = agNULL; 118 bit32 tiStatus = tiError; 119 bit32 saStatus = AGSA_RC_FAILURE; 120 121 tdIORequestBody_t *tdIORequestBody; 122 agsaSSPInitiatorRequest_t *agSSPInitiatorRequest; 123 #ifdef REMOVED 124 /* only for debugging */ 125 bit32 i; 126 #endif 127 128 #ifdef SATA_ENABLE 129 #ifndef FDS_SM 130 satIOContext_t *satIOContext; 131 #endif 132 #endif 133 #ifdef FDS_SM 134 smRoot_t *smRoot = &(tdsaAllShared->smRoot); 135 smIORequest_t *smIORequest; 136 smDeviceHandle_t *smDeviceHandle; 137 smScsiInitiatorRequest_t *smSCSIRequest; 138 #endif 139 140 TDSA_INP_ENTER(tiRoot); 141 TI_DBG6(("tiINIIOStart: start\n")); 142 TI_DBG6(("tiINIIOStart:: ******* tdsaRoot %p tdsaAllShared %p \n", tdsaRoot,tdsaAllShared)); 143 144 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 145 146 TI_DBG6(("tiINIIOStart: onedevicedata %p\n", oneDeviceData)); 147 148 if(oneDeviceData == agNULL) 149 { 150 TI_DBG1(("tiINIIOStart: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle )); 151 tiStatus = tiIONoDevice; 152 goto ext; 153 } 154 155 /* for hotplug */ 156 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 157 oneDeviceData->tdPortContext == agNULL ) 158 { 159 TI_DBG1(("tiINIIOStart: tiDeviceHandle=%p did %d DeviceData was removed\n", tiDeviceHandle, oneDeviceData->id)); 160 TI_DBG6(("tiINIIOStart: device AddrHi 0x%08x AddrLo 0x%08x\n", 161 oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo)); 162 // for debugging 163 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 164 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging1Completed; 165 TI_DBG6(("tiINIIOStart: IOCompletionFunc %p\n", tdIORequestBody->IOCompletionFunc)); 166 tiStatus = tiIONoDevice; 167 goto ext; 168 } 169 #if 1 170 if (tiIORequest->osData == agNULL) 171 { 172 TI_DBG1(("tiINIIOStart: tiIORequest->osData is NULL, wrong\n")); 173 } 174 #endif 175 176 /* starting IO with SAS device */ 177 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 178 { 179 TI_DBG6(("tiINIIOStart: calling saSSPStart\n")); 180 181 agRoot = oneDeviceData->agRoot; 182 agDevHandle = oneDeviceData->agDevHandle; 183 184 /* OS layer has tdlayer data structure pointer in 185 tdIORequestBody_t tdIOReqBody; 186 in ccb_t in agtiapi.h 187 */ 188 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 189 190 /* initialize */ 191 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t)); 192 193 /* let's initialize tdIOrequestBody */ 194 /* initialize callback */ 195 tdIORequestBody->IOCompletionFunc = itdssIOCompleted; 196 197 /* initialize tiDevhandle */ 198 tdIORequestBody->tiDevHandle = tiDeviceHandle; 199 200 /* initialize tiIORequest */ 201 tdIORequestBody->tiIORequest = tiIORequest; 202 203 /* save context if we need to abort later */ 204 tiIORequest->tdData = tdIORequestBody; 205 206 /* initialize expDataLength */ 207 tdIORequestBody->IOType.InitiatorRegIO.expDataLength 208 = tiScsiRequest->scsiCmnd.expDataLength; 209 210 tdIORequestBody->IOType.InitiatorRegIO.sglVirtualAddr 211 = tiScsiRequest->sglVirtualAddr; 212 213 /* initializes "agsaSgl_t agSgl" of "agsaDifSSPInitiatorRequest_t" */ 214 tiStatus = itdssIOPrepareSGL( 215 tiRoot, 216 tdIORequestBody, 217 &tiScsiRequest->agSgl1, 218 tiScsiRequest->sglVirtualAddr 219 ); 220 221 if (tiStatus != tiSuccess) 222 { 223 TI_DBG1(("tiINIIOStart: can't get SGL\n")); 224 goto ext; 225 } 226 227 228 /* initialize agIORequest */ 229 agIORequest = &(tdIORequestBody->agIORequest); 230 agIORequest->osData = (void *) tdIORequestBody; 231 agIORequest->sdkData = agNULL; /* LL takes care of this */ 232 233 234 /* 235 initialize 236 tdIORequestBody_t tdIORequestBody -> agSASRequestBody 237 */ 238 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody); 239 agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq); 240 241 agSSPInitiatorRequest->flag = 0; 242 243 /* copy cdb bytes */ 244 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.cdb, tiScsiRequest->scsiCmnd.cdb, 16); 245 246 /* copy lun field */ 247 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.lun, 248 tiScsiRequest->scsiCmnd.lun.lun, 8); 249 250 251 /* setting the data length */ 252 agSSPInitiatorRequest->dataLength = tiScsiRequest->scsiCmnd.expDataLength; 253 TI_DBG6(("tiINIIOStart: tiScsiRequest->scsiCmnd.expDataLength %d\n", tiScsiRequest->scsiCmnd.expDataLength)); 254 255 agSSPInitiatorRequest->firstBurstSize = 0; 256 257 /* 258 process taskattribute 259 */ 260 if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_SIMPLE) 261 { 262 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 263 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_SIMPLE; 264 } 265 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_ORDERED) 266 { 267 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 268 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_ORDERED; 269 } 270 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_HEAD_OF_QUEUE) 271 { 272 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 273 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_HEAD_OF_QUEUE; 274 } 275 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_ACA) 276 { 277 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 278 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_ACA; 279 } 280 281 if (tiScsiRequest->dataDirection == tiDirectionIn) 282 { 283 agRequestType = AGSA_SSP_INIT_READ; 284 TI_DBG6(("tiINIIOStart: READ\n")); 285 } 286 else if (tiScsiRequest->dataDirection == tiDirectionOut) 287 { 288 agRequestType = AGSA_SSP_INIT_WRITE; 289 TI_DBG6(("tiINIIOStart: WRITE\n")); 290 } 291 else 292 { 293 agRequestType = AGSA_REQ_TYPE_UNKNOWN; 294 TI_DBG1(("tiINIIOStart: unknown data direction\n")); 295 } 296 297 tdIORequestBody->agRequestType = agRequestType; 298 299 TI_DBG6(("tiINIIOStart: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 300 TI_DBG6(("tiINIIOStart: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 301 302 /* for debugging */ 303 if (tdIORequestBody->IOCompletionFunc == agNULL) 304 { 305 TI_DBG1(("tiINIIOStart: Error!!!! IOCompletionFunc is NULL\n")); 306 } 307 saStatus = saSSPStart(agRoot, 308 agIORequest, 309 tdsaRotateQnumber(tiRoot, oneDeviceData), 310 agDevHandle, 311 agRequestType, 312 agSASRequestBody, 313 agNULL, 314 &ossaSSPCompleted); 315 316 tdIORequestBody->ioStarted = agTRUE; 317 tdIORequestBody->ioCompleted = agFALSE; 318 tdIORequestBody->reTries = 0; 319 320 if (saStatus == AGSA_RC_SUCCESS) 321 { 322 Initiator->NumIOsActive++; 323 tiStatus = tiSuccess; 324 } 325 else 326 { 327 tdIORequestBody->ioStarted = agFALSE; 328 tdIORequestBody->ioCompleted = agTRUE; 329 if (saStatus == AGSA_RC_BUSY) 330 { 331 TI_DBG4(("tiINIIOStart: saSSPStart busy\n")); 332 tiStatus = tiBusy; 333 } 334 else 335 { 336 tiStatus = tiError; 337 } 338 goto ext; 339 } 340 } 341 #ifdef FDS_SM 342 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 343 { 344 TI_DBG5(("tiINIIOStart: calling satIOStart\n")); 345 TI_DBG5(("tiINIIOStart: onedevicedata did %d\n", oneDeviceData->id)); 346 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 347 /* initialize */ 348 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t)); 349 /* initialize tiDevhandle */ 350 tdIORequestBody->tiDevHandle = tiDeviceHandle; 351 tdIORequestBody->superIOFlag = agFALSE; 352 353 tiIORequest->tdData = tdIORequestBody; 354 tdIORequestBody->tiIORequest = tiIORequest; 355 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest); 356 smIORequest->tdData = tdIORequestBody; 357 358 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle); 359 smDeviceHandle->tdData = oneDeviceData; 360 361 smSCSIRequest = (smScsiInitiatorRequest_t *)&(tdIORequestBody->SM.smSCSIRequest); 362 osti_memcpy(smSCSIRequest, tiScsiRequest, sizeof(smScsiInitiatorRequest_t)); 363 364 tiStatus = smIOStart(smRoot, 365 smIORequest, 366 smDeviceHandle, 367 smSCSIRequest, 368 interruptContext); 369 /* 370 osGLOBAL bit32 371 smIOStart( 372 smRoot_t *smRoot, 373 smIORequest_t *smIORequest, 374 smDeviceHandle_t *smDeviceHandle, 375 smScsiInitiatorRequest_t *smSCSIRequest, 376 bit32 interruptContext 377 ) 378 379 380 */ 381 } 382 #else 383 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 384 { 385 TI_DBG5(("tiINIIOStart: calling satIOStart\n")); 386 TI_DBG5(("tiINIIOStart: onedevicedata did %d\n", oneDeviceData->id)); 387 388 #ifdef SATA_ENABLE 389 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 390 391 /* initialize */ 392 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t)); 393 394 /* initialize tiDevhandle */ 395 tdIORequestBody->tiDevHandle = tiDeviceHandle; 396 397 /* initialize tiIORequest */ 398 tdIORequestBody->tiIORequest = tiIORequest; 399 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging2Completed; 400 401 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 402 403 /* 404 * Need to initialize all the fields within satIOContext except 405 * reqType and satCompleteCB which will be set in sat.c depending on cmd. 406 */ 407 tdIORequestBody->transport.SATA.tiSenseData.senseData = agNULL; 408 tdIORequestBody->transport.SATA.tiSenseData.senseLen = 0; 409 satIOContext->pSatDevData = &oneDeviceData->satDevData; 410 satIOContext->pFis = 411 &tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev; 412 satIOContext->pScsiCmnd = &tiScsiRequest->scsiCmnd; 413 satIOContext->pSense = &tdIORequestBody->transport.SATA.sensePayload; 414 satIOContext->pTiSenseData = &tdIORequestBody->transport.SATA.tiSenseData; 415 satIOContext->pTiSenseData->senseData = satIOContext->pSense; 416 /* satIOContext->pSense = (scsiRspSense_t *)satIOContext->pTiSenseData->senseData; */ 417 satIOContext->tiRequestBody = tiRequestBody; 418 satIOContext->interruptContext = interruptContext; 419 satIOContext->ptiDeviceHandle = tiDeviceHandle; 420 satIOContext->tiScsiXchg = tiScsiRequest; 421 satIOContext->satIntIoContext = agNULL; 422 satIOContext->satOrgIOContext = agNULL; 423 /* satIOContext->tiIORequest = tiIORequest; */ 424 425 /* save context if we need to abort later */ 426 tiIORequest->tdData = tdIORequestBody; 427 428 /* followings are used only for internal IO */ 429 satIOContext->currentLBA = 0; 430 satIOContext->OrgTL = 0; 431 432 TI_DBG5(("tiINIIOStart: pSatDevData=%p\n", satIOContext->pSatDevData )); 433 434 tiStatus = satIOStart( tiRoot, 435 tiIORequest, 436 tiDeviceHandle, 437 tiScsiRequest, 438 satIOContext); 439 goto ext; 440 #endif 441 } 442 #endif /* else of FDS_SM */ 443 else 444 { 445 446 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 447 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging3Completed; 448 TI_DBG1(("tiINIIOStart: wrong unspported Device %d\n", oneDeviceData->DeviceType)); 449 /* 450 error. unsupported IO 451 */ 452 } 453 ext: 454 TDSA_INP_LEAVE(tiRoot); 455 return tiStatus; 456 } 457 458 #ifdef FAST_IO_TEST 459 osGLOBAL bit32 460 tiINIFastIOSend(void *ioh) 461 { 462 bit32 saStatus, tiStatus; 463 464 saStatus = saFastSSPSend(ioh); 465 if (saStatus == AGSA_RC_SUCCESS) 466 tiStatus = tiSuccess; 467 else 468 tiStatus = tiError; 469 return tiStatus; 470 } 471 472 osGLOBAL bit32 473 tiINIFastIOCancel(void *ioh) 474 { 475 bit32 saStatus, tiStatus; 476 477 saStatus = saFastSSPCancel(ioh); 478 if (saStatus == AGSA_RC_SUCCESS) 479 tiStatus = tiSuccess; 480 else 481 tiStatus = tiError; 482 return tiStatus; 483 } 484 485 osGLOBAL void* 486 tiINIFastIOPrepare( 487 tiRoot_t *tiRoot, 488 void *ioHandle, 489 agsaFastCommand_t *fc) 490 { 491 tdsaDeviceData_t *oneDeviceData; 492 tiDeviceHandle_t *tiDeviceHandle = fc->devHandle; 493 bit32 taskAttribute = fc->taskAttribute; 494 void *ioh = ioHandle; 495 496 TDSA_INP_ENTER(tiRoot); 497 TI_DBG6(("tiINIFastIOPrepare: enter\n")); 498 499 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 500 if(oneDeviceData == agNULL) 501 { 502 TI_DBG1(("tiINIFastIOPrepare: tiDeviceHandle=%p DeviceData is NULL\n", 503 tiDeviceHandle)); 504 ioHandle = 0; 505 TD_ASSERT((0), ""); 506 goto ext; 507 } 508 TI_DBG6(("tiINIFastIOPrepare: onedevicedata %p\n", oneDeviceData)); 509 510 /* starting IO with SAS device */ 511 if (oneDeviceData->DeviceType != TD_SAS_DEVICE) 512 { 513 TI_DBG1(("tiINISuperIOSend: wrong Device %d\n", oneDeviceData->DeviceType)); 514 /* error: unsupported IO */ 515 ioHandle = 0; 516 TD_ASSERT((0), ""); 517 goto ext; 518 } 519 520 fc->agRoot = oneDeviceData->agRoot; 521 TD_ASSERT((NULL != fc->agRoot), ""); 522 523 fc->devHandle = oneDeviceData->agDevHandle; 524 TD_ASSERT((NULL != fc->devHandle), ""); 525 fc->safb->oneDeviceData = oneDeviceData; 526 527 /* 528 process taskattribute 529 */ 530 switch (taskAttribute) 531 { 532 case TASK_SIMPLE: 533 fc->taskAttribute = TD_TASK_SIMPLE; 534 break; 535 case TASK_ORDERED: 536 fc->taskAttribute = TD_TASK_ORDERED; 537 break; 538 case TASK_HEAD_OF_QUEUE: 539 fc->taskAttribute = TD_TASK_HEAD_OF_QUEUE; 540 break; 541 case TASK_ACA: 542 fc->taskAttribute = TD_TASK_ACA; 543 break; 544 /* compile out for "iniload" */ 545 } 546 547 548 TI_DBG3(("tiINIFastIOPrepare: data direction: %x\n", fc->agRequestType)); 549 TI_DBG6(("tiINIFastIOPrepare: device AddrHi/Lo 0x%08x / 0x%08x\n", 550 oneDeviceData->SASAddressID.sasAddressHi, 551 oneDeviceData->SASAddressID.sasAddressLo)); 552 553 fc->queueNum = tdsaRotateQnumber(tiRoot, oneDeviceData); 554 555 ioHandle = saFastSSPPrepare(ioHandle, fc, ossaFastSSPCompleted, fc->safb); 556 if (!ioHandle) 557 { 558 TI_DBG1(("tiINIFastIOPrepare: saSuperSSPSend error\n")); 559 TD_ASSERT((0), ""); 560 //goto ext; 561 } 562 563 ext: 564 if (ioh && !ioHandle) 565 { 566 saFastSSPCancel(ioh); 567 } 568 569 TI_DBG6(("tiINIFastIOPrepare: leave\n")); 570 571 TDSA_INP_LEAVE(tiRoot); 572 return ioHandle; 573 } /* tiINIFastIOPrepare */ 574 #endif 575 576 /***************************************************************************** 577 * 578 * tiINIIOStartDif 579 * 580 * Purpose: This routine is called to initiate a new SCSI request with 581 * DIF enable. 582 * 583 * Parameters: 584 * tiRoot: Pointer to initiator driver/port instance. 585 * tiIORequest: Pointer to the I/O request context for this I/O. 586 * tiDeviceHandle: Pointer to device handle for this I/O. 587 * tiScsiRequest: Pointer to the SCSI-3 I/O request and SGL list. 588 * tiRequestBody: Pointer to the OS Specific module allocated storage 589 * to be used by the TD layer for executing this I/O. 590 * interruptContext: The interrupt context within which this function 591 * is called. 592 * difOption: DIF option. 593 * 594 * Return: 595 * 596 * tiSuccess: I/O request successfully initiated. 597 * tiBusy: No resources available, try again later. 598 * tiIONoDevice: Invalid device handle. 599 * tiError: Other errors that prevent the I/O request to be started. 600 * 601 * 602 *****************************************************************************/ 603 osGLOBAL bit32 tiINIIOStartDif( 604 tiRoot_t *tiRoot, 605 tiIORequest_t *tiIORequest, 606 tiDeviceHandle_t *tiDeviceHandle, 607 tiScsiInitiatorRequest_t *tiScsiRequest, 608 void *tiRequestBody, 609 bit32 interruptContext, 610 tiDif_t *difOption 611 ) 612 { 613 614 /* This function was never used by SAS/SATA. Use tiINISuperIOStart() instead. */ 615 return tiBusy; 616 } 617 618 619 /***************************************************************************** 620 * 621 * tiINISuperIOStart 622 * 623 * Purpose: This routine is called to initiate a new SCSI request. 624 * 625 * Parameters: 626 * tiRoot: Pointer to initiator driver/port instance. 627 * tiIORequest: Pointer to the I/O request context for this I/O. 628 * tiDeviceHandle: Pointer to device handle for this I/O. 629 * tiScsiRequest: Pointer to the SCSI-3 I/O request and SGL list. 630 * tiRequestBody: Pointer to the OS Specific module allocated storage 631 * to be used by the TD layer for executing this I/O. 632 * interruptContext: The interrupt context within which this function 633 * is called. 634 * Return: 635 * 636 * tiSuccess: I/O request successfully initiated. 637 * tiBusy: No resources available, try again later. 638 * tiIONoDevice: Invalid device handle. 639 * tiError: Other errors that prevent the I/O request to be started. 640 * 641 * 642 *****************************************************************************/ 643 osGLOBAL bit32 644 tiINISuperIOStart( 645 tiRoot_t *tiRoot, 646 tiIORequest_t *tiIORequest, 647 tiDeviceHandle_t *tiDeviceHandle, 648 tiSuperScsiInitiatorRequest_t *tiScsiRequest, 649 void *tiRequestBody, 650 bit32 interruptContext 651 ) 652 { 653 tdsaRoot_t *tdsaRoot = agNULL; 654 tdsaContext_t *tdsaAllShared = agNULL; 655 itdsaIni_t *Initiator = agNULL; 656 tdsaDeviceData_t *oneDeviceData = agNULL; 657 tdIORequestBody_t *tdIORequestBody = agNULL; 658 agsaSSPInitiatorRequest_t *agSSPInitiatorRequest = agNULL; 659 agsaRoot_t *agRoot = agNULL; 660 agsaIORequest_t *agIORequest = agNULL; 661 agsaDevHandle_t *agDevHandle = agNULL; 662 agsaSASRequestBody_t *agSASRequestBody = agNULL; 663 bit32 tiStatus = tiError; 664 bit32 saStatus = AGSA_RC_FAILURE; 665 bit32 adjusted_length = 0; 666 bit32 agRequestType = 0; 667 agBOOLEAN needPlusDataLenAdjustment = agFALSE; 668 agBOOLEAN needMinusDataLenAdjustment = agFALSE; 669 670 #ifdef SATA_ENABLE 671 #ifndef FDS_SM 672 satIOContext_t *satIOContext; 673 #endif 674 #endif 675 #ifdef FDS_SM 676 smRoot_t *smRoot; 677 smIORequest_t *smIORequest; 678 smDeviceHandle_t *smDeviceHandle; 679 smSuperScsiInitiatorRequest_t *smSuperSCSIRequest; 680 #endif 681 #ifdef CCBUILD_INDIRECT_CDB 682 agsaSSPInitiatorRequestIndirect_t *agSSPInitiatorIndRequest = agNULL; 683 #endif 684 TD_ASSERT(tiRoot , "tiRoot"); 685 TD_ASSERT(tiIORequest, "tiIORequest"); 686 TD_ASSERT(tiDeviceHandle, "tiDeviceHandle"); 687 TD_ASSERT(tiRequestBody, "tiRequestBody"); 688 TD_ASSERT(tiRoot->tdData, "tiRoot->tdData"); 689 TD_ASSERT(tiDeviceHandle, "tiDeviceHandle"); 690 691 tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 692 TD_ASSERT(tdsaRoot, "tdsaRoot"); 693 694 tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 695 TD_ASSERT(tdsaAllShared, "tdsaAllShared"); 696 697 Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 698 TD_ASSERT(Initiator, "Initiator"); 699 700 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 701 TD_ASSERT(oneDeviceData, "oneDeviceData"); 702 703 704 #ifdef FDS_SM 705 smRoot = &(tdsaAllShared->smRoot); 706 TD_ASSERT(smRoot , "smRoot"); 707 #endif 708 709 710 TI_DBG6(("tiINISuperIOStart: start\n")); 711 TI_DBG6(("tiINISuperIOStart:: ******* tdsaRoot %p tdsaAllShared %p \n", tdsaRoot,tdsaAllShared)); 712 713 TI_DBG6(("tiINISuperIOStart: onedevicedata %p\n", oneDeviceData)); 714 715 if (oneDeviceData == agNULL) 716 { 717 TI_DBG1(("tiINISuperIOStart: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle )); 718 return tiIONoDevice; 719 } 720 721 /* for hotplug */ 722 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 723 oneDeviceData->tdPortContext == agNULL ) 724 { 725 TI_DBG1(("tiINISuperIOStart: tiDeviceHandle=%p did %d DeviceData was removed\n", tiDeviceHandle, oneDeviceData->id)); 726 TI_DBG6(("tiINISuperIOStart: device AddrHi 0x%08x AddrLo 0x%08x\n", 727 oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo)); 728 // for debugging 729 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 730 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging1Completed; 731 TI_DBG6(("tiINISuperIOStart: IOCompletionFunc %p\n", tdIORequestBody->IOCompletionFunc)); 732 return tiIONoDevice; 733 } 734 735 #ifdef DBG 736 if (tiIORequest->osData == agNULL) 737 { 738 TI_DBG1(("tiINISuperIOStart: tiIORequest->osData is NULL, wrong\n")); 739 return tiError; 740 } 741 #endif 742 /* starting IO with SAS device */ 743 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 744 { 745 TI_DBG3(("tiINISuperIOStart: calling saSSPStart\n")); 746 747 agRoot = oneDeviceData->agRoot; 748 agDevHandle = oneDeviceData->agDevHandle; 749 750 /* OS layer has tdlayer data structure pointer in tdIORequestBody_t tdIOReqBody; in ccb_t in agtiapi.h */ 751 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 752 753 /* initialize */ 754 /*the tdIORequestBody has been initialized in HwBuildIo routine */ 755 /*osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t));*/ 756 757 /* let's initialize tdIOrequestBody */ 758 /* initialize callback */ 759 tdIORequestBody->IOCompletionFunc = itdssIOCompleted; 760 761 /* initialize tiDevhandle */ 762 tdIORequestBody->tiDevHandle = tiDeviceHandle; 763 764 /* initialize tiIORequest */ 765 tdIORequestBody->tiIORequest = tiIORequest; 766 767 /* save context if we need to abort later */ 768 tiIORequest->tdData = tdIORequestBody; 769 770 /* initialize expDataLength */ 771 tdIORequestBody->IOType.InitiatorRegIO.expDataLength 772 = tiScsiRequest->scsiCmnd.expDataLength; 773 774 tdIORequestBody->IOType.InitiatorRegIO.sglVirtualAddr 775 = tiScsiRequest->sglVirtualAddr; 776 777 /* initialize agIORequest */ 778 agIORequest = &(tdIORequestBody->agIORequest); 779 agIORequest->osData = (void *) tdIORequestBody; 780 781 /* initialize tdIORequestBody_t tdIORequestBody -> agSASRequestBody */ 782 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody); 783 agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq); 784 785 agSSPInitiatorRequest->flag = 0; 786 if (tiScsiRequest->flags & TI_SCSI_INITIATOR_ENCRYPT) 787 { 788 TI_DBG3(("tiINISuperIOStart: TI_SCSI_INITIATOR_ENCRYPT\n")); 789 790 /* Copy all of the relevant encrypt information */ 791 agSSPInitiatorRequest->flag |= AGSA_SAS_ENABLE_ENCRYPTION; 792 TD_ASSERT( sizeof(tiEncrypt_t) == sizeof(agsaEncrypt_t) , "sizeof(tiEncrypt_t) == sizeof(agsaEncrypt_t)"); 793 osti_memcpy(&agSSPInitiatorRequest->encrypt, &tiScsiRequest->Encrypt, sizeof(agsaEncrypt_t)); 794 } 795 796 if ((tiScsiRequest->flags & TI_SCSI_INITIATOR_DIF) && 797 (tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_READ_10 || 798 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_WRITE_10 || 799 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_WRITE_6 || 800 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_READ_6 || 801 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_READ_12 || 802 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_WRITE_12 || 803 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_WRITE_16 || 804 tiScsiRequest->scsiCmnd.cdb[0] == SCSIOPC_READ_16 )) 805 { 806 TI_DBG3(("tiINISuperIOStart: TI_SCSI_INITIATOR_DIF\n")); 807 /* Copy all of the relevant DIF information */ 808 agSSPInitiatorRequest->flag |= AGSA_SAS_ENABLE_DIF; 809 osti_memcpy(&agSSPInitiatorRequest->dif, &tiScsiRequest->Dif, sizeof(agsaDif_t)); 810 811 /* Check if need to adjust dataLength. */ 812 switch (tiScsiRequest->dataDirection) 813 { 814 case tiDirectionOut: /* Write/Outbound */ 815 break; 816 817 case tiDirectionIn: /* Read/Inbound */ 818 if ((agSSPInitiatorRequest->dif.flags & DIF_ACTION_FLAG_MASK) == DIF_INSERT) 819 { 820 needPlusDataLenAdjustment = agTRUE; 821 } 822 break; 823 } 824 825 /* Set SGL data len XXX This code needs to support more sector sizes */ 826 /* Length adjustment for PCIe DMA only not SAS */ 827 if (needPlusDataLenAdjustment == agTRUE) 828 { 829 adjusted_length = tiScsiRequest->scsiCmnd.expDataLength; 830 adjusted_length += (adjusted_length/512) * 8; 831 agSSPInitiatorRequest->dataLength = adjusted_length; 832 } 833 else if (needMinusDataLenAdjustment == agTRUE) 834 { 835 adjusted_length = tiScsiRequest->scsiCmnd.expDataLength; 836 adjusted_length -= (adjusted_length/520) * 8; 837 agSSPInitiatorRequest->dataLength = adjusted_length; 838 } 839 else 840 { 841 /* setting the data length */ 842 agSSPInitiatorRequest->dataLength = tiScsiRequest->scsiCmnd.expDataLength; 843 } 844 845 /* initializes "agsaSgl_t agSgl" of "agsaDifSSPInitiatorRequest_t" */ 846 tiStatus = itdssIOPrepareSGL( 847 tiRoot, 848 tdIORequestBody, 849 &tiScsiRequest->agSgl1, 850 tiScsiRequest->sglVirtualAddr 851 ); 852 TI_DBG2(("tiINISuperIOStart:TI_SCSI_INITIATOR_DIF needMinusDataLenAdjustment %d needPlusDataLenAdjustment %d difAction %X\n", 853 needMinusDataLenAdjustment, 854 needPlusDataLenAdjustment, 855 agSSPInitiatorRequest->dif.flags & DIF_ACTION_FLAG_MASK)); 856 857 } 858 else 859 { 860 /* setting the data length */ 861 agSSPInitiatorRequest->dataLength = tiScsiRequest->scsiCmnd.expDataLength; 862 863 /* initializes "agsaSgl_t agSgl" of "agsaSSPInitiatorRequest_t" */ 864 tiStatus = itdssIOPrepareSGL( 865 tiRoot, 866 tdIORequestBody, 867 &tiScsiRequest->agSgl1, 868 tiScsiRequest->sglVirtualAddr 869 ); 870 } 871 872 if (tiStatus != tiSuccess) 873 { 874 TI_DBG1(("tiINISuperIOStart: can't get SGL\n")); 875 return tiStatus; 876 } 877 878 TI_DBG6(("tiINISuperIOStart: tiScsiRequest->scsiCmnd.expDataLength %d\n", tiScsiRequest->scsiCmnd.expDataLength)); 879 880 /* process taskattribute */ 881 if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_SIMPLE) 882 { 883 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 884 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_SIMPLE; 885 } 886 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_ORDERED) 887 { 888 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 889 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_ORDERED; 890 } 891 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_HEAD_OF_QUEUE) 892 { 893 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 894 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_HEAD_OF_QUEUE; 895 } 896 else if (tiScsiRequest->scsiCmnd.taskAttribute == TASK_ACA) 897 { 898 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute = (bit8) 899 agSSPInitiatorRequest->sspCmdIU.efb_tp_taskAttribute | TD_TASK_ACA; 900 } 901 902 /* copy cdb bytes */ 903 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.cdb, tiScsiRequest->scsiCmnd.cdb, 16); 904 /* copy lun field */ 905 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.lun, tiScsiRequest->scsiCmnd.lun.lun, 8); 906 #ifdef CCBUILD_INDIRECT_CDB 907 /* check the Indirect CDB flag */ 908 if (tiScsiRequest->flags & TI_SCSI_INITIATOR_INDIRECT_CDB) 909 { 910 /* Indirect CDB */ 911 if (tiScsiRequest->dataDirection == tiDirectionIn) 912 { 913 agRequestType = AGSA_SSP_INIT_READ_INDIRECT; 914 TI_DBG6(("tiINISuperIOStart: Indirect READ\n")); 915 } 916 else if (tiScsiRequest->dataDirection == tiDirectionOut) 917 { 918 agRequestType = AGSA_SSP_INIT_WRITE_INDIRECT; 919 TI_DBG6(("tiINISuperIOStart: Indirect WRITE\n")); 920 } 921 else 922 { 923 agRequestType = AGSA_REQ_TYPE_UNKNOWN; 924 TI_DBG1(("tiINISuperIOStart: unknown data direction\n")); 925 } 926 agSSPInitiatorIndRequest = &(agSASRequestBody->sspInitiatorReqIndirect); 927 /* copy the constructed SSPIU info to indirect SSPIU buffer */ 928 osti_memcpy(tiScsiRequest->IndCDBBuffer, &agSSPInitiatorRequest->sspCmdIU, sizeof(agsaSSPCmdInfoUnit_t)); 929 /* initialize the indirect CDB buffer address and length */ 930 agSSPInitiatorIndRequest->sspInitiatorReqAddrLower32 = tiScsiRequest->IndCDBLowAddr; 931 agSSPInitiatorIndRequest->sspInitiatorReqAddrUpper32 = tiScsiRequest->IndCDBHighAddr; 932 agSSPInitiatorIndRequest->sspInitiatorReqLen = sizeof(agsaSSPCmdInfoUnit_t); 933 } 934 else 935 #endif //CCBUILD_INDIRECT_CDB 936 { 937 /* Direct CDB */ 938 if (tiScsiRequest->dataDirection == tiDirectionIn) 939 { 940 agRequestType = AGSA_SSP_INIT_READ; 941 TI_DBG6(("tiINISuperIOStart: READ\n")); 942 } 943 else if (tiScsiRequest->dataDirection == tiDirectionOut) 944 { 945 agRequestType = AGSA_SSP_INIT_WRITE; 946 TI_DBG6(("tiINISuperIOStart: WRITE\n")); 947 } 948 else 949 { 950 agRequestType = AGSA_REQ_TYPE_UNKNOWN; 951 TI_DBG1(("tiINISuperIOStart: unknown data direction\n")); 952 } 953 } 954 955 tdIORequestBody->agRequestType = agRequestType; 956 957 TI_DBG6(("tiINISuperIOStart: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 958 TI_DBG6(("tiINISuperIOStart: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 959 960 #ifdef DBG 961 /* for debugging */ 962 if (tdIORequestBody->IOCompletionFunc == agNULL) 963 { 964 TI_DBG1(("tiINISuperIOStart: Error!!!! IOCompletionFunc is NULL\n")); 965 return tiError; 966 } 967 #endif 968 saStatus = saSSPStart(agRoot, 969 agIORequest, 970 tdsaRotateQnumber(tiRoot, oneDeviceData), 971 agDevHandle, 972 agRequestType, 973 agSASRequestBody, 974 agNULL, 975 &ossaSSPCompleted); 976 977 if (saStatus == AGSA_RC_SUCCESS) 978 { 979 Initiator->NumIOsActive++; 980 tdIORequestBody->ioStarted = agTRUE; 981 tdIORequestBody->ioCompleted = agFALSE; 982 tiStatus = tiSuccess; 983 } 984 else 985 { 986 tdIORequestBody->ioStarted = agFALSE; 987 tdIORequestBody->ioCompleted = agTRUE; 988 if (saStatus == AGSA_RC_BUSY) 989 { 990 TI_DBG4(("tiINISuperIOStart: saSSPStart busy\n")); 991 tiStatus = tiBusy; 992 } 993 else 994 { 995 tiStatus = tiError; 996 } 997 return tiStatus; 998 } 999 } 1000 #ifdef FDS_SM 1001 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1002 { 1003 TI_DBG5(("tiINISuperIOStart: calling satIOStart\n")); 1004 TI_DBG5(("tiINISuperIOStart: onedevicedata did %d\n", oneDeviceData->id)); 1005 TI_DBG5(("tiINISuperIOStart: SATA sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 1006 TI_DBG5(("tiINISuperIOStart: SATA sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 1007 1008 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1009 /* initialize */ 1010 /* the tdIORequestBody has been initialized by Storport in SRB Extension */ 1011 /*osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t));*/ 1012 /* initialize tiDevhandle */ 1013 tdIORequestBody->tiDevHandle = tiDeviceHandle; 1014 tdIORequestBody->superIOFlag = agTRUE; 1015 1016 tiIORequest->tdData = tdIORequestBody; 1017 tdIORequestBody->tiIORequest = tiIORequest; 1018 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest); 1019 smIORequest->tdData = tdIORequestBody; 1020 smIORequest->smData = &tdIORequestBody->smIORequestBody; 1021 1022 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle); 1023 smDeviceHandle->tdData = oneDeviceData; 1024 1025 smSuperSCSIRequest = (smSuperScsiInitiatorRequest_t *)&(tdIORequestBody->SM.smSuperSCSIRequest); 1026 osti_memcpy(smSuperSCSIRequest, tiScsiRequest, sizeof(smSuperScsiInitiatorRequest_t)); 1027 1028 tiStatus = smSuperIOStart(smRoot, 1029 smIORequest, 1030 smDeviceHandle, 1031 smSuperSCSIRequest, 1032 oneDeviceData->SASAddressID.sasAddressHi, 1033 oneDeviceData->SASAddressID.sasAddressLo, 1034 interruptContext); 1035 1036 } 1037 #else 1038 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1039 { 1040 1041 TI_DBG5(("tiINISuperIOStart: calling satIOStart\n")); 1042 TI_DBG5(("tiINISuperIOStart: onedevicedata did %d\n", oneDeviceData->id)); 1043 1044 #ifdef SATA_ENABLE 1045 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1046 1047 /* initialize */ 1048 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t)); 1049 1050 /* initialize tiDevhandle */ 1051 tdIORequestBody->tiDevHandle = tiDeviceHandle; 1052 1053 /* initialize tiIORequest */ 1054 tdIORequestBody->tiIORequest = tiIORequest; 1055 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging2Completed; 1056 1057 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 1058 1059 /* 1060 * Need to initialize all the fields within satIOContext except 1061 * reqType and satCompleteCB which will be set in sat.c depending on cmd. 1062 */ 1063 tdIORequestBody->transport.SATA.tiSenseData.senseData = agNULL; 1064 tdIORequestBody->transport.SATA.tiSenseData.senseLen = 0; 1065 satIOContext->pSatDevData = &oneDeviceData->satDevData; 1066 satIOContext->pFis = 1067 &tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev; 1068 satIOContext->pScsiCmnd = &tiScsiRequest->scsiCmnd; 1069 satIOContext->pSense = &tdIORequestBody->transport.SATA.sensePayload; 1070 satIOContext->pTiSenseData = &tdIORequestBody->transport.SATA.tiSenseData; 1071 satIOContext->pTiSenseData->senseData = satIOContext->pSense; 1072 /* satIOContext->pSense = (scsiRspSense_t *)satIOContext->pTiSenseData->senseData; */ 1073 satIOContext->tiRequestBody = tiRequestBody; 1074 satIOContext->interruptContext = interruptContext; 1075 satIOContext->ptiDeviceHandle = tiDeviceHandle; 1076 /* 1077 This code uses a kludge for the tiScsiXchg. Many subroutines in the SATA code 1078 require a tiScsiInitiatorRequest. Since it would be a lot of work to replicate 1079 those functions for a tiSuperScsiInitiatorRequest, we will use a short cut. 1080 The standard pointer will be passed, but the superIOFlag marks the real type of the structure. 1081 */ 1082 satIOContext->tiScsiXchg = tiScsiRequest; 1083 satIOContext->superIOFlag = agTRUE; 1084 1085 satIOContext->satIntIoContext = agNULL; 1086 satIOContext->satOrgIOContext = agNULL; 1087 /* satIOContext->tiIORequest = tiIORequest; */ 1088 1089 /* save context if we need to abort later */ 1090 tiIORequest->tdData = tdIORequestBody; 1091 1092 /* followings are used only for internal IO */ 1093 satIOContext->currentLBA = 0; 1094 satIOContext->OrgTL = 0; 1095 1096 TI_DBG5(("tiINISuperIOStart: pSatDevData=%p\n", satIOContext->pSatDevData )); 1097 1098 tiStatus = satIOStart( tiRoot, 1099 tiIORequest, 1100 tiDeviceHandle, 1101 satIOContext->tiScsiXchg, 1102 satIOContext); 1103 1104 return tiStatus; 1105 #endif 1106 } 1107 #endif /* else of FDS_SM */ 1108 1109 else 1110 { 1111 1112 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1113 tdIORequestBody->IOCompletionFunc = itdssIOForDebugging3Completed; 1114 TI_DBG1(("tiINISuperIOStart: wrong unspported Device %d\n", oneDeviceData->DeviceType)); 1115 /* 1116 error. unsupported IO 1117 */ 1118 } 1119 return tiStatus; 1120 } 1121 1122 osGLOBAL bit32 1123 tiINISMPStart( 1124 tiRoot_t *tiRoot, 1125 tiIORequest_t *tiIORequest, 1126 tiDeviceHandle_t *tiDeviceHandle, 1127 tiSMPFrame_t *tiSMPFrame, 1128 void *tiSMPBody, 1129 bit32 interruptContext 1130 ) 1131 { 1132 tdsaDeviceData_t *oneDeviceData; 1133 agsaIORequest_t *agIORequest = agNULL; 1134 tdIORequestBody_t *tdSMPRequestBody = agNULL; 1135 agsaRoot_t *agRoot = agNULL; 1136 agsaDevHandle_t *agDevHandle = agNULL; 1137 agsaSASRequestBody_t *agRequestBody = agNULL; 1138 agsaSMPFrame_t *agSMPFrame = agNULL; 1139 bit32 agRequestType; 1140 bit32 tiStatus = tiError; 1141 bit32 saStatus = AGSA_RC_FAILURE; 1142 bit32 queueNum; 1143 TDSA_INP_ENTER(tiRoot); 1144 TI_DBG6(("tiINISMPStart: start\n")); 1145 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1146 TI_DBG6(("tiINISMPStart: onedevicedata %p\n", oneDeviceData)); 1147 TI_DBG6(("tiINISMPStart: tiDeviceHandle %p\n", tiDeviceHandle)); 1148 if (oneDeviceData == agNULL) 1149 { 1150 TI_DBG1(("tiINISMPStart: tiDeviceHandle=%p Expander DeviceData is NULL\n", tiDeviceHandle )); 1151 return tiError; 1152 } 1153 if (tiIORequest->osData == agNULL) 1154 { 1155 TI_DBG1(("tiINISMPStart: tiIORequest->osData is NULL, wrong\n")); 1156 return tiError; 1157 } 1158 agRoot = oneDeviceData->agRoot; 1159 agDevHandle = oneDeviceData->agDevHandle; 1160 tdSMPRequestBody = (tdIORequestBody_t *)tiSMPBody; 1161 tdSMPRequestBody->tiIORequest = tiIORequest; 1162 tiIORequest->tdData = tdSMPRequestBody; 1163 agIORequest = &(tdSMPRequestBody->agIORequest); 1164 agIORequest->osData = (void *) tdSMPRequestBody; 1165 agRequestBody = &(tdSMPRequestBody->transport.SAS.agSASRequestBody); 1166 agSMPFrame = &(agRequestBody->smpFrame); 1167 if (!DEVICE_IS_SMP_TARGET(oneDeviceData)) 1168 { 1169 TI_DBG1(("tiINISMPStart: Target Device is not SMP device\n")); 1170 return tiError; 1171 } 1172 if (tiSMPFrame->flag == 0) // define DIRECT SMP at td layer? 1173 { 1174 TI_DBG6(("tiINISMPStart: Direct SMP\n")); 1175 agSMPFrame->outFrameBuf = tiSMPFrame->outFrameBuf; 1176 agSMPFrame->outFrameLen = tiSMPFrame->outFrameLen; 1177 tdhexdump("tiINISMPStart agSMPFrame", (bit8 *)agSMPFrame->outFrameBuf, agSMPFrame->outFrameLen); 1178 agSMPFrame->expectedRespLen = tiSMPFrame->expectedRespLen; 1179 agSMPFrame->inFrameLen = 0; 1180 agSMPFrame->flag = tiSMPFrame->flag; 1181 agRequestType = AGSA_SMP_INIT_REQ; 1182 queueNum = 0; 1183 saStatus = saSMPStart(agRoot, 1184 agIORequest, 1185 queueNum, 1186 agDevHandle, 1187 agRequestType, 1188 agRequestBody, 1189 &ossaSMPCAMCompleted 1190 ); 1191 if (saStatus == AGSA_RC_SUCCESS) 1192 { 1193 tiStatus = tiSuccess; 1194 } 1195 else 1196 { 1197 if (saStatus == AGSA_RC_BUSY) 1198 { 1199 TI_DBG1(("tiINISMPStart: saSSPStart busy\n")); 1200 tiStatus = tiBusy; 1201 } 1202 else 1203 { 1204 TI_DBG1(("tiINISMPStart: saSSPStart error\n")); 1205 tiStatus = tiError; 1206 } 1207 return tiStatus; 1208 } 1209 } 1210 else 1211 { 1212 TI_DBG1(("tiINISMPStart: Indirect SMP! Not supported yet\n")); 1213 tiStatus = tiError; 1214 } 1215 return tiStatus; 1216 } 1217 #ifdef TD_INT_COALESCE 1218 osGLOBAL bit32 1219 tiINIIOStartIntCoalesce( 1220 tiRoot_t *tiRoot, 1221 tiIORequest_t *tiIORequest, 1222 tiDeviceHandle_t *tiDeviceHandle, 1223 tiScsiInitiatorRequest_t *tiScsiRequest, 1224 void *tiRequestBody, 1225 bit32 interruptContext, 1226 tiIntCoalesceContext_t *tiIntCoalesceCxt 1227 ) 1228 { 1229 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1230 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1231 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 1232 tdsaDeviceData_t *oneDeviceData; 1233 agsaRoot_t *agRoot = agNULL; 1234 agsaIORequest_t *agIORequest = agNULL; 1235 agsaDevHandle_t *agDevHandle = agNULL; 1236 bit32 agRequestType; 1237 agsaSASRequestBody_t *agSASRequestBody = agNULL; 1238 bit32 tiStatus = tiError; 1239 bit32 saStatus = AGSA_RC_FAILURE; 1240 1241 tdIORequestBody_t *tdIORequestBody; 1242 agsaSSPInitiatorRequest_t *agSSPInitiatorRequest; 1243 tdsaIntCoalesceContext_t *tdsaIntCoalCxt; 1244 agsaIntCoalesceContext_t *agIntCoalCxt; 1245 1246 TI_DBG1(("tiINIIOStartIntCoalesce: start\n")); 1247 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1248 1249 TI_DBG6(("tiINIIOStartIntCoalesce: onedevicedata %p\n", oneDeviceData)); 1250 1251 if(oneDeviceData == agNULL) 1252 { 1253 TI_DBG1(("tiINIIOStartIntCoalesce: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle )); 1254 return tiIONoDevice; 1255 } 1256 1257 /* starting IO with SAS device */ 1258 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 1259 { 1260 TI_DBG6(("tiINIIOStartIntCoalesce: calling saSSPStart\n")); 1261 1262 agRoot = oneDeviceData->agRoot; 1263 agDevHandle = oneDeviceData->agDevHandle; 1264 1265 /* OS layer has tdlayer data structure pointer in 1266 tdIORequestBody_t tdIOReqBody; 1267 in ccb_t in agtiapi.h 1268 */ 1269 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1270 1271 /* let's initialize tdIOrequestBody */ 1272 /* initialize callback */ 1273 tdIORequestBody->IOCompletionFunc = itdssIOCompleted; 1274 1275 /* initialize tiDevhandle */ 1276 tdIORequestBody->tiDevHandle = tiDeviceHandle; 1277 1278 /* initialize tiIORequest */ 1279 tdIORequestBody->tiIORequest = tiIORequest; 1280 1281 /* save context if we need to abort later */ 1282 tiIORequest->tdData = tdIORequestBody; 1283 1284 /* initialize expDataLength */ 1285 tdIORequestBody->IOType.InitiatorRegIO.expDataLength 1286 = tiScsiRequest->scsiCmnd.expDataLength; 1287 1288 /* initializes "agsaSgl_t agSgl" of "agsaDifSSPInitiatorRequest_t" */ 1289 tiStatus = itdssIOPrepareSGL( 1290 tiRoot, 1291 tdIORequestBody, 1292 &tiScsiRequest->agSgl1, 1293 tiScsiRequest->sglVirtualAddr 1294 ); 1295 1296 if (tiStatus != tiSuccess) 1297 { 1298 TI_DBG1(("tiINIIOStartIntCoalesce: can't get SGL\n")); 1299 return tiStatus; 1300 } 1301 1302 1303 /* initialize agIORequest */ 1304 agIORequest = &(tdIORequestBody->agIORequest); 1305 agIORequest->osData = (void *) tdIORequestBody; 1306 agIORequest->sdkData = agNULL; /* LL takes care of this */ 1307 1308 1309 /* 1310 initialize 1311 tdIORequestBody_t tdIORequestBody -> agSASRequestBody 1312 */ 1313 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody); 1314 agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq); 1315 1316 1317 /* copy cdb bytes */ 1318 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.cdb, tiScsiRequest->scsiCmnd.cdb, 16); 1319 1320 /* copy lun field */ 1321 osti_memcpy(agSSPInitiatorRequest->sspCmdIU.lun, 1322 tiScsiRequest->scsiCmnd.lun.lun, 8); 1323 1324 /* setting the data length */ 1325 agSSPInitiatorRequest->dataLength = tiScsiRequest->scsiCmnd.expDataLength; 1326 TI_DBG6(("tiINIIOStartIntCoalesce: tiScsiRequest->scsiCmnd.expDataLength %d\n", tiScsiRequest->scsiCmnd.expDataLength)); 1327 1328 agSSPInitiatorRequest->firstBurstSize = 0; 1329 1330 if (tiScsiRequest->dataDirection == tiDirectionIn) 1331 { 1332 agRequestType = AGSA_SSP_INIT_READ; 1333 TI_DBG6(("tiINIIOStartIntCoalesce: READ\n")); 1334 } 1335 else if (tiScsiRequest->dataDirection == tiDirectionOut) 1336 { 1337 agRequestType = AGSA_SSP_INIT_WRITE; 1338 TI_DBG6(("tiINIIOStartIntCoalesce: WRITE\n")); 1339 } 1340 else 1341 { 1342 agRequestType = AGSA_REQ_TYPE_UNKNOWN; 1343 TI_DBG1(("tiINIIOStartIntCoalesce: unknown data direction\n")); 1344 } 1345 1346 tdIORequestBody->agRequestType = agRequestType; 1347 1348 tdsaIntCoalCxt = (tdsaIntCoalesceContext_t *)tiIntCoalesceCxt->tdData; 1349 agIntCoalCxt = &(tdsaIntCoalCxt->agIntCoalCxt); 1350 1351 1352 1353 #ifdef LL_INT_COALESCE 1354 saStatus = saSSPStartIntCoalesce(agRoot, 1355 agIORequest, 1356 agIntCoalCxt, 1357 agDevHandle, 1358 agRequestType, 1359 agSASRequestBody, 1360 &ossaSSPCompleted); 1361 #endif 1362 1363 tdIORequestBody->ioStarted = agTRUE; 1364 tdIORequestBody->ioCompleted = agFALSE; 1365 1366 if (saStatus == AGSA_RC_SUCCESS) 1367 { 1368 Initiator->NumIOsActive++; 1369 tiStatus = tiSuccess; 1370 } 1371 else 1372 { 1373 TI_DBG1(("tiINIIOStartIntCoalesce: saSSPStart failed\n")); 1374 tdIORequestBody->ioStarted = agFALSE; 1375 tdIORequestBody->ioCompleted = agTRUE; 1376 if (saStatus == AGSA_RC_BUSY) 1377 { 1378 tiStatus = tiBusy; 1379 } 1380 else 1381 { 1382 tiStatus = tiError; 1383 } 1384 return tiStatus; 1385 } 1386 } 1387 1388 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1389 { 1390 /* 1391 satIOStart() -> saSATAStartIntCoalesce() 1392 */ 1393 TI_DBG1(("tiINIIOStartIntCoalesce: SATA not supported yet\n")); 1394 return tiStatus; 1395 } 1396 else 1397 { 1398 TI_DBG1(("tiINIIOStartIntCoalesce: wrong unspported Device %d\n", oneDeviceData->DeviceType)); 1399 /* 1400 error. unsupported IO 1401 */ 1402 } 1403 return tiStatus; 1404 1405 1406 } 1407 1408 osGLOBAL bit32 1409 tiINIIOStartIntCoalesceDif( 1410 tiRoot_t *tiRoot, 1411 tiIORequest_t *tiIORequest, 1412 tiDeviceHandle_t *tiDeviceHandle, 1413 tiScsiInitiatorRequest_t *tiScsiRequest, 1414 void *tiRequestBody, 1415 bit32 interruptContext, 1416 tiIntCoalesceContext_t *tiIntCoalesceCxt, 1417 tiDif_t *difOption 1418 ) 1419 { 1420 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1421 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1422 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 1423 tdsaDeviceData_t *oneDeviceData; 1424 agsaRoot_t *agRoot = agNULL; 1425 agsaIORequest_t *agIORequest = agNULL; 1426 agsaDevHandle_t *agDevHandle = agNULL; 1427 bit32 agRequestType; 1428 agsaDifSSPRequestBody_t *agEdcSSPRequestBody = agNULL; 1429 bit32 tiStatus = tiError; 1430 bit32 saStatus = AGSA_RC_FAILURE; 1431 1432 tdIORequestBody_t *tdIORequestBody; 1433 agsaDifSSPInitiatorRequest_t *agEdcSSPInitiatorRequest; 1434 agsaDif_t *agEdc; 1435 bit32 agUpdateMask = 0; 1436 bit32 agVerifyMask = 0; 1437 tdsaIntCoalesceContext_t *tdsaIntCoalCxt; 1438 agsaIntCoalesceContext_t *agIntCoalCxt; 1439 1440 TI_DBG1(("tiINIIOStartIntCoalesceDif: start\n")); 1441 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1442 1443 TI_DBG6(("tiINIIOStartIntCoalesceDif: onedevicedata %p\n", oneDeviceData)); 1444 1445 if(oneDeviceData == agNULL) 1446 { 1447 TI_DBG1(("tiINIIOStartIntCoalesceDif: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle )); 1448 return tiIONoDevice; 1449 } 1450 1451 /* starting IO with SAS device */ 1452 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 1453 { 1454 TI_DBG6(("tiINIIOStartIntCoalesceDif: calling saSSPStart\n")); 1455 1456 agRoot = oneDeviceData->agRoot; 1457 agDevHandle = oneDeviceData->agDevHandle; 1458 1459 /* OS layer has tdlayer data structure pointer in 1460 tdIORequestBody_t tdIOReqBody; 1461 in ccb_t in agtiapi.h 1462 */ 1463 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1464 1465 /* let's initialize tdIOrequestBody */ 1466 /* initialize callback */ 1467 tdIORequestBody->IOCompletionFunc = itdssIOCompleted; 1468 1469 /* initialize tiDevhandle */ 1470 tdIORequestBody->tiDevHandle = tiDeviceHandle; 1471 1472 /* initialize tiIORequest */ 1473 tdIORequestBody->tiIORequest = tiIORequest; 1474 1475 /* save context if we need to abort later */ 1476 tiIORequest->tdData = tdIORequestBody; 1477 1478 /* initialize expDataLength */ 1479 tdIORequestBody->IOType.InitiatorRegIO.expDataLength 1480 = tiScsiRequest->scsiCmnd.expDataLength; 1481 1482 /* initializes "agsaSgl_t agSgl" of "agsaDifSSPInitiatorRequest_t" */ 1483 tiStatus = itdssIOPrepareSGL( 1484 tiRoot, 1485 tdIORequestBody, 1486 &tiScsiRequest->agSgl1, 1487 tiScsiRequest->sglVirtualAddr 1488 ); 1489 1490 if (tiStatus != tiSuccess) 1491 { 1492 TI_DBG1(("tiINIIOStartIntCoalesceDif: can't get SGL\n")); 1493 return tiStatus; 1494 } 1495 1496 1497 /* initialize agIORequest */ 1498 agIORequest = &(tdIORequestBody->agIORequest); 1499 agIORequest->osData = (void *) tdIORequestBody; 1500 agIORequest->sdkData = agNULL; /* LL takes care of this */ 1501 1502 1503 /* 1504 initialize 1505 tdIORequestBody_t tdIORequestBody -> agSASRequestBody 1506 */ 1507 agEdcSSPRequestBody = &(tdIORequestBody->transport.SAS.agEdcSSPRequestBody); 1508 agEdcSSPInitiatorRequest = &(agEdcSSPRequestBody->edcSSPInitiatorReq); 1509 1510 1511 /* copy cdb bytes */ 1512 osti_memcpy(agEdcSSPInitiatorRequest->sspCmdIU.cdb, tiScsiRequest->scsiCmnd.cdb, 16); 1513 1514 /* copy lun field */ 1515 osti_memcpy(agEdcSSPInitiatorRequest->sspCmdIU.lun, 1516 tiScsiRequest->scsiCmnd.lun.lun, 8); 1517 1518 1519 /* setting the data length */ 1520 agEdcSSPInitiatorRequest->dataLength = tiScsiRequest->scsiCmnd.expDataLength; 1521 TI_DBG6(("tiINIIOStartIntCoalesceDif: tiScsiRequest->scsiCmnd.expDataLength %d\n", tiScsiRequest->scsiCmnd.expDataLength)); 1522 1523 agEdcSSPInitiatorRequest->firstBurstSize = 0; 1524 1525 1526 if (tiScsiRequest->dataDirection == tiDirectionIn) 1527 { 1528 agRequestType = AGSA_SSP_INIT_READ; 1529 TI_DBG1(("tiINIIOStartIntCoalesceDif: READ difAction %X\n",difOption->difAction)); 1530 } 1531 else if (tiScsiRequest->dataDirection == tiDirectionOut) 1532 { 1533 agRequestType = AGSA_SSP_INIT_WRITE; 1534 TI_DBG1(("tiINIIOStartIntCoalesceDif: WRITE difAction %X\n",difOption->difAction)); 1535 } 1536 else 1537 { 1538 agRequestType = AGSA_REQ_TYPE_UNKNOWN; 1539 TI_DBG1(("tiINIIOStartIntCoalesceDif: unknown data direction\n")); 1540 } 1541 1542 tdIORequestBody->agRequestType = agRequestType; 1543 1544 /* process interrupt coalesce context */ 1545 tdsaIntCoalCxt = (tdsaIntCoalesceContext_t *)tiIntCoalesceCxt->tdData; 1546 agIntCoalCxt = &(tdsaIntCoalCxt->agIntCoalCxt); 1547 1548 /* process DIF */ 1549 1550 agEdc = &(agEdcSSPInitiatorRequest->edc); 1551 1552 osti_memset(agEdc, 0, sizeof(agsaDif_t)); 1553 1554 /* setting edcFlag */ 1555 if (difOption->enableBlockCount) 1556 { 1557 /* enables block count; bit5 */ 1558 agEdc->edcFlag = agEdc->edcFlag | 0x20; /* 0010 0000 */ 1559 } 1560 1561 if (difOption->enableCrc) 1562 { 1563 /* enables CRC verification; bit6 */ 1564 agEdc->edcFlag = agEdc->edcFlag | 0x40; /* 0100 0000 */ 1565 } 1566 1567 if (difOption->enableIOSeed) 1568 { 1569 1570 } 1571 if (difOption->difAction == DIF_INSERT) 1572 { 1573 /* bit 0 - 2; 000 */ 1574 agEdc->edcFlag = agEdc->edcFlag & 0xFFFFFFF8; 1575 } 1576 else if (difOption->difAction == DIF_VERIFY_FORWARD) 1577 { 1578 /* bit 0 - 2; 001 */ 1579 agEdc->edcFlag = agEdc->edcFlag | 0x01; 1580 } 1581 else if (difOption->difAction == DIF_VERIFY_DELETE) 1582 { 1583 /* bit 0 - 2; 010 */ 1584 agEdc->edcFlag = agEdc->edcFlag | 0x02; 1585 } 1586 else 1587 { 1588 /* DIF_VERIFY_REPLACE */ 1589 /* bit 0 - 2; 011 */ 1590 agEdc->edcFlag = agEdc->edcFlag | 0x04; 1591 } 1592 1593 /* set Update Mask; bit 16-21 */ 1594 agUpdateMask = (difOption->tagUpdateMask) & 0x3F; /* 0011 1111 */ 1595 agUpdateMask = agUpdateMask << 16; 1596 agEdc->edcFlag = agEdc->edcFlag | agUpdateMask; 1597 1598 /* set Verify Mask bit 24-29 */ 1599 agVerifyMask = (difOption->tagVerifyMask) & 0x3F; /* 0011 1111 */ 1600 agVerifyMask = agVerifyMask << 24; 1601 agEdc->edcFlag = agEdc->edcFlag | agVerifyMask; 1602 1603 agEdc->appTag = difOption->udtArray[0]; 1604 agEdc->appTag = (agEdc->appTag << 8) | difOption->udtArray[1]; 1605 1606 agEdc->lbaReferenceTag = difOption->udtArray[2]; 1607 agEdc->lbaReferenceTag = (agEdc->lbaReferenceTag << 8) | difOption->udtArray[3]; 1608 agEdc->lbaReferenceTag = (agEdc->lbaReferenceTag << 8) | difOption->udtArray[4]; 1609 agEdc->lbaReferenceTag = (agEdc->lbaReferenceTag << 8) | difOption->udtArray[5]; 1610 1611 /* currently TISA supports only 512 logical block size */ 1612 agEdc->lbSize = 512; 1613 1614 1615 #ifdef LL_INT_COALESCE 1616 saStatus = saSSPStartIntCoalesceEdc(agRoot, 1617 agIORequest, 1618 agIntCoalCxt, 1619 agDevHandle, 1620 agRequestType, 1621 agEdcSSPRequestBody, 1622 &ossaSSPCompleted); 1623 #endif 1624 1625 tdIORequestBody->ioStarted = agTRUE; 1626 tdIORequestBody->ioCompleted = agFALSE; 1627 1628 if (saStatus == AGSA_RC_SUCCESS) 1629 { 1630 Initiator->NumIOsActive++; 1631 tiStatus = tiSuccess; 1632 } 1633 else 1634 { 1635 TI_DBG1(("tiINIIOStartIntCoalesceDif: saSSPStart failed\n")); 1636 tdIORequestBody->ioStarted = agFALSE; 1637 tdIORequestBody->ioCompleted = agTRUE; 1638 if (saStatus == AGSA_RC_BUSY) 1639 { 1640 tiStatus = tiBusy; 1641 } 1642 else 1643 { 1644 tiStatus = tiError; 1645 } 1646 return tiStatus; 1647 } 1648 } 1649 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1650 { 1651 /* 1652 satIOStart() -> saSATAStartIntCoalesceEdc() 1653 */ 1654 TI_DBG1(("tiINIIOStartIntCoalesceDif: SATA not supported yet\n")); 1655 return tiStatus; 1656 } 1657 else 1658 { 1659 TI_DBG1(("tiINIIOStartIntCoalesceDif: wrong unspported Device %d\n", oneDeviceData->DeviceType)); 1660 /* 1661 error. unsupported IO 1662 */ 1663 } 1664 return tiStatus; 1665 } 1666 1667 1668 osGLOBAL bit32 1669 tiINIIntCoalesceInit( 1670 tiRoot_t *tiRoot, 1671 tiIntCoalesceContext_t *tiIntCoalesceCxt, 1672 bit32 count 1673 ) 1674 { 1675 1676 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1677 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1678 agsaRoot_t *agRoot = agNULL; 1679 tdsaIntCoalesceContext_t *tdsaIntCoalCxtHead 1680 = (tdsaIntCoalesceContext_t *)tdsaAllShared->IntCoalesce; 1681 tdsaIntCoalesceContext_t *tdsaIntCoalCxt; 1682 agsaIntCoalesceContext_t *agIntCoalCxt; 1683 tdList_t *tdsaIntCoalCxtList = agNULL; 1684 1685 bit32 tiStatus = tiError; 1686 1687 TI_DBG1(("tiINIIntCoalesceInit: start\n")); 1688 1689 tdsaSingleThreadedEnter(tiRoot, TD_INTCOAL_LOCK); 1690 if (TDLIST_NOT_EMPTY(&(tdsaIntCoalCxtHead->FreeLink))) 1691 { 1692 TDLIST_DEQUEUE_FROM_HEAD(&tdsaIntCoalCxtList, &(tdsaIntCoalCxtHead->FreeLink)); 1693 tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK); 1694 tdsaIntCoalCxt 1695 = TDLIST_OBJECT_BASE(tdsaIntCoalesceContext_t, FreeLink, tdsaIntCoalCxtList); 1696 1697 TI_DBG1(("tiINIIntCoalesceInit: id %d\n", tdsaIntCoalCxt->id)); 1698 1699 agRoot = &(tdsaAllShared->agRootNonInt); 1700 1701 agIntCoalCxt = &(tdsaIntCoalCxt->agIntCoalCxt); 1702 tdsaIntCoalCxt->tiIntCoalesceCxt = tiIntCoalesceCxt; 1703 tiIntCoalesceCxt->tdData = tdsaIntCoalCxt; 1704 agIntCoalCxt->osData = tdsaIntCoalCxt; 1705 1706 tdsaSingleThreadedEnter(tiRoot, TD_INTCOAL_LOCK); 1707 TDLIST_ENQUEUE_AT_TAIL(&(tdsaIntCoalCxt->MainLink), &(tdsaIntCoalCxtHead->MainLink)); 1708 tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK); 1709 1710 /* 1711 note: currently asynchronously call is assumed. In other words, 1712 "ossaIntCoalesceInitCB()" -> "ostiInitiatorCoalesceInitCB()" are used 1713 */ 1714 #ifdef LL_INT_COALESCE 1715 tiStatus = saIntCoalesceInit(agRoot, agIntCoalCxt, count); 1716 #endif 1717 1718 TI_DBG6(("tiINIIntCoalesceInit: status %d\n", tiStatus)); 1719 return tiStatus; 1720 } 1721 else 1722 { 1723 tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK); 1724 TI_DBG1(("tiINIIntCoalesceInit: no more interrupt coalesce context; return fail\n")); 1725 return tiStatus; 1726 } 1727 } 1728 #endif /* TD_INT_COALESCE */ 1729 1730 /***************************************************************************** 1731 *! \brief itdssIOPrepareSGL 1732 * 1733 * Purpose: This function is called to translate TISA SGL information to the 1734 * LL layer SGL. 1735 * 1736 * \param tiRoot: Pointer to initiator driver/port instance. 1737 * \param IORequestBody: TD layer request body for the I/O. 1738 * \param tiSgl1: First TISA SGL info. 1739 * \param sglVirtualAddr: The virtual address of the first element in 1740 * tiSgl1 when tiSgl1 is used with the type tiSglList. 1741 * 1742 * \return: 1743 * 1744 * tiSuccess: SGL initialized successfully. 1745 * tiError: Failed to initialize SGL. 1746 * 1747 * 1748 *****************************************************************************/ 1749 osGLOBAL FORCEINLINE bit32 1750 itdssIOPrepareSGL( 1751 tiRoot_t *tiRoot, 1752 tdIORequestBody_t *tdIORequestBody, 1753 tiSgl_t *tiSgl1, 1754 void *sglVirtualAddr 1755 ) 1756 { 1757 agsaSgl_t *agSgl; 1758 1759 TI_DBG6(("itdssIOPrepareSGL: start\n")); 1760 1761 agSgl = &(tdIORequestBody->transport.SAS.agSASRequestBody.sspInitiatorReq.agSgl); 1762 1763 agSgl->len = 0; 1764 1765 if (tiSgl1 == agNULL) 1766 { 1767 TI_DBG1(("itdssIOPrepareSGL: Error tiSgl1 is NULL\n")); 1768 return tiError; 1769 } 1770 1771 if (tdIORequestBody->IOType.InitiatorRegIO.expDataLength == 0) 1772 { 1773 TI_DBG6(("itdssIOPrepareSGL: expDataLength is 0\n")); 1774 agSgl->sgUpper = 0; 1775 agSgl->sgLower = 0; 1776 agSgl->len = 0; 1777 CLEAR_ESGL_EXTEND(agSgl->extReserved); 1778 return tiSuccess; 1779 } 1780 1781 agSgl->sgUpper = tiSgl1->upper; 1782 agSgl->sgLower = tiSgl1->lower; 1783 agSgl->len = tiSgl1->len; 1784 agSgl->extReserved = tiSgl1->type; 1785 1786 return tiSuccess; 1787 } 1788 1789 osGLOBAL bit32 1790 tiNumOfLunIOCTLreq( 1791 tiRoot_t *tiRoot, 1792 tiIORequest_t *tiIORequest, 1793 tiDeviceHandle_t *tiDeviceHandle, 1794 void *tiRequestBody, 1795 tiIOCTLPayload_t *agIOCTLPayload, 1796 void *agParam1, 1797 void *agParam2 1798 ) 1799 { 1800 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1801 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1802 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 1803 void *respBuffer = agNULL; 1804 void *osMemHandle = agNULL; 1805 bit32 ostiMemoryStatus = 0; 1806 tdsaDeviceData_t *oneDeviceData = agNULL; 1807 agsaSSPInitiatorRequest_t *agSSPFrame = agNULL; 1808 bit32 status = IOCTL_CALL_SUCCESS; 1809 bit32 agRequestType = 0; 1810 agsaDevHandle_t *agDevHandle = agNULL; 1811 agsaIORequest_t *agIORequest = agNULL; 1812 tdIORequestBody_t *tdIORequestBody = agNULL; 1813 agsaSASRequestBody_t *agSASRequestBody = agNULL; 1814 1815 do 1816 { 1817 if((tiIORequest == agNULL) || (tiRequestBody == agNULL)) 1818 { 1819 status = IOCTL_CALL_FAIL; 1820 break; 1821 } 1822 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 1823 1824 if(tdIORequestBody == agNULL) 1825 { 1826 status = IOCTL_CALL_FAIL; 1827 break; 1828 } 1829 tdIORequestBody->tiIORequest = tiIORequest; 1830 1831 /* save context if we need to abort later */ 1832 tiIORequest->tdData = tdIORequestBody; 1833 1834 agIORequest = &(tdIORequestBody->agIORequest); 1835 agIORequest->osData = (void *) tdIORequestBody; 1836 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody); 1837 agSSPFrame = &(agSASRequestBody->sspInitiatorReq); 1838 1839 ostiMemoryStatus = ostiAllocMemory( tiRoot, 1840 &osMemHandle, 1841 (void **)&respBuffer, 1842 &(agSSPFrame->agSgl.sgUpper), 1843 &(agSSPFrame->agSgl.sgLower), 1844 8, 1845 REPORT_LUN_LEN, 1846 agFALSE); 1847 if((ostiMemoryStatus != tiSuccess) && (respBuffer == agNULL )) 1848 { 1849 status = IOCTL_CALL_FAIL; 1850 break; 1851 } 1852 1853 osti_memset((void *)respBuffer, 0, REPORT_LUN_LEN); 1854 1855 // use FW control place in shared structure to keep the neccesary information 1856 tdsaAllShared->tdFWControlEx.virtAddr = respBuffer; 1857 tdsaAllShared->tdFWControlEx.len = REPORT_LUN_LEN; 1858 tdsaAllShared->tdFWControlEx.param1 = agParam1; 1859 tdsaAllShared->tdFWControlEx.param2 = agParam2; 1860 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 1861 tdsaAllShared->tdFWControlEx.inProgress = 1; 1862 agRequestType = AGSA_SSP_INIT_READ; 1863 1864 status = IOCTL_CALL_PENDING; 1865 oneDeviceData = (tdsaDeviceData_t *)(tiDeviceHandle->tdData); 1866 agDevHandle = oneDeviceData->agDevHandle; 1867 1868 agSSPFrame->sspCmdIU.cdb[0] = REPORT_LUN_OPCODE; 1869 agSSPFrame->sspCmdIU.cdb[1] = 0x0; 1870 agSSPFrame->sspCmdIU.cdb[2] = 0x0; 1871 agSSPFrame->sspCmdIU.cdb[3] = 0x0; 1872 agSSPFrame->sspCmdIU.cdb[4] = 0x0; 1873 agSSPFrame->sspCmdIU.cdb[5] = 0x0; 1874 agSSPFrame->sspCmdIU.cdb[6] = 0x0; 1875 agSSPFrame->sspCmdIU.cdb[7] = 0x0; 1876 agSSPFrame->sspCmdIU.cdb[8] = 0x0; 1877 agSSPFrame->sspCmdIU.cdb[9] = REPORT_LUN_LEN; 1878 agSSPFrame->sspCmdIU.cdb[10] = 0x0; 1879 agSSPFrame->sspCmdIU.cdb[11] = 0x0; 1880 1881 agSSPFrame->dataLength = REPORT_LUN_LEN; 1882 agSSPFrame->agSgl.len = sizeof(agsaSSPCmdInfoUnit_t); 1883 1884 status = saSSPStart(agRoot, agIORequest, 0, agDevHandle, agRequestType,agSASRequestBody,agNULL, 1885 &ossaSSPIoctlCompleted); 1886 if(status != AGSA_RC_SUCCESS) 1887 { 1888 ostiFreeMemory(tiRoot, 1889 tdsaAllShared->tdFWControlEx.virtAddr, 1890 tdsaAllShared->tdFWControlEx.len); 1891 tdsaAllShared->tdFWControlEx.payload = NULL; 1892 tdsaAllShared->tdFWControlEx.inProgress = 0; 1893 status = IOCTL_CALL_FAIL; 1894 } 1895 }while(0); 1896 return status; 1897 } 1898 1899 1900