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 TB misc. functions 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 tiINIIOAbort 79 * 80 * Purpose: This function is called to abort an I/O request previously started 81 * by a call to tiINIIOStart() or tiINIIOStartDif() . 82 * 83 * \param tiRoot: Pointer to initiator driver/port instance. 84 * \param taskTag: Pointer to the associated task to be aborted 85 * 86 * \return: 87 * 88 * tiSuccess: I/O request successfully initiated. 89 * tiBusy: No resources available, try again later. 90 * tiIONoDevice: Invalid device handle. 91 * tiError: Other errors that prevent the I/O request to be 92 * started. 93 * 94 *****************************************************************************/ 95 #ifdef INITIATOR_DRIVER /*TBD: INITIATOR SPECIFIC API in tiapi.h (TP)*/ 96 osGLOBAL bit32 97 tiINIIOAbort( 98 tiRoot_t *tiRoot, 99 tiIORequest_t *taskTag 100 ) 101 { 102 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 103 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 104 agsaRoot_t *agRoot = agNULL; 105 tdIORequestBody_t *tdIORequestBody = agNULL; 106 agsaIORequest_t *agIORequest = agNULL; 107 bit32 sasStatus = AGSA_RC_FAILURE; 108 tdsaDeviceData_t *oneDeviceData; 109 bit32 status= tiError; 110 agsaIORequest_t *agAbortIORequest; 111 tdIORequestBody_t *tdAbortIORequestBody; 112 bit32 PhysUpper32; 113 bit32 PhysLower32; 114 bit32 memAllocStatus; 115 void *osMemHandle; 116 agsaDevHandle_t *agDevHandle = agNULL; 117 #ifdef FDS_SM 118 smRoot_t *smRoot; 119 tdIORequestBody_t *ToBeAbortedtdIORequestBody; 120 smIORequest_t *ToBeAborted = agNULL; 121 #endif 122 TI_DBG2(("tiINIIOAbort: start\n")); 123 124 if(taskTag == agNULL) 125 { 126 TI_DBG1(("tiINIIOAbort: taskTag is NULL\n")); 127 return tiError; 128 } 129 130 agRoot = &(tdsaAllShared->agRootNonInt); 131 tdIORequestBody = (tdIORequestBody_t *)taskTag->tdData; 132 agIORequest = &(tdIORequestBody->agIORequest); 133 oneDeviceData = tdIORequestBody->tiDevHandle->tdData; 134 135 if(oneDeviceData == agNULL) 136 { 137 TI_DBG1(("tiINIIOAbort: DeviceData is NULL\n")); 138 return tiSuccess; 139 } 140 141 agDevHandle = oneDeviceData->agDevHandle; 142 143 TI_DBG2(("tiINIIOAbort: did %d\n", oneDeviceData->id)); 144 145 /* for hotplug */ 146 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 147 oneDeviceData->tdPortContext == agNULL ) 148 { 149 TI_DBG1(("tiINIIOAbort: NO Device did %d\n", oneDeviceData->id )); 150 TI_DBG1(("tiINIIOAbort: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 151 TI_DBG1(("tiINIIOAbort: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 152 return tiError; 153 } 154 155 /* allocating agIORequest for abort itself */ 156 memAllocStatus = ostiAllocMemory( 157 tiRoot, 158 &osMemHandle, 159 (void **)&tdAbortIORequestBody, 160 &PhysUpper32, 161 &PhysLower32, 162 8, 163 sizeof(tdIORequestBody_t), 164 agTRUE 165 ); 166 if (memAllocStatus != tiSuccess) 167 { 168 /* let os process IO */ 169 TI_DBG1(("tiINIIOAbort: ostiAllocMemory failed...\n")); 170 return tiError; 171 } 172 173 if (tdAbortIORequestBody == agNULL) 174 { 175 /* let os process IO */ 176 TI_DBG1(("tiINIIOAbort: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 177 return tiError; 178 } 179 180 /* setup task management structure */ 181 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 182 /* setting callback */ 183 tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler; 184 tdAbortIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle; 185 186 /* initialize agIORequest */ 187 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 188 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 189 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 190 191 /* remember IO to be aborted */ 192 tdAbortIORequestBody->tiIOToBeAbortedRequest = taskTag; 193 194 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 195 { 196 sasStatus = saSSPAbort(agRoot, 197 agAbortIORequest, 198 tdsaRotateQnumber(tiRoot, oneDeviceData), 199 agDevHandle, 200 0/* flag */, 201 agIORequest, 202 agNULL); 203 204 if (sasStatus == AGSA_RC_SUCCESS) 205 { 206 return tiSuccess; 207 } 208 else 209 { 210 return tiError; 211 } 212 } 213 214 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 215 { 216 TI_DBG2(("tiINIIOAbort: calling satIOAbort() oneDeviceData=%p\n", oneDeviceData)); 217 #ifdef FDS_SM 218 smRoot = &(tdsaAllShared->smRoot); 219 if ( taskTag != agNULL) 220 { 221 ToBeAbortedtdIORequestBody = (tdIORequestBody_t *)taskTag->tdData; 222 ToBeAborted = &(ToBeAbortedtdIORequestBody->smIORequest); 223 status = smIOAbort(smRoot, ToBeAborted); 224 return status; 225 } 226 else 227 { 228 TI_DBG1(("tiINIIOAbort: taskTag is NULL!!!\n")); 229 return tiError; 230 } 231 232 #else 233 234 #ifdef SATA_ENABLE 235 status = satIOAbort(tiRoot, taskTag ); 236 #endif 237 238 return status; 239 #endif /* else FDS_SM */ 240 } 241 242 else 243 { 244 return tiError; 245 } 246 247 } 248 249 osGLOBAL bit32 250 tiINIIOAbortAll( 251 tiRoot_t *tiRoot, 252 tiDeviceHandle_t *tiDeviceHandle 253 ) 254 { 255 agsaRoot_t *agRoot = agNULL; 256 tdsaDeviceData_t *oneDeviceData = agNULL; 257 bit32 status = tiError; 258 #ifdef FDS_SM 259 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 260 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 261 smRoot_t *smRoot = &(tdsaAllShared->smRoot); 262 smDeviceHandle_t *smDeviceHandle; 263 #endif 264 265 TI_DBG1(("tiINIIOAbortAll: start\n")); 266 267 if (tiDeviceHandle == agNULL) 268 { 269 TI_DBG1(("tiINIIOAbortAll: tiDeviceHandle is NULL!!!\n")); 270 return tiError; 271 } 272 273 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 274 275 if (oneDeviceData == agNULL) 276 { 277 TI_DBG1(("tiINIIOAbortAll: oneDeviceData is NULL!!!\n")); 278 return tiError; 279 } 280 281 /* for hotplug */ 282 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 283 oneDeviceData->tdPortContext == agNULL ) 284 { 285 TI_DBG1(("tiINIIOAbortAll: NO Device did %d\n", oneDeviceData->id )); 286 TI_DBG1(("tiINIIOAbortAll: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 287 TI_DBG1(("tiINIIOAbortAll: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 288 return tiError; 289 } 290 291 agRoot = oneDeviceData->agRoot; 292 293 if (agRoot == agNULL) 294 { 295 TI_DBG1(("tiINIIOAbortAll: agRoot is NULL!!!\n")); 296 return tiError; 297 } 298 299 /* this is processed in ossaSSPAbortCB, ossaSATAAbortCB, ossaSMPAbortCB */ 300 if (oneDeviceData->OSAbortAll == agTRUE) 301 { 302 TI_DBG1(("tiINIIOAbortAll: already pending!!!\n")); 303 return tiBusy; 304 } 305 else 306 { 307 oneDeviceData->OSAbortAll = agTRUE; 308 } 309 310 #ifdef FDS_SM 311 if ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData)) 312 { 313 status = tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 314 } 315 else if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || 316 DEVICE_IS_STP_TARGET(oneDeviceData) 317 ) 318 { 319 TI_DBG2(("tiINIIOAbortAll: calling smIOAbortAll\n")); 320 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle); 321 smDeviceHandle->tdData = oneDeviceData; 322 status = smIOAbortAll(smRoot, smDeviceHandle); 323 } 324 else 325 { 326 TI_DBG1(("tiINIIOAbortAll: unknow device type!!! 0x%x\n", oneDeviceData->target_ssp_stp_smp)); 327 status = AGSA_RC_FAILURE; 328 } 329 #else 330 status = tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 331 #endif 332 333 return status; 334 335 } 336 #endif /* INITIATOR_DRIVER */ 337 338 /***************************************************************************** 339 *! \brief tdsaAbortAll 340 * 341 * Purpose: This function is called to abort an all pending I/O request on a 342 * device 343 * 344 * \param tiRoot: Pointer to initiator driver/port instance. 345 * \param agRoot: Pointer to chip/driver Instance. 346 * \param oneDeviceData: Pointer to the device 347 * 348 * \return: 349 * 350 * None 351 * 352 *****************************************************************************/ 353 osGLOBAL bit32 354 tdsaAbortAll( 355 tiRoot_t *tiRoot, 356 agsaRoot_t *agRoot, 357 tdsaDeviceData_t *oneDeviceData 358 ) 359 { 360 agsaIORequest_t *agAbortIORequest = agNULL; 361 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 362 bit32 PhysUpper32; 363 bit32 PhysLower32; 364 bit32 memAllocStatus; 365 void *osMemHandle; 366 bit32 status = AGSA_RC_FAILURE; 367 368 TI_DBG1(("tdsaAbortAll: did %d\n", oneDeviceData->id)); 369 370 /* allocating agIORequest for abort itself */ 371 memAllocStatus = ostiAllocMemory( 372 tiRoot, 373 &osMemHandle, 374 (void **)&tdAbortIORequestBody, 375 &PhysUpper32, 376 &PhysLower32, 377 8, 378 sizeof(tdIORequestBody_t), 379 agTRUE 380 ); 381 if (memAllocStatus != tiSuccess) 382 { 383 /* let os process IO */ 384 TI_DBG1(("tdsaAbortAll: ostiAllocMemory failed...\n")); 385 return tiError; 386 } 387 388 if (tdAbortIORequestBody == agNULL) 389 { 390 /* let os process IO */ 391 TI_DBG1(("tdsaAbortAll: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 392 return tiError; 393 } 394 395 /* setup task management structure */ 396 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 397 /* setting callback but not used later */ 398 tdAbortIORequestBody->IOCompletionFunc = agNULL; 399 //tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler; 400 401 tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle); 402 403 /* initialize agIORequest */ 404 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 405 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 406 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 407 408 if ( DEVICE_IS_SSP_TARGET(oneDeviceData)) 409 { 410 /* SSPAbort */ 411 status = saSSPAbort(agRoot, 412 agAbortIORequest, 413 tdsaRotateQnumber(tiRoot, oneDeviceData), //0, 414 oneDeviceData->agDevHandle, 415 1, /* abort all */ 416 agNULL, 417 agNULL 418 ); 419 } 420 else if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || 421 DEVICE_IS_STP_TARGET(oneDeviceData) 422 ) 423 { 424 /* SATAAbort*/ 425 if (oneDeviceData->satDevData.IDDeviceValid == agFALSE) 426 { 427 TI_DBG2(("tdsaAbortAll: saSATAAbort\n")); 428 status = saSATAAbort(agRoot, 429 agAbortIORequest, 430 0, 431 oneDeviceData->agDevHandle, 432 1, /* abort all */ 433 agNULL, 434 agNULL 435 ); 436 } 437 else 438 { 439 TI_DBG2(("tdsaAbortAll: saSATAAbort IDDeviceValid\n")); 440 status = saSATAAbort(agRoot, 441 agAbortIORequest, 442 tdsaRotateQnumber(tiRoot, oneDeviceData), //0, 443 oneDeviceData->agDevHandle, 444 1, /* abort all */ 445 agNULL, 446 agNULL 447 ); 448 } 449 } 450 else if (DEVICE_IS_SMP_TARGET(oneDeviceData)) 451 { 452 /* SMPAbort*/ 453 TI_DBG2(("tdsaAbortAll: saSMPAbort \n")); 454 status = saSMPAbort(agRoot, 455 agAbortIORequest, 456 tdsaRotateQnumber(tiRoot, oneDeviceData), //0, 457 oneDeviceData->agDevHandle, 458 1, /* abort all */ 459 agNULL, 460 agNULL 461 ); 462 } 463 else 464 { 465 TI_DBG1(("tdsaAbortAll: unknown device type!!! 0x%x\n", oneDeviceData->target_ssp_stp_smp)); 466 status = AGSA_RC_FAILURE; 467 } 468 469 if (status == AGSA_RC_SUCCESS) 470 { 471 return tiSuccess; 472 } 473 else 474 { 475 TI_DBG1(("tdsaAbortAll: failed status=%d\n", status)); 476 //failed to send abort command, we need to free the memory 477 ostiFreeMemory( 478 tiRoot, 479 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 480 sizeof(tdIORequestBody_t) 481 ); 482 return tiError; 483 } 484 485 } 486 487 488 489 /***************************************************************************** 490 *! \brief tiCOMReset 491 * 492 * Purpose: This function is called to trigger soft or hard reset 493 * 494 * \param tiRoot: Pointer to initiator driver/port instance. 495 * \param option: Options 496 * 497 * \return: 498 * 499 * None 500 * 501 *****************************************************************************/ 502 osGLOBAL void 503 tiCOMReset( 504 tiRoot_t *tiRoot, 505 bit32 option 506 ) 507 { 508 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 509 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 510 agsaRoot_t *agRoot = agNULL; 511 512 513 #ifdef TI_GETFOR_ONRESET 514 agsaControllerStatus_t controllerStatus; 515 agsaForensicData_t forensicData; 516 bit32 once = 1; 517 bit32 status; 518 #endif /* TI_GETFOR_ONRESET */ 519 520 TI_DBG1(("tiCOMReset: start option 0x%x\n",option)); 521 tdsaAllShared->resetCount++; 522 TI_DBG2(("tiCOMReset: reset count %d\n", tdsaAllShared->resetCount)); 523 524 agRoot = &(tdsaAllShared->agRootNonInt); 525 526 if (tdsaAllShared->flags.resetInProgress == agTRUE) 527 { 528 TI_DBG1(("tiCOMReset : Reset is already in progress : \n")); 529 530 /* don't do anything : just return */ 531 return; 532 } 533 534 tdsaAllShared->flags.resetInProgress = agTRUE; 535 536 #ifdef TI_GETFOR_ONRESET 537 saGetControllerStatus(agRoot, &controllerStatus); 538 if(controllerStatus.fatalErrorInfo.errorInfo1) 539 { 540 541 bit8 * DirectData = (bit8 * )tdsaAllShared->FatalErrorData; 542 forensicData.DataType = TYPE_FATAL; 543 forensicData.dataBuf.directLen = (8 * 1024); 544 forensicData.dataBuf.directOffset = 0; /* current offset */ 545 forensicData.dataBuf.readLen = 0; /* Data read */ 546 getmoreData: 547 forensicData.dataBuf.directData = DirectData; 548 status = saGetForensicData( agRoot, agNULL, &forensicData); 549 TI_DBG1(("tiCOMReset:status %d readLen 0x%x directLen 0x%x directOffset 0x%x\n", 550 status, 551 forensicData.dataBuf.readLen, 552 forensicData.dataBuf.directLen, 553 forensicData.dataBuf.directOffset)); 554 555 if( forensicData.dataBuf.readLen == forensicData.dataBuf.directLen && !status && once) 556 { 557 DirectData += forensicData.dataBuf.readLen; 558 goto getmoreData; 559 } 560 TI_DBG1(("tiCOMReset:saGetForensicData type %d read 0x%x bytes\n", forensicData.DataType, forensicData.dataBuf.directOffset )); 561 } 562 563 #endif /* TI_GETFOR_ONRESET */ 564 if (option == tiSoftReset) 565 { 566 /* soft reset */ 567 TI_DBG6(("tiCOMReset: soft reset\n")); 568 saHwReset(agRoot, AGSA_SOFT_RESET, 0); 569 return; 570 } 571 else 572 { 573 saHwReset(agRoot, AGSA_SOFT_RESET, 0); 574 #ifdef NOT_YET 575 /* hard reset */ 576 saHwReset(agRoot, AGSA_CHIP_RESET, 0); 577 #endif 578 } 579 return; 580 } 581 582 583 /*****************************************************************************/ 584 /*! \biref tiINIReportErrorToEventLog 585 * 586 * Purpose: This function is called to report errors that needs to be logged 587 * into event log. 588 * 589 * \param tiRoot: Pointer to initiator specific root data structure for this 590 * instance of the driver. 591 * \param agEventData: Event data structure. 592 * 593 * \return None. 594 * 595 */ 596 /*****************************************************************************/ 597 #ifdef INITIATOR_DRIVER 598 osGLOBAL bit32 599 tiINIReportErrorToEventLog( 600 tiRoot_t *tiRoot, 601 tiEVTData_t *agEventData 602 ) 603 { 604 TI_DBG6(("tiINIReportErrorToEventLog: start\n")); 605 return tiError; 606 } 607 #endif /* INITIATOR_DRIVER */ 608 609 /*****************************************************************************/ 610 /*! \brief ossaReenableInterrupts 611 * 612 * 613 * Purpose: This routine is called to enable interrupt 614 * 615 * 616 * \param agRoot: Pointer to chip/driver Instance. 617 * \param outboundChannelNum: Zero-base channel number 618 * 619 * 620 * \return None. 621 * 622 * \note - The scope is shared target and initiator. 623 * 624 */ 625 /*****************************************************************************/ 626 #ifndef ossaReenableInterrupts 627 osGLOBAL void 628 ossaReenableInterrupts( 629 agsaRoot_t *agRoot, 630 bit32 outboundChannelNum 631 ) 632 { 633 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 634 635 ostiInterruptEnable( 636 osData->tiRoot, 637 outboundChannelNum 638 ); 639 return; 640 } 641 642 #endif 643 644 645 646 647 /* 648 1. initiator 649 send task management 650 call saSSPAbort() 651 652 2. Target 653 call saSSPAbort() 654 655 */ 656 657 /***************************************************************************** 658 *! \brief tiINITaskManagement 659 * 660 * Purpose: This routine is called to explicitly ask the Transport Dependent 661 * Layer to issue a Task Management command to a device. 662 * 663 * \param tiRoot: Pointer to driver instance 664 * \param tiDeviveHandle: Pointer to the device handle for this session. 665 * \param task: SAM-2 task management request. 666 * \param lun: Pointer to the SCSI-3 LUN information 667 * when applicable. Set to zero when not applicable. 668 * \param taskTag: Pointer to the associated task where the task 669 * management command is to be applied. Set to agNULL 670 * if not applicable for the specific Task Management 671 * task. 672 * \param currentTaskTag: The current context or task tag for this task. This 673 * task tag will be passed back in ostiInitiatorEvent() 674 * when this task management is completed. 675 * 676 * \return: 677 * tiSuccess TM request successfully initiated. 678 * tiBusy No resources available, try again later. 679 * tiIONoDevice Invalid device handle. 680 * tiError Other errors that prevent the TM request to be started. 681 * 682 *****************************************************************************/ 683 /* 684 warm reset->smp phy control(hard reset) or saLocalPhyControl(AGSA_PHY_HARD_RESET) 685 686 */ 687 #ifdef INITIATOR_DRIVER 688 osGLOBAL bit32 689 tiINITaskManagement ( 690 tiRoot_t *tiRoot, 691 tiDeviceHandle_t *tiDeviceHandle, 692 bit32 task, 693 tiLUN_t *lun, 694 tiIORequest_t *taskTag, /* being aborted one */ 695 tiIORequest_t *currentTaskTag /* task management itself */ 696 ) 697 { 698 699 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 700 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 701 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 702 agsaRoot_t *agRoot = agNULL; 703 bit32 tiStatus = tiError; 704 bit32 notImplemented = agFALSE; 705 tdsaDeviceData_t *oneDeviceData = agNULL; 706 void *osMemHandle; 707 tdIORequestBody_t *TMtdIORequestBody; 708 bit32 PhysUpper32; 709 bit32 PhysLower32; 710 bit32 memAllocStatus; 711 bit32 agRequestType; 712 agsaIORequest_t *agIORequest = agNULL; /* task management itself */ 713 agsaIORequest_t *agTMRequest = agNULL; /* IO being task managed */ 714 agsaDevHandle_t *agDevHandle = agNULL; 715 agsaSASRequestBody_t *agSASRequestBody = agNULL; 716 agsaSSPScsiTaskMgntReq_t *agSSPTaskMgntRequest; 717 bit32 saStatus; 718 tdIORequestBody_t *tdIORequestBody; 719 #ifdef FDS_SM 720 smRoot_t *smRoot; 721 smDeviceHandle_t *smDeviceHandle; 722 smIORequest_t *ToBeAborted = agNULL; 723 smIORequest_t *TaskManagement; 724 tdIORequestBody_t *ToBeAbortedtdIORequestBody; 725 tdIORequestBody_t *SMTMtdIORequestBody; 726 void *SMosMemHandle; 727 bit32 SMPhysUpper32; 728 bit32 SMPhysLower32; 729 bit32 SMmemAllocStatus; 730 #endif 731 732 TI_DBG2(("tiINITaskManagement: start\n")); 733 734 /* just for testing only */ 735 #ifdef REMOVED 736 //start temp 737 if(tiDeviceHandle == agNULL) 738 { 739 TI_DBG1(("tiINITaskManagement: tiDeviceHandle is NULL\n")); 740 return tiError; 741 } 742 743 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 744 if(oneDeviceData == agNULL) 745 { 746 TI_DBG1(("tiINITaskManagement: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle)); 747 return tiError; 748 } 749 TI_DBG1(("tiINITaskManagement: did %d\n", oneDeviceData->id )); 750 return tiError; 751 //end temp 752 753 // just for testing 754 if (task == AG_LOGICAL_UNIT_RESET) 755 { 756 TI_DBG1(("tiINITaskManagement: failing LUN RESET for testing\n")); 757 return tiError; 758 } 759 760 #endif 761 762 switch(task) 763 { 764 case AG_ABORT_TASK: 765 TI_DBG6(("tiINITaskManagement: ABORT_TASK\n")); 766 break; 767 case AG_ABORT_TASK_SET: 768 TI_DBG6(("tiINITaskManagement: ABORT_TASK_SET\n")); 769 break; 770 case AG_CLEAR_ACA: 771 TI_DBG6(("tiINITaskManagement: CLEAR_ACA\n")); 772 break; 773 case AG_CLEAR_TASK_SET: 774 TI_DBG6(("tiINITaskManagement: CLEAR_TASK_SET\n")); 775 break; 776 case AG_LOGICAL_UNIT_RESET: 777 TI_DBG6(("tiINITaskManagement: LOGICAL_UNIT_RESET\n")); 778 break; 779 case AG_TARGET_WARM_RESET: 780 TI_DBG6(("tiINITaskManagement: TARGET_WARM_RESET\n")); 781 break; 782 case AG_QUERY_TASK: 783 TI_DBG6(("tiINITaskManagement: QUERY_TASK\n")); 784 break; 785 default: 786 TI_DBG1(("tiINITaskManagement: notImplemented 0x%0x !!!\n",task)); 787 notImplemented = agTRUE; 788 break; 789 } 790 791 if (notImplemented) 792 { 793 TI_DBG1(("tiINITaskManagement: not implemented 0x%0x !!!\n",task)); 794 return tiStatus; 795 } 796 797 if(tiDeviceHandle == agNULL) 798 { 799 TI_DBG1(("tiINITaskManagement: tiDeviceHandle is NULL\n")); 800 return tiError; 801 } 802 803 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 804 if(oneDeviceData == agNULL) 805 { 806 TI_DBG1(("tiINITaskManagement: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle)); 807 return tiIONoDevice; 808 } 809 810 /* for hotplug */ 811 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 812 oneDeviceData->tdPortContext == agNULL ) 813 { 814 TI_DBG1(("tiINITaskManagement: NO Device did %d Addr 0x%08x:0x%08x\n", oneDeviceData->id , oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo)); 815 return tiIONoDevice; 816 } 817 818 /* 1. call tiINIOAbort() 819 2. call tdssTaskXmit() 820 */ 821 822 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 823 { 824 agRoot = oneDeviceData->agRoot; 825 agDevHandle = oneDeviceData->agDevHandle; 826 TI_DBG1(("tiINITaskManagement: SAS Device\n")); 827 828 /* 829 WARM_RESET is experimental code. 830 Needs more testing and debugging 831 */ 832 if (task == AG_TARGET_WARM_RESET) 833 { 834 agsaContext_t *agContext; 835 tdsaDeviceData_t *tdsaDeviceData; 836 837 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 838 currentTaskTag->tdData = tdsaDeviceData; 839 agContext = &(tdsaDeviceData->agDeviceResetContext); 840 agContext->osData = currentTaskTag; 841 842 TI_DBG2(("tiINITaskManagement: did %d device reset for SAS\n", oneDeviceData->id)); 843 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_IN_RECOVERY); 844 845 /* warm reset by saLocalPhyControl or SMP PHY control */ 846 if (oneDeviceData->directlyAttached == agTRUE) 847 { 848 TI_DBG2(("tiINITaskManagement: device reset directly attached\n")); 849 saLocalPhyControl(agRoot, 850 agContext, 851 tdsaRotateQnumber(tiRoot, oneDeviceData), 852 oneDeviceData->phyID, 853 AGSA_PHY_HARD_RESET, 854 agNULL 855 ); 856 return tiSuccess; 857 } 858 else 859 { 860 TI_DBG2(("tiINITaskManagement: device reset expander attached\n")); 861 saStatus = tdsaPhyControlSend(tiRoot, 862 oneDeviceData, 863 SMP_PHY_CONTROL_HARD_RESET, 864 currentTaskTag, 865 tdsaRotateQnumber(tiRoot, oneDeviceData) 866 ); 867 return saStatus; 868 } 869 } 870 else 871 { 872 /* task management */ 873 TI_DBG6(("tiINITaskManagement: making task management frame \n")); 874 /* 1. create task management frame 875 2. sends it using "saSSPStart()" 876 */ 877 /* Allocate memory for task management */ 878 memAllocStatus = ostiAllocMemory( 879 tiRoot, 880 &osMemHandle, 881 (void **)&TMtdIORequestBody, 882 &PhysUpper32, 883 &PhysLower32, 884 8, 885 sizeof(tdIORequestBody_t), 886 agTRUE 887 ); 888 889 if (memAllocStatus != tiSuccess) 890 { 891 TI_DBG1(("tiINITaskManagement: ostiAllocMemory failed...\n")); 892 return tiError; 893 } 894 895 if (TMtdIORequestBody == agNULL) 896 { 897 TI_DBG1(("tiINITaskManagement: ostiAllocMemory returned NULL TMIORequestBody\n")); 898 return tiError; 899 } 900 901 /* initialize */ 902 osti_memset(TMtdIORequestBody, 0, sizeof(tdIORequestBody_t)); 903 904 /* setup task management structure */ 905 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 906 TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = currentTaskTag; 907 TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag; 908 909 /* let's initialize tdIOrequestBody */ 910 /* initialize jump table */ 911 912 /* direct callback for task management */ 913 TMtdIORequestBody->IOCompletionFunc = itdssTaskCompleted; 914 /* to be removed */ 915 /* TMtdIORequestBody->IOCompletionFunc = itdssIOCompleted; */ 916 917 /* initialize tiDevhandle */ 918 TMtdIORequestBody->tiDevHandle = tiDeviceHandle; 919 920 /* initialize tiIORequest */ 921 TMtdIORequestBody->tiIORequest = currentTaskTag; 922 /* save context if we need to abort later */ 923 currentTaskTag->tdData = TMtdIORequestBody; 924 925 /* initialize agIORequest */ 926 agIORequest = &(TMtdIORequestBody->agIORequest); 927 agIORequest->osData = (void *) TMtdIORequestBody; 928 agIORequest->sdkData = agNULL; /* SA takes care of this */ 929 930 /* request type */ 931 agRequestType = AGSA_SSP_TASK_MGNT_REQ; 932 TMtdIORequestBody->agRequestType = AGSA_SSP_TASK_MGNT_REQ; 933 /* 934 initialize 935 tdIORequestBody_t tdIORequestBody -> agSASRequestBody 936 */ 937 agSASRequestBody = &(TMtdIORequestBody->transport.SAS.agSASRequestBody); 938 agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq); 939 940 TI_DBG2(("tiINITaskManagement: did %d LUN reset for SAS\n", oneDeviceData->id)); 941 /* fill up LUN field */ 942 if (lun == agNULL) 943 { 944 osti_memset(agSSPTaskMgntRequest->lun, 0, 8); 945 } 946 else 947 { 948 osti_memcpy(agSSPTaskMgntRequest->lun, lun->lun, 8); 949 } 950 951 /* default: unconditionally set device state to SA_DS_IN_RECOVERY 952 bit1 (DS) bit0 (ADS) 953 bit1: 1 bit0: 0 954 */ 955 agSSPTaskMgntRequest->tmOption = 2; 956 957 /* sets taskMgntFunction field */ 958 switch(task) 959 { 960 case AG_ABORT_TASK: 961 agSSPTaskMgntRequest->taskMgntFunction = AGSA_ABORT_TASK; 962 /* For abort task management, unconditionally set device state to SA_DS_IN_RECOVERY 963 and if can't find, set device state to SA_DS_IN_RECOVERY 964 bit1 (DS) bit0 (ADS) 965 bit1: 1; bit0: 1 966 */ 967 agSSPTaskMgntRequest->tmOption = 3; 968 break; 969 case AG_ABORT_TASK_SET: 970 agSSPTaskMgntRequest->taskMgntFunction = AGSA_ABORT_TASK_SET; 971 break; 972 case AG_CLEAR_ACA: 973 agSSPTaskMgntRequest->taskMgntFunction = AGSA_CLEAR_ACA; 974 break; 975 case AG_CLEAR_TASK_SET: 976 agSSPTaskMgntRequest->taskMgntFunction = AGSA_CLEAR_TASK_SET; 977 break; 978 case AG_LOGICAL_UNIT_RESET: 979 agSSPTaskMgntRequest->taskMgntFunction = AGSA_LOGICAL_UNIT_RESET; 980 break; 981 case AG_QUERY_TASK: 982 agSSPTaskMgntRequest->taskMgntFunction = AGSA_QUERY_TASK; 983 break; 984 default: 985 TI_DBG1(("tiINITaskManagement: notImplemented task\n")); 986 break; 987 } 988 989 if (task == AGSA_ABORT_TASK || task == AGSA_QUERY_TASK) 990 { 991 /* set agTMRequest, which is IO being task managed */ 992 tdIORequestBody = (tdIORequestBody_t *)taskTag->tdData; 993 if (tdIORequestBody == agNULL) 994 { 995 /* to be aborted IO has been completed. */ 996 /* free up allocated memory */ 997 TI_DBG1(("tiINITaskManagement: IO has been completed\n")); 998 ostiFreeMemory( 999 tiRoot, 1000 osMemHandle, 1001 sizeof(tdIORequestBody_t) 1002 ); 1003 return tiIONoDevice; 1004 } 1005 else 1006 { 1007 agTMRequest = &(tdIORequestBody->agIORequest); 1008 } 1009 } 1010 else 1011 { 1012 /* 1013 For LUN RESET, WARM_RESET, ABORT_TASK_SET, CLEAR_ACA and CLEAR_TASK_SET 1014 no tag to be managed. 1015 Therefore, set it to zero. 1016 */ 1017 agSSPTaskMgntRequest->tagOfTaskToBeManaged = 0; 1018 agTMRequest = agNULL; 1019 1020 } 1021 1022 TDLIST_INIT_HDR(&TMtdIORequestBody->EsglPageList); 1023 /* debuggging */ 1024 if (TMtdIORequestBody->IOCompletionFunc == agNULL) 1025 { 1026 TI_DBG1(("tiINITaskManagement: Error!!!!! IOCompletionFunc is NULL\n")); 1027 } 1028 saStatus = saSSPStart(agRoot, 1029 agIORequest, /* task management itself */ 1030 tdsaRotateQnumber(tiRoot, oneDeviceData), 1031 agDevHandle, 1032 agRequestType, 1033 agSASRequestBody, /* task management itself */ 1034 agTMRequest, /* io to be aborted if exits */ 1035 &ossaSSPCompleted); 1036 1037 1038 if (saStatus == AGSA_RC_SUCCESS) 1039 { 1040 Initiator->NumIOsActive++; 1041 tiStatus = tiSuccess; 1042 } 1043 else 1044 { 1045 TI_DBG1(("tiINITaskManagement: saSSPStart failed 0x%x\n",saStatus)); 1046 /* free up allocated memory */ 1047 ostiFreeMemory( 1048 tiRoot, 1049 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 1050 sizeof(tdIORequestBody_t) 1051 ); 1052 if (saStatus == AGSA_RC_FAILURE) 1053 { 1054 tiStatus = tiError; 1055 } 1056 else 1057 { 1058 /* AGSA_RC_BUSY */ 1059 tiStatus = tiBusy; 1060 } 1061 } 1062 } 1063 } /* end of sas device */ 1064 1065 #ifdef FDS_SM 1066 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1067 { 1068 agsaContext_t *agContext = agNULL; 1069 1070 /* save the task tag in tdsaDeviceData_t structure, for handling PORT_RESET_COMPLETE hw event */ 1071 agContext = &(oneDeviceData->agDeviceResetContext); 1072 agContext->osData = currentTaskTag; 1073 1074 #ifdef REMOVED 1075 /* for directly attached SATA, do localphycontrol for LUN and target reset, not smTaskManagement*/ 1076 if (oneDeviceData->directlyAttached == agTRUE && 1077 (task == AG_LOGICAL_UNIT_RESET || task == AG_TARGET_WARM_RESET)) 1078 { 1079 agRoot = oneDeviceData->agRoot; 1080 agDevHandle = oneDeviceData->agDevHandle; 1081 1082 currentTaskTag->tdData = oneDeviceData; 1083 1084 if (task == AG_LOGICAL_UNIT_RESET) 1085 { 1086 if ( (lun->lun[0] | lun->lun[1] | lun->lun[2] | lun->lun[3] | 1087 lun->lun[4] | lun->lun[5] | lun->lun[6] | lun->lun[7] ) != 0 ) 1088 { 1089 TI_DBG1(("tiINITaskManagement: *** REJECT *** LUN not zero, tiDeviceHandle=%p\n", 1090 tiDeviceHandle)); 1091 return tiError; 1092 } 1093 } 1094 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_IN_RECOVERY); 1095 tiStatus = saLocalPhyControl(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL); 1096 } 1097 else 1098 #endif 1099 { 1100 smRoot = &(tdsaAllShared->smRoot); 1101 smDeviceHandle = &(oneDeviceData->smDeviceHandle); 1102 TI_DBG1(("tiINITaskManagement: FDS_SM SATA Device\n")); 1103 1104 if ( taskTag != agNULL) 1105 { 1106 ToBeAbortedtdIORequestBody = (tdIORequestBody_t *)taskTag->tdData; 1107 ToBeAborted = &(ToBeAbortedtdIORequestBody->smIORequest); 1108 } 1109 SMmemAllocStatus = ostiAllocMemory( 1110 tiRoot, 1111 &SMosMemHandle, 1112 (void **)&SMTMtdIORequestBody, 1113 &SMPhysUpper32, 1114 &SMPhysLower32, 1115 8, 1116 sizeof(tdIORequestBody_t), 1117 agTRUE 1118 ); 1119 if (SMmemAllocStatus != tiSuccess) 1120 { 1121 TI_DBG1(("tiINITaskManagement: ostiAllocMemory failed... loc 2\n")); 1122 return tiError; 1123 } 1124 1125 if (SMTMtdIORequestBody == agNULL) 1126 { 1127 TI_DBG1(("tiINITaskManagement: ostiAllocMemory returned NULL TMIORequestBody loc 2\n")); 1128 return tiError; 1129 } 1130 1131 /* initialize */ 1132 osti_memset(SMTMtdIORequestBody, 0, sizeof(tdIORequestBody_t)); 1133 1134 /* setup task management structure */ 1135 SMTMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = SMosMemHandle; 1136 SMTMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = currentTaskTag; 1137 SMTMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag; 1138 1139 /* initialize tiDevhandle */ 1140 SMTMtdIORequestBody->tiDevHandle = tiDeviceHandle; 1141 1142 /* initialize tiIORequest */ 1143 SMTMtdIORequestBody->tiIORequest = currentTaskTag; 1144 /* save context if we need to abort later */ 1145 currentTaskTag->tdData = SMTMtdIORequestBody; 1146 1147 TaskManagement = &(SMTMtdIORequestBody->smIORequest); 1148 1149 TaskManagement->tdData = SMTMtdIORequestBody; 1150 TaskManagement->smData = &SMTMtdIORequestBody->smIORequestBody; 1151 1152 tiStatus = smTaskManagement(smRoot, 1153 smDeviceHandle, 1154 task, 1155 (smLUN_t*)lun, 1156 ToBeAborted, 1157 TaskManagement 1158 ); 1159 if (tiStatus != SM_RC_SUCCESS) 1160 { 1161 TI_DBG1(("tiINITaskManagement: smTaskManagement failed... loc 2\n")); 1162 /* free up allocated memory */ 1163 ostiFreeMemory( 1164 tiRoot, 1165 SMTMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 1166 sizeof(tdIORequestBody_t) 1167 ); 1168 } 1169 } /* else */ 1170 } 1171 #else 1172 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1173 { 1174 agRoot = oneDeviceData->agRoot; 1175 agDevHandle = oneDeviceData->agDevHandle; 1176 TI_DBG1(("tiINITaskManagement: not FDS_SM SATA Device\n")); 1177 /* 1178 WARM_RESET is experimental 1179 Needs more testing and debugging 1180 Soft reset for SATA as LUN RESET tends not to work. 1181 Let's do hard reset 1182 */ 1183 if (task == AG_LOGICAL_UNIT_RESET || task == AG_TARGET_WARM_RESET) 1184 { 1185 1186 agsaContext_t *agContext; 1187 satDeviceData_t *satDevData; 1188 tdsaDeviceData_t *tdsaDeviceData; 1189 1190 TI_DBG2(("tiINITaskManagement: did %d LUN reset or device reset for SATA\n", oneDeviceData->id)); 1191 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1192 satDevData = &tdsaDeviceData->satDevData; 1193 currentTaskTag->tdData = tdsaDeviceData; 1194 agContext = &(tdsaDeviceData->agDeviceResetContext); 1195 agContext->osData = currentTaskTag; 1196 1197 1198 if (task == AG_LOGICAL_UNIT_RESET) 1199 { 1200 if ( (lun->lun[0] | lun->lun[1] | lun->lun[2] | lun->lun[3] | 1201 lun->lun[4] | lun->lun[5] | lun->lun[6] | lun->lun[7] ) != 0 ) 1202 { 1203 TI_DBG1(("tiINITaskManagement: *** REJECT *** LUN not zero, tiDeviceHandle=%p\n", 1204 tiDeviceHandle)); 1205 return tiError; 1206 } 1207 1208 /* 1209 * Check if there is other TM request pending 1210 */ 1211 if (satDevData->satTmTaskTag != agNULL) 1212 { 1213 TI_DBG1(("tiINITaskManagement: *** REJECT *** other TM pending, tiDeviceHandle=%p\n", 1214 tiDeviceHandle)); 1215 return tiError; 1216 } 1217 } 1218 satDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 1219 satDevData->satAbortAfterReset = agFALSE; 1220 1221 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_IN_RECOVERY); 1222 1223 /* 1224 warm reset by saLocalPhyControl or SMP PHY control 1225 */ 1226 if (oneDeviceData->directlyAttached == agTRUE) 1227 { 1228 TI_DBG1(("tiINITaskManagement: LUN reset or device reset directly attached\n")); 1229 saLocalPhyControl(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL); 1230 return tiSuccess; 1231 } 1232 else 1233 { 1234 TI_DBG1(("tiINITaskManagement: LUN reset or device reset expander attached\n")); 1235 saStatus = tdsaPhyControlSend(tiRoot, 1236 oneDeviceData, 1237 SMP_PHY_CONTROL_HARD_RESET, 1238 currentTaskTag, 1239 tdsaRotateQnumber(tiRoot, oneDeviceData) 1240 ); 1241 return saStatus; 1242 } 1243 } 1244 else 1245 { 1246 TI_DBG2(("tiINITaskManagement: calling satTM().\n")); 1247 /* allocation tdIORequestBody and pass it to satTM() */ 1248 memAllocStatus = ostiAllocMemory( 1249 tiRoot, 1250 &osMemHandle, 1251 (void **)&TMtdIORequestBody, 1252 &PhysUpper32, 1253 &PhysLower32, 1254 8, 1255 sizeof(tdIORequestBody_t), 1256 agTRUE 1257 ); 1258 1259 if (memAllocStatus != tiSuccess) 1260 { 1261 TI_DBG1(("tiINITaskManagement: ostiAllocMemory failed... loc 2\n")); 1262 return tiError; 1263 } 1264 1265 if (TMtdIORequestBody == agNULL) 1266 { 1267 TI_DBG1(("tiINITaskManagement: ostiAllocMemory returned NULL TMIORequestBody loc 2\n")); 1268 return tiError; 1269 1270 } 1271 1272 /* initialize */ 1273 osti_memset(TMtdIORequestBody, 0, sizeof(tdIORequestBody_t)); 1274 1275 /* setup task management structure */ 1276 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 1277 TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = currentTaskTag; 1278 TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag; 1279 1280 /* initialize tiDevhandle */ 1281 TMtdIORequestBody->tiDevHandle = tiDeviceHandle; 1282 1283 /* initialize tiIORequest */ 1284 TMtdIORequestBody->tiIORequest = currentTaskTag; 1285 /* save context if we need to abort later */ 1286 currentTaskTag->tdData = TMtdIORequestBody; 1287 1288 /* initialize agIORequest */ 1289 agIORequest = &(TMtdIORequestBody->agIORequest); 1290 agIORequest->osData = (void *) TMtdIORequestBody; 1291 agIORequest->sdkData = agNULL; /* SA takes care of this */ 1292 1293 1294 #ifdef SATA_ENABLE 1295 tiStatus = satTM( tiRoot, 1296 tiDeviceHandle, 1297 task, 1298 lun, 1299 taskTag, 1300 currentTaskTag, 1301 TMtdIORequestBody, 1302 agTRUE 1303 ); 1304 #endif 1305 } 1306 } 1307 #endif /* FDS_SM else*/ 1308 1309 return tiStatus; 1310 } 1311 #endif /* INITIATOR_DRIVER */ 1312 1313 #ifdef PASSTHROUGH 1314 osGLOBAL bit32 1315 tiCOMPassthroughCmndStart( 1316 tiRoot_t *tiRoot, 1317 tiPassthroughRequest_t *tiPassthroughRequest, 1318 tiDeviceHandle_t *tiDeviceHandle, 1319 tiPassthroughCmnd_t *tiPassthroughCmnd, 1320 void *tiPassthroughBody, 1321 tiPortalContext_t *tiportalContext, 1322 ostiPassthroughCmndEvent_t agEventCB 1323 ) 1324 { 1325 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1326 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1327 tdsaDeviceData_t *oneDeviceData; 1328 agsaRoot_t *agRoot = agNULL; 1329 agsaIORequest_t *agIORequest = agNULL; 1330 agsaDevHandle_t *agDevHandle = agNULL; 1331 bit32 agRequestType; 1332 agsaSASRequestBody_t *agSASRequestBody = agNULL; 1333 1334 tdPassthroughCmndBody_t *tdPTCmndBody; 1335 tdssSMPRequestBody_t *tdssSMPRequestBody; 1336 agsaSMPFrame_t *agSMPFrame; 1337 agsaSSPVSFrame_t *agSSPVendorFrame; /* RMC */ 1338 bit32 SMPFn, SMPFnResult, SMPFrameLen; 1339 bit32 tiStatus = tiError; 1340 bit32 saStatus = AGSA_RC_FAILURE; 1341 tdsaPortStartInfo_t *tdsaPortStartInfo; 1342 tdsaPortContext_t *tdsaPortContext; 1343 1344 TI_DBG2(("tiCOMPassthroughCmndStart: start\n")); 1345 1346 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1347 1348 TI_DBG6(("tiCOMPassthroughCmndStart: onedevicedata %p\n", oneDeviceData)); 1349 1350 1351 tdPTCmndBody = (tdPassthroughCmndBody_t *)tiPassthroughBody; 1352 1353 1354 if (tiPassthroughCmnd->passthroughCmnd != tiSMPCmnd || 1355 tiPassthroughCmnd->passthroughCmnd != tiRMCCmnd) 1356 { 1357 return tiNotSupported; 1358 } 1359 1360 1361 if (oneDeviceData == agNULL && tiPassthroughCmnd->passthroughCmnd != tiSMPCmnd) 1362 { 1363 TI_DBG1(("tiCOMPassthroughCmndStart: tiDeviceHandle=%p DeviceData is NULL\n", tiDeviceHandle )); 1364 return tiIONoDevice; 1365 } 1366 1367 /* starting IO with SAS device */ 1368 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 1369 { 1370 if (tiPassthroughCmnd->passthroughCmnd == tiSMPCmnd) 1371 { 1372 TI_DBG2(("tiCOMPassthroughCmndStart: SMP\n")); 1373 if (oneDeviceData == agNULL) 1374 { 1375 tdsaPortStartInfo = (tdsaPortStartInfo_t *)tiportalContext->tdData; 1376 tdsaPortContext = tdsaPortStartInfo->portContext; 1377 agRoot = tdsaPortContext->agRoot; 1378 } 1379 else 1380 { 1381 agRoot = oneDeviceData->agRoot; 1382 agDevHandle = oneDeviceData->agDevHandle; 1383 } 1384 1385 1386 tdssSMPRequestBody = &(tdPTCmndBody->protocol.SMP.SMPBody); 1387 agSASRequestBody = &(tdssSMPRequestBody->agSASRequestBody); 1388 agSMPFrame = &(agSASRequestBody->smpFrame); 1389 1390 /* saves callback function */ 1391 tdPTCmndBody->EventCB = agEventCB; 1392 1393 /* initialize command type */ 1394 tdPTCmndBody->tiPassthroughCmndType = tiSMPCmnd; 1395 1396 /* initialize tipassthroughrequest */ 1397 tdPTCmndBody->tiPassthroughRequest = tiPassthroughRequest; 1398 tiPassthroughRequest->tdData = tdPTCmndBody; 1399 1400 /* initialize tiDevhandle */ 1401 tdPTCmndBody->tiDevHandle = tiDeviceHandle; 1402 1403 /* fill in SMP header */ 1404 agSMPFrame->frameHeader.smpFrameType 1405 = tiPassthroughCmnd->protocol.SMP.SMPHeader.smpFrameType; 1406 agSMPFrame->frameHeader.smpFunction 1407 = tiPassthroughCmnd->protocol.SMP.SMPHeader.smpFunction; 1408 agSMPFrame->frameHeader.smpFunctionResult 1409 = tiPassthroughCmnd->protocol.SMP.SMPHeader.smpFunctionResult; 1410 agSMPFrame->frameHeader.smpReserved 1411 = tiPassthroughCmnd->protocol.SMP.SMPHeader.smpReserved; 1412 1413 if (tiPassthroughCmnd->protocol.SMP.IT == SMP_INITIATOR) 1414 { 1415 agRequestType = AGSA_SMP_INIT_REQ; 1416 } 1417 else 1418 { 1419 agRequestType = AGSA_SMP_TGT_RESPONSE; 1420 /* this is only for SMP target */ 1421 agSMPFrame->phyId = tiPassthroughCmnd->protocol.SMP.phyID; 1422 } 1423 1424 /* fill in payload */ 1425 /* assumption: SMP payload is in tisgl1 */ 1426 agSMPFrame->frameAddrUpper32 = tiPassthroughCmnd->tiSgl.upper; 1427 agSMPFrame->frameAddrLower32 = tiPassthroughCmnd->tiSgl.lower; 1428 1429 /* This length excluding SMP header (4 bytes) and CRC field */ 1430 agSMPFrame->frameLen = tiPassthroughCmnd->tiSgl.len; 1431 1432 /* initialize agIORequest */ 1433 /* 1434 Compare: 1435 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 1436 */ 1437 agIORequest = &(tdssSMPRequestBody->agIORequest); 1438 agIORequest->osData = (void *) tdPTCmndBody; 1439 agIORequest->sdkData = agNULL; /* LL takes care of this */ 1440 1441 1442 1443 /* not work yet because of high priority q */ 1444 saStatus = saSMPStart( 1445 agRoot, 1446 agIORequest, 1447 agDevHandle, 1448 agRequestType, 1449 agSASRequestBody, 1450 &ossaSMPCompleted 1451 ); 1452 1453 if (saStatus == AGSA_RC_SUCCESS) 1454 { 1455 tiStatus = tiSuccess; 1456 } 1457 else if (saStatus == AGSA_RC_FAILURE) 1458 { 1459 TI_DBG1(("tiCOMPassthroughCmndStart: saSMPStart failed\n")); 1460 tiStatus = tiError; 1461 } 1462 else 1463 { 1464 /* AGSA_RC_BUSY */ 1465 TI_DBG1(("tiCOMPassthroughCmndStart: saSMPStart busy\n")); 1466 tiStatus = tiBusy; 1467 } 1468 return tiStatus; 1469 1470 1471 #ifdef TO_DO 1472 /* fill in SMP header */ 1473 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1474 { 1475 agSMPFrame->frameHeader.smpFrameType = SMP_REQUEST; /* SMP REQUEST */ 1476 agRequestType = AGSA_SMP_INIT_REQ; 1477 } 1478 else 1479 { 1480 /* SMP target */ 1481 agSMPFrame->frameHeader.smpFrameType = SMP_RESPONSE; /* SMP RESPONSE */ 1482 agRequestType = AGSA_SMP_TGT_RESPONSE; 1483 switch (tdPTCmndBody->protocol.SMP.SMPFnResult) 1484 { 1485 case tiSMPFunctionAccepted: 1486 SMPFnResult = SMP_FUNCTION_ACCEPTED; 1487 break; 1488 case tiUnknownSMPFunction: 1489 SMPFnResult = UNKNOWN_SMP_FUNCTION; 1490 break; 1491 case tiSMPFunctionFailed: 1492 SMPFnResult = SMP_FUNCTION_FAILED; 1493 break; 1494 case tiInvalidRequestFrameLength: 1495 SMPFnResult = INVALID_REQUEST_FRAME_LENGTH; 1496 break; 1497 case tiPhyDoesNotExist: 1498 SMPFnResult =PHY_DOES_NOT_EXIST; 1499 break; 1500 case tiIndexDoesNotExist: 1501 SMPFnResult = INDEX_DOES_NOT_EXIST; 1502 break; 1503 case tiPhyDoesNotSupportSATA: 1504 SMPFnResult = PHY_DOES_NOT_SUPPORT_SATA; 1505 break; 1506 case tiUnknownPhyOperation: 1507 SMPFnResult = UNKNOWN_PHY_OPERATION; 1508 break; 1509 case tiUnknownPhyTestFunction: 1510 SMPFnResult = UNKNOWN_PHY_TEST_FUNCTION; 1511 break; 1512 case tiPhyTestFunctionInProgress: 1513 SMPFnResult = PHY_TEST_FUNCTION_IN_PROGRESS; 1514 break; 1515 case tiPhyVacant: 1516 SMPFnResult = PHY_VACANT; 1517 break; 1518 1519 default: 1520 TI_DBG1(("tiCOMPassthroughCmndStart: unknown SMP function result %d\n", tdPTCmndBody->protocol.SMP.SMPFnResult)); 1521 return tiError; 1522 } 1523 agSMPFrame->frameHeader.smpFunctionResult = SMPFnResult; 1524 } 1525 1526 /* common */ 1527 switch (tdPTCmndBody->protocol.SMP.SMPFn) 1528 { 1529 case tiGeneral: 1530 SMPFn = SMP_REPORT_GENERAL; 1531 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1532 { 1533 SMPFrameLen = 0; 1534 } 1535 else 1536 { 1537 SMPFrameLen = sizeof(smpRespReportGeneral_t); 1538 } 1539 break; 1540 1541 case tiManufacturerInfo: 1542 SMPFn = SMP_REPORT_MANUFACTURE_INFORMATION; 1543 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1544 { 1545 SMPFrameLen = 0; 1546 } 1547 else 1548 { 1549 SMPFrameLen = sizeof(smpRespReportManufactureInfo_t); 1550 } 1551 break; 1552 1553 case tiDiscover: 1554 SMPFn = SMP_DISCOVER; 1555 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1556 { 1557 SMPFrameLen = sizeof(smpReqDiscover_t); 1558 } 1559 else 1560 { 1561 SMPFrameLen = sizeof(smpRespDiscover_t); 1562 } 1563 break; 1564 1565 case tiReportPhyErrLog: 1566 SMPFn = SMP_REPORT_PHY_ERROR_LOG; 1567 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1568 { 1569 SMPFrameLen = 8; 1570 } 1571 else 1572 { 1573 SMPFrameLen = 24; 1574 } 1575 break; 1576 1577 case tiReportPhySATA: 1578 SMPFn = SMP_REPORT_PHY_SATA; 1579 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1580 { 1581 SMPFrameLen = sizeof(SmpReqReportPhySata_t); 1582 } 1583 else 1584 { 1585 SMPFrameLen = sizeof(SmpRespReportPhySata_t); 1586 } 1587 break; 1588 1589 case tiReportRteInfo: 1590 SMPFn = SMP_REPORT_ROUTING_INFORMATION; 1591 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1592 { 1593 SMPFrameLen = sizeof(SmpReqReportRouteTable_t); 1594 } 1595 else 1596 { 1597 SMPFrameLen = sizeof(SmpRespReportRouteTable_t); 1598 } 1599 break; 1600 1601 case tiConfigureRteInfo: 1602 SMPFn = SMP_CONFIGURE_ROUTING_INFORMATION; 1603 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1604 { 1605 SMPFrameLen = sizeof(SmpReqConfigureRouteInformation_t); 1606 } 1607 else 1608 { 1609 SMPFrameLen = 0; 1610 } 1611 break; 1612 1613 case tiPhyCtrl: 1614 SMPFn = SMP_PHY_CONTROL; 1615 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1616 { 1617 SMPFrameLen = sizeof(SmpReqPhyControl_t); 1618 } 1619 else 1620 { 1621 SMPFrameLen = 0; 1622 } 1623 break; 1624 1625 case tiPhyTestFn: 1626 SMPFn = SMP_PHY_TEST_FUNCTION; 1627 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1628 { 1629 SMPFrameLen = 36; 1630 } 1631 else 1632 { 1633 SMPFrameLen = 0; 1634 } 1635 break; 1636 1637 case tiPMC: 1638 SMPFn = SMP_PMC_SPECIFIC; 1639 if (tdPTCmndBody->protocol.SMP.IT == SMP_INITIATOR) 1640 { 1641 SMPFrameLen = 0; 1642 } 1643 else 1644 { 1645 SMPFrameLen = 0; 1646 } 1647 break; 1648 1649 1650 default: 1651 TI_DBG1(("tiCOMPassthroughCmndStart: unknown SMP function %d\n", tdPTCmndBody->protocol.SMP.SMPFn)); 1652 return tiError; 1653 } 1654 agSMPFrame->frameHeader.smpFunction = SMPFn; 1655 1656 1657 /* assumption: SMP payload is in tisgl1 */ 1658 agSMPFrame->frameAddrUpper32 = tdPTCmndBody->tiSgl.upper; 1659 agSMPFrame->frameAddrLower32 = tdPTCmndBody->tiSgl.lower; 1660 1661 /* This length excluding SMP header (4 bytes) and CRC field */ 1662 agSMPFrame->frameLen = SMPFrameLen; 1663 1664 1665 1666 1667 1668 1669 #endif 1670 1671 1672 } 1673 else if (tiPassthroughCmnd->passthroughCmnd == tiRMCCmnd) 1674 { 1675 TI_DBG2(("tiCOMPassthroughCmndStart: RMC\n")); 1676 } 1677 else 1678 { 1679 TI_DBG1(("tiCOMPassthroughCmndStart: unknown protocol %d\n", tiPassthroughCmnd->passthroughCmnd)); 1680 } 1681 1682 1683 } 1684 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 1685 { 1686 TI_DBG1(("tiCOMPassthroughCmndStart: error !!! no SATA support\n")); 1687 return tiError; 1688 } 1689 else 1690 { 1691 TI_DBG1(("tiCOMPassthroughCmndStart: error !!! unknown devietype %d\n", oneDeviceData->DeviceType)); 1692 return tiError; 1693 1694 } 1695 1696 return tiSuccess; 1697 } 1698 1699 1700 osGLOBAL bit32 1701 tiCOMPassthroughCmndAbort( 1702 tiRoot_t *tiRoot, 1703 tiPassthroughRequest_t *taskTag 1704 ) 1705 { 1706 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1707 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1708 agsaRoot_t *agRoot = agNULL; 1709 tdPassthroughCmndBody_t *tdPTCmndBody = agNULL; 1710 tdssSMPRequestBody_t *tdssSMPRequestBody = agNULL; 1711 agsaIORequest_t *agIORequest = agNULL; 1712 bit32 saStatus, tiStatus = tiError; 1713 1714 TI_DBG2(("tiCOMPassthroughCmndAbort: start\n")); 1715 1716 agRoot = &(tdsaAllShared->agRootNonInt); 1717 tdPTCmndBody = (tdPassthroughCmndBody_t *)taskTag->tdData; 1718 1719 if (tdPTCmndBody->tiPassthroughCmndType == tiSMPCmnd) 1720 { 1721 tdssSMPRequestBody = &(tdPTCmndBody->protocol.SMP.SMPBody); 1722 agIORequest = &(tdssSMPRequestBody->agIORequest); 1723 1724 saStatus = saSMPAbort(agRoot, agIORequest); 1725 1726 if (saStatus == AGSA_RC_SUCCESS) 1727 { 1728 tiStatus = tiSuccess; 1729 } 1730 else if (saStatus == AGSA_RC_FAILURE) 1731 { 1732 TI_DBG1(("tiCOMPassthroughCmndAbort: saSMPAbort failed\n")); 1733 tiStatus = tiError; 1734 } 1735 else 1736 { 1737 /* AGSA_RC_BUSY */ 1738 TI_DBG1(("tiCOMPassthroughCmndAbort: saSMPAbort busy\n")); 1739 tiStatus = tiBusy; 1740 } 1741 return tiStatus; 1742 } 1743 else if (tdPTCmndBody->tiPassthroughCmndType == tiRMCCmnd) 1744 { 1745 TI_DBG1(("tiCOMPassthroughCmndAbort: RMC passthrough command type, not yet\n")); 1746 1747 } 1748 else 1749 { 1750 TI_DBG1(("tiCOMPassthroughCmndAbort: unknown passthrough command type %d\n", tdPTCmndBody->tiPassthroughCmndType)); 1751 return tiStatus; 1752 } 1753 1754 1755 } 1756 1757 osGLOBAL bit32 1758 tiINIPassthroughCmndRemoteAbort( 1759 tiRoot_t *tiRoot, 1760 tiDeviceHandle_t *tiDeviceHandle, 1761 tiPassthroughRequest_t *taskTag, 1762 tiPassthroughRequest_t *currentTaskTag, 1763 tiPortalContext_t *tiportalContext 1764 ) 1765 { 1766 TI_DBG2(("tiINIPassthroughCmndRemoteAbort: start\n")); 1767 /* 1768 for SMP, nothing. Can't abot remotely 1769 */ 1770 return tiSuccess; 1771 } 1772 #endif /* PASSTHROUGH */ 1773 1774 1775 /***************************************************************************** 1776 *! \brief tiCOMShutDown 1777 * 1778 * Purpose: This function is called to shutdown the initiator and/or target 1779 * operation. Following the completion of this call, the state is 1780 * equivalent to the state prior to tiCOMInit() 1781 * 1782 * \param tiRoot: Pointer to root data structure. 1783 * 1784 * \return None 1785 * 1786 * 1787 *****************************************************************************/ 1788 osGLOBAL void 1789 tiCOMShutDown( tiRoot_t *tiRoot) 1790 { 1791 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1792 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1793 1794 // #define TI_GETFOR_ONSHUTDOWN 1795 #ifdef TI_GETFOR_ONSHUTDOWN 1796 agsaForensicData_t forensicData; 1797 bit32 once = 1; 1798 bit32 status; 1799 #endif /* TI_GETFOR_ONSHUTDOWN */ 1800 1801 agsaRoot_t *agRoot = agNULL; 1802 1803 TI_DBG1(("tiCOMShutDown: start\n")); 1804 1805 1806 agRoot = &(tdsaAllShared->agRootNonInt); 1807 /* 1808 1. free up cardID 1809 2. call saHwShutdown() 1810 3. tdInitEsgl(tiRoot); 1811 4. tdsaResetComMemFlags(tiRoot) 1812 5. ostiPortEvent() 1813 */ 1814 1815 tdsaFreeCardID(tiRoot, tdsaAllShared->CardID); 1816 1817 #ifdef TI_GETFOR_ONSHUTDOWN 1818 forensicData.DataType = TYPE_NON_FATAL; 1819 forensicData.dataBuf.directLen = (8 * 1024); 1820 forensicData.dataBuf.directOffset = 0; /* current offset */ 1821 forensicData.dataBuf.directData = agNULL; 1822 forensicData.dataBuf.readLen = 0; /* Data read */ 1823 1824 getmoreData: 1825 status = saGetForensicData( agRoot, agNULL, &forensicData); 1826 1827 TI_DBG1(("tiCOMShutDown:readLen 0x%x directLen 0x%x directOffset 0x%x\n", 1828 forensicData.dataBuf.readLen, 1829 forensicData.dataBuf.directLen, 1830 forensicData.dataBuf.directOffset)); 1831 if( forensicData.dataBuf.readLen == forensicData.dataBuf.directLen && !status && once) 1832 { 1833 goto getmoreData; 1834 } 1835 1836 TI_DBG1(("tiCOMShutDown:saGetForensicData type %d read 0x%x bytes\n", forensicData.DataType, forensicData.dataBuf.directOffset )); 1837 #endif /* TI_GETFOR_ONSHUTDOWN */ 1838 1839 saHwShutdown(agRoot); 1840 1841 /* resets all the relevant flags */ 1842 tdsaResetComMemFlags(tiRoot); 1843 1844 /* 1845 * send an event to the oslayer 1846 */ 1847 ostiPortEvent ( 1848 tiRoot, 1849 tiPortShutdown, 1850 tiSuccess, 1851 agNULL 1852 ); 1853 1854 return; 1855 } 1856 1857 #ifdef INITIATOR_DRIVER 1858 osGLOBAL void 1859 tiINITimerTick( tiRoot_t *tiRoot ) 1860 { 1861 /* 1862 no timer is used in SAS TD layer. 1863 Therefore, this function is null. 1864 */ 1865 // TI_DBG2(("tiINITimerTick: start\n")); 1866 /*itdsaProcessTimers(tiRoot);*/ 1867 return; 1868 } 1869 #endif 1870 1871 /*****************************************************************************/ 1872 /*! \brief ossaDisableInterrupts 1873 * 1874 * 1875 * Purpose: This routine is called to disable interrupt 1876 * 1877 * 1878 * \param agRoot: Pointer to chip/driver Instance. 1879 * \param outboundChannelNum: Zero-base channel number 1880 * 1881 * 1882 * \return None. 1883 * 1884 * \note - The scope is shared target and initiator. 1885 * 1886 */ 1887 /*****************************************************************************/ 1888 #ifndef ossaDisableInterrupts 1889 osGLOBAL void 1890 ossaDisableInterrupts( 1891 agsaRoot_t *agRoot, 1892 bit32 outboundChannelNum 1893 ) 1894 { 1895 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 1896 1897 ostiInterruptDisable( 1898 osData->tiRoot, 1899 outboundChannelNum 1900 ); 1901 return; 1902 } 1903 1904 #endif 1905 1906 1907 osGLOBAL void 1908 tiCOMFrameReadBlock( 1909 tiRoot_t *tiRoot, 1910 void *agFrame, 1911 bit32 FrameOffset, 1912 void *FrameBuffer, 1913 bit32 FrameBufLen ) 1914 { 1915 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1916 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1917 agsaRoot_t *agRoot = agNULL; 1918 1919 TI_DBG6(("tiCOMFrameReadBlock: start\n")); 1920 1921 1922 agRoot = &(tdsaAllShared->agRootNonInt); 1923 1924 1925 TI_DBG6(("tiCOMFrameReadBlock: start\n")); 1926 1927 saFrameReadBlock(agRoot, agFrame, FrameOffset, FrameBuffer, FrameBufLen); 1928 1929 return; 1930 } 1931 1932 1933 1934 /***************************************************************************** 1935 *! \brief tiINITransportRecovery 1936 * 1937 * Purpose: This routine is called to explicitly ask the Transport Dependent 1938 * Layer to initiate the recovery for the transport/protocol specific 1939 * error for a specific device connection. 1940 * 1941 * \param tiRoot: Pointer to driver instance 1942 * \param tiDeviveHandle: Pointer to the device handle for this session. 1943 * 1944 * \return: None 1945 * 1946 * 1947 *****************************************************************************/ 1948 #ifdef INITIATOR_DRIVER 1949 osGLOBAL void 1950 tiINITransportRecovery ( 1951 tiRoot_t *tiRoot, 1952 tiDeviceHandle_t *tiDeviceHandle 1953 ) 1954 { 1955 agsaRoot_t *agRoot = agNULL; 1956 tdsaDeviceData_t *oneDeviceData = agNULL; 1957 tdsaPortContext_t *onePortContext = agNULL; 1958 tiPortalContext_t *tiPortalContext = agNULL; 1959 tiIORequest_t *currentTaskTag; 1960 agsaDevHandle_t *agDevHandle = agNULL; 1961 1962 TI_DBG1(("tiINITransportRecovery: start\n")); 1963 1964 if (tiDeviceHandle == agNULL) 1965 { 1966 TI_DBG1(("tiINITransportRecovery: tiDeviceHandle is NULL\n")); 1967 1968 return; 1969 } 1970 1971 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 1972 1973 if (oneDeviceData == agNULL) 1974 { 1975 TI_DBG1(("tiINITransportRecovery: oneDeviceData is NULL\n")); 1976 return; 1977 } 1978 1979 /* for hotplug */ 1980 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 1981 oneDeviceData->tdPortContext == agNULL ) 1982 { 1983 TI_DBG1(("tiINITransportRecovery: NO Device did %d\n", oneDeviceData->id )); 1984 TI_DBG1(("tiINITransportRecovery: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 1985 TI_DBG1(("tiINITransportRecovery: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 1986 return; 1987 } 1988 1989 onePortContext = oneDeviceData->tdPortContext; 1990 1991 if (onePortContext == agNULL) 1992 { 1993 TI_DBG1(("tiINITransportRecovery: onePortContext is NULL\n")); 1994 return; 1995 } 1996 1997 tiPortalContext = onePortContext->tiPortalContext; 1998 currentTaskTag = &(oneDeviceData->TransportRecoveryIO); 1999 currentTaskTag->osData = agNULL; 2000 agRoot = oneDeviceData->agRoot; 2001 agDevHandle = oneDeviceData->agDevHandle; 2002 2003 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 2004 { 2005 agsaContext_t *agContext; 2006 currentTaskTag->tdData = oneDeviceData; 2007 agContext = &(oneDeviceData->agDeviceResetContext); 2008 agContext->osData = currentTaskTag; 2009 oneDeviceData->TRflag = agTRUE; 2010 2011 TI_DBG2(("tiINITransportRecovery: SAS device\n")); 2012 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_IN_RECOVERY); 2013 2014 if (oneDeviceData->directlyAttached == agTRUE) 2015 { 2016 TI_DBG2(("tiINITransportRecovery: saLocalPhyControl\n")); 2017 saLocalPhyControl(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL); 2018 ostiInitiatorEvent(tiRoot, 2019 tiPortalContext, 2020 tiDeviceHandle, 2021 tiIntrEventTypeTransportRecovery, 2022 tiRecStarted, 2023 agNULL 2024 ); 2025 2026 return; 2027 } 2028 else 2029 { 2030 TI_DBG2(("tiINITransportRecovery: device reset expander attached\n")); 2031 tdsaPhyControlSend(tiRoot, 2032 oneDeviceData, 2033 SMP_PHY_CONTROL_HARD_RESET, 2034 currentTaskTag, 2035 tdsaRotateQnumber(tiRoot, oneDeviceData) 2036 ); 2037 ostiInitiatorEvent(tiRoot, 2038 tiPortalContext, 2039 tiDeviceHandle, 2040 tiIntrEventTypeTransportRecovery, 2041 tiRecStarted, 2042 agNULL 2043 ); 2044 return; 2045 } 2046 } 2047 else if (oneDeviceData->DeviceType == TD_SATA_DEVICE) 2048 { 2049 agsaContext_t *agContext; 2050 currentTaskTag->tdData = oneDeviceData; 2051 agContext = &(oneDeviceData->agDeviceResetContext); 2052 agContext->osData = currentTaskTag; 2053 oneDeviceData->TRflag = agTRUE; 2054 2055 TI_DBG2(("tiINITransportRecovery: SATA device\n")); 2056 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_IN_RECOVERY); 2057 2058 if (oneDeviceData->directlyAttached == agTRUE) 2059 { 2060 TI_DBG2(("tiINITransportRecovery: saLocalPhyControl\n")); 2061 saLocalPhyControl(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), oneDeviceData->phyID, AGSA_PHY_LINK_RESET, agNULL); 2062 ostiInitiatorEvent(tiRoot, 2063 tiPortalContext, 2064 tiDeviceHandle, 2065 tiIntrEventTypeTransportRecovery, 2066 tiRecStarted, 2067 agNULL 2068 ); 2069 2070 return; 2071 } 2072 else 2073 { 2074 TI_DBG2(("tiINITransportRecovery: device reset expander attached\n")); 2075 tdsaPhyControlSend(tiRoot, 2076 oneDeviceData, 2077 SMP_PHY_CONTROL_LINK_RESET, 2078 currentTaskTag, 2079 tdsaRotateQnumber(tiRoot, oneDeviceData) 2080 ); 2081 ostiInitiatorEvent(tiRoot, 2082 tiPortalContext, 2083 tiDeviceHandle, 2084 tiIntrEventTypeTransportRecovery, 2085 tiRecStarted, 2086 agNULL 2087 ); 2088 return; 2089 } 2090 } 2091 else 2092 { 2093 TI_DBG1(("tiINITransportRecovery: wrong device type %d\n", oneDeviceData->DeviceType)); 2094 } 2095 2096 2097 return; 2098 } 2099 #endif 2100 2101 #if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER) 2102 /***************************************************************************** 2103 *! \brief tdsaPhyControlSend 2104 * 2105 * Purpose: This function sends Phy Control to a device. 2106 * 2107 * \param tiRoot: Pointer to the OS Specific module allocated tiRoot_t 2108 * instance. 2109 * \param oneDeviceData: Pointer to the device data. 2110 * \param phyId: Phy Identifier. 2111 * \param queueNumber: bits 0-15: inbound queue number. 2112 * bits 16-31: outbound queue number. 2113 * 2114 * \return: 2115 * Status 2116 * 2117 * \note: 2118 * 2119 *****************************************************************************/ 2120 /* phyop of interest 2121 SMP_PHY_CONTROL_HARD_RESET or SMP_PHY_CONTROL_CLEAR_AFFILIATION 2122 if CurrentTaskTag == agNULL, clear affiliation 2123 if CurrentTaskTag != agNULL, PHY_CONTROL (device reset) 2124 2125 */ 2126 osGLOBAL bit32 2127 tdsaPhyControlSend( 2128 tiRoot_t *tiRoot, 2129 tdsaDeviceData_t *oneDeviceData, /* taget disk */ 2130 bit8 phyOp, 2131 tiIORequest_t *CurrentTaskTag, 2132 bit32 queueNumber 2133 ) 2134 { 2135 return 0; 2136 } 2137 #endif 2138 2139 #ifdef TARGET_DRIVER 2140 /***************************************************************************** 2141 *! \brief tdsaPhyControlSend 2142 * 2143 * Purpose: This function sends Phy Control to a device. 2144 * 2145 * \param tiRoot: Pointer to the OS Specific module allocated tiRoot_t 2146 * instance. 2147 * \param oneDeviceData: Pointer to the device data. 2148 * \param phyId: Phy Identifier. 2149 * \param queueNumber: bits 0-15: inbound queue number. 2150 * bits 16-31: outbound queue number. 2151 * 2152 * \return: 2153 * Status 2154 * 2155 * \note: 2156 * 2157 *****************************************************************************/ 2158 /* phyop of interest 2159 SMP_PHY_CONTROL_HARD_RESET or SMP_PHY_CONTROL_CLEAR_AFFILIATION 2160 if CurrentTaskTag == agNULL, clear affiliation 2161 if CurrentTaskTag != agNULL, PHY_CONTROL (device reset) 2162 2163 */ 2164 osGLOBAL bit32 2165 tdsaPhyControlSend( 2166 tiRoot_t *tiRoot, 2167 tdsaDeviceData_t *oneDeviceData, /* taget disk */ 2168 bit8 phyOp, 2169 tiIORequest_t *CurrentTaskTag, 2170 bit32 queueNumber 2171 ) 2172 { 2173 return 0; 2174 } 2175 #endif 2176 2177 2178 #ifdef INITIATOR_DRIVER 2179 /***************************************************************************** 2180 *! \brief tdsaPhyControlSend 2181 * 2182 * Purpose: This function sends Phy Control to a device. 2183 * 2184 * \param tiRoot: Pointer to the OS Specific module allocated tiRoot_t 2185 * instance. 2186 * \param oneDeviceData: Pointer to the device data. 2187 * \param phyId: Phy Identifier. 2188 * \param queueNumber: bits 0-15: inbound queue number. 2189 * bits 16-31: outbound queue number. 2190 * 2191 * \return: 2192 * Status 2193 * 2194 * \note: 2195 * 2196 *****************************************************************************/ 2197 /* phyop of interest 2198 SMP_PHY_CONTROL_HARD_RESET or SMP_PHY_CONTROL_CLEAR_AFFILIATION 2199 if CurrentTaskTag == agNULL, clear affiliation 2200 if CurrentTaskTag != agNULL, PHY_CONTROL (device reset) 2201 2202 */ 2203 osGLOBAL bit32 2204 tdsaPhyControlSend( 2205 tiRoot_t *tiRoot, 2206 tdsaDeviceData_t *oneDeviceData, /* taget disk */ 2207 bit8 phyOp, 2208 tiIORequest_t *CurrentTaskTag, 2209 bit32 queueNumber 2210 ) 2211 { 2212 agsaRoot_t *agRoot; 2213 tdsaDeviceData_t *oneExpDeviceData; 2214 tdsaPortContext_t *onePortContext; 2215 smpReqPhyControl_t smpPhyControlReq; 2216 bit8 phyID; 2217 bit32 status; 2218 2219 TI_DBG3(("tdsaPhyControlSend: start\n")); 2220 2221 agRoot = oneDeviceData->agRoot; 2222 onePortContext = oneDeviceData->tdPortContext; 2223 oneExpDeviceData = oneDeviceData->ExpDevice; 2224 phyID = oneDeviceData->phyID; 2225 2226 if (oneDeviceData->directlyAttached == agTRUE) 2227 { 2228 TI_DBG1(("tdsaPhyControlSend: Error!!! deivce is directly attached\n")); 2229 return AGSA_RC_FAILURE; 2230 } 2231 if (onePortContext == agNULL) 2232 { 2233 TI_DBG1(("tdsaPhyControlSend: Error!!! portcontext is NULL\n")); 2234 return AGSA_RC_FAILURE; 2235 } 2236 2237 if (oneExpDeviceData == agNULL) 2238 { 2239 TI_DBG1(("tdsaPhyControlSend: Error!!! expander is NULL\n")); 2240 return AGSA_RC_FAILURE; 2241 } 2242 2243 if (phyOp == SMP_PHY_CONTROL_HARD_RESET) 2244 { 2245 TI_DBG3(("tdsaPhyControlSend: SMP_PHY_CONTROL_HARD_RESET\n")); 2246 } 2247 if (phyOp == SMP_PHY_CONTROL_LINK_RESET) 2248 { 2249 TI_DBG3(("tdsaPhyControlSend: SMP_PHY_CONTROL_LINK_RESET\n")); 2250 } 2251 if (phyOp == SMP_PHY_CONTROL_CLEAR_AFFILIATION) 2252 { 2253 TI_DBG3(("tdsaPhyControlSend: SMP_PHY_CONTROL_CLEAR_AFFILIATION\n")); 2254 } 2255 TI_DBG3(("tdsaPhyControlSend: target device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 2256 TI_DBG3(("tdsaPhyControlSend: target device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 2257 TI_DBG3(("tdsaPhyControlSend: expander AddrHi 0x%08x\n", oneExpDeviceData->SASAddressID.sasAddressHi)); 2258 TI_DBG3(("tdsaPhyControlSend: expander AddrLo 0x%08x\n", oneExpDeviceData->SASAddressID.sasAddressLo)); 2259 TI_DBG3(("tdsaPhyControlSend: did %d expander did %d phyid %d\n", oneDeviceData->id, oneExpDeviceData->id, phyID)); 2260 2261 2262 osti_memset(&smpPhyControlReq, 0, sizeof(smpReqPhyControl_t)); 2263 2264 /* fill in SMP payload */ 2265 smpPhyControlReq.phyIdentifier = phyID; 2266 smpPhyControlReq.phyOperation = phyOp; 2267 2268 status = tdSMPStart( 2269 tiRoot, 2270 agRoot, 2271 oneExpDeviceData, 2272 SMP_PHY_CONTROL, 2273 (bit8 *)&smpPhyControlReq, 2274 sizeof(smpReqPhyControl_t), 2275 AGSA_SMP_INIT_REQ, 2276 CurrentTaskTag, 2277 queueNumber 2278 ); 2279 return status; 2280 } 2281 #endif 2282 2283 /***************************************************************************** 2284 *! \brief tdsaPhyControlFailureRespRcvd 2285 * 2286 * Purpose: This function processes the failure of Phy Control response. 2287 * 2288 * \param tiRoot: Pointer to the OS Specific module allocated tiRoot_t 2289 * instance. 2290 * \param agRoot: Pointer to chip/driver Instance. 2291 * \param oneDeviceData: Pointer to the device data. 2292 * \param frameHeader: Pointer to SMP frame header. 2293 * \param frameHandle: A Handle used to refer to the response frame 2294 * 2295 * \return: 2296 * None 2297 * 2298 * \note: 2299 * 2300 *****************************************************************************/ 2301 osGLOBAL void 2302 tdsaPhyControlFailureRespRcvd( 2303 tiRoot_t *tiRoot, 2304 agsaRoot_t *agRoot, 2305 tdsaDeviceData_t *oneDeviceData, 2306 tdssSMPFrameHeader_t *frameHeader, 2307 agsaFrameHandle_t frameHandle, 2308 tiIORequest_t *CurrentTaskTag 2309 ) 2310 { 2311 #if defined(INITIATOR_DRIVER) || defined(TD_DEBUG_ENABLE) 2312 tdsaDeviceData_t *TargetDeviceData = agNULL; 2313 #endif 2314 #ifdef TD_DEBUG_ENABLE 2315 satDeviceData_t *pSatDevData = agNULL; 2316 #endif 2317 // agsaDevHandle_t *agDevHandle = agNULL; 2318 2319 TI_DBG1(("tdsaPhyControlFailureRespRcvd: start\n")); 2320 2321 TI_DBG3(("tdsaPhyControlFailureRespRcvd: expander device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 2322 TI_DBG3(("tdsaPhyControlFailureRespRcvd: expander device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 2323 2324 if (CurrentTaskTag != agNULL ) 2325 { 2326 /* This was set in tiINITaskmanagement() */ 2327 #if defined(INITIATOR_DRIVER) || defined(TD_DEBUG_ENABLE) 2328 TargetDeviceData = (tdsaDeviceData_t *)CurrentTaskTag->tdData; 2329 #endif 2330 #ifdef TD_DEBUG_ENABLE 2331 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData); 2332 #endif 2333 // agDevHandle = TargetDeviceData->agDevHandle; 2334 TI_DBG2(("tdsaPhyControlFailureRespRcvd: target AddrHi 0x%08x\n", TargetDeviceData->SASAddressID.sasAddressHi)); 2335 TI_DBG2(("tdsaPhyControlFailureRespRcvd: target AddrLo 0x%08x\n", TargetDeviceData->SASAddressID.sasAddressLo)); 2336 2337 #ifdef TD_DEBUG_ENABLE 2338 TI_DBG2(("tdsaPhyControlFailureRespRcvd: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2339 TI_DBG2(("tdsaPhyControlFailureRespRcvd: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2340 #endif 2341 } 2342 2343 #ifdef INITIATOR_DRIVER 2344 if (CurrentTaskTag != agNULL ) 2345 { 2346 TI_DBG1(("tdsaPhyControlRespRcvd: callback to OS layer with failure\n")); 2347 if (TargetDeviceData->TRflag == agTRUE) 2348 { 2349 TargetDeviceData->TRflag = agFALSE; 2350 ostiInitiatorEvent(tiRoot, 2351 TargetDeviceData->tdPortContext->tiPortalContext, 2352 &(TargetDeviceData->tiDeviceHandle), 2353 tiIntrEventTypeTransportRecovery, 2354 tiRecFailed , 2355 agNULL 2356 ); 2357 } 2358 else 2359 { 2360 ostiInitiatorEvent( tiRoot, 2361 NULL, 2362 NULL, 2363 tiIntrEventTypeTaskManagement, 2364 tiTMFailed, 2365 CurrentTaskTag ); 2366 } 2367 } 2368 #endif 2369 return; 2370 } 2371 /***************************************************************************** 2372 *! \brief tdsaPhyControlRespRcvd 2373 * 2374 * Purpose: This function processes Phy Control response. 2375 * 2376 * \param tiRoot: Pointer to the OS Specific module allocated tiRoot_t 2377 * instance. 2378 * \param agRoot: Pointer to chip/driver Instance. 2379 * \param oneDeviceData: Pointer to the device data. 2380 * \param frameHeader: Pointer to SMP frame header. 2381 * \param frameHandle: A Handle used to refer to the response frame 2382 * 2383 * \return: 2384 * None 2385 * 2386 * \note: 2387 * 2388 *****************************************************************************/ 2389 osGLOBAL void 2390 tdsaPhyControlRespRcvd( 2391 tiRoot_t *tiRoot, 2392 agsaRoot_t *agRoot, 2393 agsaIORequest_t *agIORequest, 2394 tdsaDeviceData_t *oneDeviceData, 2395 tdssSMPFrameHeader_t *frameHeader, 2396 agsaFrameHandle_t frameHandle, 2397 tiIORequest_t *CurrentTaskTag 2398 ) 2399 { 2400 #if defined(INITIATOR_DRIVER) || defined(TD_DEBUG_ENABLE) 2401 tdsaDeviceData_t *TargetDeviceData = agNULL; 2402 #endif 2403 #ifdef INITIATOR_DRIVER 2404 satDeviceData_t *pSatDevData = agNULL; 2405 agsaDevHandle_t *agDevHandle = agNULL; 2406 #endif 2407 2408 TI_DBG3(("tdsaPhyControlRespRcvd: start\n")); 2409 2410 TI_DBG3(("tdsaPhyControlRespRcvd: expander device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 2411 TI_DBG3(("tdsaPhyControlRespRcvd: expander device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 2412 2413 if (CurrentTaskTag != agNULL ) 2414 { 2415 /* This was set in tiINITaskmanagement() */ 2416 #if defined(INITIATOR_DRIVER) || defined(TD_DEBUG_ENABLE) 2417 TargetDeviceData = (tdsaDeviceData_t *)CurrentTaskTag->tdData; 2418 #endif 2419 #ifdef INITIATOR_DRIVER 2420 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData); 2421 agDevHandle = TargetDeviceData->agDevHandle; 2422 #endif 2423 TI_DBG2(("tdsaPhyControlRespRcvd: target AddrHi 0x%08x\n", TargetDeviceData->SASAddressID.sasAddressHi)); 2424 TI_DBG2(("tdsaPhyControlRespRcvd: target AddrLo 0x%08x\n", TargetDeviceData->SASAddressID.sasAddressLo)); 2425 2426 #ifdef INITIATOR_DRIVER 2427 TI_DBG2(("tdsaPhyControlRespRcvd: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2428 TI_DBG2(("tdsaPhyControlRespRcvd: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2429 #endif 2430 } 2431 2432 #ifdef INITIATOR_DRIVER 2433 /* no payload */ 2434 if (frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) 2435 { 2436 TI_DBG3(("tdsaPhyControlRespRcvd: SMP success\n")); 2437 2438 /* warm reset or clear affiliation is done 2439 call ostiInitiatorEvent() 2440 */ 2441 if (CurrentTaskTag != agNULL ) 2442 { 2443 TI_DBG3(("tdsaPhyControlRespRcvd: callback to OS layer with success\n")); 2444 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 2445 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, TargetDeviceData), agDevHandle, SA_DS_OPERATIONAL); 2446 2447 if (TargetDeviceData->TRflag == agTRUE) 2448 { 2449 TargetDeviceData->TRflag = agFALSE; 2450 ostiInitiatorEvent(tiRoot, 2451 TargetDeviceData->tdPortContext->tiPortalContext, 2452 &(TargetDeviceData->tiDeviceHandle), 2453 tiIntrEventTypeTransportRecovery, 2454 tiRecOK, 2455 agNULL 2456 ); 2457 } 2458 else 2459 { 2460 agDevHandle = TargetDeviceData->agDevHandle; 2461 if (agDevHandle == agNULL) 2462 { 2463 TI_DBG1(("tdsaPhyControlRespRcvd: wrong, agDevHandle is NULL\n")); 2464 } 2465 ostiInitiatorEvent( tiRoot, 2466 NULL, 2467 NULL, 2468 tiIntrEventTypeTaskManagement, 2469 tiTMOK, 2470 CurrentTaskTag ); 2471 } 2472 } 2473 2474 } 2475 else 2476 { 2477 TI_DBG1(("tdsaPhyControlRespRcvd: SMP failure; result %d\n", frameHeader->smpFunctionResult)); 2478 /* warm reset or clear affiliation is done 2479 */ 2480 if (CurrentTaskTag != agNULL ) 2481 { 2482 TI_DBG1(("tdsaPhyControlRespRcvd: callback to OS layer with failure\n")); 2483 if (TargetDeviceData->TRflag == agTRUE) 2484 { 2485 TargetDeviceData->TRflag = agFALSE; 2486 ostiInitiatorEvent(tiRoot, 2487 TargetDeviceData->tdPortContext->tiPortalContext, 2488 &(TargetDeviceData->tiDeviceHandle), 2489 tiIntrEventTypeTransportRecovery, 2490 tiRecFailed , 2491 agNULL 2492 ); 2493 } 2494 else 2495 { 2496 ostiInitiatorEvent( tiRoot, 2497 NULL, 2498 NULL, 2499 tiIntrEventTypeTaskManagement, 2500 tiTMFailed, 2501 CurrentTaskTag ); 2502 } 2503 } 2504 2505 } 2506 #endif 2507 return; 2508 } 2509 2510 2511 #ifdef TARGET_DRIVER 2512 /***************************************************************************** 2513 *! \brief ttdsaAbortAll 2514 * 2515 * Purpose: This function is called to abort an all pending I/O request on a 2516 * device 2517 * 2518 * \param tiRoot: Pointer to initiator driver/port instance. 2519 * \param agRoot: Pointer to chip/driver Instance. 2520 * \param oneDeviceData: Pointer to the device 2521 * 2522 * \return: 2523 * 2524 * None 2525 * 2526 *****************************************************************************/ 2527 /* 2528 for abort itself, 2529 should we allocate tdAbortIORequestBody or get one from ttdsaXchg_t? 2530 Currently, we allocate tdAbortIORequestBody. 2531 */ 2532 osGLOBAL void 2533 ttdsaAbortAll( 2534 tiRoot_t *tiRoot, 2535 agsaRoot_t *agRoot, 2536 tdsaDeviceData_t *oneDeviceData 2537 ) 2538 { 2539 agsaIORequest_t *agAbortIORequest = agNULL; 2540 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 2541 bit32 PhysUpper32; 2542 bit32 PhysLower32; 2543 bit32 memAllocStatus; 2544 void *osMemHandle; 2545 2546 TI_DBG3(("tdsaAbortAll: start\n")); 2547 2548 TI_DBG3(("tdsaAbortAll: did %d\n", oneDeviceData->id)); 2549 2550 2551 /* allocating agIORequest for abort itself */ 2552 memAllocStatus = ostiAllocMemory( 2553 tiRoot, 2554 &osMemHandle, 2555 (void **)&tdAbortIORequestBody, 2556 &PhysUpper32, 2557 &PhysLower32, 2558 8, 2559 sizeof(tdIORequestBody_t), 2560 agTRUE 2561 ); 2562 if (memAllocStatus != tiSuccess) 2563 { 2564 /* let os process IO */ 2565 TI_DBG1(("tdsaAbortAll: ostiAllocMemory failed...\n")); 2566 return; 2567 } 2568 2569 if (tdAbortIORequestBody == agNULL) 2570 { 2571 /* let os process IO */ 2572 TI_DBG1(("tdsaAbortAll: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 2573 return; 2574 } 2575 2576 /* setup task management structure */ 2577 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 2578 /* setting callback */ 2579 /* not needed; it is already set to be ossaSSPAbortCB() */ 2580 tdAbortIORequestBody->IOCompletionFunc = ttdssIOAbortedHandler; 2581 2582 tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle); 2583 2584 /* initialize agIORequest */ 2585 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 2586 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 2587 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 2588 2589 /* SSPAbort */ 2590 saSSPAbort(agRoot, 2591 agAbortIORequest, 2592 0, 2593 oneDeviceData->agDevHandle, 2594 1, /* abort all */ 2595 agNULL, 2596 agNULL 2597 ); 2598 return; 2599 } 2600 #endif /* TARGET_DRIVER */ 2601 2602 2603 osGLOBAL void 2604 tdsaDeregisterDevicesInPort( 2605 tiRoot_t *tiRoot, 2606 tdsaPortContext_t *onePortContext 2607 ) 2608 { 2609 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2610 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2611 tdsaDeviceData_t *oneDeviceData = agNULL; 2612 tdList_t *DeviceListList; 2613 agsaRoot_t *agRoot = agNULL; 2614 2615 agRoot = &(tdsaAllShared->agRootNonInt); 2616 2617 TI_DBG1(("tdsaDeregisterDevicesInPort: start\n")); 2618 2619 /* find a device's existence */ 2620 DeviceListList = tdsaAllShared->MainDeviceList.flink; 2621 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 2622 { 2623 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 2624 if (oneDeviceData == agNULL) 2625 { 2626 TI_DBG1(("tdsaDeregisterDevicesInPort: oneDeviceData is NULL!!!\n")); 2627 return; 2628 } 2629 if (oneDeviceData->tdPortContext == onePortContext) 2630 { 2631 TI_DBG3(("tdsaDeregisterDevicesInPort: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id)); 2632 if ( !( DEVICE_IS_SMP_TARGET(oneDeviceData) && oneDeviceData->directlyAttached == agTRUE)) 2633 { 2634 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 2635 } 2636 else 2637 { 2638 TI_DBG1(("tdsaDeregisterDevicesInPort: keeping\n")); 2639 oneDeviceData->registered = agTRUE; 2640 } 2641 } 2642 DeviceListList = DeviceListList->flink; 2643 } 2644 2645 TI_DBG3(("tdsaDeregisterDevicesInPort: end\n")); 2646 2647 return; 2648 } 2649 2650 /******************** for debugging only ***************************/ 2651 osGLOBAL void 2652 tdsaPrintSwConfig( 2653 agsaSwConfig_t *SwConfig 2654 ) 2655 { 2656 if (SwConfig == agNULL) 2657 { 2658 TI_DBG6(("tdsaPrintSwConfig: SwConfig is NULL\n")); 2659 return; 2660 } 2661 else 2662 { 2663 TI_DBG6(("SwConfig->maxActiveIOs %d\n", SwConfig->maxActiveIOs)); 2664 TI_DBG6(("SwConfig->smpReqTimeout %d\n", SwConfig->smpReqTimeout)); 2665 } 2666 2667 return; 2668 2669 } 2670 2671 osGLOBAL void 2672 tdsaPrintHwConfig( 2673 agsaHwConfig_t *HwConfig 2674 ) 2675 { 2676 if (HwConfig == agNULL) 2677 { 2678 TI_DBG6(("tdsaPrintHwConfig: HwConfig is NULL\n")); 2679 return; 2680 } 2681 else 2682 { 2683 TI_DBG6(("HwConfig->phyCount %d\n", HwConfig->phyCount)); 2684 } 2685 return; 2686 } 2687 2688 osGLOBAL void 2689 tdssPrintSASIdentify( 2690 agsaSASIdentify_t *id 2691 ) 2692 { 2693 if (id == agNULL) 2694 { 2695 TI_DBG1(("tdsaPrintSASIdentify: ID is NULL\n")); 2696 return; 2697 } 2698 else 2699 { 2700 TI_DBG6(("SASID->sspTargetPort %d\n", SA_IDFRM_IS_SSP_TARGET(id)?1:0)); 2701 TI_DBG6(("SASID->stpTargetPort %d\n", SA_IDFRM_IS_STP_TARGET(id)?1:0)); 2702 TI_DBG6(("SASID->smpTargetPort %d\n", SA_IDFRM_IS_SMP_TARGET(id)?1:0)); 2703 TI_DBG6(("SASID->sspInitiatorPort %d\n", SA_IDFRM_IS_SSP_INITIATOR(id)?1:0)); 2704 TI_DBG6(("SASID->stpInitiatorPort %d\n", SA_IDFRM_IS_STP_INITIATOR(id)?1:0)); 2705 TI_DBG6(("SASID->smpInitiatorPort %d\n", SA_IDFRM_IS_SMP_INITIATOR(id)?1:0)); 2706 TI_DBG6(("SASID->deviceType %d\n", SA_IDFRM_GET_DEVICETTYPE(id))); 2707 TI_DBG6(("SASID->sasAddressHi 0x%x\n", SA_IDFRM_GET_SAS_ADDRESSHI(id))); 2708 TI_DBG6(("SASID->sasAddressLo 0x%x\n", SA_IDFRM_GET_SAS_ADDRESSLO(id))); 2709 TI_DBG6(("SASID->phyIdentifier 0x%x\n", id->phyIdentifier)); 2710 2711 } 2712 2713 return; 2714 } 2715 2716 osGLOBAL void 2717 tdsaInitTimerHandler( 2718 tiRoot_t *tiRoot, 2719 void *timerData 2720 ) 2721 { 2722 2723 TI_DBG6(("tdsaInitTimerHandler: start\n")); 2724 return; 2725 } 2726 2727 /* 2728 type: 1 portcontext 2 devicedata 2729 flag: 1 FreeLink 2 MainLink 2730 */ 2731 2732 osGLOBAL void 2733 print_tdlist_flink(tdList_t *hdr, int type, int flag) 2734 { 2735 tdList_t *hdr_tmp1 = NULL; 2736 #ifdef TD_DEBUG_ENABLE 2737 tdsaPortContext_t *ele1; 2738 #endif 2739 #ifdef REMOVED 2740 tdsaDeviceData_t *ele2; 2741 #endif 2742 hdr_tmp1 = hdr; 2743 2744 if (type == 1 && flag == 1) 2745 { 2746 TI_DBG6(("PortContext and FreeLink\n")); 2747 } 2748 else if (type != 1 && flag == 1) 2749 { 2750 TI_DBG6(("DeviceData and FreeLink\n")); 2751 } 2752 else if (type == 1 && flag != 1) 2753 { 2754 TI_DBG6(("PortContext and MainLink\n")); 2755 } 2756 else 2757 { 2758 TI_DBG6(("DeviceData and MainLink\n")); 2759 } 2760 if (type == 1) 2761 { 2762 do 2763 { 2764 /* data structure type variable = (data structure type, file name, header of the tdList) */ 2765 if (flag == 1) 2766 { 2767 #ifdef TD_DEBUG_ENABLE 2768 ele1 = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, hdr_tmp1); 2769 #endif 2770 } 2771 else 2772 { 2773 #ifdef TD_DEBUG_ENABLE 2774 ele1 = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, hdr_tmp1); 2775 #endif 2776 } 2777 TI_DBG6(("flist ele %d\n", ele1->id)); 2778 TI_DBG6(("flist ele %p\n", ele1)); 2779 hdr_tmp1 = hdr_tmp1->flink; 2780 } while (hdr_tmp1 != hdr); 2781 } 2782 else 2783 { 2784 do 2785 { 2786 /* data structure type variable = (data structure type, file name, header of the tdList) */ 2787 #ifdef REMOVED 2788 if (flag == 1) 2789 { 2790 ele2 = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, hdr_tmp1); 2791 } 2792 else 2793 { 2794 ele2 = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, hdr_tmp1); 2795 } 2796 TI_DBG6(("flist ele %d\n", ele2->id)); 2797 TI_DBG6(("flist ele %p\n", ele2)); 2798 #endif 2799 hdr_tmp1 = hdr_tmp1->flink; 2800 } while (hdr_tmp1 != hdr); 2801 } 2802 TI_DBG6(("\n")); 2803 } 2804 2805 /* not verified yet. 6/15/2005 */ 2806 osGLOBAL void 2807 print_tdlist_blink(tdList_t *hdr, int flag) 2808 { 2809 tdList_t *hdr_tmp1 = NULL; 2810 #ifdef REMOVED 2811 tdsaPortContext_t *ele1; 2812 #endif 2813 hdr_tmp1 = hdr; 2814 2815 do 2816 { 2817 /* data structure type variable = (data structure type, file name, header of the tdList) */ 2818 #ifdef REMOVED 2819 if (flag == 1) 2820 { 2821 ele1 = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, hdr_tmp1); 2822 } 2823 else 2824 { 2825 ele1 = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, hdr_tmp1); 2826 } 2827 TI_DBG6(("blist ele %d\n", ele1->id)); 2828 #endif 2829 2830 hdr_tmp1 = hdr_tmp1->blink; 2831 } while (hdr_tmp1 != hdr); 2832 } 2833 2834 2835 /** hexidecimal dump */ 2836 void tdhexdump(const char *ptitle, bit8 *pbuf, int len) 2837 { 2838 int i; 2839 TI_DBG2(("%s - hexdump(len=%d):\n", ptitle, (int)len)); 2840 if (!pbuf) 2841 { 2842 TI_DBG1(("pbuf is NULL\n")); 2843 return; 2844 } 2845 for (i = 0; i < len; ) 2846 { 2847 if (len - i > 4) 2848 { 2849 TI_DBG2((" 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n", pbuf[i], pbuf[i+1], pbuf[i+2], pbuf[i+3])); 2850 i += 4; 2851 } 2852 else 2853 { 2854 TI_DBG2((" 0x%02x,", pbuf[i])); 2855 i++; 2856 } 2857 } 2858 TI_DBG2(("\n")); 2859 } 2860 2861 void 2862 tdsaSingleThreadedEnter(tiRoot_t *ptiRoot, bit32 queueId) 2863 { 2864 tdsaRoot_t * tiroot = agNULL; 2865 bit32 offset = 0; 2866 TD_ASSERT(ptiRoot,"ptiRoot"); 2867 tiroot = ptiRoot->tdData; 2868 2869 offset = tiroot->tdsaAllShared.MaxNumLLLocks + tiroot->tdsaAllShared.MaxNumOSLocks; 2870 2871 ostiSingleThreadedEnter(ptiRoot, queueId + offset); 2872 } 2873 2874 void 2875 tdsaSingleThreadedLeave(tiRoot_t *ptiRoot, bit32 queueId) 2876 { 2877 tdsaRoot_t * tiroot = agNULL; 2878 bit32 offset = 0; 2879 2880 TD_ASSERT(ptiRoot,"ptiRoot"); 2881 tiroot = ptiRoot->tdData; 2882 2883 offset = tiroot->tdsaAllShared.MaxNumLLLocks + tiroot->tdsaAllShared.MaxNumOSLocks; 2884 2885 ostiSingleThreadedLeave(ptiRoot, queueId + offset); 2886 } 2887 2888 #ifdef PERF_COUNT 2889 void 2890 tdsaEnter(tiRoot_t *ptiRoot, int io) 2891 { 2892 ostiEnter(ptiRoot, 1, io); 2893 } 2894 2895 void 2896 tdsaLeave(tiRoot_t *ptiRoot, int io) 2897 { 2898 ostiLeave(ptiRoot, 1, io); 2899 } 2900 #endif 2901 2902