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 * 27 * This file contains CB functions used by lower layer in SAS/SATA TD layer 28 * 29 */ 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 #include <dev/pms/config.h> 33 34 #include <dev/pms/freebsd/driver/common/osenv.h> 35 #include <dev/pms/freebsd/driver/common/ostypes.h> 36 #include <dev/pms/freebsd/driver/common/osdebug.h> 37 38 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 39 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 40 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 41 42 #include <dev/pms/RefTisa/tisa/api/titypes.h> 43 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 44 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 45 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 46 47 #ifdef FDS_SM 48 #include <dev/pms/RefTisa/sat/api/sm.h> 49 #include <dev/pms/RefTisa/sat/api/smapi.h> 50 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 51 #endif 52 53 #ifdef FDS_DM 54 #include <dev/pms/RefTisa/discovery/api/dm.h> 55 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 56 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 57 #endif 58 59 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 60 #include <dev/pms/freebsd/driver/common/osstring.h> 61 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h> 62 63 #ifdef INITIATOR_DRIVER 64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h> 66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h> 67 #endif 68 69 #ifdef TARGET_DRIVER 70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h> 71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h> 72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h> 73 #endif 74 75 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 76 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 77 78 #ifdef ECHO_TESTING 79 /* temporary to test saEchoCommand() */ 80 extern bit8 gEcho; 81 #endif 82 83 #if defined(SALLSDK_DEBUG) 84 extern bit32 gLLDebugLevel; 85 #endif 86 87 88 #include <dev/pms/RefTisa/sallsdk/spc/mpidebug.h> 89 90 #ifdef SA_ENABLE_TRACE_FUNCTIONS 91 92 #ifdef siTraceFileID 93 #undef siTraceFileID 94 #endif 95 #define siTraceFileID 'R' 96 #endif 97 /* 98 functions that are common to SAS and SATA 99 */ 100 101 FORCEINLINE 102 void ossaCacheInvalidate( 103 agsaRoot_t *agRoot, 104 void *osMemHandle, 105 void *virtPtr, 106 bit32 length 107 ) 108 { 109 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 110 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 111 112 TI_DBG6(("ossaCacheInvalidate: start\n")); 113 ostiCacheInvalidate(tiRoot, osMemHandle, virtPtr, length); 114 return; 115 } 116 117 FORCEINLINE 118 void ossaCacheFlush( 119 agsaRoot_t *agRoot, 120 void *osMemHandle, 121 void *virtPtr, 122 bit32 length 123 ) 124 { 125 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 126 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 127 128 TI_DBG6(("ossaCacheFlush: start\n")); 129 ostiCacheFlush(tiRoot, osMemHandle, virtPtr, length); 130 return; 131 } 132 133 FORCEINLINE 134 void ossaCachePreFlush( 135 agsaRoot_t *agRoot, 136 void *osMemHandle, 137 void *virtPtr, 138 bit32 length 139 ) 140 141 { 142 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 143 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 144 145 TI_DBG6(("ossaCachePreFlush: start\n")); 146 ostiCachePreFlush(tiRoot, osMemHandle, virtPtr, length); 147 return; 148 } 149 150 /***************************************************************************** 151 *! \brief ossaDeviceHandleAccept 152 * 153 * Purpose: This function is called by lower layer to inform TD layer of 154 * a new SAS device arrival. Used only at the target 155 * 156 * 157 * \param agRoot Pointer to chip/driver Instance. 158 * \param agDevHandle Pointer to the device handle of the device 159 * \param agDevInfo Pointer to the device info structure 160 * \param agPortContext Pointer to a port context 161 * 162 * \return: 163 * OSSA_RC_REJECT A device is accpeted 164 * OSSA_RC_ACCEPT A device is rejected 165 * 166 * \note - For details, refer to SAS/SATA Low-Level API Specification 167 * 168 *****************************************************************************/ 169 osGLOBAL bit32 ossaDeviceHandleAccept( 170 agsaRoot_t *agRoot, 171 agsaDevHandle_t *agDevHandle, 172 agsaSASDeviceInfo_t *agDevInfo, 173 agsaPortContext_t *agPortContext, 174 bit32 *hostAssignedDeviceId 175 ) 176 { 177 #ifdef TARGET_DRIVER 178 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 179 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 180 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 181 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 182 183 tdsaPortContext_t *onePortContext = agNULL; 184 tiPortalContext_t *tiPortalContext = agNULL; 185 tdsaDeviceData_t *oneDeviceData = agNULL; 186 tiDeviceHandle_t *tiDeviceHandle = agNULL; 187 tdsaSASSubID_t agSASSubID; 188 bit32 option; 189 bit32 param; 190 /* 191 at target only 192 by default TD layer accpets all devices 193 */ 194 /* 195 at this point, 196 by LINK_UP event tdsaPortContext should have been created 197 */ 198 smTraceFuncEnter(hpDBG_VERY_LOUD, "Y0"); 199 TI_DBG1(("ossaDeviceHandleAccept: start hostAssignedDeviceId 0x%X\n",*hostAssignedDeviceId)); 200 201 202 if (agPortContext == agNULL) 203 { 204 TI_DBG1(("ossaDeviceHandleAccept: NULL agsaPortContext; wrong\n")); 205 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y0"); 206 return OSSA_RC_REJECT; 207 } 208 209 210 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 211 212 if (onePortContext == agNULL) 213 { 214 TI_DBG1(("ossaDeviceHandleAccept: NULL oneportcontext; wrong\n")); 215 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y0"); 216 return OSSA_RC_REJECT; 217 } 218 219 tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext; 220 221 if (tiPortalContext == agNULL) 222 { 223 TI_DBG1(("ossaDeviceHandleAccept: NULL tiPortalContext; wrong\n")); 224 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y0"); 225 return OSSA_RC_REJECT; 226 } 227 228 /* 229 add the device to device list 230 cf) OSSA_DISCOVER_FOUND_DEVICE 231 */ 232 TI_DBG4(("ossaDeviceHandleAccept: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo))); 233 TI_DBG4(("ossaDeviceHandleAccept: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo))); 234 TI_DBG4(("ossaDeviceHandleAccept: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo))); 235 TI_DBG4(("ossaDeviceHandleAccept: phys %d\n", agDevInfo->numOfPhys)); 236 TI_DBG4(("ossaDeviceHandleAccept: pid %d\n", onePortContext->id)); 237 238 if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_END_DEVICE) 239 { 240 TI_DBG4(("ossaDeviceHandleAccept: SAS_END_DEVICE\n")); 241 } 242 else if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_EDGE_EXPANDER_DEVICE) 243 { 244 TI_DBG4(("ossaDeviceHandleAccept: SAS_EDGE_EXPANDER_DEVICE\n")); 245 } 246 else /* SAS_FANOUT_EXPANDER_DEVICE */ 247 { 248 TI_DBG4(("ossaDeviceHandleAccept: SAS_FANOUT_EXPANDER_DEVICE\n")); 249 } 250 agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo); 251 agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo); 252 agSASSubID.initiator_ssp_stp_smp = agDevInfo->initiator_ssp_stp_smp; 253 agSASSubID.target_ssp_stp_smp = agDevInfo->target_ssp_stp_smp; 254 255 256 tdssAddSASToSharedcontext( 257 onePortContext, 258 agRoot, 259 agDevHandle, 260 &agSASSubID, 261 agTRUE, 262 0xFF, 263 TD_OPERATION_TARGET 264 ); 265 266 /* at this point devicedata for new device exists */ 267 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 268 269 if (oneDeviceData == agNULL) 270 { 271 TI_DBG1(("ossaDeviceHandleAccept: NULL oneDeviceData; wrong\n")); 272 return OSSA_RC_REJECT; 273 } 274 275 oneDeviceData->registered = agTRUE; 276 277 tiDeviceHandle = &(oneDeviceData->tiDeviceHandle); 278 279 if (tiDeviceHandle == agNULL) 280 { 281 TI_DBG1(("ossaDeviceHandleAccept: NULL tiDeviceHandle; wrong\n")); 282 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y0"); 283 return OSSA_RC_REJECT; 284 } 285 286 /* setting MCN in agsaDeviceInfo_t*/ 287 agDevInfo->commonDevInfo.flag = agDevInfo->commonDevInfo.flag | (tdsaAllShared->MCN << 16); 288 /* increment RegisteredDevNums */ 289 onePortContext->RegisteredDevNums++; 290 291 *hostAssignedDeviceId |= 0xBEEF0000; 292 293 TI_DBG1(("ossaDeviceHandleAccept: Now hostAssignedDeviceId 0x%X\n", *hostAssignedDeviceId)); 294 295 296 /* no login in SAS */ 297 /* 298 osGLOBAL bit32 ostiTargetEvent ( 299 tiRoot_t *tiRoot, 300 tiPortalContext_t *portalContext, 301 tiDeviceHandle_t *tiDeviceHandle, 302 tiTgtEventType_t eventType, 303 bit32 eventStatus, 304 void *parm 305 ); 306 */ 307 308 ostiTargetEvent( 309 tiRoot, 310 tiPortalContext, 311 tiDeviceHandle, 312 tiTgtEventTypeDeviceChange, 313 tiDeviceArrival, 314 agNULL 315 ); 316 /* set MCN and initiator role bit using saSetDeviceInfo */ 317 option = 24; /* setting MCN and initiator role 1 1000b*/ 318 param = (1 << 18) | (tdsaAllShared->MCN << 24); 319 TI_DBG1(("ossaDeviceHandleAccept: option 0x%x param 0x%x MCN 0x%x\n", option, param, tdsaAllShared->MCN)); 320 saSetDeviceInfo(agRoot, agNULL, 0, agDevHandle, option, param, ossaSetDeviceInfoCB); 321 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y0"); 322 return OSSA_RC_ACCEPT; 323 #endif 324 325 #ifdef INITIATOR_DRIVER 326 /* this function is not used in case of Initiator */ 327 return OSSA_RC_ACCEPT; 328 #endif 329 } 330 331 #ifdef INITIATOR_DRIVER 332 /***************************************************************************** 333 *! \brief ossaDiscoverSasCB 334 * 335 * Purpose: This function is called by lower layer to inform TD layer of 336 * SAS discovery results 337 * 338 * 339 * \param agRoot Pointer to chip/driver Instance. 340 * \param agPortContext Pointer to the port context of TD and Lower layer 341 * \param event event type 342 * \param pParm1 Pointer to data associated with event 343 * \param pParm2 Pointer to data associated with event 344 * 345 * \return: none 346 * 347 * \note - For details, refer to SAS/SATA Low-Level API Specification 348 * 349 *****************************************************************************/ 350 osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot, 351 agsaPortContext_t *agPortContext, 352 bit32 event, 353 void *pParm1, 354 void *pParm2 355 ) 356 { 357 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 358 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 359 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared; 360 361 tdsaPortContext_t *onePortContext = agNULL; 362 tdsaDeviceData_t *oneDeviceData = agNULL; 363 364 agsaDevHandle_t *agDevHandle = agNULL; 365 agsaSASDeviceInfo_t *agDeviceInfo = agNULL; 366 tiPortalContext_t *tiPortalContext = agNULL; 367 tdList_t *DeviceListList; 368 tdsaSASSubID_t agSASSubID; 369 370 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y1"); 371 TI_DBG2(("ossaDiscoverSasCB: start\n")); 372 373 if (agPortContext == agNULL) 374 { 375 TI_DBG1(("ossaDiscoverSasCB: NULL agsaPortContext; wrong\n")); 376 return; 377 } 378 379 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 380 tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext; 381 382 switch ( event ) 383 { 384 case OSSA_DISCOVER_STARTED: 385 { 386 TI_DBG3(("ossaDiscoverSasCB: STARTED pid %d\n", onePortContext->id)); 387 /* 388 invalidate all devices in current device list 389 */ 390 DeviceListList = tdsaAllShared->MainDeviceList.flink; 391 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 392 { 393 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 394 TI_DBG3(("ossaDiscoverSasCB: loop did %d\n", oneDeviceData->id)); 395 TI_DBG3(("ossaDiscoverSasCB: loop sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 396 TI_DBG6(("ossaDiscoverSasCB: loop sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 397 if (oneDeviceData->tdPortContext == onePortContext) 398 { 399 TI_DBG3(("ossaDiscoverSasCB: did %d is invalidated \n", oneDeviceData->id)); 400 /* temporary solution: only for sata direct attached */ 401 } 402 DeviceListList = DeviceListList->flink; 403 } 404 onePortContext->DiscoveryState = ITD_DSTATE_STARTED; 405 break; 406 } 407 408 case OSSA_DISCOVER_FOUND_DEVICE: 409 { 410 TI_DBG4(("ossaDiscoverSasCB: $$$$$ FOUND_DEVICE pid %d\n", onePortContext->id)); 411 agDevHandle = (agsaDevHandle_t *)pParm1; 412 agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2; 413 TI_DBG5(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo))); 414 TI_DBG5(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo))); 415 TI_DBG5(("ossaDiscoverSasCB: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo))); 416 417 TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys)); 418 TI_DBG4(("ossaDiscoverSasCB: pid %d\n", onePortContext->id)); 419 420 421 /* Add only target devices; do not add expander device */ 422 if (DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo) == SAS_END_DEVICE) 423 { 424 agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo); 425 agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo); 426 agSASSubID.initiator_ssp_stp_smp = agDeviceInfo->initiator_ssp_stp_smp; 427 agSASSubID.target_ssp_stp_smp = agDeviceInfo->target_ssp_stp_smp; 428 429 TI_DBG2(("ossaDiscoverSasCB: adding ....\n")); 430 431 tdssAddSASToSharedcontext( 432 onePortContext, 433 agRoot, 434 agDevHandle, 435 &agSASSubID, 436 agTRUE, 437 agDeviceInfo->phyIdentifier, 438 TD_OPERATION_INITIATOR 439 ); 440 ostiInitiatorEvent( 441 tiRoot, 442 tiPortalContext, 443 agNULL, 444 tiIntrEventTypeDeviceChange, 445 tiDeviceArrival, 446 agNULL 447 ); 448 } 449 else 450 { 451 TI_DBG5(("ossaDiscoverSasCB: $$$$$ not end device. not adding....\n")); 452 } 453 454 455 break; 456 } 457 458 case OSSA_DISCOVER_REMOVED_DEVICE: 459 { 460 TI_DBG3(("ossaDiscoverSasCB: REMOVED_DEVICE\n")); 461 agDevHandle = (agsaDevHandle_t *)pParm1; 462 agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2; 463 oneDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 464 465 TI_DBG6(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n", 466 SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo))); 467 TI_DBG6(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n", 468 SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo))); 469 TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys)); 470 TI_DBG6(("ossaDiscoverSasCB: onePortContext->id %d\n", onePortContext->id)); 471 472 if (oneDeviceData == agNULL) 473 { 474 TI_DBG1(("ossaDiscoverSasCB: Wrong. DevHandle->osData is NULL but is being removed\n")); 475 } 476 else 477 { 478 tdssRemoveSASFromSharedcontext(onePortContext, 479 oneDeviceData, 480 agRoot); 481 agDevHandle->osData = agNULL; 482 ostiInitiatorEvent( 483 tiRoot, 484 tiPortalContext, 485 agNULL, 486 tiIntrEventTypeDeviceChange, 487 tiDeviceRemoval, 488 agNULL 489 ); 490 } 491 492 break; 493 } 494 case OSSA_DISCOVER_COMPLETE: 495 { 496 TI_DBG2(("ossaDiscoverSasCB: SAS COMPLETE pid %d\n", onePortContext->id)); 497 /* 498 note: 499 SAS discovery must be called before SATA discovery 500 "onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED" is 501 in ossaDiscoverSataCB not in ossaDiscoverSasCB when SATA_ENABLE 502 */ 503 #ifndef SATA_ENABLE 504 onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED; 505 TI_DBG6(("ossaDiscoverSasCB: COMPLETE pid %d\n", onePortContext->id)); 506 #endif 507 508 #ifdef SATA_ENABLE 509 TI_DBG2(("ossaDiscoverSasCB: calling SATA discovery\n")); 510 511 /* Continue with SATA discovery */ 512 saDiscover(agRoot, agPortContext, AG_SA_DISCOVERY_TYPE_SATA, 513 onePortContext->discoveryOptions); 514 515 #else /* SATA not enable */ 516 517 #ifdef TD_INTERNAL_DEBUG /* for debugging */ 518 /* dump device list */ 519 DeviceListList = tdsaAllShared->MainPortContextList.flink; 520 521 while (DeviceListList != &(tdsaAllShared->MainPortContextList)) 522 { 523 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 524 TI_DBG2(("ossaDiscoverSasCB: did %d valid %d\n", oneDeviceData->id, oneDeviceData->valid)); 525 TI_DBG2(("ossaDiscoverSasCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 526 TI_DBG2(("ossaDiscoverSasCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 527 DeviceListList = DeviceListList->flink; 528 } 529 #endif 530 531 /* letting OS layer know discovery has been successfully complete */ 532 ostiInitiatorEvent( 533 tiRoot, 534 tiPortalContext, 535 agNULL, 536 tiIntrEventTypeDiscovery, 537 tiDiscOK, 538 agNULL 539 ); 540 #endif /* SATA_ENABLE */ 541 542 break; 543 } 544 case OSSA_DISCOVER_ABORT: 545 { 546 TI_DBG3(("ossaDiscoverSasCB: ABORT\n")); 547 /* letting OS layer know discovery has not been successfully complete */ 548 ostiInitiatorEvent( 549 tiRoot, 550 tiPortalContext, 551 agNULL, 552 tiIntrEventTypeDiscovery, 553 tiDiscFailed, 554 agNULL 555 ); 556 break; 557 } 558 case OSSA_DISCOVER_ABORT_ERROR_1: 559 { 560 TI_DBG3(("ossaDiscoverSasCB: ERROR 1\n")); 561 /* letting OS layer know discovery has not been successfully complete */ 562 ostiInitiatorEvent( 563 tiRoot, 564 tiPortalContext, 565 agNULL, 566 tiIntrEventTypeDiscovery, 567 tiDiscFailed, 568 agNULL 569 ); 570 break; 571 } 572 573 case OSSA_DISCOVER_ABORT_ERROR_2: 574 { 575 TI_DBG3(("ossaDiscoverSasCB: ERROR 2\n")); 576 /* letting OS layer know discovery has not been successfully complete */ 577 ostiInitiatorEvent( 578 tiRoot, 579 tiPortalContext, 580 agNULL, 581 tiIntrEventTypeDiscovery, 582 tiDiscFailed, 583 agNULL 584 ); 585 break; 586 } 587 588 case OSSA_DISCOVER_ABORT_ERROR_3: 589 { 590 TI_DBG3(("ossaDiscoverSasCB: ERROR 3\n")); 591 /* letting OS layer know discovery has not been successfully complete */ 592 ostiInitiatorEvent( 593 tiRoot, 594 tiPortalContext, 595 agNULL, 596 tiIntrEventTypeDiscovery, 597 tiDiscFailed, 598 agNULL 599 ); 600 break; 601 } 602 case OSSA_DISCOVER_ABORT_ERROR_4: 603 { 604 TI_DBG3(("ossaDiscoverSasCB: ERROR 4\n")); 605 /* letting OS layer know discovery has not been successfully complete */ 606 ostiInitiatorEvent( 607 tiRoot, 608 tiPortalContext, 609 agNULL, 610 tiIntrEventTypeDiscovery, 611 tiDiscFailed, 612 agNULL 613 ); 614 break; 615 } 616 case OSSA_DISCOVER_ABORT_ERROR_5: 617 { 618 TI_DBG3(("ossaDiscoverSasCB: ERROR 5\n")); 619 /* letting OS layer know discovery has not been successfully complete */ 620 ostiInitiatorEvent( 621 tiRoot, 622 tiPortalContext, 623 agNULL, 624 tiIntrEventTypeDiscovery, 625 tiDiscFailed, 626 agNULL 627 ); 628 break; 629 } 630 case OSSA_DISCOVER_ABORT_ERROR_6: 631 { 632 TI_DBG3(("ossaDiscoverSasCB: ERROR 6\n")); 633 /* letting OS layer know discovery has not been successfully complete */ 634 ostiInitiatorEvent( 635 tiRoot, 636 tiPortalContext, 637 agNULL, 638 tiIntrEventTypeDiscovery, 639 tiDiscFailed, 640 agNULL 641 ); 642 break; 643 } 644 case OSSA_DISCOVER_ABORT_ERROR_7: 645 { 646 TI_DBG3(("ossaDiscoverSasCB: ERROR 7\n")); 647 /* letting OS layer know discovery has not been successfully complete */ 648 ostiInitiatorEvent( 649 tiRoot, 650 tiPortalContext, 651 agNULL, 652 tiIntrEventTypeDiscovery, 653 tiDiscFailed, 654 agNULL 655 ); 656 break; 657 } 658 case OSSA_DISCOVER_ABORT_ERROR_8: 659 { 660 TI_DBG3(("ossaDiscoverSasCB: ERROR 8\n")); 661 /* letting OS layer know discovery has not been successfully complete */ 662 ostiInitiatorEvent( 663 tiRoot, 664 tiPortalContext, 665 agNULL, 666 tiIntrEventTypeDiscovery, 667 tiDiscFailed, 668 agNULL 669 ); 670 break; 671 } 672 case OSSA_DISCOVER_ABORT_ERROR_9: 673 { 674 TI_DBG3(("ossaDiscoverSasCB: ERROR 9\n")); 675 /* letting OS layer know discovery has not been successfully complete */ 676 ostiInitiatorEvent( 677 tiRoot, 678 tiPortalContext, 679 agNULL, 680 tiIntrEventTypeDiscovery, 681 tiDiscFailed, 682 agNULL 683 ); 684 break; 685 } 686 default: 687 TI_DBG3(("ossaDiscoverSasCB: ERROR default event 0x%x\n", event)); 688 /* letting OS layer know discovery has not been successfully complete */ 689 ostiInitiatorEvent( 690 tiRoot, 691 tiPortalContext, 692 agNULL, 693 tiIntrEventTypeDiscovery, 694 tiDiscFailed, 695 agNULL 696 ); 697 break; 698 } /* end of switch */ 699 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y1"); 700 return; 701 } 702 #endif // #ifdef INITIATOR_DRIVER 703 704 osGLOBAL void ossaLogTrace0( 705 agsaRoot_t *agRoot, 706 bit32 traceCode 707 ) 708 { 709 return; 710 } 711 712 osGLOBAL void ossaLogTrace1( 713 agsaRoot_t *agRoot, 714 bit32 traceCode, 715 bit32 value1 716 ) 717 { 718 return; 719 } 720 721 osGLOBAL void ossaLogTrace2( 722 agsaRoot_t *agRoot, 723 bit32 traceCode, 724 bit32 value1, 725 bit32 value2 726 ) 727 { 728 return; 729 } 730 731 osGLOBAL void ossaLogTrace3( 732 agsaRoot_t *agRoot, 733 bit32 traceCode, 734 bit32 value1, 735 bit32 value2, 736 bit32 value3 737 ) 738 { 739 return; 740 } 741 742 743 osGLOBAL void 744 ossaLogTrace4( 745 agsaRoot_t *agRoot, 746 bit32 traceCode, 747 bit32 value1, 748 bit32 value2, 749 bit32 value3, 750 bit32 value4 751 ) 752 { 753 return; 754 } 755 756 757 /***************************************************************************** 758 *! \brief ossaHwCB 759 * 760 * Purpose: This function is called by lower layer to inform TD layer of 761 * HW related results 762 * 763 * \param agRoot Pointer to chip/driver Instance. 764 * \param agPortContext Pointer to the port context of TD and Lower layer 765 * \param event event type 766 * \param eventParm1 event-specific parameter 767 * \param eventParm2 event-specific parameter 768 * \param eventParm3 event-specific parameter of pointer type 769 * 770 * \return: none 771 * 772 * \note - For details, refer to SAS/SATA Low-Level API Specification 773 * 774 *****************************************************************************/ 775 osGLOBAL void ossaHwCB( 776 agsaRoot_t *agRoot, 777 agsaPortContext_t *agPortContext, 778 bit32 event, 779 bit32 eventParm1, 780 void *eventParm2, 781 void *eventParm3 782 ) 783 { 784 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 785 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 786 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared; 787 tdList_t *PortContextList = agNULL; 788 tdsaPortContext_t *onePortContext = agNULL; 789 agsaDevHandle_t *agDevHandle = agNULL; 790 agsaSASIdentify_t *IDframe = agNULL; 791 int i = 0; 792 #ifdef INITIATOR_DRIVER 793 tdsaSASSubID_t agSASSubID; 794 #endif 795 bit32 PhyID; 796 bit32 PhyStatus; 797 bit32 LinkRate; 798 bit32 PortState; 799 bit32 HwAckSatus = AGSA_RC_SUCCESS; 800 801 // #ifdef INITIATOR_DRIVER 802 #ifdef INITIATOR_DRIVER 803 agsaFisRegDeviceToHost_t *RegD2H = agNULL; 804 tdsaDeviceData_t *oneDeviceData = agNULL; 805 tdList_t *DeviceListList; 806 #endif 807 #ifdef REMOVED 808 bit32 found = agFALSE; 809 #endif 810 agsaHWEventEncrypt_t *pEncryptCBData; 811 agsaEncryptInfo_t *pEncryptInfo; 812 agsaHWEventMode_t *pModeEvent; 813 tiEncryptPort_t encryptEventData; 814 tiEncryptInfo_t encryptInfo; 815 bit32 *pModePage; 816 bit32 securityMode; 817 bit32 cipherMode; 818 bit32 encryptStatus; 819 bit32 securitySetModeStatus; 820 bit32 securityModeStatus; 821 822 // #endif /* INITIATOR_DRIVER */ 823 agsaPhyErrCountersPage_t *agPhyErrCountersPage; 824 agsaEventSource_t eventSource; 825 826 #ifdef FDS_DM 827 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot); 828 dmPortContext_t *dmPortContext = agNULL; 829 bit32 status = DM_RC_FAILURE; 830 dmPortInfo_t dmPortInfo; 831 // bit32 discStatus = dmDiscInProgress; 832 #endif 833 834 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y2"); 835 836 TI_DBG2(("ossaHwCB: agPortContext %p event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n", 837 agPortContext,event,eventParm1,eventParm2,eventParm3 )); 838 839 switch ( event ) 840 { 841 case OSSA_HW_EVENT_SAS_PHY_UP: 842 { 843 PhyID = TD_GET_PHY_ID(eventParm1); 844 LinkRate = TD_GET_LINK_RATE(eventParm1); 845 PortState = TD_GET_PORT_STATE(eventParm1); 846 agDevHandle = agNULL; 847 IDframe = (agsaSASIdentify_t *)eventParm3; 848 849 850 TI_DBG2(("ossaHwCB: Phy%d SAS link Up\n", PhyID)); 851 852 if (agPortContext == agNULL) 853 { 854 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n")); 855 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y2"); 856 return; 857 } 858 if (agDevHandle == agNULL) 859 { 860 TI_DBG3(("ossaHwCB: agDevHandle null by design change\n")); 861 } 862 863 if (IDframe == agNULL) 864 { 865 TI_DBG1(("ossaHwCB: IDframe null, wrong\n")); 866 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y2"); 867 return; 868 } 869 /* debugging only */ 870 if (LinkRate == 0x01) 871 { 872 TI_DBG1(("ossaHwCB: SAS Link Rate is 1.5 Gbps PhyID %d\n",PhyID)); 873 } 874 if (LinkRate == 0x02) 875 { 876 TI_DBG1(("ossaHwCB: SAS Link Rate is 3.0 Gbps PhyID %d\n",PhyID)); 877 } 878 if (LinkRate == 0x04) 879 { 880 TI_DBG1(("ossaHwCB: SAS Link Rate is 6.0 Gbps PhyID %d\n",PhyID)); 881 } 882 if (LinkRate == 0x08) 883 { 884 TI_DBG1(("ossaHwCB: SAS Link Rate is 12.0 Gbps PhyID %d\n",PhyID)); 885 } 886 887 if (PortState == OSSA_PORT_INVALID) 888 { 889 TI_DBG1(("ossaHwCB: Wrong port state with SAS link up\n")); 890 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y2"); 891 return; 892 } 893 894 if ( agPortContext->osData == agNULL) 895 {/* if */ 896 TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared)); 897 if (tdsaAllShared->Ports[PhyID].tiPortalContext == agNULL) 898 { 899 TI_DBG6(("ossaHwCB: NULL portalcontext\n")); 900 } 901 else 902 { 903 TI_DBG6(("ossaHwCB: NOT NULL portalcontext\n")); 904 } 905 906 if (IDframe == agNULL) 907 { 908 TI_DBG1(("ossaHwCB: IDFrame is NULL; SATA !!!!\n")); 909 } 910 else 911 { 912 TI_DBG3(("ossaHwCB: IDframe->sasAddressHi 0x%08x \n", 913 SA_IDFRM_GET_SAS_ADDRESSHI(IDframe))); 914 TI_DBG3(("ossaHwCB: IDframe->sasAddressLo 0x%08x \n", 915 SA_IDFRM_GET_SAS_ADDRESSLO(IDframe))); 916 917 } 918 /* 919 setting tdsaPortContext fields 920 take the head from the FreeLink of tdsaPortContext_t 921 then modify it 922 then put it in MainLink of tdsaPortContext_t 923 */ 924 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 925 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList))) 926 { 927 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList)); 928 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 929 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList); 930 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 931 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext)); 932 if (onePortContext == agNULL) 933 { 934 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n")); 935 return; 936 } 937 938 /* sets fields of tdsaportcontext */ 939 #ifdef INITIATOR_DRIVER 940 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 941 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START; 942 #endif 943 onePortContext->PhyIDList[PhyID] = agTRUE; 944 if (IDframe == agNULL) 945 { 946 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF; 947 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF; 948 onePortContext->directAttatchedSAS = agTRUE; 949 } 950 else 951 { 952 onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe); 953 onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe); 954 /* Create ID frame and storing ID frame */ 955 osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t)); 956 tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t)); 957 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE) 958 { 959 onePortContext->directAttatchedSAS = agTRUE; 960 } 961 #ifdef FDS_DM 962 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_EDGE_EXPANDER_DEVICE || 963 SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_FANOUT_EXPANDER_DEVICE 964 ) 965 { 966 onePortContext->UseDM = agTRUE; 967 } 968 #endif 969 } 970 971 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID); 972 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID); 973 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext; 974 onePortContext->agRoot = agRoot; 975 onePortContext->agPortContext = agPortContext; 976 tdsaAllShared->Ports[PhyID].portContext = onePortContext; 977 agPortContext->osData = onePortContext; 978 onePortContext->valid = agTRUE; 979 if (LinkRate == 0x01) 980 { 981 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G; 982 } 983 else if (LinkRate == 0x02) 984 { 985 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G; 986 } 987 else if (LinkRate == 0x04) 988 { 989 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G; 990 } 991 else /* (LinkRate == 0x08) */ 992 { 993 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G; 994 } 995 996 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 997 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList)); 998 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 999 #ifdef FDS_DM 1000 dmPortContext = &(onePortContext->dmPortContext); 1001 dmPortContext->tdData = onePortContext; 1002 /* set up dmPortInfo_t */ 1003 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo); 1004 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi); 1005 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo); 1006 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi); 1007 1008 TI_DBG2(("ossaHwCB: phy %d hi 0x%x lo 0x%x\n", PhyID, 1009 SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[PhyID].SASID)), 1010 SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[PhyID].SASID)))); 1011 TI_DBG2(("ossaHwCB: LocalAddrHi 0x%08x LocaAddrLo 0x%08x\n", onePortContext->sasLocalAddressHi, onePortContext->sasLocalAddressLo)); 1012 1013 dmPortInfo.flag = onePortContext->LinkRate; 1014 1015 if (onePortContext->UseDM == agTRUE) 1016 { 1017 TI_DBG1(("ossaHwCB: calling dmCreatePort\n")); 1018 status = dmCreatePort(dmRoot, dmPortContext, &dmPortInfo); 1019 if (status != DM_RC_SUCCESS) 1020 { 1021 TI_DBG1(("ossaHwCB: dmCreatePort failed!!! 0x%x\n", status)); 1022 } 1023 } 1024 #endif 1025 1026 } 1027 else 1028 { 1029 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1030 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n")); 1031 } 1032 #ifdef TD_INTERNAL_DEBUG /* for debugging only */ 1033 1034 print_tdlist_flink(&(tdsaPortContext->FreeLink), 1, 1); 1035 print_tdlist_flink(&(tdsaPortContext->MainLink), 1, 2); 1036 print_tdlist_flink(&(tdsaDeviceData->FreeLink), 2, 1); 1037 print_tdlist_flink(&(tdsaDeviceData->MainLink), 2, 2); 1038 #endif 1039 1040 #ifdef TD_INTERNAL_DEBUG /* for debugging */ 1041 PortContextList = tdsaPortContext->MainLink.flink; 1042 while (PortContextList != &(tdsaPortContext->MainLink)) 1043 { 1044 twoPortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList); 1045 TI_DBG6(("ossaHwCB: in while portContext ID %d\n", twoPortContext->id)); 1046 TI_DBG6(("ossaHwCB: in while PortContext %p\n", twoPortContext)); 1047 PortContextList = PortContextList->flink; 1048 } 1049 #endif 1050 /* add agDevHandle */ 1051 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE) 1052 { 1053 #ifdef INITIATOR_DRIVER 1054 agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe); 1055 agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe); 1056 agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp; 1057 agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp; 1058 #endif 1059 1060 TI_DBG2(("ossaHwCB: adding ....\n")); 1061 /* uses only SASIDframe not agsaSASDeviceInfo_t */ 1062 #ifdef INITIATOR_DRIVER 1063 tdssAddSASToSharedcontext( 1064 onePortContext, 1065 agRoot, 1066 agDevHandle, /* agNULL */ 1067 &agSASSubID, 1068 agTRUE, 1069 (bit8)PhyID, 1070 TD_OPERATION_INITIATOR 1071 ); 1072 #endif 1073 1074 #ifdef FDS_DM 1075 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE && 1076 SA_IDFRM_IS_SSP_TARGET(IDframe) ) 1077 { 1078 TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID)); 1079 1080 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++) 1081 { 1082 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL); 1083 } 1084 } 1085 1086 /* update MCN */ 1087 tdsaUpdateMCN(dmRoot, onePortContext); 1088 #endif 1089 1090 #ifdef TARGET_DRIVER 1091 TI_DBG1(("ossaHwCB: target, link up PhyID 0x%x\n",PhyID)); 1092 1093 /* notifying link up */ 1094 ostiPortEvent ( 1095 tiRoot, 1096 tiPortLinkUp, 1097 tiSuccess, 1098 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 1099 ); 1100 #endif 1101 } 1102 else 1103 { 1104 TI_DBG5(("ossaHwCB: $$$$$ not end device. not adding....\n")); 1105 } 1106 1107 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RECOVERY_TIME */ 1108 agNULL, 1109 0, 1110 agPortContext, 1111 AGSA_PORT_SET_PORT_RECOVERY_TIME, 1112 tdsaAllShared->portTMO, //PORT_RECOVERY_TIMEOUT 1113 0 1114 ); 1115 /* setting SAS PORT RESET TMO and SATA PORT RESET TMO*/ 1116 if (tIsSPCV12G(agRoot)) 1117 { 1118 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */ 1119 agNULL, 1120 0, 1121 agPortContext, 1122 AGSA_PORT_SET_PORT_RESET_TIME, 1123 SAS_12G_PORT_RESET_TMO, // 800 ms 1124 0 1125 ); 1126 } 1127 else 1128 { 1129 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */ 1130 agNULL, 1131 0, 1132 agPortContext, 1133 AGSA_PORT_SET_PORT_RESET_TIME, 1134 SAS_PORT_RESET_TMO, // 300 ms 1135 0 1136 ); 1137 } 1138 } 1139 else 1140 { 1141 /* 1142 an existing portcontext 1143 to be tested 1144 */ 1145 1146 TI_DBG2(("ossaHwCB: SAS existing portcontext returned\n")); 1147 1148 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 1149 if (onePortContext == agNULL) 1150 { 1151 TI_DBG1(("ossaHwCB: onePortContext is NULL, wrong!\n")); 1152 return; 1153 } 1154 if (onePortContext->valid == agFALSE) 1155 { 1156 /* port has been invalidated; needs to be allocated */ 1157 TI_DBG2(("ossaHwCB: SAS allocating port context\n")); 1158 1159 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1160 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList))) 1161 { 1162 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList)); 1163 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1164 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList); 1165 TI_DBG2(("ossaHwCB: allocating pid %d\n", onePortContext->id)); 1166 TI_DBG6(("ossaHwCB: allocating onePortContext %p\n", onePortContext)); 1167 if (onePortContext == agNULL) 1168 { 1169 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n")); 1170 return; 1171 } 1172 /* sets fields of tdsaportcontext */ 1173 #ifdef INITIATOR_DRIVER 1174 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 1175 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START; 1176 #endif 1177 onePortContext->PhyIDList[PhyID] = agTRUE; 1178 if (IDframe == agNULL) 1179 { 1180 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF; 1181 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF; 1182 onePortContext->directAttatchedSAS = agTRUE; 1183 } 1184 else 1185 { 1186 onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe); 1187 onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe); 1188 /* Create ID frame and storing ID frame */ 1189 osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t)); 1190 tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t)); 1191 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE) 1192 { 1193 onePortContext->directAttatchedSAS = agTRUE; 1194 } 1195 } 1196 1197 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID); 1198 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID); 1199 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext; 1200 onePortContext->agRoot = agRoot; 1201 onePortContext->agPortContext = agPortContext; 1202 tdsaAllShared->Ports[PhyID].portContext = onePortContext; 1203 agPortContext->osData = onePortContext; 1204 onePortContext->valid = agTRUE; 1205 if (LinkRate == 0x01) 1206 { 1207 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G; 1208 } 1209 else if (LinkRate == 0x02) 1210 { 1211 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G; 1212 } 1213 else if (LinkRate == 0x04) 1214 { 1215 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G; 1216 } 1217 else /* (LinkRate == 0x08) */ 1218 { 1219 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G; 1220 } 1221 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1222 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList)); 1223 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1224 } 1225 else 1226 { 1227 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1228 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n")); 1229 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y2"); 1230 return; 1231 } 1232 } /* invalidated port */ 1233 else 1234 { 1235 /* already alloacated */ 1236 TI_DBG2(("ossaHwCB: SAS already allocated port context\n")); 1237 if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList))) 1238 { 1239 TI_DBG1(("ossaHwCB: wrong!!! null tdsaPortContext list\n")); 1240 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y2"); 1241 return; 1242 } 1243 if (onePortContext == agNULL) 1244 { 1245 TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n")); 1246 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "Y2"); 1247 return; 1248 } 1249 1250 TI_DBG2(("ossaHwCB: existing pid %d\n", onePortContext->id)); 1251 if (tdsaAllShared->Ports[PhyID].portContext == agNULL) 1252 { 1253 TI_DBG1(("ossaHwCB: existing allshared pid is NULL\n")); 1254 } 1255 else 1256 { 1257 TI_DBG2(("ossaHwCB: existing allshared pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id)); 1258 } 1259 /* updates PhyID belong to a port */ 1260 onePortContext->PhyIDList[PhyID] = agTRUE; 1261 #ifdef FDS_DM 1262 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE && 1263 SA_IDFRM_IS_SSP_TARGET(IDframe) ) 1264 { 1265 TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID)); 1266 1267 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++) 1268 { 1269 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL); 1270 } 1271 } 1272 1273 /* update MCN */ 1274 tdsaUpdateMCN(dmRoot, onePortContext); 1275 #endif 1276 } 1277 onePortContext->SeenLinkUp = agTRUE; 1278 } /* else, old portcontext */ 1279 1280 break; 1281 } 1282 #ifdef INITIATOR_DRIVER 1283 case OSSA_HW_EVENT_SATA_PHY_UP: 1284 { 1285 PhyID = TD_GET_PHY_ID(eventParm1); 1286 LinkRate = TD_GET_LINK_RATE(eventParm1); 1287 PortState = TD_GET_PORT_STATE(eventParm1); 1288 agDevHandle = agNULL; 1289 RegD2H = ( agsaFisRegDeviceToHost_t *)eventParm3; 1290 1291 TI_DBG2(("ossaHwCB: Phy%d SATA link Up\n", PhyID)); 1292 1293 if (agDevHandle == agNULL) 1294 { 1295 TI_DBG3(("ossaHwCB: agDevHandle null by design change\n")); 1296 } 1297 1298 if (RegD2H == agNULL) 1299 { 1300 TI_DBG1(("ossaHwCB: RegD2H null, wrong\n")); 1301 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "Y2"); 1302 return; 1303 } 1304 1305 1306 TI_DBG2(("ossaHwCB: agDevHandle %p\n", agDevHandle)); 1307 tdhexdump("ossaHWCB RegD2H", (bit8 *)RegD2H, sizeof(agsaFisRegDeviceToHost_t)); 1308 TI_DBG2(("ossaHwCB: Sector Count %d\n", RegD2H->d.sectorCount)); 1309 TI_DBG2(("ossaHwCB: LBA LOW %d\n", RegD2H->d.lbaLow)); 1310 TI_DBG2(("ossaHwCB: LBA MID %d\n", RegD2H->d.lbaMid)); 1311 TI_DBG2(("ossaHwCB: LBA HIGH %d\n", RegD2H->d.lbaHigh)); 1312 TI_DBG2(("ossaHwCB: DEVICE %d\n", RegD2H->d.device)); 1313 1314 /* debugging only */ 1315 if (LinkRate == 0x01) 1316 { 1317 TI_DBG1(("ossaHwCB: SATA Link Rate is 1.5 Gbps PhyID %d\n",PhyID)); 1318 } 1319 if (LinkRate == 0x02) 1320 { 1321 TI_DBG1(("ossaHwCB: SATA Link Rate is 3.0 Gbps PhyID %d\n",PhyID)); 1322 } 1323 if (LinkRate == 0x04) 1324 { 1325 TI_DBG1(("ossaHwCB: SATA Link Rate is 6.0 Gbps PhyID %d\n",PhyID)); 1326 } 1327 if (LinkRate == 0x08) 1328 { 1329 TI_DBG1(("ossaHwCB: SATA Link Rate is 12.0 Gbps PhyID %d\n",PhyID)); 1330 } 1331 1332 if (PortState == OSSA_PORT_INVALID) 1333 { 1334 TI_DBG1(("ossaHwCB: Wrong port state with SATA link up\n")); 1335 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "Y2"); 1336 return; 1337 } 1338 1339 if ( agPortContext->osData == agNULL) 1340 {/* if */ 1341 TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared)); 1342 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1343 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList))) 1344 { 1345 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList)); 1346 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1347 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList); 1348 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 1349 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext)); 1350 if (onePortContext == agNULL) 1351 { 1352 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n")); 1353 return; 1354 } 1355 1356 /* sets fields of tdsaportcontext */ 1357 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 1358 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START; 1359 onePortContext->PhyIDList[PhyID] = agTRUE; 1360 /* NO sas address for SATA */ 1361 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF; 1362 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF; 1363 /* copying the signature */ 1364 onePortContext->remoteSignature[0] = RegD2H->d.sectorCount; 1365 onePortContext->remoteSignature[1] = RegD2H->d.lbaLow; 1366 onePortContext->remoteSignature[2] = RegD2H->d.lbaMid; 1367 onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh; 1368 onePortContext->remoteSignature[4] = RegD2H->d.device; 1369 1370 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID); 1371 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID); 1372 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext; 1373 onePortContext->agRoot = agRoot; 1374 onePortContext->agPortContext = agPortContext; 1375 tdsaAllShared->Ports[PhyID].portContext = onePortContext; 1376 agPortContext->osData = onePortContext; 1377 onePortContext->nativeSATAMode = agTRUE; 1378 onePortContext->valid = agTRUE; 1379 if (LinkRate == 0x01) 1380 { 1381 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G; 1382 } 1383 else if (LinkRate == 0x02) 1384 { 1385 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G; 1386 } 1387 else if (LinkRate == 0x04) 1388 { 1389 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G; 1390 } 1391 else /* (LinkRate == 0x08) */ 1392 { 1393 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G; 1394 } 1395 1396 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1397 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList)); 1398 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1399 } 1400 else 1401 { 1402 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1403 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n")); 1404 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "Y2"); 1405 return; 1406 } 1407 #ifdef SATA_ENABLE 1408 /* tdssAddSATAToSharedcontext() sends identify device data to find out the uniqueness of 1409 target. In identify device data CB fn (satAddSATAIDDevCB()), 1410 tiPortLinkUp and tiPortDiscoveryReady happen 1411 */ 1412 tdssAddSATAToSharedcontext( 1413 onePortContext, 1414 agRoot, 1415 agDevHandle, /* agNULL */ 1416 agNULL, 1417 agTRUE, 1418 (bit8)PhyID 1419 ); 1420 #endif 1421 /* setting SAS PORT RESET TMO and SATA PORT RESET TMO*/ 1422 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */ 1423 agNULL, 1424 0, 1425 agPortContext, 1426 AGSA_PORT_SET_PORT_RESET_TIME, 1427 0, 1428 SATA_PORT_RESET_TMO // 8000 ms 1429 ); 1430 1431 } 1432 else 1433 { 1434 /* 1435 an existing portcontext 1436 to be tested 1437 */ 1438 1439 TI_DBG1(("ossaHwCB: SATA existing portcontext returned. need testing\n")); 1440 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 1441 /* for debugging only */ 1442 if (onePortContext->valid == agFALSE) 1443 { 1444 /* port has been invalidated; needs to be allocated */ 1445 TI_DBG2(("ossaHwCB: SATA allocating port context\n")); 1446 } 1447 else 1448 { 1449 /* already alloacated */ 1450 TI_DBG1(("ossaHwCB: Wrong!!! SATA already allocated port context\n")); 1451 smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "Y2"); 1452 return; 1453 } 1454 1455 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1456 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList))) 1457 { 1458 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList)); 1459 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1460 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList); 1461 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 1462 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext)); 1463 if (onePortContext == agNULL) 1464 { 1465 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n")); 1466 return; 1467 } 1468 1469 /* sets fields of tdsaportcontext */ 1470 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 1471 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START; 1472 onePortContext->PhyIDList[PhyID] = agTRUE; 1473 /* NO sas address for SATA */ 1474 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF; 1475 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF; 1476 /* copying the signature */ 1477 onePortContext->remoteSignature[0] = RegD2H->d.sectorCount; 1478 onePortContext->remoteSignature[1] = RegD2H->d.lbaLow; 1479 onePortContext->remoteSignature[2] = RegD2H->d.lbaMid; 1480 onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh; 1481 onePortContext->remoteSignature[4] = RegD2H->d.device; 1482 1483 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID); 1484 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID); 1485 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext; 1486 onePortContext->agRoot = agRoot; 1487 onePortContext->agPortContext = agPortContext; 1488 tdsaAllShared->Ports[PhyID].portContext = onePortContext; 1489 agPortContext->osData = onePortContext; 1490 onePortContext->nativeSATAMode = agTRUE; 1491 onePortContext->valid = agTRUE; 1492 if (LinkRate == 0x01) 1493 { 1494 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G; 1495 } 1496 else if (LinkRate == 0x02) 1497 { 1498 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G; 1499 } 1500 else if (LinkRate == 0x04) 1501 { 1502 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G; 1503 } 1504 else /* (LinkRate == 0x08) */ 1505 { 1506 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G; 1507 } 1508 1509 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 1510 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList)); 1511 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1512 } 1513 else 1514 { 1515 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 1516 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n")); 1517 smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "Y2"); 1518 return; 1519 } 1520 1521 1522 /*hotplug */ 1523 #ifdef SATA_ENABLE 1524 tdssAddSATAToSharedcontext( 1525 onePortContext, 1526 agRoot, 1527 agDevHandle, /* agNULL */ 1528 agNULL, 1529 agTRUE, 1530 (bit8)PhyID 1531 ); 1532 #endif 1533 /* end hotplug */ 1534 } 1535 1536 break; 1537 } 1538 #endif 1539 case OSSA_HW_EVENT_SATA_SPINUP_HOLD: 1540 { 1541 PhyID = TD_GET_PHY_ID(eventParm1); 1542 1543 TI_DBG2(("ossaHwCB: spinup hold PhyID %d\n", PhyID)); 1544 break; 1545 } 1546 1547 case OSSA_HW_EVENT_PHY_DOWN: 1548 { 1549 bit32 AllPhyDown = agTRUE; 1550 1551 /* 4/15/08 spec */ 1552 PhyID = TD_GET_PHY_ID(eventParm1); 1553 LinkRate = TD_GET_LINK_RATE(eventParm1); 1554 PortState = TD_GET_PORT_STATE(eventParm1); 1555 1556 1557 TI_DBG2(("ossaHwCB: Phy%d link Down\n", PhyID)); 1558 1559 if (agPortContext == agNULL) 1560 { 1561 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n")); 1562 smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "Y2"); 1563 return; 1564 } 1565 1566 if ( agPortContext->osData == agNULL) 1567 { /* if */ 1568 /* PortContext must exit at this point */ 1569 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n")); 1570 } 1571 else 1572 { 1573 TI_DBG3(("ossaHwCB: NOT NULL portalcontext\n")); 1574 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 1575 if (onePortContext == agNULL) 1576 { 1577 TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n")); 1578 smTraceFuncExit(hpDBG_VERY_LOUD, 'm', "Y2"); 1579 return; 1580 } 1581 onePortContext->PhyIDList[PhyID] = agFALSE; 1582 for(i=0;i<TD_MAX_NUM_PHYS;i++) 1583 { 1584 if (onePortContext->PhyIDList[i] == agTRUE) 1585 { 1586 TI_DBG3(("ossaHwCB: Phy %d is still up\n", i)); 1587 AllPhyDown = agFALSE; 1588 break; 1589 } 1590 } 1591 1592 /* last phy belong to the portcontext */ 1593 if (AllPhyDown == agTRUE) 1594 { 1595 #ifdef NOT_YET 1596 TI_DBG1(("ossaHwCB: calling tiPortLinkDown\n")); 1597 ostiPortEvent ( 1598 tiRoot, 1599 tiPortLinkDown, 1600 tiSuccess, 1601 (void *)onePortContext->tiPortalContext 1602 ); 1603 #endif 1604 } 1605 1606 if (PortState == OSSA_PORT_VALID) 1607 { 1608 /* do nothing */ 1609 /* no ack for every phy down */ 1610 #ifdef FDS_DM 1611 /* update MCN for all devices belong to this port */ 1612 tdsaUpdateMCN(dmRoot, onePortContext); 1613 #endif 1614 } 1615 else if (PortState == OSSA_PORT_LOSTCOMM) 1616 { 1617 /* 1618 1. Mark the port as invalid and stop the io for that port and its device 1619 No ack here. Otherwise, port will be released by FW. 1620 */ 1621 TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_LOSTCOMM\n")); 1622 /* save eventSource related information in tdsaAllShared */ 1623 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE; 1624 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext; 1625 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN; 1626 /* phy ID */ 1627 tdsaAllShared->eventSource[PhyID].Source.param = PhyID; 1628 /* phy ID */ 1629 onePortContext->eventPhyID = PhyID; 1630 /* to stop IO's */ 1631 onePortContext->valid = agFALSE; 1632 break; 1633 } 1634 else if (PortState == OSSA_PORT_IN_RESET) 1635 { 1636 TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_IN_RESET\n")); 1637 /* save eventSource related information in tdsaAllShared */ 1638 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE; 1639 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext; 1640 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN; 1641 /* phy ID */ 1642 tdsaAllShared->eventSource[PhyID].Source.param = PhyID; 1643 /* phy ID */ 1644 onePortContext->eventPhyID = PhyID; 1645 /* to stop IO's */ 1646 onePortContext->valid = agFALSE; 1647 break; 1648 } 1649 else if (PortState == OSSA_PORT_INVALID) 1650 { 1651 TI_DBG1(("ossaHwCB: Last phy Down and port invalid OSSA_PORT_INVALID\n")); 1652 /* 1653 invalidate port 1654 then, saHwEventAck() in ossaDeregisterDeviceHandleCB() 1655 */ 1656 1657 /* save eventSource related information in tdsaAllShared */ 1658 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE; 1659 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext; 1660 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN; 1661 /* phy ID */ 1662 tdsaAllShared->eventSource[PhyID].Source.param = PhyID; 1663 /* phy ID */ 1664 onePortContext->eventPhyID = PhyID; 1665 1666 onePortContext->valid = agFALSE; 1667 1668 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 1669 #ifdef INITIATOR_DRIVER 1670 /* notifying link down (all links belonging to a port are down) */ 1671 ostiPortEvent( 1672 tiRoot, 1673 tiPortStopped, 1674 tiSuccess, 1675 (void *)onePortContext->tiPortalContext 1676 ); 1677 #endif 1678 1679 #ifdef TARGET_DRIVER 1680 ostiPortEvent( 1681 tiRoot, 1682 tiPortLinkDown, 1683 tiSuccess, 1684 (void *)onePortContext->tiPortalContext 1685 ); 1686 1687 #endif 1688 1689 #ifdef INITIATOR_DRIVER 1690 tdssReportRemovals(agRoot, 1691 onePortContext, 1692 agFALSE 1693 ); 1694 #endif 1695 #ifdef TARGET_DRIVER 1696 ttdssReportRemovals(agRoot, 1697 onePortContext, 1698 agFALSE 1699 ); 1700 1701 #endif 1702 1703 /* find a PhyID and reset for portContext in tdssSASShared */ 1704 for(i=0;i<TD_MAX_NUM_PHYS;i++) 1705 { 1706 if (onePortContext->PhyIDList[i] == agTRUE) 1707 { 1708 tdsaAllShared->Ports[i].portContext = agNULL; 1709 } 1710 } 1711 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or 1712 ossaDeregisterDeviceHandleCB 1713 */ 1714 }/* OSSA_PORT_INVALID */ 1715 else 1716 { 1717 /* other newly defined port state */ 1718 /* do nothing */ 1719 TI_DBG2(("ossaHwCB: portstate 0x%x\n", PortState)); 1720 } 1721 } /* big else */ 1722 break; 1723 } 1724 case OSSA_HW_EVENT_PHY_START_STATUS: 1725 { 1726 PhyID = TD_GET_PHY_ID(eventParm1); 1727 PhyStatus = TD_GET_PHY_STATUS(eventParm1); 1728 1729 TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS\n")); 1730 if (PhyStatus == 0x00) 1731 { 1732 TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, SUCCESS\n")); 1733 } 1734 else if (PhyStatus == 0x01) 1735 { 1736 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, INVALID_PHY\n")); 1737 } 1738 else if (PhyStatus == 0x02) 1739 { 1740 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, PHY_NOT_DISABLED\n")); 1741 } 1742 else 1743 { 1744 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, OTHER_FAILURE %d\n", PhyStatus)); 1745 } 1746 break; 1747 } 1748 case OSSA_HW_EVENT_PHY_STOP_STATUS: 1749 { 1750 agsaContext_t *agContext; 1751 PhyID = TD_GET_PHY_ID(eventParm1); 1752 PhyStatus = TD_GET_PHY_STATUS(eventParm1); 1753 PortState = TD_GET_PORT_STATE(eventParm1); 1754 1755 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS\n")); 1756 if (PhyStatus == 0x00) 1757 { 1758 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, SUCCESS\n")); 1759 agContext = (agsaContext_t *)eventParm2; 1760 onePortContext = (tdsaPortContext_t *)agContext->osData; 1761 if (onePortContext == agNULL) 1762 { 1763 TI_DBG1(("ossaHwCB: onePortContext is null, wrong!!!\n")); 1764 return; 1765 } 1766 onePortContext->PhyIDList[PhyID] = agFALSE; 1767 if (PortState == OSSA_PORT_INVALID) /* invalid port */ 1768 { 1769 TI_DBG1(("ossaHwCB: OSSA_PORT_INVALID\n")); 1770 tdsaAllShared->eventSource[PhyID].EventValid = NO_ACK; 1771 onePortContext->eventPhyID = PhyID; 1772 onePortContext->valid = agFALSE; 1773 1774 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 1775 #ifdef INITIATOR_DRIVER 1776 /* notifying link down (all links belonging to a port are down) */ 1777 ostiPortEvent( 1778 tiRoot, 1779 tiPortStopped, 1780 tiSuccess, 1781 (void *)onePortContext->tiPortalContext 1782 ); 1783 #endif 1784 1785 #ifdef TARGET_DRIVER 1786 ostiPortEvent( 1787 tiRoot, 1788 tiPortLinkDown, 1789 tiSuccess, 1790 (void *)onePortContext->tiPortalContext 1791 ); 1792 1793 #endif 1794 1795 #ifdef INITIATOR_DRIVER 1796 tdssReportRemovals(agRoot, 1797 onePortContext, 1798 agFALSE 1799 ); 1800 #endif 1801 #ifdef TARGET_DRIVER 1802 ttdssReportRemovals(agRoot, 1803 onePortContext, 1804 agFALSE 1805 ); 1806 1807 #endif 1808 1809 /* find a PhyID and reset for portContext in tdssSASShared */ 1810 for(i=0;i<TD_MAX_NUM_PHYS;i++) 1811 { 1812 if (onePortContext->PhyIDList[i] == agTRUE) 1813 { 1814 tdsaAllShared->Ports[i].portContext = agNULL; 1815 } 1816 } 1817 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or 1818 ossaDeregisterDeviceHandleCB 1819 */ 1820 } /* invalid port */ 1821 } 1822 else if (PhyStatus == 0x01) 1823 { 1824 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, INVALID_PHY\n")); 1825 } 1826 else if (PhyStatus == 0x02) 1827 { 1828 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, DEVICES_ATTACHED\n")); 1829 } 1830 else if (PhyStatus == 0x03) 1831 { 1832 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, OTHER_FAILURE\n")); 1833 } 1834 else if (PhyStatus == 0x04) 1835 { 1836 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, PHY_NOT_DISABLED\n")); 1837 } 1838 else 1839 { 1840 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, Unknown %d\n", PhyStatus)); 1841 } 1842 break; 1843 } 1844 1845 case OSSA_HW_EVENT_RESET_START: 1846 { 1847 bit32 new_status = TD_GET_RESET_STATUS(eventParm1); 1848 TI_DBG2(("ossaHwCB: RESET_START, status %d\n", new_status)); 1849 if (new_status == OSSA_SUCCESS) 1850 { 1851 tdsaAllShared->flags.resetInProgress = agTRUE; 1852 TI_DBG2(("ossaHwCB: RESET_START, SUCCESS\n")); 1853 } 1854 else if (new_status == OSSA_FAILURE) 1855 { 1856 TI_DBG1(("ossaHwCB: RESET_START, FAILURE\n")); 1857 } 1858 else 1859 { 1860 TI_DBG1(("ossaHwCB: RESET_START, PENDING\n")); 1861 } 1862 break; 1863 } 1864 1865 case OSSA_HW_EVENT_RESET_COMPLETE: 1866 { 1867 bit32 new_status = TD_GET_RESET_STATUS(eventParm1); 1868 #ifdef SOFT_RESET_TEST 1869 DbgPrint("Reset Complete\n"); 1870 #endif 1871 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_RESET_COMPLETE, status %d\n", new_status)); 1872 if (new_status == OSSA_SUCCESS) 1873 { 1874 /* remove all portcontext and devices */ 1875 #ifdef INITIATOR_DRIVER 1876 tdssRemoveSASSATAFromSharedcontextByReset(agRoot); 1877 #endif 1878 tdsaAllShared->flags.resetInProgress = agFALSE; 1879 /* 1880 a callback notifying reset completion 1881 */ 1882 ostiPortEvent( 1883 tiRoot, 1884 tiPortResetComplete, 1885 tiSuccess, 1886 agNULL 1887 ); 1888 } 1889 else 1890 { 1891 /* 1892 a callback notifying reset completion 1893 */ 1894 tdsaAllShared->flags.resetInProgress = agFALSE; 1895 ostiPortEvent( 1896 tiRoot, 1897 tiPortResetComplete, 1898 tiError, 1899 agNULL 1900 ); 1901 1902 } 1903 break; 1904 } 1905 1906 case OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC: 1907 { 1908 PhyID = TD_GET_PHY_ID(eventParm1); 1909 PortState = TD_GET_PORT_STATE(eventParm1); 1910 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 1911 1912 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d; to be tested\n", PhyID)); 1913 1914 if (PortState == OSSA_PORT_INVALID) 1915 { 1916 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC\n")); 1917 smTraceFuncExit(hpDBG_VERY_LOUD, 'n', "Y2"); 1918 return; 1919 } 1920 1921 if (agPhyErrCountersPage != agNULL) 1922 { 1923 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d\n", PhyID)); 1924 TI_DBG1(("ossaHwCB: iDw %d rDE %d cV %d lS %d rP %d iCRC %d\n", 1925 agPhyErrCountersPage->invalidDword, 1926 agPhyErrCountersPage->runningDisparityError, 1927 agPhyErrCountersPage->codeViolation, 1928 agPhyErrCountersPage->lossOfDwordSynch, 1929 agPhyErrCountersPage->phyResetProblem, 1930 agPhyErrCountersPage->inboundCRCError )); 1931 } 1932 else 1933 { 1934 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC: Error!!! eventParm2 is NULL\n")); 1935 } 1936 1937 /* saHwEventAck() */ 1938 eventSource.agPortContext = agPortContext; 1939 eventSource.event = OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC; 1940 /* phy ID */ 1941 eventSource.param = PhyID; 1942 HwAckSatus = saHwEventAck( 1943 agRoot, 1944 agNULL, /* agContext */ 1945 0, 1946 &eventSource, /* agsaEventSource_t */ 1947 0, 1948 0 1949 ); 1950 if ( HwAckSatus != AGSA_RC_SUCCESS) 1951 { 1952 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 1953 smTraceFuncExit(hpDBG_VERY_LOUD, 'o', "Y2"); 1954 return; 1955 } 1956 break; 1957 } 1958 #ifdef REMOVED 1959 case OSSA_HW_EVENT_PORT_INVALID: 1960 { 1961 TI_DBG1(("ossaHwCB: PORT_INVALID\n")); 1962 1963 if ( agPortContext == agNULL) 1964 { 1965 TI_DBG1(("ossaHwCB: agPortContext is NULL, wrong.\n")); 1966 smTraceFuncExit(hpDBG_VERY_LOUD, 'p', "Y2"); 1967 return; 1968 } 1969 if ( agPortContext->osData != agNULL) 1970 { 1971 TI_DBG1(("ossaHwCB: NOT NULL osDATA\n")); 1972 /* 1973 put the old portcontext back to free list 1974 */ 1975 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 1976 TI_DBG1(("ossaHwCB: pid %d\n", onePortContext->id)); 1977 1978 #ifdef INITIATOR_DRIVER 1979 /* notifying link down (all links belonging to a port are down) */ 1980 ostiPortEvent ( 1981 tiRoot, 1982 tiPortStopped, 1983 tiSuccess, 1984 (void *)onePortContext->tiPortalContext 1985 1986 ); 1987 #endif /* INITIATOR_DRIVER */ 1988 #ifdef TARGET_DRIVER 1989 ostiPortEvent( 1990 tiRoot, 1991 tiPortLinkDown, 1992 tiSuccess, 1993 (void *)onePortContext->tiPortalContext 1994 ); 1995 1996 #endif /*TARGET_DRIVER */ 1997 1998 /* find the device belonging to the port and remove it from the device list */ 1999 //tdssRemoveSASSATAFromSharedcontext(agRoot, tdsaDeviceData, onePortContext); 2000 2001 2002 #ifdef INITIATOR_DRIVER 2003 /* reset the fields of portcontext */ 2004 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 2005 tdssReportRemovals(agRoot, 2006 onePortContext, 2007 agFALSE 2008 ); 2009 2010 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START; 2011 onePortContext->DiscoveryRdyGiven = agFALSE; 2012 onePortContext->SeenLinkUp = agFALSE; 2013 2014 #endif /* INITIATOR_DRIVER */ 2015 2016 2017 2018 /* for hotplug */ 2019 2020 /* find a PhyID and reset for portContext in tdssSASShared */ 2021 for(i=0;i<TD_MAX_NUM_PHYS;i++) 2022 { 2023 if (onePortContext->PhyIDList[i] == agTRUE) 2024 { 2025 tdsaAllShared->Ports[i].portContext = agNULL; 2026 } 2027 } 2028 2029 /* reset PhyIDList in portcontext */ 2030 for(i=0;i<TD_MAX_NUM_PHYS;i++) 2031 { 2032 onePortContext->PhyIDList[i] = agFALSE; 2033 } 2034 2035 // onePortContext->tiPortalContext = agNULL; 2036 // onePortContext->agRoot = agNULL; 2037 onePortContext->agPortContext = agNULL; 2038 onePortContext->valid = agFALSE; 2039 2040 TI_DBG4(("ossaHwCB: pid %d count %d\n", onePortContext->id, onePortContext->Count)); 2041 2042 /* resets the number of devices in onePortContext */ 2043 onePortContext->Count = 0; 2044 onePortContext->discovery.pendingSMP = 0; 2045 onePortContext->discovery.SeenBC = agFALSE; 2046 2047 2048 /* 2049 put all devices belonging to the onePortContext 2050 back to the free link 2051 */ 2052 2053 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 2054 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink)); 2055 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaPortContext->FreeLink)); 2056 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 2057 } 2058 else 2059 { 2060 TI_DBG1(("ossaHwCB: NULL osDATA: wrong\n")); 2061 } 2062 TI_DBG6(("ossaHwCB: PORT_INVALID end\n")); 2063 break; 2064 } 2065 #endif /* REMOVED */ 2066 2067 case OSSA_HW_EVENT_BROADCAST_CHANGE: 2068 { 2069 PhyID = TD_GET_PHY_ID(eventParm1); 2070 PortState = TD_GET_PORT_STATE(eventParm1); 2071 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE from PhyID %d\n", PhyID)); 2072 2073 if (PortState == OSSA_PORT_INVALID) 2074 { 2075 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_CHANGE\n")); 2076 smTraceFuncExit(hpDBG_VERY_LOUD, 'q', "Y2"); 2077 return; 2078 } 2079 /* saHwEventAck() */ 2080 eventSource.agPortContext = agPortContext; 2081 eventSource.event = OSSA_HW_EVENT_BROADCAST_CHANGE; 2082 /* phy ID */ 2083 eventSource.param = PhyID; 2084 HwAckSatus = saHwEventAck( 2085 agRoot, 2086 agNULL, /* agContext */ 2087 0, 2088 &eventSource, /* agsaEventSource_t */ 2089 0, 2090 0 2091 ); 2092 TI_DBG4(("ossaHwCB: calling saHwEventAck\n")); 2093 2094 if ( HwAckSatus != AGSA_RC_SUCCESS) 2095 { 2096 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 2097 smTraceFuncExit(hpDBG_VERY_LOUD, 'r', "Y2"); 2098 return; 2099 } 2100 if (tIsSPC12SATA(agRoot)) 2101 { 2102 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE received for SATA Controller\n")); 2103 break; 2104 } 2105 /* 2106 * incremental discovery is to be tested and debugged further 2107 */ 2108 2109 /* just for testing discovery abort */ 2110 #ifdef FDS_DM_NO 2111 if (agPortContext == agNULL) 2112 { 2113 /* this case happens when broadcase is received first before the link up */ 2114 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n")); 2115 } 2116 else if ( agPortContext->osData != agNULL) 2117 { 2118 dmRoot = &(tdsaAllShared->dmRoot); 2119 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2120 dmPortContext = &(onePortContext->dmPortContext); 2121 2122 dmQueryDiscovery(dmRoot, dmPortContext); 2123 // dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_ABORT); 2124 2125 #if 1 2126 if (onePortContext->DMDiscoveryState == dmDiscInProgress) 2127 { 2128 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_ABORT); 2129 } 2130 #endif /* 1 */ 2131 2132 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id)); 2133 if (onePortContext->DMDiscoveryState == dmDiscCompleted || 2134 onePortContext->DMDiscoveryState == dmDiscAborted || 2135 onePortContext->DMDiscoveryState == dmDiscAbortInvalid ) 2136 { 2137 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery\n")); 2138 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2139 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START); 2140 2141 } 2142 else 2143 { 2144 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id)); 2145 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2146 } 2147 } 2148 else 2149 { 2150 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n")); 2151 } 2152 2153 2154 #endif /* FDS_DM_NO */ 2155 2156 #ifdef FDS_DM 2157 if (agPortContext == agNULL) 2158 { 2159 /* this case happens when broadcase is received first before the link up */ 2160 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n")); 2161 } 2162 else if ( agPortContext->osData != agNULL) 2163 { 2164 dmRoot = &(tdsaAllShared->dmRoot); 2165 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2166 dmPortContext = &(onePortContext->dmPortContext); 2167 2168 dmQueryDiscovery(dmRoot, dmPortContext); 2169 2170 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id)); 2171 if (onePortContext->DMDiscoveryState == dmDiscCompleted || 2172 onePortContext->DMDiscoveryState == dmDiscAborted || 2173 onePortContext->DMDiscoveryState == dmDiscAbortInvalid ) 2174 { 2175 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery, pid %d\n", onePortContext->id)); 2176 onePortContext->DiscoveryState = ITD_DSTATE_STARTED; 2177 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2178 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START); 2179 2180 } 2181 else if (onePortContext->DMDiscoveryState == dmDiscFailed ) 2182 { 2183 TI_DBG1(("ossaHwCB: dmDiscFailed; pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id)); 2184 onePortContext->DiscFailNSeenBC = agTRUE; 2185 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2186 } 2187 else 2188 { 2189 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id)); 2190 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2191 } 2192 } 2193 else 2194 { 2195 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n")); 2196 } 2197 #endif /* FDS_DM */ 2198 2199 #ifdef FDS_DM_WORKED 2200 if (agPortContext == agNULL) 2201 { 2202 /* this case happens when broadcase is received first before the link up */ 2203 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n")); 2204 } 2205 else if ( agPortContext->osData != agNULL) 2206 { 2207 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2208 TI_DBG2(("ossaHwCB: calling dmNotifyBC\n")); 2209 dmRoot = &(tdsaAllShared->dmRoot); 2210 dmPortContext = &(onePortContext->dmPortContext); 2211 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE); 2212 } 2213 #endif /* FDS_DM_WORKED */ 2214 2215 #ifndef FDS_DM 2216 #ifdef INITIATOR_DRIVER 2217 if (agPortContext == agNULL) 2218 { 2219 /* this case happens when broadcase is received first before the link up */ 2220 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n")); 2221 } 2222 else if ( agPortContext->osData != agNULL) 2223 { 2224 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2225 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id)); 2226 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED) 2227 { 2228 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; does incremental discovery\n")); 2229 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED; 2230 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_INCREMENTAL_START; 2231 /* processed broadcast change */ 2232 onePortContext->discovery.SeenBC = agFALSE; 2233 #ifdef TD_DISCOVER 2234 if (tdsaAllShared->ResetInDiscovery != 0 && 2235 onePortContext->discovery.ResetTriggerred == agTRUE) 2236 { 2237 TI_DBG2(("ossaHwCB: tdsaBCTimer\n")); 2238 tdsaBCTimer(tiRoot, onePortContext); 2239 } 2240 else 2241 { 2242 tdsaDiscover( 2243 tiRoot, 2244 onePortContext, 2245 TDSA_DISCOVERY_TYPE_SAS, 2246 TDSA_DISCOVERY_OPTION_INCREMENTAL_START 2247 ); 2248 } 2249 #else 2250 saDiscover(agRoot, 2251 agPortContext, 2252 AG_SA_DISCOVERY_TYPE_SAS, 2253 onePortContext->discoveryOptions); 2254 #endif 2255 } 2256 else 2257 { 2258 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. Do nothing.\n", onePortContext->id)); 2259 onePortContext->discovery.SeenBC = agTRUE; 2260 } 2261 } 2262 else 2263 { 2264 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n")); 2265 } 2266 #endif 2267 #endif /* ifndef FDS_DM */ 2268 2269 break; 2270 } 2271 2272 case OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO: 2273 { 2274 PhyID = TD_GET_PHY_ID(eventParm1); 2275 PortState = TD_GET_PORT_STATE(eventParm1); 2276 2277 /* 2278 1. tear town the portcontext just like link down last phy down 2279 2. ack 2280 port state must be invalid 2281 */ 2282 2283 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO\n")); 2284 2285 if (PortState == OSSA_PORT_VALID) 2286 { 2287 TI_DBG1(("ossaHwCB: Wrong port state\n")); 2288 smTraceFuncExit(hpDBG_VERY_LOUD, 's', "Y2"); 2289 return; 2290 } 2291 2292 TD_ASSERT(agPortContext, "agPortContext"); 2293 if ( agPortContext->osData == agNULL) 2294 { /* if */ 2295 /* PortContext must exit at this point */ 2296 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n")); 2297 } 2298 else 2299 { 2300 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2301 onePortContext->valid = agFALSE; 2302 2303 TI_DBG1(("ossaHwCB: tiPortStopped pid %d\n", onePortContext->id)); 2304 #ifdef INITIATOR_DRIVER 2305 /* notifying link down (all links belonging to a port are down) */ 2306 ostiPortEvent( 2307 tiRoot, 2308 tiPortStopped, 2309 tiSuccess, 2310 (void *)onePortContext->tiPortalContext 2311 ); 2312 #endif 2313 2314 #ifdef TARGET_DRIVER 2315 ostiPortEvent( 2316 tiRoot, 2317 tiPortLinkDown, 2318 tiSuccess, 2319 (void *)onePortContext->tiPortalContext 2320 ); 2321 2322 #endif 2323 2324 #ifdef INITIATOR_DRIVER 2325 tdssReportRemovals(agRoot, 2326 onePortContext, 2327 agFALSE 2328 ); 2329 #endif 2330 #ifdef TARGET_DRIVER 2331 ttdssReportRemovals(agRoot, 2332 onePortContext, 2333 agFALSE 2334 ); 2335 2336 #endif 2337 /* find a PhyID and reset for portContext in tdssSASShared */ 2338 for(i=0;i<TD_MAX_NUM_PHYS;i++) 2339 { 2340 if (onePortContext->PhyIDList[i] == agTRUE) 2341 { 2342 tdsaAllShared->Ports[i].portContext = agNULL; 2343 } 2344 } 2345 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or 2346 ossaDeregisterDeviceHandleCB 2347 */ 2348 } 2349 2350 break; 2351 } 2352 2353 case OSSA_HW_EVENT_PORT_RESET_TIMER_TMO: 2354 { 2355 /* 2356 clean up 2357 */ 2358 PhyID = TD_GET_PHY_ID(eventParm1); 2359 PortState = TD_GET_PORT_STATE(eventParm1); 2360 2361 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_TIMER_TMO\n")); 2362 2363 if (PortState == OSSA_PORT_VALID) 2364 { 2365 TI_DBG1(("ossaHwCB: Wrong port state\n")); 2366 smTraceFuncExit(hpDBG_VERY_LOUD, 't', "Y2"); 2367 return; 2368 } 2369 2370 if (agPortContext == agNULL) 2371 { 2372 TI_DBG1(("ossaHwCB: agPortContext is NULL, error\n")); 2373 smTraceFuncExit(hpDBG_VERY_LOUD, 'u', "Y2"); 2374 return; 2375 } 2376 2377 if ( agPortContext->osData == agNULL) 2378 { /* if */ 2379 /* PortContext must exit at this point */ 2380 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n")); 2381 } 2382 else 2383 { 2384 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2385 onePortContext->valid = agFALSE; 2386 2387 TI_DBG1(("ossaHwCB: pid %d tiPortStopped\n", onePortContext->id)); 2388 2389 #ifdef INITIATOR_DRIVER 2390 /* notifying link down (all links belonging to a port are down) */ 2391 ostiPortEvent( 2392 tiRoot, 2393 tiPortStopped, 2394 tiSuccess, 2395 (void *)onePortContext->tiPortalContext 2396 ); 2397 #endif 2398 2399 #ifdef TARGET_DRIVER 2400 ostiPortEvent( 2401 tiRoot, 2402 tiPortLinkDown, 2403 tiSuccess, 2404 (void *)onePortContext->tiPortalContext 2405 ); 2406 2407 #endif 2408 2409 #ifdef INITIATOR_DRIVER 2410 tdssReportRemovals(agRoot, 2411 onePortContext, 2412 agFALSE 2413 ); 2414 #endif 2415 #ifdef TARGET_DRIVER 2416 ttdssReportRemovals(agRoot, 2417 onePortContext, 2418 agFALSE 2419 ); 2420 2421 #endif 2422 /* find a PhyID and reset for portContext in tdssSASShared */ 2423 for(i=0;i<TD_MAX_NUM_PHYS;i++) 2424 { 2425 if (onePortContext->PhyIDList[i] == agTRUE) 2426 { 2427 tdsaAllShared->Ports[i].portContext = agNULL; 2428 } 2429 } 2430 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or 2431 ossaDeregisterDeviceHandleCB 2432 */ 2433 } 2434 2435 break; 2436 } 2437 2438 case OSSA_HW_EVENT_PORT_RESET_COMPLETE: 2439 { 2440 #ifdef INITIATOR_DRIVER 2441 tiIORequest_t *currentTaskTag = agNULL; 2442 #endif 2443 2444 #ifdef REMOVED 2445 smRoot_t *smRoot = &(tdsaAllShared->smRoot); 2446 #endif 2447 2448 PhyID = TD_GET_PHY_ID(eventParm1); 2449 PortState = TD_GET_PORT_STATE(eventParm1); 2450 IDframe = (agsaSASIdentify_t *)eventParm3; 2451 2452 /* completes for Lun Reset and Target reset for directly attached SATA */ 2453 /* completes for Target reset for directly attached SAS */ 2454 2455 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_COMPLETE, phyID %d\n", PhyID)); 2456 2457 /* error check */ 2458 if (PortState == OSSA_PORT_INVALID) 2459 { 2460 TI_DBG1(("ossaHwCB: Wrong port state\n")); 2461 smTraceFuncExit(hpDBG_VERY_LOUD, 'v', "Y2"); 2462 return; 2463 } 2464 2465 if (agPortContext == agNULL) 2466 { 2467 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n")); 2468 smTraceFuncExit(hpDBG_VERY_LOUD, 'w', "Y2"); 2469 return; 2470 } 2471 if ( agPortContext->osData == agNULL) 2472 { 2473 TI_DBG1(("ossaHwCB: agPortContext->osData null, wrong\n")); 2474 smTraceFuncExit(hpDBG_VERY_LOUD, 'x', "Y2"); 2475 return; 2476 } 2477 2478 /* find a corresponding portcontext */ 2479 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2480 2481 if (onePortContext == agNULL) 2482 { 2483 TI_DBG1(("ossaHwCB: oneportContext is NULL; wrong??????\n")); 2484 } 2485 else 2486 { 2487 TI_DBG1(("ossaHwCB: oneportContext %p pid %d\n", onePortContext, onePortContext->id)); 2488 onePortContext->valid = agTRUE; 2489 #ifdef INITIATOR_DRIVER 2490 #ifdef REMOVED 2491 if (tdsaAllShared->ResetInDiscovery != 0) 2492 { 2493 DeviceListList = tdsaAllShared->MainDeviceList.flink; 2494 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 2495 { 2496 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 2497 if (oneDeviceData->tdPortContext != onePortContext) 2498 { 2499 DeviceListList = DeviceListList->flink; 2500 } 2501 else 2502 { 2503 found = agTRUE; 2504 break; 2505 } 2506 } /* while */ 2507 if (found == agTRUE) 2508 { 2509 /* applied to only SATA devices */ 2510 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 2511 { 2512 #ifdef FDS_SM 2513 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext); 2514 #else 2515 tdssRetrySATAID(tiRoot, oneDeviceData); 2516 #endif 2517 } 2518 } 2519 else 2520 { 2521 TI_DBG1(("ossaHwCB: no onedevicedata found!\n")); 2522 } 2523 } 2524 #endif 2525 /* completed TM */ 2526 DeviceListList = tdsaAllShared->MainDeviceList.flink; 2527 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 2528 { 2529 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 2530 if ( oneDeviceData == agNULL) 2531 { 2532 TI_DBG1(("ossaHwCB: oneDeviceData is NULL!!!\n")); 2533 return; 2534 } 2535 2536 if ( (oneDeviceData->tdPortContext == onePortContext) && 2537 (oneDeviceData->directlyAttached == agTRUE) && 2538 (oneDeviceData->phyID == PhyID) ) 2539 { 2540 TI_DBG1(("ossaHwCB: found the onePortContext and oneDeviceData!!\n")); 2541 2542 currentTaskTag = (tiIORequest_t *)oneDeviceData->agDeviceResetContext.osData; 2543 if (currentTaskTag != agNULL ) 2544 { 2545 /* applied to only SATA devices */ 2546 if (DEVICE_IS_SATA_DEVICE(oneDeviceData)) 2547 { 2548 tdIORequestBody_t *SMTMtdIORequestBody = agNULL; 2549 SMTMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData; 2550 if (SMTMtdIORequestBody != agNULL) 2551 { 2552 /* free the SMTMtdIORequestBody memory allocated in tiINITaskManagement function */ 2553 ostiFreeMemory( 2554 tiRoot, 2555 SMTMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 2556 sizeof(tdIORequestBody_t) 2557 ); 2558 } 2559 else 2560 { 2561 TI_DBG1(("ossaHwCB: SATA device but SMTMtdIORequestBody is NULL!!!\n")); 2562 } 2563 } 2564 /* set device state to DS_OPERATIONAL */ 2565 saSetDeviceState(agRoot, 2566 agNULL, 2567 tdsaRotateQnumber(tiRoot, oneDeviceData), 2568 oneDeviceData->agDevHandle, 2569 SA_DS_OPERATIONAL 2570 ); 2571 /* notify OS layer to complete the TMF IO */ 2572 ostiInitiatorEvent(tiRoot, 2573 agNULL, 2574 agNULL, 2575 tiIntrEventTypeTaskManagement, 2576 tiTMOK, 2577 currentTaskTag 2578 ); 2579 2580 } 2581 else 2582 { 2583 TI_DBG1(("ossaHwCB: currentTaskTag is NULL!!!\n")); 2584 } 2585 2586 break; 2587 } 2588 else 2589 { 2590 DeviceListList = DeviceListList->flink; 2591 } 2592 } 2593 #endif 2594 } 2595 break; 2596 } 2597 case OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT: 2598 { 2599 PhyID = TD_GET_PHY_ID(eventParm1); 2600 PortState = TD_GET_PORT_STATE(eventParm1); 2601 2602 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT\n")); 2603 if (tIsSPC12SATA(agRoot)) 2604 { 2605 TI_DBG1(("ossaHwCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n")); 2606 break; 2607 } 2608 if (agPortContext == agNULL) 2609 { 2610 TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID)); 2611 smTraceFuncExit(hpDBG_VERY_LOUD, 'y', "Y2"); 2612 return; 2613 } 2614 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2615 if (onePortContext == agNULL) 2616 { 2617 TI_DBG1(("ossaHwCB: Error!!! onePortContext is NULL %d\n", PhyID)); 2618 smTraceFuncExit(hpDBG_VERY_LOUD, 'z', "Y2"); 2619 return; 2620 } 2621 2622 if (onePortContext->tiPortalContext != agNULL) 2623 { 2624 #if 0 2625 ostiInitiatorEvent( 2626 tiRoot, 2627 onePortContext->tiPortalContext, 2628 agNULL, 2629 tiIntrEventTypeDeviceChange, 2630 OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT, 2631 agNULL 2632 ); 2633 #endif 2634 } 2635 else 2636 { 2637 TI_DBG1(("ossaHwCB: Error!!! onePortContext->tiPortalContext is NULL\n")); 2638 smTraceFuncExit(hpDBG_VERY_LOUD, 'A', "Y2"); 2639 return; 2640 } 2641 2642 break; 2643 } 2644 2645 case OSSA_HW_EVENT_PORT_RECOVER: 2646 { 2647 2648 PhyID = TD_GET_PHY_ID(eventParm1); 2649 if (agPortContext == agNULL) 2650 { 2651 TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID)); 2652 smTraceFuncExit(hpDBG_VERY_LOUD, 'B', "Y2"); 2653 return; 2654 } 2655 2656 LinkRate = TD_GET_LINK_RATE(eventParm1); 2657 PortState = TD_GET_PORT_STATE(eventParm1); 2658 agDevHandle = agNULL; 2659 IDframe = (agsaSASIdentify_t *)eventParm3; 2660 2661 /* 2662 1. this is like link up 2663 2. handle the phyID 2664 3. no trigger discovery (broadcast change will do this later) 2665 port state must be valid 2666 */ 2667 2668 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, phyID %d\n", PhyID)); 2669 2670 if (PortState == OSSA_PORT_INVALID) 2671 { 2672 TI_DBG1(("ossaHwCB: Wrong port state\n")); 2673 smTraceFuncExit(hpDBG_VERY_LOUD, 'C', "Y2"); 2674 return; 2675 } 2676 if ( agPortContext->osData == agNULL) 2677 { /* if */ 2678 /* PortContext must exit at this point */ 2679 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n")); 2680 } 2681 else 2682 { 2683 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 2684 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id)); 2685 onePortContext->PhyIDList[PhyID] = agTRUE; 2686 onePortContext->valid = agTRUE; 2687 tdsaAllShared->Ports[PhyID].portContext = onePortContext; 2688 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext; 2689 onePortContext->PortRecoverPhyID = PhyID; 2690 if (LinkRate == 0x01) 2691 { 2692 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G; 2693 } 2694 else if (LinkRate == 0x02) 2695 { 2696 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G; 2697 } 2698 else if (LinkRate == 0x04) 2699 { 2700 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G; 2701 } 2702 else /* (LinkRate == 0x08) */ 2703 { 2704 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G; 2705 } 2706 2707 if (SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe) == SAS_END_DEVICE && 2708 SA_IDFRM_IS_SSP_TARGET(&onePortContext->sasIDframe) ) 2709 { 2710 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, sending spinup on phyID %d\n", PhyID)); 2711 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++) 2712 { 2713 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL); 2714 } 2715 } 2716 2717 /* transient period between link up and link down/port recovery */ 2718 if (onePortContext->Transient == agTRUE && onePortContext->RegisteredDevNums == 0) 2719 { 2720 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER transient period")); 2721 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE) 2722 { 2723 #ifdef INITIATOR_DRIVER 2724 agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe); 2725 agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe); 2726 agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp; 2727 agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp; 2728 tdssAddSASToSharedcontext( 2729 onePortContext, 2730 agRoot, 2731 agDevHandle, /* agNULL */ 2732 &agSASSubID, 2733 agTRUE, 2734 (bit8)PhyID, 2735 TD_OPERATION_INITIATOR 2736 ); 2737 #endif 2738 } 2739 onePortContext->Transient = agFALSE; 2740 } 2741 2742 2743 2744 2745 } 2746 break; 2747 } 2748 2749 case OSSA_HW_EVENT_BROADCAST_SES: 2750 { 2751 PhyID = TD_GET_PHY_ID(eventParm1); 2752 PortState = TD_GET_PORT_STATE(eventParm1); 2753 2754 TI_DBG2(("ossaHwCB: BROADCAST_SES from PhyID %d; to be tested\n", PhyID)); 2755 if (tIsSPC12SATA(agRoot)) 2756 { 2757 TI_DBG1(("ossaHwCB: BROADCAST_SES received for SATA Controller\n")); 2758 break; 2759 } 2760 if (PortState == OSSA_PORT_INVALID) 2761 { 2762 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_SES\n")); 2763 smTraceFuncExit(hpDBG_VERY_LOUD, 'D', "Y2"); 2764 return; 2765 } 2766 2767 /* 2768 let os layer read payload 2769 */ 2770 break; 2771 } 2772 case OSSA_HW_EVENT_BROADCAST_EXP: 2773 { 2774 PhyID = TD_GET_PHY_ID(eventParm1); 2775 PortState = TD_GET_PORT_STATE(eventParm1); 2776 2777 TI_DBG2(("ossaHwCB: BROADCAST_EXP from PhyID %d; to be tested\n", PhyID)); 2778 if (tIsSPC12SATA(agRoot)) 2779 { 2780 TI_DBG1(("ossaHwCB: BROADCAST_EXP received for SATA Controller\n")); 2781 break; 2782 } 2783 2784 if (PortState == OSSA_PORT_INVALID) 2785 { 2786 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_EXP\n")); 2787 smTraceFuncExit(hpDBG_VERY_LOUD, 'E', "Y2"); 2788 return; 2789 } 2790 /* to-do: 2791 let os layer read payload 2792 */ 2793 break; 2794 } 2795 2796 case OSSA_HW_EVENT_HARD_RESET_RECEIVED: 2797 { 2798 PhyID = TD_GET_PHY_ID(eventParm1); 2799 PortState = TD_GET_PORT_STATE(eventParm1); 2800 2801 TI_DBG2(("ossaHwCB: HARD_RESET_RECEIVED from PhyID %d\n", PhyID)); 2802 2803 if (PortState == OSSA_PORT_VALID && tiIS_SPC(agRoot)) 2804 { 2805 TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_VALID\n")); 2806 saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0); 2807 } 2808 else if (PortState == OSSA_PORT_3RDPARTY_RESET && (tIsSPCV12or6G(agRoot)) ) 2809 { 2810 TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_3RDPARTY_RESET\n")); 2811 saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0); 2812 } 2813 else /* PortState == OSSA_PORT_INVALID */ 2814 { 2815 TI_DBG1(("ossaHwCB: Error. Port state is invalid\n")); 2816 #ifdef REMOVED 2817 TI_DBG1(("ossaHwCB: calling saLocalPhyControl on phyID %d\n", PhyID)); 2818 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_LINK_RESET, agNULL); 2819 #endif 2820 } 2821 2822 break; 2823 } 2824 2825 case OSSA_HW_EVENT_MALFUNCTION: 2826 { 2827 #ifdef TD_DEBUG_ENABLE 2828 agsaFatalErrorInfo_t *FatalError = (agsaFatalErrorInfo_t *)eventParm2; 2829 #endif 2830 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MALFUNCTION \n")); 2831 TI_DBG1(("ossaHwCB: errorInfo0 %8X errorInfo1 %8X\n", FatalError->errorInfo0, FatalError->errorInfo1)); 2832 TI_DBG1(("ossaHwCB: errorInfo2 %8X errorInfo3 %8X\n", FatalError->errorInfo2, FatalError->errorInfo3)); 2833 TI_DBG1(("ossaHwCB: regDumpBusBaseNum0 %8X regDumpOffset0 %8X regDumpLen0 %8X\n", FatalError->regDumpBusBaseNum0, FatalError->regDumpOffset0, FatalError->regDumpLen0)); 2834 TI_DBG1(("ossaHwCB: regDumpBusBaseNum1 %8X regDumpOffset1 %8X regDumpLen1 %8X\n", FatalError->regDumpBusBaseNum1, FatalError->regDumpOffset1, FatalError->regDumpLen1)); 2835 2836 2837 if (eventParm1 == agTRUE) 2838 { 2839 TI_DBG1(("ossaHwCB: fatal error\n")); 2840 /* port panic */ 2841 ostiPortEvent ( 2842 tiRoot, 2843 tiPortPanic, 2844 0, 2845 agNULL 2846 ); 2847 } 2848 else 2849 { 2850 TI_DBG1(("ossaHwCB: non-fatal error \n")); 2851 } 2852 break; 2853 } 2854 2855 case OSSA_HW_EVENT_ID_FRAME_TIMEOUT: 2856 { 2857 PhyID = TD_GET_PHY_ID(eventParm1); 2858 PortState = TD_GET_PORT_STATE(eventParm1); 2859 2860 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_ID_FRAME_TIMEOUT from PhyID %d\n", PhyID)); 2861 2862 if (PortState == OSSA_PORT_INVALID) 2863 { 2864 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_ID_FRAME_TIMEOUT\n")); 2865 smTraceFuncExit(hpDBG_VERY_LOUD, 'F', "Y2"); 2866 return; 2867 } 2868 break; 2869 } 2870 2871 case OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD: 2872 { 2873 PhyID = TD_GET_PHY_ID(eventParm1); 2874 PortState = TD_GET_PORT_STATE(eventParm1); 2875 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 2876 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n")); 2877 2878 if (PortState == OSSA_PORT_INVALID) 2879 { 2880 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n")); 2881 smTraceFuncExit(hpDBG_VERY_LOUD, 'G', "Y2"); 2882 return; 2883 } 2884 2885 if (agPhyErrCountersPage != agNULL) 2886 { 2887 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD from PhyID %d\n", PhyID)); 2888 TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword)); 2889 } 2890 else 2891 { 2892 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD: Error!!! eventParm2 is NULL\n")); 2893 } 2894 2895 /* saHwEventAck() */ 2896 eventSource.agPortContext = agPortContext; 2897 eventSource.event = OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD; 2898 /* phy ID */ 2899 eventSource.param = PhyID; 2900 HwAckSatus = saHwEventAck( 2901 agRoot, 2902 agNULL, /* agContext */ 2903 0, 2904 &eventSource, /* agsaEventSource_t */ 2905 0, 2906 0 2907 ); 2908 if ( HwAckSatus != AGSA_RC_SUCCESS) 2909 { 2910 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 2911 smTraceFuncExit(hpDBG_VERY_LOUD, 'H', "Y2"); 2912 return; 2913 } 2914 2915 break; 2916 } 2917 2918 case OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR: 2919 { 2920 PhyID = TD_GET_PHY_ID(eventParm1); 2921 PortState = TD_GET_PORT_STATE(eventParm1); 2922 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 2923 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n")); 2924 2925 if (PortState == OSSA_PORT_INVALID) 2926 { 2927 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n")); 2928 smTraceFuncExit(hpDBG_VERY_LOUD, 'I', "Y2"); 2929 return; 2930 } 2931 2932 if (agPhyErrCountersPage != agNULL) 2933 { 2934 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR from PhyID %d\n", PhyID)); 2935 TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError)); 2936 } 2937 else 2938 { 2939 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR: Error!!! eventParm2 is NULL\n")); 2940 } 2941 2942 /* saHwEventAck() */ 2943 eventSource.agPortContext = agPortContext; 2944 eventSource.event = OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR; 2945 /* phy ID */ 2946 eventSource.param = PhyID; 2947 HwAckSatus = saHwEventAck( 2948 agRoot, 2949 agNULL, /* agContext */ 2950 0, 2951 &eventSource, /* agsaEventSource_t */ 2952 0, 2953 0 2954 ); 2955 if ( HwAckSatus != AGSA_RC_SUCCESS) 2956 { 2957 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 2958 smTraceFuncExit(hpDBG_VERY_LOUD, 'J', "Y2"); 2959 return; 2960 } 2961 2962 break; 2963 } 2964 2965 case OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION: 2966 { 2967 PhyID = TD_GET_PHY_ID(eventParm1); 2968 PortState = TD_GET_PORT_STATE(eventParm1); 2969 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 2970 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n")); 2971 2972 if (PortState == OSSA_PORT_INVALID) 2973 { 2974 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n")); 2975 smTraceFuncExit(hpDBG_VERY_LOUD, 'K', "Y2"); 2976 return; 2977 } 2978 2979 if (agPhyErrCountersPage != agNULL) 2980 { 2981 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION from PhyID %d\n", PhyID)); 2982 TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation)); 2983 } 2984 else 2985 { 2986 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION: Error!!! eventParm2 is NULL\n")); 2987 } 2988 2989 /* saHwEventAck() */ 2990 eventSource.agPortContext = agPortContext; 2991 eventSource.event = OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION; 2992 /* phy ID */ 2993 eventSource.param = PhyID; 2994 HwAckSatus = saHwEventAck( 2995 agRoot, 2996 agNULL, /* agContext */ 2997 0, 2998 &eventSource, /* agsaEventSource_t */ 2999 0, 3000 0 3001 ); 3002 if ( HwAckSatus != AGSA_RC_SUCCESS) 3003 { 3004 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 3005 smTraceFuncExit(hpDBG_VERY_LOUD, 'L', "Y2"); 3006 return; 3007 } 3008 3009 break; 3010 } 3011 3012 #ifdef REMOVED 3013 case OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1: 3014 { 3015 PhyID = eventParm1 & 0xFF; 3016 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 3017 3018 if (agPhyErrCountersPage != agNULL) 3019 { 3020 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1 from PhyID %d\n", PhyID)); 3021 TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword)); 3022 TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError)); 3023 TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation)); 3024 TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch)); 3025 TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem)); 3026 TI_DBG1(("ossaHwCB: inboundCRCError %d\n", agPhyErrCountersPage->inboundCRCError)); 3027 } 3028 else 3029 { 3030 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1: Error!!! eventParm2 is NULL\n")); 3031 } 3032 break; 3033 } 3034 #endif /* REMOVED */ 3035 3036 case OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH: 3037 { 3038 PhyID = TD_GET_PHY_ID(eventParm1); 3039 PortState = TD_GET_PORT_STATE(eventParm1); 3040 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 3041 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n")); 3042 3043 if (PortState == OSSA_PORT_INVALID) 3044 { 3045 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n")); 3046 smTraceFuncExit(hpDBG_VERY_LOUD, 'M', "Y2"); 3047 return; 3048 } 3049 3050 if (agPhyErrCountersPage != agNULL) 3051 { 3052 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH from PhyID %d\n", PhyID)); 3053 TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch)); 3054 } 3055 else 3056 { 3057 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH: Error!!! eventParm2 is NULL\n")); 3058 } 3059 3060 /* saHwEventAck() */ 3061 eventSource.agPortContext = agPortContext; 3062 eventSource.event = OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH; 3063 /* phy ID */ 3064 eventSource.param = PhyID; 3065 HwAckSatus = saHwEventAck( 3066 agRoot, 3067 agNULL, /* agContext */ 3068 0, 3069 &eventSource, /* agsaEventSource_t */ 3070 0, 3071 0 3072 ); 3073 if ( HwAckSatus != AGSA_RC_SUCCESS) 3074 { 3075 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 3076 smTraceFuncExit(hpDBG_VERY_LOUD, 'N', "Y2"); 3077 return; 3078 } 3079 3080 break; 3081 } 3082 3083 case OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED: 3084 { 3085 PhyID = TD_GET_PHY_ID(eventParm1); 3086 PortState = TD_GET_PORT_STATE(eventParm1); 3087 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2; 3088 3089 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n")); 3090 3091 if (PortState == OSSA_PORT_INVALID) 3092 { 3093 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n")); 3094 smTraceFuncExit(hpDBG_VERY_LOUD, 'O', "Y2"); 3095 return; 3096 } 3097 3098 if (agPhyErrCountersPage != agNULL) 3099 { 3100 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED from PhyID %d\n", PhyID)); 3101 TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem)); 3102 } 3103 else 3104 { 3105 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED: Error!!! eventParm2 is NULL\n")); 3106 } 3107 3108 /* saHwEventAck() */ 3109 eventSource.agPortContext = agPortContext; 3110 eventSource.event = OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED; 3111 /* phy ID */ 3112 eventSource.param = PhyID; 3113 HwAckSatus = saHwEventAck( 3114 agRoot, 3115 agNULL, /* agContext */ 3116 0, 3117 &eventSource, /* agsaEventSource_t */ 3118 0, 3119 0 3120 ); 3121 if ( HwAckSatus != AGSA_RC_SUCCESS) 3122 { 3123 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 3124 smTraceFuncExit(hpDBG_VERY_LOUD, 'P', "Y2"); 3125 return; 3126 } 3127 3128 break; 3129 } 3130 3131 // #ifdef INITIATOR_DRIVER 3132 case OSSA_HW_EVENT_ENCRYPTION: 3133 { 3134 pEncryptCBData = (agsaHWEventEncrypt_t *) eventParm2; 3135 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_ENCRYPTION: encryptOperation 0x%x\n",pEncryptCBData->encryptOperation)); 3136 TI_DBG1(("ossaHwCB: event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n",event,eventParm1,eventParm2,eventParm3)); 3137 3138 /* 3139 * All events and status need to be translated from 3140 * SAS specific values to TISA specific values. This 3141 * is effectively a NOP, but the OS layer won't want to 3142 * look for SAS values. 3143 */ 3144 if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE) 3145 { 3146 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE\n")); 3147 encryptEventData.encryptEvent = tiEncryptKekStore; 3148 } 3149 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE) 3150 { 3151 TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_UPDATE \n")); 3152 encryptEventData.encryptEvent = tiEncryptKekAdd; 3153 } 3154 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_INVALIDTE) 3155 { 3156 TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_INVALIDTE \n")); 3157 /* none */ 3158 } 3159 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_UPDATE) 3160 { 3161 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_UPDATE\n")); 3162 encryptEventData.encryptEvent = tiEncryptDekAdd; 3163 } 3164 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_INVALIDTE) 3165 { 3166 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_INVALIDTE\n")); 3167 encryptEventData.encryptEvent = tiEncryptDekInvalidate; 3168 } 3169 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT) 3170 { 3171 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT\n")); 3172 encryptEventData.encryptEvent = tiEncryptOperatorManagement; 3173 } 3174 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_TEST_EXECUTE) 3175 { 3176 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_TEST_EXECUTE\n")); 3177 encryptEventData.encryptEvent = tiEncryptSelfTest; 3178 encryptEventData.subEvent = pEncryptCBData->eq; 3179 } 3180 else 3181 { 3182 TI_DBG1(("ossaHwCB: unknown encryptOperation 0x%x\n",pEncryptCBData->encryptOperation)); 3183 } 3184 3185 if (pEncryptCBData->status != OSSA_SUCCESS) 3186 { 3187 encryptStatus = tiError; 3188 3189 /* prints out status and error qualifier */ 3190 TI_DBG1(("ossaHwCB: encrypt response status 0x%x error qualifier 0x%x\n", pEncryptCBData->status, pEncryptCBData->eq)); 3191 } 3192 else 3193 { 3194 encryptStatus = tiSuccess; 3195 } 3196 3197 if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE || 3198 pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE ) 3199 { 3200 /* returning new KEK index */ 3201 encryptEventData.pData = pEncryptCBData->handle; 3202 } 3203 else 3204 { 3205 /* returning current KEK index or DEK index */ 3206 encryptEventData.pData = pEncryptCBData->param; 3207 } 3208 3209 ostiPortEvent(tiRoot, 3210 tiEncryptOperation, 3211 encryptStatus, 3212 &encryptEventData); 3213 break; 3214 } 3215 case OSSA_HW_EVENT_SECURITY_MODE: 3216 { 3217 securitySetModeStatus = eventParm1; 3218 pEncryptInfo = (agsaEncryptInfo_t *) eventParm2; 3219 3220 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_SECURITY_MODE\n")); 3221 if (securitySetModeStatus == OSSA_SUCCESS) 3222 { 3223 securityModeStatus = tiSuccess; 3224 } 3225 else 3226 { 3227 securityModeStatus = tiError; 3228 } 3229 3230 encryptEventData.encryptEvent = tiEncryptSetMode; 3231 /* process status to fill in subevent */ 3232 /* See PM 4.26.12.6 */ 3233 TI_DBG1(("ossaHwCB: pEncryptInfo->status 0x%x\n", pEncryptInfo->status)); 3234 if ( pEncryptInfo->status == OSSA_SUCCESS) 3235 { 3236 encryptEventData.subEvent = tiNVRAMSuccess; 3237 } 3238 else if (pEncryptInfo->status == 0x24) 3239 { 3240 encryptEventData.subEvent = tiNVRAMNotFound; 3241 } 3242 else if (pEncryptInfo->status == 0x05 || pEncryptInfo->status == 0x20 || pEncryptInfo->status == 0x21) 3243 { 3244 encryptEventData.subEvent = tiNVRAMAccessTimeout; 3245 } 3246 else 3247 { 3248 encryptEventData.subEvent = tiNVRAMWriteFail; 3249 } 3250 3251 encryptEventData.pData = agNULL; 3252 ostiPortEvent(tiRoot, 3253 tiEncryptOperation, 3254 securityModeStatus, 3255 &encryptEventData); 3256 3257 break; 3258 } 3259 case OSSA_HW_EVENT_MODE: 3260 { 3261 pModeEvent = (agsaHWEventMode_t *) eventParm2; 3262 pModePage = (bit32 *) pModeEvent->modePage; 3263 3264 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE modePageOperation 0x%x status 0x%x modePageLen 0x%x\n", 3265 pModeEvent->modePageOperation, pModeEvent->status, pModeEvent->modePageLen)); 3266 3267 if (pModeEvent->modePageOperation == agsaModePageSet) 3268 { 3269 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE page code 0x%x error qualifier 0x%x\n", (eventParm1 & 0xFF), (eventParm1 >> 16))); 3270 ostiPortEvent(tiRoot, 3271 tiModePageOperation, 3272 pModeEvent->status, 3273 eventParm2); 3274 } 3275 else if (pModeEvent->modePageOperation == agsaModePageGet) 3276 { 3277 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE error qualifier 0x%x\n", eventParm1)); 3278 switch ((*pModePage) & 0xFF) 3279 { 3280 case AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE: 3281 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3282 TI_DBG1(("ossaHwCB:modePageOperation 0x%x status 0x%x modePageLen 0x%x modePage %p context %p\n", 3283 pModeEvent->modePageOperation, 3284 pModeEvent->status, 3285 pModeEvent->modePageLen, 3286 pModeEvent->modePage, 3287 pModeEvent->context)); 3288 ostiPortEvent(tiRoot, 3289 tiModePageOperation, 3290 pModeEvent->status, 3291 eventParm2); 3292 break; 3293 case AGSA_ENCRYPTION_DEK_CONFIG_PAGE: 3294 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_DEK_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3295 ostiPortEvent(tiRoot, 3296 tiModePageOperation, 3297 pModeEvent->status, 3298 eventParm2); 3299 break; 3300 case AGSA_ENCRYPTION_HMAC_CONFIG_PAGE: 3301 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_HMAC_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3302 ostiPortEvent(tiRoot, 3303 tiModePageOperation, 3304 pModeEvent->status, 3305 eventParm2); 3306 break; 3307 case AGSA_ENCRYPTION_CONTROL_PARM_PAGE: 3308 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_CONTROL_PARM_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3309 /* 3310 * This page is directly related to tiCOMEncryptGetInfo() and 3311 * will be translated into a tiEncrytOperation for the OS layer. 3312 */ 3313 3314 /* Fill out tiEncryptInfo_t */ 3315 securityMode = *pModePage & 0x0F00 >> 8; 3316 cipherMode = *pModePage & 0xF000 >> 12; 3317 3318 if (securityMode == agsaEncryptSMA) 3319 { 3320 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_A; 3321 } 3322 else if (securityMode == agsaEncryptSMB) 3323 { 3324 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_B; 3325 } 3326 else 3327 { 3328 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_FACT_INIT; 3329 } 3330 3331 if (cipherMode == agsaEncryptCipherModeECB) 3332 { 3333 encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_ECB; 3334 } 3335 3336 if (cipherMode == agsaEncryptCipherModeXTS) 3337 { 3338 encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_XTS; 3339 } 3340 3341 /* How will subEvents be tracked? */ 3342 encryptInfo.status = 0; 3343 3344 encryptInfo.sectorSize[0] = 512; /* DIF is allowed on 512 BPS SATA drives */ 3345 encryptInfo.sectorSize[1] = 520; 3346 encryptInfo.sectorSize[2] = 528; 3347 encryptInfo.sectorSize[3] = 4104; 3348 encryptInfo.sectorSize[4] = 4168; 3349 encryptInfo.sectorSize[5] = 4232; 3350 3351 encryptEventData.encryptEvent = tiEncryptGetInfo; 3352 encryptEventData.subEvent = 0; 3353 encryptEventData.pData = &encryptInfo; 3354 3355 ostiPortEvent(tiRoot, 3356 tiEncryptOperation, 3357 pModeEvent->status, 3358 &encryptEventData); 3359 break; 3360 case AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE: 3361 TI_DBG1(("ossaHwCB: AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3362 3363 #ifdef IOCTL_INTERRUPT_TIME_CONFIG 3364 ostiPortEvent(tiRoot, 3365 tiModePageOperation, 3366 pModeEvent->status, 3367 eventParm2 3368 ); 3369 #endif /* IOCTL_INTERRUPT_TIME_CONFIG */ 3370 3371 /*ostiPortEvent(tiRoot, 3372 tiModePageOperation, 3373 pModeEvent->status, 3374 &encryptEventData);*/ 3375 break; 3376 case AGSA_INTERRUPT_CONFIGURATION_PAGE: 3377 TI_DBG1(("ossaHwCB: AGSA_INTERRUPT_CONFIGURATION_PAGE 0x%x %p\n", pModeEvent->status,eventParm2)); 3378 3379 #ifdef IOCTL_INTERRUPT_TIME_CONFIG 3380 ostiPortEvent(tiRoot, 3381 tiModePageOperation, 3382 pModeEvent->status, 3383 eventParm2 3384 ); 3385 #endif /* IOCTL_INTERRUPT_TIME_CONFIG */ 3386 3387 break; 3388 default: 3389 TI_DBG1(("ossaHwCB: Unknown Mode Event %x\n", *pModePage)); 3390 break; 3391 } 3392 3393 } 3394 else 3395 { 3396 TI_DBG1(("ossaHwCB: Unknown modePageOperation %x\n", pModeEvent->modePageOperation)); 3397 } 3398 break; 3399 } 3400 3401 // #endif /* INITIATOR_DRIVER */ 3402 3403 #ifdef REMOVED 3404 case OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR: 3405 { 3406 PhyID = TD_GET_PHY_ID(eventParm1); 3407 PortState = TD_GET_PORT_STATE(eventParm1); 3408 3409 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR\n")); 3410 3411 if (PortState == OSSA_PORT_INVALID) 3412 { 3413 TI_DBG1(("ossaHwCB: INVALID port state\n")); 3414 } 3415 else 3416 { 3417 TI_DBG1(("ossaHwCB: VALID port state\n")); 3418 } 3419 break; 3420 } 3421 #endif /* REMOVED */ 3422 case OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED: 3423 { 3424 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED\n")); 3425 break; 3426 } 3427 3428 default: 3429 { 3430 TI_DBG1(("ossaHwCB: default error (0x%X)!!!!!\n",event)); 3431 break; 3432 } 3433 } 3434 3435 smTraceFuncExit(hpDBG_VERY_LOUD, 'R', "Y2"); 3436 return; 3437 } 3438 3439 osGLOBAL void ossaPortControlCB( 3440 agsaRoot_t *agRoot, 3441 agsaContext_t *agContext, 3442 agsaPortContext_t *agPortContext, 3443 bit32 portOperation, 3444 bit32 status) 3445 { 3446 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3447 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3448 tdsaPortContext_t *onePortContext = agNULL; 3449 3450 TI_DBG6(("ossaPortControlCB: start\n")); 3451 3452 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y3"); 3453 if (portOperation == AGSA_PORT_SET_SMP_PHY_WIDTH) 3454 { 3455 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_SMP_PHY_WIDTH\n")); 3456 } 3457 else if (portOperation == AGSA_PORT_SET_PORT_RECOVERY_TIME) 3458 { 3459 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RECOVERY_TIME\n")); 3460 } 3461 else if (portOperation == AGSA_PORT_IO_ABORT) 3462 { 3463 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_IO_ABORT\n")); 3464 /* code is here because disocvery failed 3465 deregister all targets. Then, later call discovery if broacast is seen in ossaDeregisterDeviceHandleCB. 3466 */ 3467 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 3468 if (onePortContext == agNULL) 3469 { 3470 TI_DBG1(("ossaPortControlCB: onePortContext is NULL\n")); 3471 return; 3472 } 3473 /* qqqqq deregister all devices */ 3474 tdsaDeregisterDevicesInPort(tiRoot, onePortContext); 3475 3476 } 3477 else if (portOperation == AGSA_PORT_SET_PORT_RESET_TIME) 3478 { 3479 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RESET_TIME\n")); 3480 } 3481 else if (portOperation == AGSA_PORT_HARD_RESET) 3482 { 3483 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_HARD_RESET\n")); 3484 } 3485 else if (portOperation == AGSA_PORT_CLEAN_UP) 3486 { 3487 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_CLEAN_UP\n")); 3488 } 3489 else if (portOperation == AGSA_STOP_PORT_RECOVERY_TIMER) 3490 { 3491 TI_DBG1(("ossaPortControlCB: portOperation AGSA_STOP_PORT_RECOVERY_TIMER\n")); 3492 } 3493 else 3494 { 3495 TI_DBG1(("ossaPortControlCB: undefined portOperation %d\n", portOperation)); 3496 } 3497 3498 TI_DBG1(("ossaPortControlCB: status %d\n", status)); 3499 3500 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y3"); 3501 return; 3502 } 3503 3504 /***************************************************************************** 3505 *! \brief ossaHwRegRead 3506 * 3507 * Purpose: This routine is called to read a 32-bit value from the PCI 3508 * registers of the controller 3509 * 3510 * \param agRoot: Pointer to chip/driver Instance. 3511 * \param regOffset: Byte offset to chip register from which to read a 32-bit 3512 * value. 3513 * 3514 * \return: 32-bit value. 3515 * 3516 * \note - The scope is shared target and initiator. 3517 * 3518 *****************************************************************************/ 3519 FORCEINLINE 3520 bit32 3521 ossaHwRegRead(agsaRoot_t *agRoot, 3522 bit32 regOffset 3523 ) 3524 { 3525 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3526 bit32 return_value; 3527 3528 3529 return_value = ostiChipReadBit32 ( 3530 osData->tiRoot, 3531 regOffset 3532 ); 3533 if( agNULL != agRoot->sdkData ) 3534 { 3535 smTrace(hpDBG_REGISTERS,"RR",regOffset); 3536 /* TP:RR regOffset */ 3537 smTrace(hpDBG_REGISTERS,"RV",return_value); 3538 /* TP:RV value read */ 3539 } 3540 3541 return(return_value); 3542 3543 } 3544 3545 /***************************************************************************** 3546 *! \brief ossaHwRegWrite 3547 * 3548 * Purpose: This routine is called to write a 32-bit value to the PCI 3549 * registers of the controller. 3550 * 3551 * \param agRoot: Pointer to chip/driver Instance. 3552 * \param regOffset: Byte offset to chip register to which chipIOValue is 3553 * written. 3554 * \param regValue: 32-bit value to write at chipIOOffset in host byte order. 3555 * 3556 * \return: None. 3557 * 3558 * \note - The scope is shared target and initiator. 3559 * 3560 *****************************************************************************/ 3561 FORCEINLINE 3562 void 3563 ossaHwRegWrite(agsaRoot_t *agRoot, 3564 bit32 regOffset, 3565 bit32 regValue 3566 ) 3567 { 3568 3569 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3570 if( agNULL != agRoot->sdkData ) 3571 { 3572 smTrace(hpDBG_REGISTERS,"RW",regOffset); 3573 /* TP:RW regOffset */ 3574 smTrace(hpDBG_REGISTERS,"VW",regValue); 3575 /* TP:VW value written */ 3576 } 3577 3578 ostiChipWriteBit32 ( 3579 osData->tiRoot, 3580 regOffset, 3581 regValue 3582 ); 3583 return; 3584 } 3585 3586 /***************************************************************************** 3587 *! \brief ossaHwRegReadExt 3588 * 3589 * Purpose: This routine is called to read a 32-bit value from a bus-specific 3590 * mapped registers of the controller 3591 * 3592 * \param agRoot: Pointer to chip/driver Instance. 3593 * \param regOffset: Byte offset to chip register from which to read a 32-bit 3594 * value. 3595 * 3596 * \return: 32-bit value. 3597 * 3598 * \note - The scope is shared target and initiator. 3599 * 3600 *****************************************************************************/ 3601 FORCEINLINE 3602 bit32 3603 ossaHwRegReadExt( 3604 agsaRoot_t *agRoot, 3605 bit32 busBaseNumber, 3606 bit32 regOffset 3607 ) 3608 { 3609 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3610 3611 bit32 return_value; 3612 3613 return_value = ostiChipReadBit32Ext( 3614 osData->tiRoot, 3615 busBaseNumber, 3616 regOffset 3617 ); 3618 3619 /* TI_DBG4(("#_R: 0x%x:0x%x=0x%x\n",busBaseNumber,regOffset,return_value)); */ 3620 3621 if( agNULL != agRoot->sdkData ) 3622 { 3623 smTrace(hpDBG_REGISTERS,"EB",busBaseNumber); 3624 /* TP:EB EX read busBaseNumber */ 3625 smTrace(hpDBG_REGISTERS,"EO",regOffset); 3626 /* TP:EO regOffset */ 3627 smTrace(hpDBG_REGISTERS,"ER",return_value); 3628 /* TP:ER value read */ 3629 } 3630 return(return_value); 3631 } 3632 3633 void ossaPCI_TRIGGER(agsaRoot_t *agRoot ) 3634 { 3635 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3636 ostiPCI_TRIGGER(osData->tiRoot); 3637 3638 } 3639 3640 3641 3642 /***************************************************************************** 3643 *! \brief ossaHwRegWriteExt 3644 * 3645 * Purpose: This routine is called to write a 32-bit value to a bus specific 3646 * mapped registers of the controller. 3647 * 3648 * \param agRoot: Pointer to chip/driver Instance. 3649 * \param regOffset: Byte offset to chip register to which chipIOValue is 3650 * written. 3651 * \param regValue: 32-bit value to write at chipIOOffset in host byte order. 3652 * 3653 * \return: None. 3654 * 3655 * \note - The scope is shared target and initiator. 3656 * 3657 *****************************************************************************/ 3658 FORCEINLINE 3659 void 3660 ossaHwRegWriteExt( 3661 agsaRoot_t *agRoot, 3662 bit32 busBaseNumber, 3663 bit32 regOffset, 3664 bit32 regValue 3665 ) 3666 { 3667 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3668 ostiChipWriteBit32Ext( 3669 osData->tiRoot, 3670 busBaseNumber, 3671 regOffset, 3672 regValue 3673 ); 3674 3675 /* TI_DBG4(("#_W: 0x%x:0x%x=0x%x\n",busBaseNumber,regOffset,regValue)); */ 3676 3677 if( agNULL != agRoot->sdkData ) 3678 { 3679 smTrace(hpDBG_REGISTERS,"Eb",busBaseNumber); 3680 /* TP:Eb Ex Write busBaseNumber */ 3681 smTrace(hpDBG_REGISTERS,"Eo",regOffset); 3682 /* TP:Eo regOffset */ 3683 smTrace(hpDBG_REGISTERS,"Ew",regValue); 3684 /* TP:Ew value written regValue*/ 3685 } 3686 return; 3687 } 3688 3689 3690 osGLOBAL bit32 ossaHwRegReadConfig32( 3691 agsaRoot_t *agRoot, 3692 bit32 regOffset 3693 ) 3694 { 3695 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData); 3696 bit32 to_ret; 3697 to_ret= ostiChipConfigReadBit32( osData->tiRoot, regOffset); 3698 TI_DBG4(("ossaHwRegReadConfig32: regOffset 0x%x returns 0x%x\n",regOffset,to_ret)); 3699 return(to_ret); 3700 } 3701 3702 3703 3704 3705 #ifdef TD_INT_COALESCE 3706 void 3707 ossaIntCoalesceInitCB( 3708 agsaRoot_t *agRoot, 3709 agsaIntCoalesceContext_t *agIntCoContext, 3710 bit32 status 3711 ) 3712 { 3713 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3714 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3715 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared; 3716 tiIntCoalesceContext_t *tiIntCoalesceCxt; 3717 tdsaIntCoalesceContext_t *tdsaIntCoalCxt; 3718 tdsaIntCoalesceContext_t *tdsaIntCoalCxtHead 3719 = (tdsaIntCoalesceContext_t *)tdsaAllShared->IntCoalesce; 3720 bit32 tiStatus; 3721 3722 TI_DBG2(("ossaIntCoalesceInitCB: start\n")); 3723 3724 tdsaIntCoalCxt = (tdsaIntCoalesceContext_t *)agIntCoContext->osData; 3725 tiIntCoalesceCxt = tdsaIntCoalCxt->tiIntCoalesceCxt; 3726 switch (status) 3727 { 3728 case AGSA_RC_SUCCESS: 3729 tiStatus = tiSuccess; 3730 break; 3731 case AGSA_RC_BUSY: 3732 tiStatus = tiBusy; 3733 break; 3734 case AGSA_RC_FAILURE: 3735 tiStatus = tiError; 3736 break; 3737 default: 3738 TI_DBG1(("ossaIntCoalesceInitCB: unknown status %d\n", status)); 3739 tiStatus = tiError; 3740 break; 3741 } 3742 3743 TI_DBG2(("ossaIntCoalesceInitCB: status %d\n", tiStatus)); 3744 3745 /* enqueue tdsaIntCoalCxt to freelink */ 3746 tdsaIntCoalCxt->tiIntCoalesceCxt = agNULL; 3747 TI_DBG2(("ossaIntCoalesceInitCB: id %d\n", tdsaIntCoalCxt->id)); 3748 3749 tdsaSingleThreadedEnter(tiRoot, TD_INTCOAL_LOCK); 3750 TDLIST_DEQUEUE_THIS(&(tdsaIntCoalCxt->MainLink)); 3751 TDLIST_ENQUEUE_AT_TAIL(&(tdsaIntCoalCxt->FreeLink), &(tdsaIntCoalCxtHead->FreeLink)); 3752 tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK); 3753 3754 #ifdef OS_INT_COALESCE 3755 ostiInitiatorIntCoalesceInitCB(tiRoot, 3756 tiIntCoalesceCxt, 3757 tiStatus); 3758 #endif 3759 3760 TI_DBG2(("ossaIntCoalesceInitCB: return end\n")); 3761 3762 return; 3763 } 3764 #endif /* TD_INT_COALESCE */ 3765 3766 /*****************************************************************************/ 3767 /*! \brief ossaSingleThreadedEnter 3768 * 3769 * 3770 * Purpose: This routine is called to ensure that only a single thread of 3771 * the given port instance executes code in the region protected by 3772 * this function. 3773 * 3774 * 3775 * \param agRoot: Pointer to chip/driver Instance. 3776 * \param syncLockId to be explained. 3777 * 3778 * 3779 * \return None. 3780 * 3781 * \note - The scope is shared target and initiator. 3782 * 3783 */ 3784 /*****************************************************************************/ 3785 FORCEINLINE 3786 void ossaSingleThreadedEnter( 3787 agsaRoot_t *agRoot, 3788 bit32 syncLockId 3789 ) 3790 { 3791 tdsaRootOsData_t *pOsData = agNULL; 3792 tiRoot_t *ptiRoot = agNULL; 3793 tdsaContext_t *tdsaAllShared = agNULL; 3794 3795 TD_ASSERT(agRoot, "agRoot"); 3796 pOsData = (tdsaRootOsData_t *) (agRoot->osData); 3797 TD_ASSERT(pOsData, "pOsData"); 3798 ptiRoot = pOsData->tiRoot; 3799 TD_ASSERT(ptiRoot, "ptiRoot"); 3800 3801 tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared; 3802 TD_ASSERT(tdsaAllShared, "tdsaAllShared"); 3803 3804 ostiSingleThreadedEnter(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks); 3805 return; 3806 } 3807 3808 /*****************************************************************************/ 3809 /*! \brief ossaSingleThreadedLeave 3810 * 3811 * 3812 * Purpose: This routine is called to leave a critical region of code 3813 * previously protected by a call to osSingleThreadedEnter() 3814 * 3815 * 3816 * \param agRoot: Pointer to chip/driver Instance. 3817 * \param syncLockId to be explained. 3818 * 3819 * 3820 * \return None. 3821 * 3822 * \note - The scope is shared target and initiator. 3823 * 3824 */ 3825 /*****************************************************************************/ 3826 FORCEINLINE 3827 void ossaSingleThreadedLeave( 3828 agsaRoot_t *agRoot, 3829 bit32 syncLockId 3830 ) 3831 { 3832 tdsaRootOsData_t *pOsData = agNULL; 3833 tiRoot_t *ptiRoot = agNULL; 3834 tdsaContext_t *tdsaAllShared = agNULL; 3835 3836 TD_ASSERT(agRoot, "agRoot"); 3837 pOsData = (tdsaRootOsData_t *) (agRoot->osData); 3838 TD_ASSERT(pOsData, "pOsData"); 3839 ptiRoot = pOsData->tiRoot; 3840 TD_ASSERT(ptiRoot, "ptiRoot"); 3841 3842 tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared; 3843 TD_ASSERT(tdsaAllShared, "tdsaAllShared"); 3844 3845 ostiSingleThreadedLeave(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks); 3846 return; 3847 } 3848 3849 #ifdef PERF_COUNT 3850 osGLOBAL void ossaEnter(agsaRoot_t *agRoot, int io) 3851 { 3852 ostiEnter(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io); 3853 return; 3854 } 3855 3856 osGLOBAL void ossaLeave(agsaRoot_t *agRoot, int io) 3857 { 3858 ostiLeave(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io); 3859 return; 3860 } 3861 #endif 3862 3863 3864 osGLOBAL void 3865 ossaSSPIoctlCompleted( 3866 agsaRoot_t *agRoot, 3867 agsaIORequest_t *agIORequest, 3868 bit32 agIOStatus, 3869 bit32 agIOInfoLen, 3870 void *agParam, 3871 bit16 sspTag, 3872 bit32 agOtherInfo 3873 ) 3874 { 3875 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3876 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3877 tdIORequestBody_t *tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 3878 agsaSASRequestBody_t *agSASRequestBody = agNULL; 3879 agsaSSPInitiatorRequest_t *agSSPFrame = agNULL; 3880 bit8 scsiOpcode = 0; 3881 3882 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody); 3883 agSSPFrame = &(agSASRequestBody->sspInitiatorReq); 3884 scsiOpcode = agSSPFrame->sspCmdIU.cdb[0]; 3885 3886 TI_DBG2(("ossaSSPIoctlCompleted: start\n")); 3887 3888 if (agIOStatus == OSSA_SUCCESS) 3889 { 3890 TI_DBG2(("ossaSSPIoctlCompleted: Success status\n")); 3891 } 3892 else 3893 { 3894 TI_DBG1(("ossaSSPIoctlCompleted: Status 0x%x\n", agIOStatus)); 3895 } 3896 switch(scsiOpcode) 3897 { 3898 case REPORT_LUN_OPCODE: 3899 ostiNumOfLUNIOCTLRsp(tiRoot, agIOStatus); 3900 break; 3901 3902 default: 3903 TI_DBG1(("ossaSSPIoctlCompleted: Unsupported SCSI command Response 0x%x\n",scsiOpcode)); 3904 break; 3905 } 3906 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi"); 3907 return; 3908 3909 } 3910 3911 osGLOBAL void 3912 ossaSMPIoctlCompleted( 3913 agsaRoot_t *agRoot, 3914 agsaIORequest_t *agIORequest, 3915 bit32 agIOStatus, 3916 bit32 agIOInfoLen, 3917 agsaFrameHandle_t agFrameHandle 3918 ) 3919 { 3920 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3921 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3922 TI_DBG2(("ossaSMPIoctlCompleted: start\n")); 3923 3924 if (agIOStatus == OSSA_SUCCESS) 3925 { 3926 TI_DBG2(("ossaSMPIoctlCompleted: Success status\n")); 3927 } 3928 else 3929 { 3930 TI_DBG1(("ossaSMPIoctlCompleted: Status 0x%x\n", agIOStatus)); 3931 } 3932 3933 ostiSendSMPIOCTLRsp(tiRoot, agIOStatus); 3934 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi"); 3935 return; 3936 3937 } 3938 3939 3940 /*****************************************************************************/ 3941 /*! \brief ossaSMPCompleted 3942 * 3943 * 3944 * Purpose: This routine is called by lower layer to indicate the completion of 3945 * SMP request 3946 * 3947 * \param agRoot: Pointer to chip/driver Instance. 3948 * \param agIORequest Pointer to SMP request handle 3949 * \param agIOStatus Status 3950 * \param agFrameHeader:Pointer to SMP frame header. 3951 * \param agIOInfoLen IO information length assoicated with the IO 3952 * \param agFrameHandle A Handle used to refer to the response frame 3953 * 3954 * 3955 * \return None. 3956 * 3957 * \note - The scope is shared target and initiator. 3958 * For details, refer to SAS/SATA Low-Level API Specification 3959 */ 3960 /*****************************************************************************/ 3961 osGLOBAL void ossaSMPCompleted( 3962 agsaRoot_t *agRoot, 3963 agsaIORequest_t *agIORequest, 3964 bit32 agIOStatus, 3965 bit32 agIOInfoLen, 3966 agsaFrameHandle_t agFrameHandle 3967 ) 3968 { 3969 #ifdef PASSTHROUGH 3970 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3971 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3972 tdPassthroughCmndBody_t *tdPTCmndBody = (tdPassthroughCmndBody_t *)agIORequest->osData; 3973 bit32 tiStatus = tiPassthroughError; 3974 bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)]; 3975 bit8 SMPpayload[agIOInfoLen]; 3976 3977 TI_DBG2(("ossaSMPCompleted: start and passthrough\n")); 3978 #else /* not PASSTHROUGH */ 3979 3980 tdssSMPRequestBody_t *pSMPRequestBody = (tdssSMPRequestBody_t *) agIORequest->osData; 3981 TI_DBG4(("ossaSMPCompleted: start\n")); 3982 #endif /* end not PASSTHROUGH */ 3983 3984 TDSA_OUT_ENTER((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot); 3985 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y4"); 3986 3987 #ifdef PASSTHROUGH 3988 if (tdPTCmndBody == agNULL) 3989 { 3990 TI_DBG1(("ossaSMPCompleted: tdPTCmndBody is NULL \n")); 3991 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y4"); 3992 goto ext; 3993 } 3994 3995 if (tdPTCmndBody->EventCB == agNULL) 3996 { 3997 TI_DBG1(("ossaSMPCompleted: tdPTCmndBody->EventCB is NULL \n")); 3998 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y4"); 3999 goto ext; 4000 } 4001 4002 if (agIOStatus == OSSA_IO_SUCCESS) 4003 { 4004 tiStatus = tiPassthroughSuccess; 4005 } 4006 else if (agIOStatus == OSSA_IO_ABORTED) 4007 { 4008 tiStatus = tiPassthroughAborted; 4009 } 4010 else 4011 { 4012 tiStatus = tiPassthroughError; 4013 } 4014 4015 osti_memset(SMPpayload, 0, agIOInfoLen); 4016 osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t)); 4017 4018 /* combine the header and payload */ 4019 saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen); 4020 osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t)); 4021 osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen); 4022 4023 tdPTCmndBody->EventCB(tiRoot, 4024 tdPTCmndBody->tiPassthroughRequest, 4025 tiStatus, 4026 SMPframe, 4027 agIOInfoLen + sizeof(agsaSMPFrameHeader_t) 4028 ); 4029 4030 4031 #else /* not PASSTHROUGH */ 4032 4033 /* 4034 At initiator, passing SMP to TD layer, itdssSMPCompleted(), which does nothing. 4035 At target, passing SMP to TD layer, ttdsaSMPCompleted() 4036 */ 4037 /* 4038 how to use agFrameHandle, when saFrameReadBlock() is used 4039 */ 4040 4041 /* SPC can't be SMP target */ 4042 4043 TI_DBG4(("ossaSMPCompleted: start\n")); 4044 4045 if (pSMPRequestBody == agNULL) 4046 { 4047 TI_DBG1(("ossaSMPCompleted: pSMPRequestBody is NULL \n")); 4048 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y4"); 4049 goto ext; 4050 } 4051 4052 if (pSMPRequestBody->SMPCompletionFunc == agNULL) 4053 { 4054 TI_DBG1(("ossaSMPCompleted: pSMPRequestBody->SMPCompletionFunc is NULL \n")); 4055 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y4"); 4056 goto ext; 4057 } 4058 #ifdef TD_INTERNAL_DEBUG /* debugging */ 4059 TI_DBG4(("ossaSMPCompleted: agIOrequest %p\n", agIORequest->osData)); 4060 TI_DBG4(("ossaSMPCompleted: sizeof(tdIORequestBody_t) %d 0x%x\n", sizeof(tdIORequestBody_t), 4061 sizeof(tdIORequestBody_t))); 4062 TI_DBG4(("ossaSMPCompleted: SMPRequestbody %p\n", pSMPRequestBody)); 4063 TI_DBG4(("ossaSMPCompleted: calling callback fn\n")); 4064 TI_DBG4(("ossaSMPCompleted: callback fn %p\n",pSMPRequestBody->SMPCompletionFunc)); 4065 #endif /* TD_INTERNAL_DEBUG */ 4066 /* 4067 if initiator, calling itdssSMPCompleted() in itdcb.c 4068 if target, calling ttdsaSMPCompleted() in ttdsmp.c 4069 */ 4070 pSMPRequestBody->SMPCompletionFunc( 4071 agRoot, 4072 agIORequest, 4073 agIOStatus, 4074 agIOInfoLen, 4075 agFrameHandle 4076 ); 4077 4078 #endif /* Not PASSTHROUGH */ 4079 4080 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y4"); 4081 ext: 4082 TDSA_OUT_LEAVE((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot); 4083 return; 4084 } 4085 4086 osGLOBAL void 4087 ossaSMPReqReceived( 4088 agsaRoot_t *agRoot, 4089 agsaDevHandle_t *agDevHandle, 4090 agsaFrameHandle_t agFrameHandle, 4091 bit32 agIOInfoLen, 4092 bit32 phyId 4093 ) 4094 { 4095 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y5"); 4096 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y5"); 4097 return; 4098 } 4099 4100 /*****************************************************************************/ 4101 /*! \brief ossaSMPCAMCompleted 4102 * 4103 * 4104 * Purpose: This routine is called by lower layer to indicate the completion of 4105 * SMP request 4106 * 4107 * \param agRoot: Pointer to chip/driver Instance. 4108 * \param agIORequest Pointer to SMP request handle 4109 * \param agIOStatus Status 4110 * \param agIOInfoLen IO information length assoicated with the IO 4111 * \param agFrameHandle A Handle used to refer to the response frame 4112 * 4113 * 4114 * \return None. 4115 * 4116 * \note - The scope is shared target and initiator. 4117 * For details, refer to SAS/SATA Low-Level API Specification 4118 */ 4119 /*****************************************************************************/ 4120 osGLOBAL void ossaSMPCAMCompleted( 4121 agsaRoot_t *agRoot, 4122 agsaIORequest_t *agIORequest, 4123 bit32 agIOStatus, 4124 bit32 agIOInfoLen, 4125 agsaFrameHandle_t agFrameHandle 4126 ) 4127 { 4128 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4129 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4130 tdIORequestBody_t *tdSMPRequestBody = agNULL; 4131 bit32 context = osData->IntContext; 4132 tiSMPStatus_t status; 4133 bit32 PhysUpper32; 4134 bit32 PhysLower32; 4135 bit32 memAllocStatus; 4136 void *osMemHandle; 4137 bit32 *SMPpayload; 4138 TI_DBG2(("ossaSMPCAMCompleted: start\n")); 4139 TI_DBG2(("ossaSMPCAMCompleted: agIOInfoLen %d\n", agIOInfoLen)); 4140 if (!agIORequest->osData) 4141 { 4142 TD_ASSERT((0), "ossaSMPCAMCompleted agIORequest->osData"); 4143 goto ext; 4144 } 4145 tdSMPRequestBody = (tdIORequestBody_t *)agIORequest->osData; 4146 if (tdSMPRequestBody->tiIORequest->osData == agNULL) 4147 { 4148 TI_DBG1(("ossaSMPCAMCompleted: tdIORequestBody->tiIORequest->osData is null, wrong\n")); 4149 goto ext; 4150 } 4151 /* allocating agIORequest for SMP Payload itself */ 4152 memAllocStatus = ostiAllocMemory( 4153 tiRoot, 4154 &osMemHandle, 4155 (void **)&SMPpayload, 4156 &PhysUpper32, 4157 &PhysLower32, 4158 8, 4159 agIOInfoLen, 4160 agTRUE 4161 ); 4162 if (memAllocStatus != tiSuccess) 4163 { 4164 /* let os process IO */ 4165 TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory failed...\n")); 4166 goto ext; 4167 } 4168 if (SMPpayload == agNULL) 4169 { 4170 TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory returned NULL SMPpayload\n")); 4171 goto ext; 4172 } 4173 if (agIOStatus == OSSA_IO_SUCCESS) 4174 { 4175 TI_DBG1(("ossaSMPCAMCompleted: Success status\n")); 4176 osti_memset(SMPpayload, 0, agIOInfoLen); 4177 TI_DBG1(("ossaSMPCAMCompleted: after memset\n")); 4178 saFrameReadBlock(agRoot, agFrameHandle, 0, SMPpayload, agIOInfoLen); 4179 TI_DBG1(("ossaSMPCAMCompleted: after read \n")); 4180 status = tiSMPSuccess; 4181 } 4182 else if (agIOStatus == OSSA_IO_ABORTED) 4183 { 4184 TI_DBG1(("ossaSMPCAMCompleted: SMP Aborted status\n")); 4185 status = tiSMPAborted; 4186 TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status)); 4187 //failed to send smp command, we need to free the memory 4188 ostiFreeMemory( 4189 tiRoot, 4190 osMemHandle, 4191 agIOInfoLen 4192 ); 4193 } 4194 else 4195 { 4196 TI_DBG1(("ossaSMPCAMCompleted: SMP failed status\n")); 4197 status = tiSMPFailed; 4198 TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status)); 4199 //failed to send smp command, we need to free the memory 4200 ostiFreeMemory( 4201 tiRoot, 4202 osMemHandle, 4203 agIOInfoLen 4204 ); 4205 } 4206 ostiInitiatorSMPCompleted(tiRoot, 4207 tdSMPRequestBody->tiIORequest, 4208 status, 4209 agIOInfoLen, 4210 SMPpayload, 4211 context 4212 ); 4213 ext: 4214 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot); 4215 return; 4216 } 4217 #ifdef REMOVED 4218 #ifdef TARGET_DRIVER 4219 /*****************************************************************************/ 4220 /*! \brief ossaSMPReqReceived 4221 * 4222 * 4223 * Purpose: This routine is called by lower layer to indicate the reception of 4224 * SMP request 4225 * 4226 * \param agRoot: Pointer to chip/driver Instance. 4227 * \param agDevHandle Pointer to the device handle of the device 4228 * \param agFrameHandle A Handle used to refer to the response frame 4229 * 4230 * 4231 * \return None. 4232 * 4233 * \note - The scope is target only 4234 * For details, refer to SAS/SATA Low-Level API Specification 4235 */ 4236 /*****************************************************************************/ 4237 osGLOBAL void ossaSMPReqReceived( 4238 agsaRoot_t *agRoot, 4239 agsaDevHandle_t *agDevHandle, 4240 agsaFrameHandle_t agFrameHandle, 4241 bit32 agFrameLength, 4242 bit32 phyId 4243 ) 4244 { 4245 bit8 smpHeader[4]; 4246 agsaSMPFrameHeader_t *agFrameHeader; 4247 #ifdef PASSTHROUGH 4248 /* call the registered function(parameter in tiTGTPassthroughCmndRegister() by target */ 4249 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4250 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4251 ttdsaTgt_t *Target = (ttdsaTgt_t *)osData->ttdsaTgt; 4252 4253 bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)]; 4254 bit8 SMPpayload[agIOInfoLen]; 4255 4256 TI_DBG2(("ossaSMPReqReceived: start and passthrough\n")); 4257 osti_memset(SMPpayload, 0, agIOInfoLen); 4258 osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t)); 4259 /* combine smp header and payload */ 4260 saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen); 4261 osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t)); 4262 osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen); 4263 4264 Target->PasthroughCB( 4265 tiRoot, 4266 tiSASATA, 4267 tiSMP, 4268 tiSMPResponse, 4269 SMPframe, 4270 agIOInfoLen + sizeof(agsaSMPFrameHeader_t), 4271 phyId 4272 ); 4273 4274 #else 4275 4276 /* 4277 agDevHandle_t->osData points to tdssDeviceData_t 4278 */ 4279 tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 4280 4281 saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4); 4282 agFrameHeader = (agsaSMPFrameHeader_t *)smpHeader; 4283 TI_DBG4(("ossaSMPReqReceived: start\n")); 4284 4285 /* tdtypes.h, calling ttdsaSMPReqReceived in ttdsmp.c */ 4286 pDeviceData->pJumpTable->pSMPReqReceived ( 4287 agRoot, 4288 agDevHandle, 4289 agFrameHeader, 4290 agFrameHandle, 4291 agFrameLength, 4292 phyId 4293 ); 4294 #endif 4295 return; 4296 } 4297 #endif 4298 #endif 4299 4300 /*****************************************************************************/ 4301 /*! \brief ossaSSPCompleted 4302 * 4303 * 4304 * Purpose: This routine is called by lower layer to indicate the completion of 4305 * SSP request 4306 * 4307 * \param agRoot: Pointer to chip/driver Instance. 4308 * \param agIORequest Pointer to SMP request handle 4309 * \param agIOStatus Status 4310 * \param agIOInfoLen IO information length assoicated with the IO 4311 * \param agFrameHandle A Handle used to refer to the response frame 4312 * 4313 * 4314 * \return None. 4315 * 4316 * \note - The scope is shared target and initiator. 4317 * For details, refer to SAS/SATA Low-Level API Specification 4318 */ 4319 /*****************************************************************************/ 4320 FORCEINLINE 4321 void ossaSSPCompleted( 4322 agsaRoot_t *agRoot, 4323 agsaIORequest_t *agIORequest, 4324 bit32 agIOStatus, 4325 bit32 agIOInfoLen, 4326 void *agParam, 4327 bit16 sspTag, 4328 bit32 agOtherInfo 4329 ) 4330 { 4331 tdIORequestBody_t *pIORequestBody; 4332 #ifdef TD_DEBUG_ENABLE 4333 tiDeviceHandle_t *tiDeviceHandle = agNULL; 4334 tdsaDeviceData_t *oneDeviceData = agNULL; 4335 #endif 4336 4337 TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot); 4338 smTraceFuncEnter(hpDBG_VERY_LOUD,"2L"); 4339 4340 if(!agIORequest->osData) 4341 { 4342 TD_ASSERT((0), "ossaSSPCompleted agIORequest->osData"); 4343 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2L"); 4344 goto ext; 4345 } 4346 pIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4347 4348 4349 TI_DBG4(("ossaSSPCompleted: start\n")); 4350 4351 if (pIORequestBody == agNULL) 4352 { 4353 TI_DBG1(("ossaSSPCompleted: pIORequestBody is NULL \n")); 4354 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2L"); 4355 goto ext; 4356 } 4357 if (pIORequestBody->IOCompletionFunc == agNULL) 4358 { 4359 #ifdef TD_DEBUG_ENABLE 4360 tiDeviceHandle = pIORequestBody->tiDevHandle; 4361 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 4362 #endif 4363 TI_DBG1(("ossaSSPCompleted: IOCompletionFunc is NULL \n")); 4364 TI_DBG1(("ossaSSPCompleted: did %d \n", oneDeviceData->id)); 4365 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2L"); 4366 goto ext; 4367 } 4368 4369 /* 4370 if initiator, calling itdssIOCompleted() in itdcb.c 4371 if initiator, calling itdssTaskCompleted in itdcb.c 4372 if target, calling ttdsaIOCompleted() in ttdio.c 4373 */ 4374 pIORequestBody->IOCompletionFunc( 4375 agRoot, 4376 agIORequest, 4377 agIOStatus, 4378 agIOInfoLen, 4379 agParam, 4380 agOtherInfo 4381 ); 4382 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2L"); 4383 ext: 4384 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot); 4385 return; 4386 } 4387 4388 #ifdef FAST_IO_TEST 4389 GLOBAL void ossaFastSSPCompleted( 4390 agsaRoot_t *agRoot, 4391 agsaIORequest_t *cbArg, 4392 bit32 agIOStatus, 4393 bit32 agIOInfoLen, 4394 void *agParam, 4395 bit16 sspTag, 4396 bit32 agOtherInfo 4397 ) 4398 { 4399 agsaFastCBBuf_t *safb = (agsaFastCBBuf_t*)cbArg; 4400 tdsaRootOsData_t *osData = (tdsaRootOsData_t*)agRoot->osData; 4401 tiRoot_t *tiRoot = (tiRoot_t*)osData->tiRoot; 4402 bit32 scsi_status; 4403 bit32 data_status; 4404 bit32 respLen; 4405 bit8 respData[128]; 4406 bit32 senseLen; 4407 agsaSSPResponseInfoUnit_t agSSPRespIU; 4408 4409 TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot); 4410 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y6"); 4411 4412 TI_DBG4(("ossaSSPCompleted: start\n")); 4413 4414 if (safb->cb == agNULL || safb->cbArg == agNULL) 4415 { 4416 TI_DBG1(("ossaFastSSPCompleted: pIORequestBody is NULL \n")); 4417 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y6"); 4418 TD_ASSERT((0), ""); 4419 goto ext; 4420 } 4421 4422 switch (agIOStatus) 4423 { 4424 case OSSA_IO_SUCCESS: 4425 4426 /* ~ itdssIOSuccessHandler */ 4427 if ((agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t))) 4428 { 4429 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, OSSA_IO_SUCCESS, 0); 4430 break; 4431 } 4432 4433 /* reads agsaSSPResponseInfoUnit_t */ 4434 saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, 4435 sizeof(agsaSSPResponseInfoUnit_t)); 4436 4437 data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU); 4438 scsi_status = agSSPRespIU.status; 4439 4440 TI_DBG1(("itdssIOSuccessHandler: scsi_status %d\n", scsi_status)); 4441 4442 /* endianess is invovled here */ 4443 senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU); 4444 respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU); 4445 TI_DBG2(("itdssIOSuccessHandler: scsi status=0x%x, senselen=0x%x resplen " 4446 "0x%x\n", scsi_status, senseLen, respLen)); 4447 4448 if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen) 4449 { 4450 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4451 tiDetailOtherError); 4452 break; 4453 } 4454 4455 /* reads response data */ 4456 saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t), 4457 respData, respLen); 4458 /* reads sense data */ 4459 saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t) 4460 + respLen, safb->pSenseData, senseLen); 4461 4462 if (data_status == 0) 4463 { 4464 /* NO_DATA */ 4465 TI_DBG2(("ossaFastSSPCompleted: no data\n")); 4466 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess, 4467 scsi_status); 4468 break; 4469 } 4470 4471 if (data_status == 1) 4472 { 4473 /* RESPONSE_DATA */ 4474 TI_DBG1(("ossaFastSSPCompleted: response data \n")); 4475 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess, 0); 4476 break; 4477 } 4478 4479 if (data_status == 2) 4480 { 4481 tiSenseData_t senseData; 4482 4483 /* SENSE_DATA */ 4484 TI_DBG2(("itdssIOSuccessHandler: sense data \n")); 4485 4486 senseData.senseData = safb->pSenseData; 4487 senseData.senseLen = MIN(*(safb->senseLen), senseLen); 4488 4489 /* when ASC = 0x04 - Log Unit Not Ready, 4490 and ASCQ = 0x11 - Enable Spinup Required: 4491 call saLocalPhyControl to notify spinup */ 4492 if (((char*)safb->pSenseData)[12] == 0x04 && 4493 ((char*)safb->pSenseData)[13] == 0x11) 4494 { 4495 int i; 4496 4497 TI_DBG2(("ossaFastSSPCompleted: sending notfify spinup\n")); 4498 4499 if (((tdsaDeviceData_t*)safb->oneDeviceData)->directlyAttached == 4500 agTRUE) 4501 { 4502 for (i = 0; i < TD_MAX_NUM_NOTIFY_SPINUP; i++) 4503 { 4504 saLocalPhyControl(agRoot, agNULL, 0, 4505 ((tdsaDeviceData_t*)safb->oneDeviceData)->phyID, 4506 AGSA_PHY_NOTIFY_ENABLE_SPINUP, 4507 agNULL); 4508 } 4509 } 4510 } 4511 4512 if (*(safb->senseLen) > senseData.senseLen) 4513 *(safb->senseLen) = senseData.senseLen; 4514 // memcpy((void *)safb->pSenseData, senseData.senseData, safb->senseLen); 4515 4516 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess, 4517 scsi_status); 4518 break; 4519 } 4520 4521 if (data_status == 3) 4522 { 4523 /* RESERVED */ 4524 TI_DBG1(("ossaFastSSPCompleted: reserved wrong!!!\n")); 4525 4526 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4527 scsi_status); 4528 break; 4529 } 4530 break; 4531 #ifdef REMOVED 4532 case OSSA_IO_OVERFLOW: 4533 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOOverRun, 4534 agIOInfoLen); 4535 break; 4536 #endif /* REMOVED */ 4537 case OSSA_IO_UNDERFLOW: 4538 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOUnderRun, 4539 agIOInfoLen); 4540 break; 4541 4542 case OSSA_IO_ABORTED: 4543 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4544 tiDetailAborted); 4545 break; 4546 case OSSA_IO_ABORT_RESET: 4547 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4548 tiDetailAbortReset); 4549 break; 4550 case OSSA_IO_NO_DEVICE: 4551 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4552 tiDetailNoLogin); 4553 break; 4554 case OSSA_IO_DS_NON_OPERATIONAL: 4555 { 4556 4557 tdsaDeviceData_t *oneDeviceData; 4558 4559 oneDeviceData = (tdsaDeviceData_t*)safb->oneDeviceData; 4560 if (oneDeviceData->valid == agTRUE && 4561 oneDeviceData->registered == agTRUE && 4562 oneDeviceData->tdPortContext != agNULL) 4563 { 4564 saSetDeviceState(oneDeviceData->agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), 4565 oneDeviceData->agDevHandle, SA_DS_OPERATIONAL); 4566 } 4567 /* fall through */ 4568 } 4569 4570 default: 4571 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed, 4572 tiDetailOtherError); 4573 break; 4574 } 4575 4576 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y6"); 4577 4578 ext: 4579 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot); 4580 return; 4581 } /* ossaFastSSPCompleted */ 4582 #endif 4583 4584 /*****************************************************************************/ 4585 /*! \brief ossaSSPReqReceived 4586 * 4587 * 4588 * Purpose: This routine is called by lower layer to indicate the reception of 4589 * SMP request 4590 * 4591 * \param agRoot: Pointer to chip/driver Instance. 4592 * \param agDevHandle Pointer to the device handle of the device 4593 * \param agFrameHandle A Handle used to refer to the response frame 4594 * \param agInitiatorTag the initiator tag 4595 * \param agFrameType SSP frame type 4596 * 4597 * \return none. 4598 * 4599 * \note - The scope is target only 4600 * For details, refer to SAS/SATA Low-Level API Specification 4601 */ 4602 /*****************************************************************************/ 4603 osGLOBAL void ossaSSPReqReceived( 4604 agsaRoot_t *agRoot, 4605 agsaDevHandle_t *agDevHandle, 4606 agsaFrameHandle_t agFrameHandle, 4607 bit16 agInitiatorTag, 4608 bit32 parameter, 4609 bit32 agFrameLen 4610 ) 4611 { 4612 /* 4613 at target only 4614 uses jumptable, not callback 4615 */ 4616 /* 4617 agDevHandle_t->osData points to tdssDeviceData_t 4618 */ 4619 tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 4620 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y7"); 4621 4622 /* tdtypes.h, calling ttdsaSSPReqReceived() in ttdio.c */ 4623 pDeviceData->pJumpTable->pSSPReqReceived ( 4624 agRoot, 4625 agDevHandle, 4626 agFrameHandle, 4627 agInitiatorTag, 4628 parameter, 4629 agFrameLen 4630 ); 4631 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y7"); 4632 return; 4633 } 4634 /*****************************************************************************/ 4635 /*! \brief ossaStallThread 4636 * 4637 * 4638 * Purpose: This routine is called to stall this thread for a number of 4639 * microseconds. 4640 * 4641 * 4642 * \param agRoot: Pointer to chip/driver Instance. 4643 * \param microseconds: Micro second to stall. 4644 * 4645 * 4646 * \return None. 4647 * 4648 * \note - The scope is shared target and initiator. 4649 * 4650 */ 4651 /*****************************************************************************/ 4652 osGLOBAL void ossaStallThread(agsaRoot_t *agRoot, 4653 bit32 microseconds 4654 ) 4655 { 4656 tdsaRootOsData_t *pOsData = (tdsaRootOsData_t *) (agRoot->osData); 4657 4658 ostiStallThread ( 4659 pOsData->tiRoot, 4660 microseconds 4661 ); 4662 return; 4663 } 4664 4665 4666 /***************************************************************************** 4667 *! \brief ossaSSPEvent 4668 * 4669 * This routine is called to notify the OS Layer of an event associated with 4670 * SAS port or SAS device 4671 * 4672 * \param agRoot: Handles for this instance of SAS/SATA hardware 4673 * \param agIORequest Pointer to IO request 4674 * \param event: event type 4675 * \param agIOInfoLen: not in use 4676 * \param agFrameHandle: not in use 4677 * 4678 * \return: none 4679 * 4680 *****************************************************************************/ 4681 /* in case of CMD ACK_NAK timeout, send query task */ 4682 osGLOBAL void ossaSSPEvent( 4683 agsaRoot_t *agRoot, 4684 agsaIORequest_t *agIORequest, 4685 agsaPortContext_t *agPortContext, 4686 agsaDevHandle_t *agDevHandle, 4687 bit32 event, 4688 bit16 sspTag, 4689 bit32 agIOInfoLen, 4690 void *agParam 4691 ) 4692 { 4693 #ifdef INITIATOR_DRIVER 4694 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4695 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4696 /* bit32 intContext = osData->IntContext; */ 4697 void *osMemHandle; 4698 tdIORequestBody_t *TMtdIORequestBody; 4699 bit32 PhysUpper32; 4700 bit32 PhysLower32; 4701 bit32 memAllocStatus; 4702 bit32 agRequestType; 4703 agsaIORequest_t *agTMIORequest = agNULL; /* task management itself */ 4704 agsaSASRequestBody_t *agSASRequestBody = agNULL; 4705 agsaSSPScsiTaskMgntReq_t *agSSPTaskMgntRequest; 4706 bit32 saStatus; 4707 bit32 agIORequestType; /* type of IO recevied */ 4708 tiIORequest_t *taskTag; /* being task managed one */ 4709 tdIORequestBody_t *tdIORequestBody; 4710 #endif 4711 4712 #ifdef REMOVED 4713 tiDeviceHandle_t *tiDeviceHandle; 4714 tdsaDeviceData_t *oneDeviceData = agNULL; 4715 tdIORequestBody_t *tdAbortIORequestBody; 4716 #endif 4717 agsaDifDetails_t agDifDetails; 4718 bit8 framePayload[256]; 4719 #ifdef REMOVED 4720 bit16 frameOffset = 0; 4721 #endif 4722 bit16 frameLen = 0; 4723 4724 TI_DBG6(("ossaSSPEvent: start\n")); 4725 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y9"); 4726 4727 4728 4729 if (event == OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT || 4730 event == OSSA_IO_XFER_ERROR_BREAK || 4731 event == OSSA_IO_XFER_ERROR_PHY_NOT_READY 4732 ) 4733 { 4734 4735 /* IO being task managed(the original IO) depending on event */ 4736 #ifdef INITIATOR_DRIVER 4737 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4738 taskTag = tdIORequestBody->tiIORequest; 4739 #endif 4740 #ifdef REMOVED 4741 tiDeviceHandle = tdIORequestBody->tiDevHandle; 4742 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 4743 #endif 4744 4745 #ifdef INITIATOR_DRIVER 4746 agIORequestType = tdIORequestBody->agRequestType; 4747 4748 /* error checking; only command is expected here */ 4749 if (agIORequestType == AGSA_REQ_TYPE_UNKNOWN) 4750 { 4751 TI_DBG1(("ossaSSPEvent: incorrect frame 0x%x. Should be command\n", agIORequestType)); 4752 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y9"); 4753 return; 4754 } 4755 4756 /* Allocate memory for query task management */ 4757 memAllocStatus = ostiAllocMemory( 4758 tiRoot, 4759 &osMemHandle, 4760 (void **)&TMtdIORequestBody, 4761 &PhysUpper32, 4762 &PhysLower32, 4763 8, 4764 sizeof(tdIORequestBody_t), 4765 agTRUE 4766 ); 4767 4768 if (memAllocStatus != tiSuccess) 4769 { 4770 /* let os process IO */ 4771 TI_DBG1(("ossaSSPEvent: ostiAllocMemory failed...\n")); 4772 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y9"); 4773 return; 4774 } 4775 4776 if (TMtdIORequestBody == agNULL) 4777 { 4778 /* let os process IO */ 4779 TI_DBG1(("ossaSSPEvent: ostiAllocMemory returned NULL TMIORequestBody\n")); 4780 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y9"); 4781 return; 4782 } 4783 4784 /* setup task management structure */ 4785 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 4786 /* TD generates Query Task not OS layer */ 4787 TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL; 4788 TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag; 4789 4790 /* initialize callback function */ 4791 TMtdIORequestBody->IOCompletionFunc = itdssQueryTaskCompleted; 4792 4793 /* initialize tiDevhandle */ 4794 TMtdIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle; 4795 4796 4797 /* initialize agIORequest */ 4798 agTMIORequest = &(TMtdIORequestBody->agIORequest); 4799 agTMIORequest->osData = (void *) TMtdIORequestBody; 4800 agTMIORequest->sdkData = agNULL; /* LL takes care of this */ 4801 4802 /* request type */ 4803 agRequestType = AGSA_SSP_TASK_MGNT_REQ; 4804 TMtdIORequestBody->agRequestType = AGSA_SSP_TASK_MGNT_REQ; 4805 4806 /* 4807 initialize 4808 tdIORequestBody_t tdIORequestBody -> agSASRequestBody 4809 */ 4810 agSASRequestBody = &(TMtdIORequestBody->transport.SAS.agSASRequestBody); 4811 agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq); 4812 4813 /* fill up LUN field */ 4814 osti_memset(agSSPTaskMgntRequest->lun, 0, 8); 4815 4816 /* sets taskMgntFunction field */ 4817 agSSPTaskMgntRequest->taskMgntFunction = AGSA_QUERY_TASK; 4818 /* debugging */ 4819 if (TMtdIORequestBody->IOCompletionFunc == agNULL) 4820 { 4821 TI_DBG1(("ossaSSPEvent: Error !!! IOCompletionFunc is NULL\n")); 4822 } 4823 /* send query task management */ 4824 saStatus = saSSPStart(agRoot, 4825 agTMIORequest, 4826 0, 4827 agDevHandle, 4828 agRequestType, 4829 agSASRequestBody, 4830 agIORequest, 4831 &ossaSSPCompleted); 4832 4833 if (saStatus != AGSA_RC_SUCCESS) 4834 { 4835 /* free up allocated memory */ 4836 ostiFreeMemory( 4837 tiRoot, 4838 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 4839 sizeof(tdIORequestBody_t) 4840 ); 4841 TI_DBG1(("ossaSSPEvent: saSSPStart failed\n")); 4842 return; 4843 } 4844 #endif 4845 } 4846 #ifdef REMOVED 4847 else if (event == OSSA_IO_ABORTED) 4848 { 4849 TI_DBG2(("ossaSSPEvent: OSSA_IO_ABORTED\n")); 4850 /* clean up TD layer's IORequestBody */ 4851 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4852 ostiFreeMemory( 4853 tiRoot, 4854 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 4855 sizeof(tdIORequestBody_t) 4856 ); 4857 4858 } 4859 else if (event == OSSA_IO_NOT_VALID) 4860 { 4861 TI_DBG1(("ossaSSPEvent: OSSA_IO_NOT_VALID\n")); 4862 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4863 ostiFreeMemory( 4864 tiRoot, 4865 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 4866 sizeof(tdIORequestBody_t) 4867 ); 4868 4869 4870 } 4871 #endif 4872 else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED) 4873 { 4874 TI_DBG2(("ossaSSPEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n")); 4875 } 4876 else if (event == OSSA_IO_XFER_ERROR_OFFSET_MISMATCH) 4877 { 4878 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_OFFSET_MISMATCH\n")); 4879 } 4880 else if (event == OSSA_IO_OVERFLOW) 4881 { 4882 TI_DBG1(("ossaSSPEvent: OSSA_IO_OVERFLOW\n")); 4883 /* 4884 ??? can't call; missing agIOInfoLen 4885 ostiInitiatorIOCompleted ( 4886 tiRoot, 4887 tdIORequestBody->tiIORequest, 4888 tiIOOverRun, 4889 agIOInfoLen, 4890 agNULL, 4891 intContext 4892 ); 4893 4894 */ 4895 4896 } 4897 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED) 4898 { 4899 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n")); 4900 } 4901 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO) 4902 { 4903 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n")); 4904 } 4905 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST) 4906 { 4907 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n")); 4908 } 4909 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE) 4910 { 4911 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n")); 4912 } 4913 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED) 4914 { 4915 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n")); 4916 } 4917 else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH) 4918 { 4919 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n")); 4920 } 4921 else if (event == OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN) 4922 { 4923 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN\n")); 4924 } 4925 else if (event == OSSA_IO_XFR_ERROR_DIF_MISMATCH || 4926 event == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH || 4927 event == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH || 4928 event == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH ) 4929 { 4930 TI_DBG1(("ossaSSPEvent: DIF related, event 0x%x\n", event)); 4931 /* process DIF detail information */ 4932 TI_DBG2(("ossaSSPEvent: agIOInfoLen %d\n", agIOInfoLen)); 4933 if (agParam == agNULL) 4934 { 4935 TI_DBG2(("ossaSSPEvent: agParam is NULL!!!\n")); 4936 return; 4937 } 4938 if (agIOInfoLen < sizeof(agsaDifDetails_t)) 4939 { 4940 TI_DBG2(("ossaSSPEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, (int)sizeof(agsaDifDetails_t))); 4941 return; 4942 } 4943 /* reads agsaDifDetails_t */ 4944 saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t)); 4945 #ifdef REMOVED 4946 frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF); 4947 #endif 4948 frameLen = (bit16)((agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16); 4949 4950 TI_DBG2(("ossaSSPEvent: UpperLBA 0x%08x LowerLBA 0x%08x\n", agDifDetails.UpperLBA, agDifDetails.LowerLBA)); 4951 TI_DBG2(("ossaSSPEvent: SASAddrHI 0x%08x SASAddrLO 0x%08x\n", 4952 TD_GET_SAS_ADDRESSHI(agDifDetails.sasAddressHi), TD_GET_SAS_ADDRESSLO(agDifDetails.sasAddressLo))); 4953 TI_DBG2(("ossaSSPEvent: DIF error mask 0x%x Device ID 0x%x\n", 4954 (agDifDetails.DIFErrDevID) & 0xFF, (agDifDetails.DIFErrDevID & 0xFFFF0000) >> 16)); 4955 if (frameLen != 0 && frameLen <= 256) 4956 { 4957 saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen); 4958 tdhexdump("ossaSSPEvent frame", framePayload, frameLen); 4959 } 4960 } 4961 else 4962 { 4963 TI_DBG1(("ossaSSPEvent: other event 0x%x\n", event)); 4964 } 4965 4966 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y9"); 4967 return; 4968 } 4969 4970 #ifdef FDS_SM 4971 osGLOBAL void ossaSATAIDAbortCB( 4972 agsaRoot_t *agRoot, 4973 agsaIORequest_t *agIORequest, 4974 bit32 flag, 4975 bit32 status) 4976 { 4977 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4978 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4979 tdIORequestBody_t *tdAbortIORequestBody; 4980 4981 TI_DBG1(("ossaSATAIDAbortCB: start flag %d status %d\n", flag, status)); 4982 4983 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4984 4985 /* 4986 triggered by tdIDStartTimerCB 4987 */ 4988 ostiFreeMemory( 4989 tiRoot, 4990 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 4991 sizeof(tdIORequestBody_t) 4992 ); 4993 return; 4994 } 4995 #endif 4996 4997 #ifdef INITIATOR_DRIVER 4998 osGLOBAL void ossaSSPAbortCB( 4999 agsaRoot_t *agRoot, 5000 agsaIORequest_t *agIORequest, 5001 bit32 flag, 5002 bit32 status) 5003 { 5004 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5005 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5006 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 5007 tdsaDeviceData_t *oneDeviceData = agNULL; 5008 tiDeviceHandle_t *tiDeviceHandle = agNULL; 5009 tiIORequest_t *taskTag = agNULL; 5010 5011 TI_DBG2(("ossaSSPAbortCB: start\n")); 5012 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ya"); 5013 5014 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 5015 if (tdAbortIORequestBody == agNULL) 5016 { 5017 TI_DBG1(("ossaSSPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n")); 5018 return; 5019 } 5020 5021 if (flag == 2) 5022 { 5023 /* abort per port */ 5024 TI_DBG1(("ossaSSPAbortCB: abort per port\n")); 5025 } 5026 else if (flag == 1) 5027 { 5028 TI_DBG2(("ossaSSPAbortCB: abort all\n")); 5029 5030 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle; 5031 if (tiDeviceHandle == agNULL) 5032 { 5033 TI_DBG1(("ossaSSPAbortCB: tiDeviceHandle is NULL warning!!!!\n")); 5034 ostiFreeMemory( 5035 tiRoot, 5036 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5037 sizeof(tdIORequestBody_t) 5038 ); 5039 return; 5040 } 5041 5042 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 5043 if (oneDeviceData == agNULL) 5044 { 5045 TI_DBG1(("ossaSSPAbortCB: oneDeviceData is NULL warning!!!!\n")); 5046 ostiFreeMemory( 5047 tiRoot, 5048 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5049 sizeof(tdIORequestBody_t) 5050 ); 5051 return; 5052 } 5053 5054 if (status == OSSA_IO_SUCCESS) 5055 { 5056 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n")); 5057 /* clean up TD layer's IORequestBody */ 5058 if (oneDeviceData->OSAbortAll == agTRUE) 5059 { 5060 oneDeviceData->OSAbortAll = agFALSE; 5061 ostiInitiatorEvent( tiRoot, 5062 agNULL, 5063 tiDeviceHandle, 5064 tiIntrEventTypeLocalAbort, 5065 tiAbortOK, 5066 agNULL); 5067 } 5068 else 5069 { 5070 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5071 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5072 } 5073 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5074 ostiFreeMemory( 5075 tiRoot, 5076 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5077 sizeof(tdIORequestBody_t) 5078 ); 5079 5080 } 5081 else if (status == OSSA_IO_NOT_VALID) 5082 { 5083 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n")); 5084 /* clean up TD layer's IORequestBody */ 5085 if (oneDeviceData->OSAbortAll == agTRUE) 5086 { 5087 oneDeviceData->OSAbortAll = agFALSE; 5088 ostiInitiatorEvent( tiRoot, 5089 agNULL, 5090 tiDeviceHandle, 5091 tiIntrEventTypeLocalAbort, 5092 tiAbortFailed, 5093 agNULL ); 5094 } 5095 else 5096 { 5097 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5098 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5099 } 5100 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5101 ostiFreeMemory( 5102 tiRoot, 5103 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5104 sizeof(tdIORequestBody_t) 5105 ); 5106 } 5107 else if (status == OSSA_IO_NO_DEVICE) 5108 { 5109 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n")); 5110 /* clean up TD layer's IORequestBody */ 5111 if (oneDeviceData->OSAbortAll == agTRUE) 5112 { 5113 oneDeviceData->OSAbortAll = agFALSE; 5114 ostiInitiatorEvent( tiRoot, 5115 agNULL, 5116 tiDeviceHandle, 5117 tiIntrEventTypeLocalAbort, 5118 tiAbortInProgress, 5119 agNULL ); 5120 } 5121 else 5122 { 5123 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5124 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5125 } 5126 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5127 ostiFreeMemory( 5128 tiRoot, 5129 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5130 sizeof(tdIORequestBody_t) 5131 ); 5132 } 5133 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 5134 { 5135 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 5136 /* clean up TD layer's IORequestBody */ 5137 if (oneDeviceData->OSAbortAll == agTRUE) 5138 { 5139 oneDeviceData->OSAbortAll = agFALSE; 5140 ostiInitiatorEvent( tiRoot, 5141 agNULL, 5142 tiDeviceHandle, 5143 tiIntrEventTypeLocalAbort, 5144 tiAbortInProgress, 5145 agNULL ); 5146 } 5147 else 5148 { 5149 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5150 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5151 } 5152 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5153 ostiFreeMemory( 5154 tiRoot, 5155 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5156 sizeof(tdIORequestBody_t) 5157 ); 5158 } 5159 #ifdef REMOVED 5160 else if (status == OSSA_IO_ABORT_DELAYED) 5161 { 5162 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 5163 /* clean up TD layer's IORequestBody */ 5164 if (oneDeviceData->OSAbortAll == agTRUE) 5165 { 5166 oneDeviceData->OSAbortAll = agFALSE; 5167 ostiInitiatorEvent( tiRoot, 5168 agNULL, 5169 tiDeviceHandle, 5170 tiIntrEventTypeLocalAbort, 5171 tiAbortDelayed, 5172 agNULL ); 5173 } 5174 else 5175 { 5176 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5177 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5178 } 5179 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5180 ostiFreeMemory( 5181 tiRoot, 5182 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5183 sizeof(tdIORequestBody_t) 5184 ); 5185 } 5186 #endif 5187 else 5188 { 5189 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status)); 5190 /* clean up TD layer's IORequestBody */ 5191 if (oneDeviceData->OSAbortAll == agTRUE) 5192 { 5193 oneDeviceData->OSAbortAll = agFALSE; 5194 ostiInitiatorEvent( tiRoot, 5195 agNULL, 5196 tiDeviceHandle, 5197 tiIntrEventTypeLocalAbort, 5198 tiAbortInProgress, 5199 agNULL ); 5200 } 5201 else 5202 { 5203 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5204 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5205 } 5206 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5207 ostiFreeMemory( 5208 tiRoot, 5209 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5210 sizeof(tdIORequestBody_t) 5211 ); 5212 } 5213 } 5214 else if (flag == 0) 5215 { 5216 TI_DBG2(("ossaSSPAbortCB: abort one\n")); 5217 taskTag = tdAbortIORequestBody->tiIOToBeAbortedRequest; 5218 5219 if ( taskTag == agNULL) 5220 { 5221 TI_DBG1(("ossaSSPAbortCB: taskTag is NULL; triggered by itdssQueryTaskCompleted\n")); 5222 } 5223 if (status == OSSA_IO_SUCCESS) 5224 { 5225 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n")); 5226 if (taskTag != agNULL) 5227 { 5228 ostiInitiatorEvent( tiRoot, 5229 agNULL, 5230 agNULL, 5231 tiIntrEventTypeLocalAbort, 5232 tiAbortOK, 5233 taskTag ); 5234 } 5235 ostiFreeMemory( 5236 tiRoot, 5237 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5238 sizeof(tdIORequestBody_t) 5239 ); 5240 5241 } 5242 else if (status == OSSA_IO_NOT_VALID) 5243 { 5244 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n")); 5245 5246 if (taskTag != agNULL) 5247 { 5248 ostiInitiatorEvent( tiRoot, 5249 agNULL, 5250 agNULL, 5251 tiIntrEventTypeLocalAbort, 5252 tiAbortFailed, 5253 taskTag ); 5254 } 5255 ostiFreeMemory( 5256 tiRoot, 5257 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5258 sizeof(tdIORequestBody_t) 5259 ); 5260 } 5261 else if (status == OSSA_IO_NO_DEVICE) 5262 { 5263 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n")); 5264 5265 if (taskTag != agNULL) 5266 { 5267 ostiInitiatorEvent( tiRoot, 5268 agNULL, 5269 agNULL, 5270 tiIntrEventTypeLocalAbort, 5271 tiAbortInProgress, 5272 taskTag ); 5273 } 5274 ostiFreeMemory( 5275 tiRoot, 5276 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5277 sizeof(tdIORequestBody_t) 5278 ); 5279 } 5280 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 5281 { 5282 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 5283 5284 if (taskTag != agNULL) 5285 { 5286 ostiInitiatorEvent( tiRoot, 5287 agNULL, 5288 agNULL, 5289 tiIntrEventTypeLocalAbort, 5290 tiAbortInProgress, 5291 taskTag ); 5292 } 5293 ostiFreeMemory( 5294 tiRoot, 5295 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5296 sizeof(tdIORequestBody_t) 5297 ); 5298 } 5299 #ifdef REMOVED 5300 else if (status == OSSA_IO_ABORT_DELAYED) 5301 { 5302 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 5303 5304 if (taskTag != agNULL) 5305 { 5306 ostiInitiatorEvent( tiRoot, 5307 agNULL, 5308 agNULL, 5309 tiIntrEventTypeLocalAbort, 5310 tiAbortDelayed, 5311 taskTag ); 5312 } 5313 ostiFreeMemory( 5314 tiRoot, 5315 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5316 sizeof(tdIORequestBody_t) 5317 ); 5318 } 5319 #endif 5320 else 5321 { 5322 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status)); 5323 5324 if (taskTag != agNULL) 5325 { 5326 ostiInitiatorEvent( tiRoot, 5327 agNULL, 5328 agNULL, 5329 tiIntrEventTypeLocalAbort, 5330 tiAbortFailed, 5331 taskTag ); 5332 } 5333 ostiFreeMemory( 5334 tiRoot, 5335 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5336 sizeof(tdIORequestBody_t) 5337 ); 5338 } 5339 } 5340 else 5341 { 5342 TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag)); 5343 } 5344 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ya"); 5345 return; 5346 5347 } 5348 #endif 5349 5350 5351 #ifdef TARGET_DRIVER 5352 osGLOBAL void ossaSSPAbortCB( 5353 agsaRoot_t *agRoot, 5354 agsaIORequest_t *agIORequest, 5355 bit32 flag, 5356 bit32 status) 5357 { 5358 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5359 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5360 tdIORequestBody_t *tdAbortIORequestBody; 5361 tdsaDeviceData_t *oneDeviceData; 5362 tiDeviceHandle_t *tiDeviceHandle; 5363 5364 TI_DBG3(("ossaSSPAbortCB: start\n")); 5365 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 5366 5367 if (flag == 2) 5368 { 5369 /* abort per port */ 5370 TI_DBG2(("ossaSSPAbortCB: abort per port\n")); 5371 } 5372 else if (flag == 1) 5373 { 5374 TI_DBG2(("ossaSSPAbortCB: abort all\n")); 5375 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle; 5376 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 5377 if (status == OSSA_IO_SUCCESS) 5378 { 5379 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n")); 5380 /* clean up TD layer's IORequestBody */ 5381 TI_DBG3(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5382 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5383 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5384 ostiFreeMemory( 5385 tiRoot, 5386 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5387 sizeof(tdIORequestBody_t) 5388 ); 5389 5390 } 5391 else if (status == OSSA_IO_NOT_VALID) 5392 { 5393 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n")); 5394 /* clean up TD layer's IORequestBody */ 5395 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5396 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5397 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5398 ostiFreeMemory( 5399 tiRoot, 5400 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5401 sizeof(tdIORequestBody_t) 5402 ); 5403 } 5404 else if (status == OSSA_IO_NO_DEVICE) 5405 { 5406 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n")); 5407 /* clean up TD layer's IORequestBody */ 5408 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5409 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5410 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5411 ostiFreeMemory( 5412 tiRoot, 5413 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5414 sizeof(tdIORequestBody_t) 5415 ); 5416 } 5417 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 5418 { 5419 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 5420 /* clean up TD layer's IORequestBody */ 5421 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5422 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5423 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5424 ostiFreeMemory( 5425 tiRoot, 5426 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5427 sizeof(tdIORequestBody_t) 5428 ); 5429 } 5430 #ifdef REMOVED 5431 else if (status == OSSA_IO_ABORT_DELAYED) 5432 { 5433 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 5434 /* clean up TD layer's IORequestBody */ 5435 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5436 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5437 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5438 ostiFreeMemory( 5439 tiRoot, 5440 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5441 sizeof(tdIORequestBody_t) 5442 ); 5443 } 5444 #endif 5445 else 5446 { 5447 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status)); 5448 /* clean up TD layer's IORequestBody */ 5449 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n")); 5450 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 5451 TI_DBG1(("ossaSSPAbortCB: did %d\n", oneDeviceData->id)); 5452 ostiFreeMemory( 5453 tiRoot, 5454 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5455 sizeof(tdIORequestBody_t) 5456 ); 5457 } 5458 } 5459 else if (flag == 0) 5460 { 5461 TI_DBG2(("ossaSSPAbortCB: abort one\n")); 5462 if (status == OSSA_IO_SUCCESS) 5463 { 5464 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n")); 5465 ostiFreeMemory( 5466 tiRoot, 5467 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5468 sizeof(tdIORequestBody_t) 5469 ); 5470 5471 } 5472 else if (status == OSSA_IO_NOT_VALID) 5473 { 5474 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n")); 5475 ostiFreeMemory( 5476 tiRoot, 5477 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5478 sizeof(tdIORequestBody_t) 5479 ); 5480 } 5481 else if (status == OSSA_IO_NO_DEVICE) 5482 { 5483 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n")); 5484 ostiFreeMemory( 5485 tiRoot, 5486 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5487 sizeof(tdIORequestBody_t) 5488 ); 5489 } 5490 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 5491 { 5492 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 5493 ostiFreeMemory( 5494 tiRoot, 5495 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5496 sizeof(tdIORequestBody_t) 5497 ); 5498 } 5499 #ifdef REMOVED 5500 else if (status == OSSA_IO_ABORT_DELAYED) 5501 { 5502 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 5503 ostiFreeMemory( 5504 tiRoot, 5505 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5506 sizeof(tdIORequestBody_t) 5507 ); 5508 } 5509 #endif 5510 else 5511 { 5512 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status)); 5513 ostiFreeMemory( 5514 tiRoot, 5515 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 5516 sizeof(tdIORequestBody_t) 5517 ); 5518 } 5519 } 5520 else 5521 { 5522 TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag)); 5523 } 5524 5525 return; 5526 5527 } 5528 #endif 5529 5530 5531 /*****************************************************************************/ 5532 /*! \brief ossaLocalPhyControlCB 5533 * 5534 * 5535 * Purpose: This routine is called by lower layer to indicate the status of 5536 * phy operations 5537 * 5538 * \param agRoot: Pointer to chip/driver Instance. 5539 * \param phyId Phy id 5540 * \param phyOperation Operation to be done on the phy 5541 * \param status Phy operation specific completion status 5542 * \param parm Additional parameter, phy operation and status specific 5543 * 5544 * 5545 * \return None. 5546 * 5547 */ 5548 /*****************************************************************************/ 5549 osGLOBAL void ossaLocalPhyControlCB( 5550 agsaRoot_t *agRoot, 5551 agsaContext_t *agContext, 5552 bit32 phyId, 5553 bit32 phyOperation, 5554 bit32 status, 5555 void *parm 5556 ) 5557 { 5558 #ifdef REMVOED 5559 agsaPhyErrCounters_t *agPhyErrCounters; 5560 #endif 5561 #ifdef INITIATOR_DRIVER 5562 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5563 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5564 tiIORequest_t *currentTaskTag; 5565 tdsaDeviceData_t *TargetDeviceData; 5566 satDeviceData_t *pSatDevData; 5567 agsaDevHandle_t *agDevHandle = agNULL; 5568 agsaContext_t *agContextDevice; 5569 #endif 5570 5571 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yb"); 5572 TI_DBG3(("ossaLocalPhyControlCB: start phyID %d\n", phyId)); 5573 TI_DBG3(("ossaLocalPhyControlCB: phyOperation %d status 0x%x\n", phyOperation, status)); 5574 switch (phyOperation) 5575 { 5576 case AGSA_PHY_LINK_RESET: /* fall through */ 5577 case AGSA_PHY_HARD_RESET: 5578 if (phyOperation == AGSA_PHY_LINK_RESET) 5579 { 5580 TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_LINK_RESET, status 0x%x\n", status)); 5581 } 5582 else 5583 { 5584 TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_HARD_RESET, status 0x%x\n", status)); 5585 } 5586 #ifdef INITIATOR_DRIVER 5587 if (agContext != agNULL) 5588 { 5589 currentTaskTag = (tiIORequest_t *)agContext->osData; 5590 if (status == OSSA_SUCCESS) 5591 { 5592 if (currentTaskTag != agNULL) 5593 { 5594 TI_DBG2(("ossaLocalPhyControlCB: callback to OS layer with success\n")); 5595 TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData; 5596 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData); 5597 agDevHandle = TargetDeviceData->agDevHandle; 5598 TI_DBG2(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 5599 TI_DBG2(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 5600 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 5601 5602 if (TargetDeviceData->TRflag == agTRUE) 5603 { 5604 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, TargetDeviceData), agDevHandle, SA_DS_OPERATIONAL); 5605 TargetDeviceData->TRflag = agFALSE; 5606 ostiInitiatorEvent(tiRoot, 5607 TargetDeviceData->tdPortContext->tiPortalContext, 5608 &(TargetDeviceData->tiDeviceHandle), 5609 tiIntrEventTypeTransportRecovery, 5610 tiRecOK, 5611 agNULL 5612 ); 5613 } 5614 else 5615 { 5616 agDevHandle = TargetDeviceData->agDevHandle; 5617 if (agDevHandle == agNULL) 5618 { 5619 TI_DBG1(("ossaLocalPhyControlCB: wrong, agDevHandle is NULL\n")); 5620 } 5621 /* move this to OSSA_HW_EVENT_PORT_RESET_COMPLETE in ossaHwCB() */ 5622 agContextDevice = &(TargetDeviceData->agDeviceResetContext); 5623 agContextDevice->osData = currentTaskTag; 5624 5625 #ifdef REMOVED 5626 ostiInitiatorEvent( tiRoot, 5627 NULL, 5628 NULL, 5629 tiIntrEventTypeTaskManagement, 5630 tiTMOK, 5631 currentTaskTag ); 5632 #endif 5633 } 5634 } 5635 } 5636 else 5637 { 5638 if (currentTaskTag != agNULL) 5639 { 5640 TI_DBG1(("ossaLocalPhyControlCB: callback to OS layer with failure\n")); 5641 TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData; 5642 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData); 5643 TI_DBG1(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 5644 TI_DBG1(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 5645 if (TargetDeviceData->TRflag == agTRUE) 5646 { 5647 TargetDeviceData->TRflag = agFALSE; 5648 ostiInitiatorEvent(tiRoot, 5649 TargetDeviceData->tdPortContext->tiPortalContext, 5650 &(TargetDeviceData->tiDeviceHandle), 5651 tiIntrEventTypeTransportRecovery, 5652 tiRecFailed , 5653 agNULL 5654 ); 5655 } 5656 else 5657 { 5658 ostiInitiatorEvent( tiRoot, 5659 NULL, 5660 NULL, 5661 tiIntrEventTypeTaskManagement, 5662 tiTMFailed, 5663 currentTaskTag ); 5664 } 5665 } 5666 } 5667 } 5668 #endif 5669 break; 5670 #ifdef REMOVED 5671 case AGSA_PHY_GET_ERROR_COUNTS: 5672 5673 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_GET_ERROR_COUNTS, status 0x%x\n", status)); 5674 if(parm !=agNULL ) 5675 { 5676 agPhyErrCounters = (agsaPhyErrCounters_t *)parm; 5677 TI_DBG2(("ossaLocalPhyControlCB: invalidDword %d\n", agPhyErrCounters->invalidDword)); 5678 TI_DBG2(("ossaLocalPhyControlCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError)); 5679 TI_DBG2(("ossaLocalPhyControlCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch)); 5680 TI_DBG2(("ossaLocalPhyControlCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem)); 5681 TI_DBG2(("ossaLocalPhyControlCB: elasticityBufferOverflow %d\n", agPhyErrCounters->elasticityBufferOverflow)); 5682 TI_DBG2(("ossaLocalPhyControlCB: receivedErrorPrimitive %d\n", agPhyErrCounters->receivedErrorPrimitive)); 5683 } 5684 break; 5685 case AGSA_PHY_CLEAR_ERROR_COUNTS: 5686 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_CLEAR_ERROR_COUNTS, status 0x%x\n", status)); 5687 break; 5688 #endif 5689 case AGSA_PHY_NOTIFY_ENABLE_SPINUP: 5690 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_NOTIFY_ENABLE_SPINUP, status 0x%x\n", status)); 5691 break; 5692 case AGSA_PHY_BROADCAST_ASYNCH_EVENT: 5693 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_BROADCAST_ASYNCH_EVENT, status 0x%x\n", status)); 5694 if (tIsSPC12SATA(agRoot)) 5695 { 5696 TI_DBG1(("ossaLocalPhyControlCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n")); 5697 break; 5698 } 5699 break; 5700 case AGSA_PHY_COMINIT_OOB : 5701 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_COMINIT_OOB, status 0x%x\n", status)); 5702 break; 5703 default: 5704 TI_DBG1(("ossaLocalPhyControlCB: UNKNOWN default case. phyOperation %d status 0x%x\n", phyOperation, status)); 5705 break; 5706 } 5707 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yb"); 5708 return; 5709 } 5710 5711 GLOBAL void ossaGetPhyProfileCB( 5712 agsaRoot_t *agRoot, 5713 agsaContext_t *agContext, 5714 bit32 status, 5715 bit32 ppc, 5716 bit32 phyID, 5717 void *parm ) 5718 { 5719 5720 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5721 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5722 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 5723 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 5724 #ifdef CCFLAGS_PHYCONTROL_COUNTS 5725 agsaPhyAnalogSettingsPage_t *analog; 5726 #endif /* CCFLAGS_PHYCONTROL_COUNTS */ 5727 tdPhyCount_t *PhyBlob = agNULL; 5728 5729 agsaPhyBWCountersPage_t *agBWCounters; 5730 agsaPhyErrCountersPage_t *agPhyErrCounters; 5731 TI_DBG1(("ossaGetPhyProfileCB: agContext %p parm %p\n", agContext, parm)); 5732 /* 5733 if( tdsaAllShared->tdFWControlEx.inProgress ) 5734 { 5735 tdsaAllShared->tdFWControlEx.inProgress = 0; 5736 PhyBlob = (tdPhyCount_t *)tdsaAllShared->tdFWControlEx.usrAddr; 5737 } 5738 */ 5739 switch(ppc) 5740 { 5741 case AGSA_SAS_PHY_BW_COUNTERS_PAGE: 5742 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_BW_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID)); 5743 if(parm !=agNULL ) 5744 { 5745 agBWCounters = (agsaPhyBWCountersPage_t *)parm; 5746 TI_DBG1(("ossaGetPhyProfileCB: RX %d TX %d\n", agBWCounters->RXBWCounter,agBWCounters->TXBWCounter)); 5747 if(PhyBlob !=agNULL ) 5748 { 5749 PhyBlob->InvalidDword = 0; 5750 PhyBlob->runningDisparityError = 0; 5751 PhyBlob->codeViolation = 0; 5752 PhyBlob->phyResetProblem = 0; 5753 PhyBlob->inboundCRCError = 0; 5754 PhyBlob->BW_rx = agBWCounters->RXBWCounter; 5755 PhyBlob->BW_tx = agBWCounters->TXBWCounter; 5756 } 5757 5758 } 5759 break; 5760 case AGSA_SAS_PHY_ERR_COUNTERS_PAGE: 5761 if( tdsaAllShared->tdFWControlEx.inProgress ) 5762 { 5763 tdsaAllShared->tdFWControlEx.inProgress = 0; 5764 PhyBlob = (tdPhyCount_t *)tdsaAllShared->tdFWControlEx.usrAddr; 5765 } 5766 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID)); 5767 if(parm !=agNULL ) 5768 { 5769 agPhyErrCounters = (agsaPhyErrCountersPage_t *)parm; 5770 if(PhyBlob !=agNULL ) 5771 { 5772 5773 PhyBlob->InvalidDword = agPhyErrCounters->invalidDword; 5774 PhyBlob->runningDisparityError = agPhyErrCounters->runningDisparityError; 5775 PhyBlob->LossOfSyncDW = agPhyErrCounters->lossOfDwordSynch; 5776 PhyBlob->codeViolation = agPhyErrCounters->codeViolation; 5777 PhyBlob->phyResetProblem = agPhyErrCounters->phyResetProblem; 5778 PhyBlob->inboundCRCError = agPhyErrCounters->inboundCRCError; 5779 PhyBlob->BW_rx = 0; 5780 PhyBlob->BW_tx = 0; 5781 5782 TI_DBG2(("ossaGetPhyProfileCB: invalidDword %d\n", agPhyErrCounters->invalidDword)); 5783 TI_DBG2(("ossaGetPhyProfileCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError)); 5784 TI_DBG2(("ossaGetPhyProfileCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch)); 5785 TI_DBG2(("ossaGetPhyProfileCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem)); 5786 TI_DBG2(("ossaGetPhyProfileCB: inboundCRCError %d\n", agPhyErrCounters->inboundCRCError)); 5787 } 5788 } 5789 break; 5790 case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE: 5791 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE status 0x%x phyID %d\n", status, phyID)); 5792 break; 5793 case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE: 5794 TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE status 0x%x phyID %d\n", status, phyID)); 5795 #ifdef CCFLAGS_PHYCONTROL_COUNTS 5796 if(parm !=agNULL ) 5797 { 5798 analog = (agsaPhyAnalogSettingsPage_t *)parm; 5799 TI_DBG1(("ossaGetPhyProfileCB: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n", 5800 analog->Dword0, analog->Dword1, analog->Dword2, analog->Dword3, analog->Dword4, 5801 analog->Dword5, analog->Dword6, analog->Dword7, analog->Dword8, analog->Dword9)); 5802 tdsaAllShared->analog[phyID].spaRegister0 = analog->Dword0; 5803 tdsaAllShared->analog[phyID].spaRegister1 = analog->Dword1; 5804 tdsaAllShared->analog[phyID].spaRegister2 = analog->Dword2; 5805 tdsaAllShared->analog[phyID].spaRegister3 = analog->Dword3; 5806 tdsaAllShared->analog[phyID].spaRegister4 = analog->Dword4; 5807 saSetPhyProfile( agRoot,agContext,tdsaRotateQnumber(tiRoot, agNULL), AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE,sizeof(agsaPhyAnalogSetupRegisters_t),&tdsaAllShared->analog[phyID],phyID); 5808 } 5809 #endif /* CCFLAGS_PHYCONTROL_COUNTS */ 5810 break; 5811 case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE: 5812 { 5813 TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE status 0x%x phyID %d\n", status, phyID)); 5814 if( parm !=agNULL ) 5815 { 5816 #ifdef TD_DEBUG_ENABLE 5817 agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *Backoff = 5818 (agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *)parm; 5819 #endif 5820 TI_DBG2(("ossaGetPhyProfileCB: DW0 0x%X DW1 0x%X DW2 0x%X DW3 0x%X\n", 5821 Backoff->Dword0,Backoff->Dword1, 5822 Backoff->Dword2,Backoff->Dword3)); 5823 } 5824 break; 5825 } 5826 5827 case AGSA_SAS_PHY_GENERAL_STATUS_PAGE: 5828 { 5829 agsaSASPhyGeneralStatusPage_t * GenStatus = NULL; 5830 5831 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_GENERAL_STATUS_PAGE status 0x%x phyID %d\n", 5832 status, phyID)); 5833 if( parm !=agNULL ) 5834 { 5835 GenStatus= 5836 (agsaSASPhyGeneralStatusPage_t *)parm; 5837 TI_DBG2(("ossaGetPhyProfileCB: " 5838 "AGSA_SAS_PHY_GENERAL_STATUS_PAGE status %d DW0 0x%x DW1 0x%x\n", 5839 status, GenStatus->Dword0, GenStatus->Dword1)); 5840 } 5841 ostiGetPhyGeneralStatusRsp(tiRoot, GenStatus, phyID); 5842 // break; 5843 return ; 5844 } 5845 5846 default: 5847 TI_DBG1(("ossaGetPhyProfileCB: UNKNOWN default case. phyOperation %d status 0x%x\n", ppc, status)); 5848 break; 5849 5850 } 5851 5852 ostiGetPhyProfileIOCTLRsp(tiRoot, status); 5853 5854 } 5855 5856 5857 GLOBAL void ossaSetPhyProfileCB( 5858 agsaRoot_t *agRoot, 5859 agsaContext_t *agContext, 5860 bit32 status, 5861 bit32 ppc, 5862 bit32 phyID, 5863 void *parm ) 5864 { 5865 TI_DBG1(("ossaSetPhyProfileCB:agContext %p status 0x%x ppc %d phyID %d parm %p\n",agContext, status, ppc, phyID,parm)); 5866 } 5867 5868 5869 /*****************************************************************************/ 5870 /*! \brief ossaGetDeviceHandlesCB 5871 * 5872 * 5873 * Purpose: This routine is called by lower layer to corresponding to 5874 * saGetDeviceHandles() 5875 * 5876 * \param agRoot: Pointer to chip/driver Instance. 5877 * \param agContext: Context of the get device handle request originally passed into 5878 * saGetDeviceHandles(). 5879 * \param agPortContext:Pointer to this instance of a port context 5880 * \param agDev: Array containing pointers to the device handles 5881 5882 * \param validDevs Number of valid device handles 5883 * 5884 * 5885 * \return None. 5886 * 5887 * \note - The scope is shared target and initiator. 5888 * For details, refer to SAS/SATA Low-Level API Specification 5889 */ 5890 /*****************************************************************************/ 5891 osGLOBAL void ossaGetDeviceHandlesCB( 5892 agsaRoot_t *agRoot, 5893 agsaContext_t *agContext, 5894 agsaPortContext_t *agPortContext, 5895 agsaDevHandle_t *agDev[], 5896 bit32 validDevs 5897 ) 5898 { 5899 TI_DBG2(("ossaGetDeviceHandlesCB: start\n")); 5900 TI_DBG2(("ossaGetDeviceHandlesCB: validDevs %d\n", validDevs)); 5901 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yc"); 5902 #ifdef TO_DO 5903 for (i = 0 ; i < validDevs ; i++) 5904 { 5905 agDev[i]; 5906 } 5907 #endif 5908 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yc"); 5909 return; 5910 } 5911 5912 /*****************************************************************************/ 5913 /*! \brief ossaGetDeviceInfoCB 5914 * 5915 * 5916 * Purpose: This routine is called by lower layer to corresponding to 5917 * saGetDeviceInfo() 5918 * 5919 * \param agRoot: Pointer to chip/driver Instance. 5920 * \param agDevHandle: Handle of the device 5921 * \param status: status 5922 * \param agInfo: Pointer to the structure that describes device information 5923 * 5924 * 5925 * \return None. 5926 * 5927 * \note - The scope is shared target and initiator. 5928 * For details, refer to SAS/SATA Low-Level API Specification 5929 */ 5930 /*****************************************************************************/ 5931 osGLOBAL void ossaGetDeviceInfoCB( 5932 agsaRoot_t *agRoot, 5933 agsaContext_t *agContext, 5934 agsaDevHandle_t *agDevHandle, 5935 bit32 status, 5936 void *agInfo 5937 ) 5938 { 5939 5940 #ifdef TD_DEBUG_ENABLE 5941 agsaDeviceInfo_t *agDeviceInfo; 5942 agsaSASDeviceInfo_t *agSASDeviceInfo; 5943 agsaSATADeviceInfo_t *agSATADeviceInfo; 5944 #endif 5945 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yd"); 5946 5947 TI_DBG1(("ossaGetDeviceInfoCB: start agContext %p\n",agContext)); 5948 switch (status) 5949 { 5950 case OSSA_DEV_INFO_INVALID_HANDLE: 5951 TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_INVALID_HANDLE\n")); 5952 /*ostiGetDeviceInfoIOCTLRsp(tiRoot, status, agNULL);*/ 5953 break; 5954 case OSSA_DEV_INFO_NO_EXTENDED_INFO: 5955 #ifdef TD_DEBUG_ENABLE 5956 agDeviceInfo = (agsaDeviceInfo_t *)agInfo; 5957 #endif 5958 TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_NO_EXTENDED_INFO\n")); 5959 TI_DBG1(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(agDeviceInfo))); 5960 TI_DBG1(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(agDeviceInfo))); 5961 TI_DBG1(("ossaGetDeviceInfoCB: devType_S_Rate 0x%08x\n", agDeviceInfo->devType_S_Rate)); 5962 TI_DBG1(("ossaGetDeviceInfoCB: firstBurstSize 0x%08x\n", agDeviceInfo->firstBurstSize)); 5963 5964 /*ostiPortEvent (tiRoot, tiGetDevInfo, tiSuccess,(void *)agContext );*/ 5965 /*ostiGetDeviceInfoIOCTLRsp(tiRoot, status, agDeviceInfo);*/ 5966 break; 5967 case OSSA_DEV_INFO_SAS_EXTENDED_INFO: 5968 #ifdef TD_DEBUG_ENABLE 5969 agSASDeviceInfo = (agsaSASDeviceInfo_t *)agInfo; 5970 #endif 5971 TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SAS_EXTENDED_INFO\n")); 5972 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSASDeviceInfo->commonDevInfo))); 5973 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSASDeviceInfo->commonDevInfo))); 5974 TI_DBG2(("ossaGetDeviceInfoCB: initiator_ssp_stp_smp %d\n", agSASDeviceInfo->initiator_ssp_stp_smp)); 5975 TI_DBG2(("ossaGetDeviceInfoCB: target_ssp_stp_smp %d\n", agSASDeviceInfo->target_ssp_stp_smp)); 5976 TI_DBG2(("ossaGetDeviceInfoCB: numOfPhys %d\n", agSASDeviceInfo->numOfPhys)); 5977 TI_DBG2(("ossaGetDeviceInfoCB: phyIdentifier %d\n", agSASDeviceInfo->phyIdentifier)); 5978 5979 break; 5980 case OSSA_DEV_INFO_SATA_EXTENDED_INFO: 5981 #ifdef TD_DEBUG_ENABLE 5982 agSATADeviceInfo = (agsaSATADeviceInfo_t *)agInfo; 5983 #endif 5984 TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SATA_EXTENDED_INFO\n")); 5985 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSATADeviceInfo->commonDevInfo))); 5986 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSATADeviceInfo->commonDevInfo))); 5987 TI_DBG2(("ossaGetDeviceInfoCB: connection %d\n", agSATADeviceInfo->connection)); 5988 TI_DBG2(("ossaGetDeviceInfoCB: portMultiplierField %d\n", agSATADeviceInfo->portMultiplierField)); 5989 TI_DBG2(("ossaGetDeviceInfoCB: stpPhyIdentifier %d\n", agSATADeviceInfo->stpPhyIdentifier)); 5990 #ifdef TD_DEBUG_ENABLE 5991 tdhexdump("ossaGetDeviceInfoCB: signature", (bit8 *)agSATADeviceInfo->signature, 8); 5992 #endif 5993 break; 5994 default: 5995 TI_DBG2(("ossaGetDeviceInfoCB: error default case, status is %d\n", status)); 5996 break; 5997 } 5998 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yd"); 5999 return; 6000 } 6001 6002 /*****************************************************************************/ 6003 /*! \brief ossaDeviceRegistrationCB 6004 * 6005 * 6006 * Purpose: This routine is called by lower layer to corresponding to 6007 * saRegisterNewDevice() 6008 * 6009 * \param agRoot: Pointer to chip/driver Instance. 6010 * \param agContext: Context of the get device handle request originally 6011 * passed into saRegisterNewDevice(). 6012 * \param status: status 6013 * \param agDevHandle: Pointer to the assigned device handle for the 6014 * registered device. 6015 * 6016 * 6017 * \return None. 6018 * 6019 */ 6020 /*****************************************************************************/ 6021 osGLOBAL void ossaDeviceRegistrationCB( 6022 agsaRoot_t *agRoot, 6023 agsaContext_t *agContext, 6024 bit32 status, 6025 agsaDevHandle_t *agDevHandle, 6026 bit32 deviceID 6027 ) 6028 { 6029 #ifdef INITIATOR_DRIVER 6030 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6031 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6032 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 6033 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 6034 bit32 Indenom = tdsaAllShared->QueueConfig.numInboundQueues; 6035 bit32 Outdenom = tdsaAllShared->QueueConfig.numOutboundQueues; 6036 tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agContext->osData; 6037 tdsaPortContext_t *onePortContext = oneDeviceData->tdPortContext; 6038 tiPortalContext_t *tiPortalContext = onePortContext->tiPortalContext; 6039 #ifdef FDS_DM 6040 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot); 6041 dmPortContext_t *dmPortContext = &(onePortContext->dmPortContext); 6042 dmDeviceInfo_t dmDeviceInfo; 6043 bit32 DMstatus = DM_RC_FAILURE; 6044 bit16 ext = 0; 6045 bit32 expanderType = 1; 6046 #endif 6047 6048 #if defined(FDS_DM) && !defined(FDS_SM) 6049 bit32 IDstatus; 6050 #endif 6051 6052 #ifdef FDS_SM 6053 smRoot_t *smRoot = &(tdsaAllShared->smRoot); 6054 bit32 SMstatus = SM_RC_FAILURE; 6055 #endif 6056 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ye"); 6057 TI_DBG3(("ossaDeviceRegistrationCB: start status 0x%x\n",status)); 6058 TI_DBG3(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 6059 TI_DBG3(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 6060 TI_DBG3(("ossaDeviceRegistrationCB: did 0x%x\n", oneDeviceData->id)); 6061 TI_DBG3(("ossaDeviceRegistrationCB: deviceID 0x%x\n", deviceID)); 6062 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle %p %p %p\n",agDevHandle,agDevHandle->osData,agDevHandle->sdkData )); 6063 6064 /* transient period caused by tdssReportRemovals(), device was in the middle 6065 of registration but port is invalidated 6066 */ 6067 if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE 6068 && oneDeviceData->DeviceType == TD_DEFAULT_DEVICE) 6069 { 6070 if (status == OSSA_SUCCESS) 6071 { 6072 TI_DBG2(("ossaDeviceRegistrationCB: transient, calling saDeregisterDeviceHandle, did %d\n", oneDeviceData->id)); 6073 oneDeviceData->agDevHandle = agDevHandle; 6074 agDevHandle->osData = oneDeviceData; 6075 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6076 { 6077 if (oneDeviceData->satDevData.IDDeviceValid == agFALSE) 6078 { 6079 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0); 6080 } 6081 else 6082 { 6083 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 6084 } 6085 } 6086 else 6087 { 6088 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 6089 } 6090 } 6091 else if (status == OSSA_FAILURE_PORT_NOT_VALID_STATE || status == OSSA_ERR_PORT_STATE_NOT_VALID) 6092 { 6093 /* do nothing */ 6094 TI_DBG2(("ossaDeviceRegistrationCB: transient, do nothing did %d\n", oneDeviceData->id)); 6095 } 6096 return; 6097 } 6098 6099 if (agDevHandle == agNULL) 6100 { 6101 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NULL\n")); 6102 } 6103 else 6104 { 6105 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NOT NULL\n")); 6106 } 6107 6108 switch (status) 6109 { 6110 case OSSA_SUCCESS: 6111 TI_DBG3(("ossaDeviceRegistrationCB: success\n")); 6112 TI_DBG2(("ossaDeviceRegistrationCB: Success did %d FW did 0x%x\n", oneDeviceData->id, deviceID)); 6113 TI_DBG2(("ossaDeviceRegistrationCB: Success pid %d\n", onePortContext->id)); 6114 if (agDevHandle == agNULL) 6115 { 6116 TI_DBG1(("ossaDeviceRegistrationCB: agDevHandle is NULL, wrong!\n")); 6117 return; 6118 } 6119 oneDeviceData->agDevHandle = agDevHandle; 6120 agDevHandle->osData = oneDeviceData; 6121 oneDeviceData->registered = agTRUE; 6122 oneDeviceData->InQID = oneDeviceData->id % Indenom; 6123 oneDeviceData->OutQID = oneDeviceData->id % Outdenom; 6124 onePortContext->RegisteredDevNums++; 6125 6126 TI_DBG3(("ossaDeviceRegistrationCB: direct %d STP target %d target_ssp_stp_smp %d\n", oneDeviceData->directlyAttached, DEVICE_IS_STP_TARGET(oneDeviceData), oneDeviceData->target_ssp_stp_smp)); 6127 TI_DBG3(("ossaDeviceRegistrationCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums)); 6128 TI_DBG3(("ossaDeviceRegistrationCB: pid %d Count %d\n", onePortContext->id, onePortContext->Count)); 6129 6130 #ifdef FDS_DM 6131 /* if device is an expander, register it to DM */ 6132 if (onePortContext->valid == agTRUE) 6133 { 6134 if (DEVICE_IS_SMP_TARGET(oneDeviceData)) 6135 { 6136 TI_DBG1(("ossaDeviceRegistrationCB: calling dmRegisterDevice\n")); 6137 TI_DBG1(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 6138 TI_DBG1(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 6139 /* set up dmDeviceInfo */ 6140 osti_memset(&dmDeviceInfo, 0, sizeof(dmDeviceInfo_t)); 6141 DEVINFO_PUT_SAS_ADDRESSLO(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressLo); 6142 DEVINFO_PUT_SAS_ADDRESSHI(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressHi); 6143 dmDeviceInfo.initiator_ssp_stp_smp = oneDeviceData->initiator_ssp_stp_smp; 6144 dmDeviceInfo.target_ssp_stp_smp = oneDeviceData->target_ssp_stp_smp; 6145 dmDeviceInfo.devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate; 6146 if (oneDeviceData->directlyAttached == agTRUE) 6147 { 6148 /* setting SMP bit */ 6149 ext = (bit16)(ext | 0x100); 6150 expanderType = SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe); 6151 ext = (bit16)( ext | (expanderType << 9)); 6152 /* setting MCN field to 0xF */ 6153 ext = (bit16)(ext | (bit16)(0xF << 11)); 6154 TI_DBG1(("ossaDeviceRegistrationCB: directlyAttached ext 0x%x\n", ext)); 6155 dmDeviceInfo.ext = ext; 6156 } 6157 DMstatus = dmRegisterDevice(dmRoot, dmPortContext, &dmDeviceInfo, oneDeviceData->agDevHandle); 6158 if (DMstatus != DM_RC_SUCCESS) 6159 { 6160 TI_DBG1(("ossaDeviceRegistrationCB: dmRegisterDevice failed!!! 0x%x\n", DMstatus)); 6161 } 6162 } 6163 } 6164 #endif /* FDS_DM */ 6165 #ifdef FDS_SM 6166 /* if device is SATA, register it to SM */ 6167 if (onePortContext->valid == agTRUE) 6168 { 6169 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6170 { 6171 TI_DBG1(("ossaDeviceRegistrationCB: calling smRegisterDevice\n")); 6172 if (oneDeviceData->directlyAttached == agTRUE) 6173 { 6174 SMstatus = smRegisterDevice(smRoot, 6175 agDevHandle, 6176 &(oneDeviceData->smDeviceHandle), 6177 agNULL, 6178 (bit32)oneDeviceData->phyID, 6179 oneDeviceData->satDevData.satDeviceType); 6180 } 6181 else 6182 { 6183 if (oneDeviceData->ExpDevice == agNULL) 6184 { 6185 TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice NULL!!!\n")); 6186 return; 6187 } 6188 if (oneDeviceData->ExpDevice->agDevHandle == agNULL) 6189 { 6190 TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice->agDevHandle NULL!!!\n")); 6191 } 6192 SMstatus = smRegisterDevice(smRoot, 6193 agDevHandle, 6194 &(oneDeviceData->smDeviceHandle), 6195 oneDeviceData->ExpDevice->agDevHandle, 6196 (bit32)oneDeviceData->phyID, 6197 oneDeviceData->satDevData.satDeviceType); 6198 } 6199 if (SMstatus != SM_RC_SUCCESS) 6200 { 6201 TI_DBG1(("ossaDeviceRegistrationCB: smRegisterDevice failed!!! 0x%x\n", DMstatus)); 6202 } 6203 } 6204 } 6205 #endif /* FDS_SM */ 6206 /* special case for directly attached targets */ 6207 if (oneDeviceData->directlyAttached == agTRUE) 6208 { 6209 TI_DBG3(("ossaDeviceRegistrationCB: directly attached did %d\n", oneDeviceData->id)); 6210 if (oneDeviceData->DeviceType == TD_SAS_DEVICE) 6211 { 6212 TI_DBG3(("ossaDeviceRegistrationCB: SAS target\n")); 6213 if (onePortContext->valid == agTRUE) 6214 { 6215 if (onePortContext->PortRecoverPhyID != 0xFF) 6216 { 6217 oneDeviceData->phyID = (bit8)onePortContext->PortRecoverPhyID; 6218 onePortContext->PortRecoverPhyID = 0xFF; 6219 TI_DBG3(("ossaDeviceRegistrationCB: PortRecoverPhyID %d\n", oneDeviceData->phyID)); 6220 } 6221 /* link up and discovery ready event */ 6222 if (onePortContext->DiscoveryRdyGiven == agFALSE) 6223 { 6224 TI_DBG2(("ossaDeviceRegistrationCB: link up and discovery ready\n")); 6225 TI_DBG3(("ossaDeviceRegistrationCB: phyID %d pid %d\n", oneDeviceData->phyID, onePortContext->id)); 6226 TI_DBG3(("ossaDeviceRegistrationCB: tiPortalContext %p\n", tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext)); 6227 TI_DBG3(("ossaDeviceRegistrationCB: onePortContext->tiPortalContext %p\n", onePortContext->tiPortalContext)); 6228 onePortContext->DiscoveryRdyGiven = agTRUE; 6229 if (onePortContext->DiscoveryState != ITD_DSTATE_NOT_STARTED) 6230 { 6231 TI_DBG1(("ossaDeviceRegistrationCB: wrong discovery state 0x%x\n", onePortContext->DiscoveryState)); 6232 } 6233 /* notifying link up */ 6234 ostiPortEvent ( 6235 tiRoot, 6236 tiPortLinkUp, 6237 tiSuccess, 6238 (void *)onePortContext->tiPortalContext 6239 ); 6240 #ifdef INITIATOR_DRIVER 6241 /* triggers discovery */ 6242 ostiPortEvent( 6243 tiRoot, 6244 tiPortDiscoveryReady, 6245 tiSuccess, 6246 (void *)onePortContext->tiPortalContext 6247 ); 6248 #endif 6249 } 6250 } 6251 else 6252 { 6253 TI_DBG2(("ossaDeviceRegistrationCB: abort call\n")); 6254 /* abort all followed by deregistration of sas target */ 6255 tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 6256 } 6257 } 6258 else 6259 { 6260 TI_DBG2(("ossaDeviceRegistrationCB: SATA target\n")); 6261 if (onePortContext->valid == agTRUE) 6262 { 6263 if (oneDeviceData->satDevData.IDDeviceValid == agFALSE) 6264 { 6265 #ifdef FDS_SM 6266 /* send identify device data */ 6267 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext); 6268 6269 #else 6270 /* send identify device data */ 6271 tdssSubAddSATAToSharedcontext(tiRoot, oneDeviceData); 6272 #endif 6273 } 6274 } 6275 else 6276 { 6277 TI_DBG2(("ossaDeviceRegistrationCB: abort call\n")); 6278 /* abort all followed by deregistration of sas target */ 6279 tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 6280 } 6281 } 6282 } 6283 else /* behind the expander */ 6284 { 6285 #if defined(FDS_DM) && defined(FDS_SM) 6286 /* send ID to SATA targets 6287 needs go allocate tdIORequestBody_t for smIORequest 6288 */ 6289 6290 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6291 && 6292 oneDeviceData->satDevData.IDDeviceValid == agFALSE) 6293 { 6294 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext); 6295 } 6296 6297 #elif defined(FDS_DM) /* worked with DM */ 6298 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6299 && 6300 oneDeviceData->satDevData.IDDeviceValid == agFALSE) 6301 { 6302 IDstatus = tdsaDiscoveryStartIDDev(tiRoot, 6303 agNULL, 6304 &(oneDeviceData->tiDeviceHandle), 6305 agNULL, 6306 oneDeviceData); 6307 6308 if (IDstatus != tiSuccess) 6309 { 6310 /* identify device data is not valid */ 6311 TI_DBG1(("ossaDeviceRegistrationCB: fail or busy %d\n", IDstatus)); 6312 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 6313 } 6314 } 6315 #endif 6316 6317 6318 } 6319 /* after discovery is finished */ 6320 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED) 6321 { 6322 TI_DBG2(("ossaDeviceRegistrationCB: calling new device arrival\n")); 6323 if (DEVICE_IS_SSP_TARGET(oneDeviceData)) 6324 { 6325 /* in case registration is finished after discovery is finished */ 6326 #ifdef AGTIAPI_CTL 6327 if (tdsaAllShared->SASConnectTimeLimit) 6328 tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDeviceChange, 6329 tiDeviceArrival); 6330 else 6331 #endif 6332 ostiInitiatorEvent( 6333 tiRoot, 6334 tiPortalContext, 6335 agNULL, 6336 tiIntrEventTypeDeviceChange, 6337 tiDeviceArrival, 6338 agNULL 6339 ); 6340 } 6341 else if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6342 && 6343 oneDeviceData->satDevData.IDDeviceValid == agTRUE ) 6344 { 6345 /* in case registration is finished after discovery is finished */ 6346 ostiInitiatorEvent( 6347 tiRoot, 6348 tiPortalContext, 6349 agNULL, 6350 tiIntrEventTypeDeviceChange, 6351 tiDeviceArrival, 6352 agNULL 6353 ); 6354 } 6355 } 6356 break; 6357 case OSSA_FAILURE_OUT_OF_RESOURCE: /* fall through */ 6358 case OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE: 6359 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_OUT_OF_RESOURCE or OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE\n")); 6360 oneDeviceData->registered = agFALSE; 6361 break; 6362 case OSSA_FAILURE_DEVICE_ALREADY_REGISTERED: /* fall through */ 6363 case OSSA_ERR_DEVICE_ALREADY_REGISTERED: 6364 /* do nothing */ 6365 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_ALREADY_REGISTERED or OSSA_ERR_DEVICE_ALREADY_REGISTERED\n")); 6366 break; 6367 case OSSA_FAILURE_INVALID_PHY_ID: /* fall through */ 6368 case OSSA_ERR_PHY_ID_INVALID: 6369 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_INVALID_PHY_ID or OSSA_ERR_PHY_ID_INVALID\n")); 6370 oneDeviceData->registered = agFALSE; 6371 break; 6372 case OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED: /* fall through */ 6373 case OSSA_ERR_PHY_ID_ALREADY_REGISTERED: 6374 /* do nothing */ 6375 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED or OSSA_ERR_PHY_ID_ALREADY_REGISTERED\n")); 6376 break; 6377 case OSSA_FAILURE_PORT_ID_OUT_OF_RANGE: /* fall through */ 6378 case OSSA_ERR_PORT_INVALID: 6379 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_ID_OUT_OF_RANGE or OSSA_ERR_PORT_INVALID\n")); 6380 oneDeviceData->registered = agFALSE; 6381 break; 6382 case OSSA_FAILURE_PORT_NOT_VALID_STATE: /* fall through */ 6383 case OSSA_ERR_PORT_STATE_NOT_VALID: 6384 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_NOT_VALID_STATE or OSSA_ERR_PORT_STATE_NOT_VALID\n")); 6385 TI_DBG2(("ossaDeviceRegistrationCB: did %d pid %d\n", oneDeviceData->id, onePortContext->id)); 6386 oneDeviceData->registered = agFALSE; 6387 /* transient period between link up and link down/port recovery */ 6388 onePortContext->Transient = agTRUE; 6389 if (onePortContext->valid == agTRUE && (oneDeviceData->valid == agTRUE || oneDeviceData->valid2 == agTRUE)) 6390 { 6391 TI_DBG1(("ossaDeviceRegistrationCB: retries regisration\n")); 6392 #ifdef REMOVED 6393 //temp; setting MCN to tdsaAllShared->MCN 6394 oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | (tdsaAllShared->MCN << 16); 6395 //end temp 6396 #endif 6397 saRegisterNewDevice( /* ossaDeviceRegistrationCB */ 6398 agRoot, 6399 &oneDeviceData->agContext, 6400 0, 6401 &oneDeviceData->agDeviceInfo, 6402 onePortContext->agPortContext, 6403 0 6404 ); 6405 } 6406 else if (oneDeviceData->directlyAttached == agTRUE && DEVICE_IS_SATA_DEVICE(oneDeviceData)) 6407 { 6408 TI_DBG1(("ossaDeviceRegistrationCB: directly attached SATA, put back into free list\n")); 6409 tdsaDeviceDataReInit(tiRoot, oneDeviceData); 6410 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 6411 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 6412 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 6413 } 6414 break; 6415 case OSSA_FAILURE_DEVICE_TYPE_NOT_VALID: /* fall through */ 6416 case OSSA_ERR_DEVICE_TYPE_NOT_VALID: 6417 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_TYPE_NOT_VALID or OSSA_ERR_DEVICE_TYPE_NOT_VALID\n")); 6418 oneDeviceData->registered = agFALSE; 6419 break; 6420 default: 6421 TI_DBG1(("ossaDeviceRegistrationCB: wrong. default status is %d\n", status)); 6422 break; 6423 6424 6425 } 6426 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ye"); 6427 return; 6428 #endif 6429 } 6430 6431 /*****************************************************************************/ 6432 /*! \brief ossaDeregisterDeviceHandleCB 6433 * 6434 * 6435 * Purpose: This routine is called by lower layer to corresponding to 6436 * saDeregisterDeviceHandle() 6437 * 6438 * \param agRoot: Pointer to chip/driver Instance. 6439 * \param agDevHandle: Pointer to the assigned device handle for the 6440 * registered device. 6441 * \param status: status 6442 * 6443 * 6444 * \return None. 6445 * 6446 */ 6447 /*****************************************************************************/ 6448 osGLOBAL void ossaDeregisterDeviceHandleCB( 6449 agsaRoot_t *agRoot, 6450 agsaContext_t *agContext, 6451 agsaDevHandle_t *agDevHandle, 6452 bit32 status 6453 ) 6454 { 6455 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6456 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6457 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 6458 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 6459 tdsaDeviceData_t *oneDeviceData = agNULL; 6460 tdsaPortContext_t *onePortContext = agNULL; 6461 agsaEventSource_t *eventSource; 6462 bit32 HwAckSatus; 6463 bit32 PhyID; 6464 #ifdef FDS_DM 6465 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot); 6466 dmPortContext_t *dmPortContext = agNULL; 6467 dmPortInfo_t dmPortInfo; 6468 bit32 DMstatus = DM_RC_FAILURE; 6469 #endif 6470 #ifdef FDS_SM 6471 smRoot_t *smRoot = &(tdsaAllShared->smRoot); 6472 #endif 6473 6474 TI_DBG3(("ossaDeregisterDeviceHandleCB: start\n")); 6475 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yf"); 6476 6477 if (status == OSSA_ERR_DEVICE_HANDLE_INVALID) 6478 { 6479 /* there is no device handle to process */ 6480 TI_DBG2(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n")); 6481 return; 6482 } 6483 6484 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 6485 onePortContext = oneDeviceData->tdPortContext; 6486 #ifdef FDS_DM 6487 dmPortContext = &(onePortContext->dmPortContext); 6488 #endif 6489 6490 if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE && 6491 oneDeviceData->DeviceType == TD_DEFAULT_DEVICE && onePortContext->valid == agTRUE) 6492 { 6493 TI_DBG2(("ossaDeregisterDeviceHandleCB: transient did %d\n", oneDeviceData->id)); 6494 return; 6495 } 6496 6497 if (onePortContext != agNULL) 6498 { 6499 TI_DBG2(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums)); 6500 } 6501 6502 switch (status) 6503 { 6504 case OSSA_SUCCESS: 6505 TI_DBG3(("ossaDeregisterDeviceHandleCB: Success\n")); 6506 if (onePortContext == agNULL) 6507 { 6508 TI_DBG1(("ossaDeregisterDeviceHandleCB: onePortContext is NULL, wrong!\n")); 6509 return; 6510 } 6511 /* port is going down */ 6512 if (onePortContext->valid == agFALSE) 6513 { 6514 if (!(oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE && oneDeviceData->DeviceType == TD_DEFAULT_DEVICE)) 6515 { 6516 /* remove oneDevice from MainLink */ 6517 TI_DBG2(("ossaDeregisterDeviceHandleCB: delete from MainLink\n")); 6518 #ifdef FDS_SM 6519 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6520 { 6521 TI_DBG1(("ossaDeregisterDeviceHandleCB: did %d calling smDeregisterDevice\n", oneDeviceData->id)); 6522 smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle)); 6523 } 6524 #endif 6525 tdsaDeviceDataReInit(tiRoot, oneDeviceData); 6526 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 6527 6528 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 6529 TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink)); 6530 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 6531 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 6532 } 6533 /* for portcontext */ 6534 PhyID = onePortContext->eventPhyID; 6535 TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID)); 6536 onePortContext->RegisteredDevNums--; 6537 /* 6538 check if valid in tdsaAllShared and the last registered device in a portcontext; 6539 if so, call saHwEventAck() 6540 */ 6541 if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE && 6542 onePortContext->RegisteredDevNums == 0 && 6543 PhyID != 0xFF 6544 ) 6545 { 6546 TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n")); 6547 eventSource = &(tdsaAllShared->eventSource[PhyID].Source); 6548 HwAckSatus = saHwEventAck( 6549 agRoot, 6550 agNULL, /* agContext */ 6551 0, 6552 eventSource, /* agsaEventSource_t */ 6553 0, 6554 0 6555 ); 6556 if ( HwAckSatus != AGSA_RC_SUCCESS) 6557 { 6558 TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 6559 } 6560 6561 /* toggle */ 6562 tdsaAllShared->eventSource[PhyID].EventValid = agFALSE; 6563 6564 #ifdef FDS_DM 6565 if (onePortContext->UseDM == agTRUE) 6566 { 6567 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n")); 6568 /* setup dmPortInfo */ 6569 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo); 6570 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi); 6571 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo); 6572 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi); 6573 DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo); 6574 if (DMstatus != DM_RC_SUCCESS) 6575 { 6576 TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus)); 6577 } 6578 } 6579 #endif 6580 tdsaPortContextReInit(tiRoot, onePortContext); 6581 /* 6582 put all devices belonging to the onePortContext 6583 back to the free link 6584 */ 6585 6586 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 6587 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink)); 6588 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList)); 6589 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 6590 } 6591 else if (tdsaAllShared->eventSource[PhyID].EventValid == NO_ACK && 6592 onePortContext->RegisteredDevNums == 0 6593 ) 6594 { 6595 TI_DBG2(("ossaDeregisterDeviceHandleCB: NO ACK case\n")); 6596 #ifdef FDS_DM 6597 if (onePortContext->UseDM == agTRUE) 6598 { 6599 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n")); 6600 /* setup dmPortInfo */ 6601 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo); 6602 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi); 6603 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo); 6604 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi); 6605 DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo); 6606 if (DMstatus != DM_RC_SUCCESS) 6607 { 6608 TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus)); 6609 } 6610 } 6611 #endif 6612 tdsaPortContextReInit(tiRoot, onePortContext); 6613 /* 6614 put all devices belonging to the onePortContext 6615 back to the free link 6616 */ 6617 6618 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK); 6619 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink)); 6620 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList)); 6621 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK); 6622 } 6623 else 6624 { 6625 if (PhyID < TD_MAX_NUM_PHYS) 6626 { 6627 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums)); 6628 } 6629 else 6630 { 6631 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID)); 6632 } 6633 } 6634 } 6635 else 6636 { 6637 PhyID = onePortContext->eventPhyID; 6638 TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID)); 6639 onePortContext->RegisteredDevNums--; 6640 #ifdef FDS_SM 6641 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 6642 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 6643 { 6644 smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle)); 6645 } 6646 #endif 6647 /* 6648 check if valid in tdsaAllShared and the last registered device in a portcontext; 6649 if so, call saHwEventAck() 6650 */ 6651 if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE && 6652 onePortContext->RegisteredDevNums == 0 && 6653 PhyID != 0xFF 6654 ) 6655 { 6656 TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n")); 6657 eventSource = &(tdsaAllShared->eventSource[PhyID].Source); 6658 HwAckSatus = saHwEventAck( 6659 agRoot, 6660 agNULL, /* agContext */ 6661 0, 6662 eventSource, /* agsaEventSource_t */ 6663 0, 6664 0 6665 ); 6666 if ( HwAckSatus != AGSA_RC_SUCCESS) 6667 { 6668 TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus)); 6669 } 6670 6671 /* toggle */ 6672 tdsaAllShared->eventSource[PhyID].EventValid = agFALSE; 6673 } 6674 #ifdef INITIATOR_DRIVER 6675 else if (onePortContext->RegisteredDevNums == 1) 6676 { 6677 TI_DBG1(("ossaDeregisterDeviceHandleCB: all devices have been deregistered except directly attached EXP\n")); 6678 /* qqqqq If broadcast has been seen, call incremental discovery*/ 6679 if (onePortContext->DiscFailNSeenBC == agTRUE) 6680 { 6681 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDiscover, incremental, pid %d\n", onePortContext->id)); 6682 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START); 6683 onePortContext->DiscFailNSeenBC = agFALSE; 6684 } 6685 else 6686 { 6687 TI_DBG1(("ossaDeregisterDeviceHandleCB: not calling dmDiscover\n")); 6688 /* qqqqq needs to change discovery state to onePortContext->DMDiscoveryState == dmDiscCompleted 6689 in dmQueryDiscovery 6690 change the discovery state from dmDiscFailed to dmDiscCompleted 6691 */ 6692 dmResetFailedDiscovery(dmRoot, dmPortContext); 6693 6694 } 6695 } 6696 #endif 6697 else 6698 { 6699 if (PhyID < TD_MAX_NUM_PHYS) 6700 { 6701 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums)); 6702 } 6703 else 6704 { 6705 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID)); 6706 } 6707 } 6708 } 6709 break; 6710 case OSSA_INVALID_HANDLE: 6711 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_INVALID_HANDLE\n")); 6712 break; 6713 #ifdef REMOVED 6714 case OSSA_FAILURE_DEVICE_DIRECT_ATTACH: 6715 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_FAILURE_DEVICE_DIRECT_ATTACH\n")); 6716 break; 6717 #endif 6718 case OSSA_ERR_DEVICE_HANDLE_INVALID: 6719 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n")); 6720 break; 6721 case OSSA_ERR_DEVICE_BUSY: 6722 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_BUSY\n")); 6723 break; 6724 default: 6725 TI_DBG1(("ossaDeregisterDeviceHandleCB: unknown status 0x%x\n", status)); 6726 break; 6727 } 6728 6729 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yf"); 6730 return; 6731 } 6732 6733 /*****************************************************************************/ 6734 /*! \brief ossaDeviceHandleRemovedEvent 6735 * 6736 * 6737 * Purpose: This routine is called by lower layer to notify the device removal 6738 * 6739 * 6740 * \param agRoot: Pointer to chip/driver Instance. 6741 * \param agDevHandle: Pointer to the assigned device handle for the 6742 * registered device. 6743 * \param agPortContext:Pointer to this instance of port context. 6744 * 6745 * 6746 * \return None. 6747 * 6748 */ 6749 /*****************************************************************************/ 6750 osGLOBAL void ossaDeviceHandleRemovedEvent ( 6751 agsaRoot_t *agRoot, 6752 agsaDevHandle_t *agDevHandle, 6753 agsaPortContext_t *agPortContext 6754 ) 6755 { 6756 #ifdef NOT_YET 6757 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6758 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6759 #endif 6760 tdsaPortContext_t *onePortContext = agNULL; 6761 tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 6762 6763 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yg"); 6764 TI_DBG2(("ossaDeviceHandleRemovedEvent: start\n")); 6765 if (oneDeviceData == agNULL) 6766 { 6767 TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! oneDeviceData is NULL\n")); 6768 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yg"); 6769 return; 6770 } 6771 TI_DBG2(("ossaDeviceHandleRemovedEvent: did %d\n", oneDeviceData->id)); 6772 oneDeviceData->registered = agFALSE; 6773 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 6774 if (onePortContext == agNULL) 6775 { 6776 TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! onePortContext is NULL\n")); 6777 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Yg"); 6778 return; 6779 } 6780 TI_DBG2(("ossaDeviceHandleRemovedEvent: pid %d\n", onePortContext->id)); 6781 onePortContext->RegisteredDevNums--; 6782 #ifdef NOT_YET 6783 ostiInitiatorEvent( 6784 tiRoot, 6785 onePortContext->tiPortalContext, 6786 agNULL, 6787 tiIntrEventTypeDeviceChange, 6788 tiDeviceRemoval, 6789 agNULL 6790 ); 6791 #endif 6792 6793 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Yg"); 6794 return; 6795 } 6796 6797 #ifdef SPC_ENABLE_PROFILE 6798 /*****************************************************************************/ 6799 /*! \brief ossaFwProfileCB 6800 * 6801 * 6802 * Purpose: This routine is called by lower layer to corresponding to 6803 * saFwProfile() 6804 * 6805 * \param agRoot: Pointer to chip/driver Instance. 6806 * \param agContext: Context of the operation originally passed 6807 * into saFwProfile() 6808 * \param status: status 6809 * 6810 * 6811 * \return None. 6812 * 6813 */ 6814 /*****************************************************************************/ 6815 osGLOBAL void ossaFwProfileCB( 6816 agsaRoot_t *agRoot, 6817 agsaContext_t *agContext, 6818 bit32 status, 6819 bit32 len) 6820 { 6821 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6822 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6823 6824 TI_DBG2(("ossaFwProfileCB: start\n")); 6825 6826 switch (status) 6827 { 6828 case AGSA_RC_SUCCESS: 6829 { 6830 TI_DBG2(("ossaFwProfileCB: SUCCESS\n")); 6831 break; 6832 } 6833 case AGSA_RC_FAILURE: 6834 { 6835 TI_DBG1(("ossaFwProfileCB: FAIL\n")); 6836 break; 6837 } 6838 default: 6839 { 6840 TI_DBG1(("ossaFwProfileCB: !!! default, status %d\n", status)); 6841 break; 6842 } 6843 } 6844 6845 ostiFWProfileIOCTLRsp(tiRoot, status, len); 6846 return; 6847 } 6848 #endif 6849 /*****************************************************************************/ 6850 /*! \brief ossaFwFlashUpdateCB 6851 * 6852 * 6853 * Purpose: This routine is called by lower layer to corresponding to 6854 * saFwFlashUpdate() 6855 * 6856 * \param agRoot: Pointer to chip/driver Instance. 6857 * \param agContext: Context of the operation originally passed 6858 * into saFwFlashUpdate() 6859 * \param status: status 6860 * 6861 * 6862 * \return None. 6863 * 6864 */ 6865 /*****************************************************************************/ 6866 osGLOBAL void ossaFwFlashUpdateCB( 6867 agsaRoot_t *agRoot, 6868 agsaContext_t *agContext, 6869 bit32 status 6870 ) 6871 { 6872 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6873 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6874 6875 TI_DBG2(("ossaFwFlashUpdateCB: start\n")); 6876 6877 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yh"); 6878 switch (status) 6879 { 6880 case OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT: 6881 { 6882 TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n")); 6883 break; 6884 } 6885 case OSSA_FLASH_UPDATE_IN_PROGRESS: 6886 { 6887 TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_IN_PROGRESS\n")); 6888 break; 6889 } 6890 case OSSA_FLASH_UPDATE_HDR_ERR: 6891 { 6892 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HDR_ERR\n")); 6893 break; 6894 } 6895 case OSSA_FLASH_UPDATE_OFFSET_ERR: 6896 { 6897 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_OFFSET_ERR\n")); 6898 break; 6899 } 6900 case OSSA_FLASH_UPDATE_CRC_ERR: 6901 { 6902 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_CRC_ERR\n")); 6903 break; 6904 } 6905 case OSSA_FLASH_UPDATE_LENGTH_ERR: 6906 { 6907 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_LENGTH_ERR\n")); 6908 break; 6909 } 6910 case OSSA_FLASH_UPDATE_HW_ERR: 6911 { 6912 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HW_ERR\n")); 6913 break; 6914 } 6915 case OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED: 6916 { 6917 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED\n")); 6918 break; 6919 } 6920 case OSSA_FLASH_UPDATE_DISABLED: 6921 { 6922 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DISABLED\n")); 6923 break; 6924 } 6925 case OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT: 6926 { 6927 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT\n")); 6928 break; 6929 } 6930 case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE: 6931 { 6932 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE\n")); 6933 break; 6934 } 6935 case OSSA_FLASH_UPDATE_HMAC_ERR: 6936 { 6937 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HMAC_ERR\n")); 6938 break; 6939 } 6940 6941 default: 6942 { 6943 TI_DBG1(("ossaFwFlashUpdateCB: !!! default, status 0x%X\n", status)); 6944 break; 6945 } 6946 } 6947 6948 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yh"); 6949 ostiCOMMgntIOCTLRsp(tiRoot, status); 6950 return; 6951 6952 } 6953 6954 6955 GLOBAL void ossaFlashExtExecuteCB( 6956 agsaRoot_t *agRoot, 6957 agsaContext_t *agContext, 6958 bit32 status, 6959 bit32 command, 6960 agsaFlashExtResponse_t *agFlashExtRsp) 6961 { 6962 TI_DBG1(("ossaFlashExtExecuteCB: command 0x%X status 0x%X\n",command, status)); 6963 6964 } 6965 6966 6967 6968 /*****************************************************************************/ 6969 /*! \brief ossaGetNVMDResponseCB 6970 * 6971 * 6972 * Purpose: This routine is called by lower layer to corresponding to 6973 * saGetNVMDCommand() 6974 * 6975 * \param agRoot: Pointer to chip/driver Instance. 6976 * \param agContext: Context of the operation originally passed 6977 * into saGetVPDCommand() 6978 * \param status: status 6979 * \param indirectPayload: The value passed in agsaNVMDData_t when 6980 * calling saGetNVMDCommand() 6981 * \param agInfoLen: the length of VPD information 6982 * \param agFrameHandle: handler of VPD information 6983 * 6984 * 6985 * \return None. 6986 * 6987 */ 6988 /*****************************************************************************/ 6989 osGLOBAL void ossaGetNVMDResponseCB( 6990 agsaRoot_t *agRoot, 6991 agsaContext_t *agContext, 6992 bit32 status, 6993 bit8 indirectPayload, 6994 bit32 agInfoLen, 6995 agsaFrameHandle_t agFrameHandle 6996 ) 6997 { 6998 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6999 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7000 TI_DBG2(("ossaGetNVMDResponseCB: start\n")); 7001 TI_DBG2(("ossaGetNVMDResponseCB: agInfoLen %d\n", agInfoLen)); 7002 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yi"); 7003 7004 if (status == OSSA_SUCCESS) 7005 { 7006 TI_DBG2(("ossaGetNVMDResponseCB: Success status\n")); 7007 if (indirectPayload == 0 && agInfoLen != 0) 7008 { 7009 TI_DBG2(("ossaGetNVMDResponseCB: direct\n")); 7010 tdhexdump("ossaGetNVMDResponseCB", (bit8 *)agFrameHandle, agInfoLen); 7011 } 7012 } 7013 else 7014 { 7015 TI_DBG1(("ossaGetNVMDResponseCB: Status 0x%x\n", status)); 7016 } 7017 7018 if (indirectPayload == 0) 7019 { 7020 TI_DBG2(("ossaGetNVMDResponseCB: direct\n")); 7021 } 7022 else 7023 { 7024 TI_DBG2(("ossaGetNVMDResponseCB: indirect\n")); 7025 } 7026 7027 ostiGetNVMDIOCTLRsp(tiRoot, status); 7028 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi"); 7029 return; 7030 } 7031 7032 7033 /*****************************************************************************/ 7034 /*! \brief ossaSetNVMDResponseCB 7035 * 7036 * 7037 * Purpose: This routine is called by lower layer to corresponding to 7038 * saSetNVMDCommand() 7039 * 7040 * \param agRoot: Pointer to chip/driver Instance. 7041 * \param agContext: Context of the operation originally passed 7042 * into saSetVPDCommand() 7043 * \param status: status 7044 * 7045 * 7046 * \return None. 7047 * 7048 */ 7049 /*****************************************************************************/ 7050 osGLOBAL void ossaSetNVMDResponseCB( 7051 agsaRoot_t *agRoot, 7052 agsaContext_t *agContext, 7053 bit32 status 7054 ) 7055 { 7056 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7057 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7058 TI_DBG2(("ossaSetNVMDResponseCB: start\n")); 7059 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yj"); 7060 if (status == OSSA_SUCCESS) 7061 { 7062 TI_DBG2(("ossaSetNVMDResponseCB: success\n")); 7063 } 7064 else 7065 { 7066 TI_DBG1(("ossaSetNVMDResponseCB: fail or undefined staus %d\n", status)); 7067 } 7068 ostiSetNVMDIOCTLRsp(tiRoot, status); 7069 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yj"); 7070 return; 7071 } 7072 7073 7074 #ifdef REMOVED 7075 /*****************************************************************************/ 7076 /*! \brief ossaGetVPDResponseCB 7077 * 7078 * 7079 * Purpose: This routine is called by lower layer to corresponding to 7080 * saGetVPDCommand() 7081 * 7082 * \param agRoot: Pointer to chip/driver Instance. 7083 * \param agContext: Context of the operation originally passed 7084 * into saGetVPDCommand() 7085 * \param status: status 7086 * \param agInfoLen: the length of VPD information 7087 * \param agFrameHandle:handler of VPD information 7088 * 7089 * 7090 * \return None. 7091 * 7092 */ 7093 /*****************************************************************************/ 7094 osGLOBAL void ossaGetVPDResponseCB( 7095 agsaRoot_t *agRoot, 7096 agsaContext_t *agContext, 7097 bit32 status, 7098 bit8 indirectMode, 7099 bit32 agInfoLen, 7100 agsaFrameHandle_t agFrameHandle 7101 ) 7102 { 7103 bit8 VPDData[48]; 7104 7105 TI_DBG2(("ossaGetVPDResponseCB: start\n")); 7106 7107 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yk"); 7108 if (status == OSSA_SUCCESS) 7109 { 7110 TI_DBG2(("ossaGetVPDResponseCB: agInfoLen %d\n", agInfoLen)); 7111 osti_memset(VPDData, 0, 48); 7112 /* We can read only in case of Direct */ 7113 saFrameReadBlock(agRoot, agFrameHandle, 0, VPDData, agInfoLen); 7114 tdhexdump("ossaGetVPDResponseCB", (bit8 *)VPDData, agInfoLen); 7115 /* 7116 callback osti.... 7117 */ 7118 } 7119 else 7120 { 7121 TI_DBG1(("ossaGetVPDResponseCB: fail or undefined staus %d\n", status)); 7122 } 7123 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yk"); 7124 return; 7125 } 7126 7127 7128 /*****************************************************************************/ 7129 /*! \brief ossaSetVPDResponseCB 7130 * 7131 * 7132 * Purpose: This routine is called by lower layer to corresponding to 7133 * saSetVPDCommand() 7134 * 7135 * \param agRoot: Pointer to chip/driver Instance. 7136 * \param agContext: Context of the operation originally passed 7137 * into saSetVPDCommand() 7138 * \param status: status 7139 * 7140 * 7141 * \return None. 7142 * 7143 */ 7144 /*****************************************************************************/ 7145 osGLOBAL void ossaSetVPDResponseCB( 7146 agsaRoot_t *agRoot, 7147 agsaContext_t *agContext, 7148 bit32 status 7149 ) 7150 { 7151 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7152 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7153 7154 TI_DBG2(("ossaSetVPDResponseCB: start\n")); 7155 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yl"); 7156 7157 if (status == OSSA_SUCCESS) 7158 { 7159 TI_DBG2(("ossaSetVPDResponseCB: success\n")); 7160 ostiCOMMgntVPDSetIOCTLRsp(tiRoot, 0); 7161 /* 7162 callback osti..... 7163 */ 7164 7165 #ifdef VPD_TESTING 7166 /* temporary to test saSetVPDCommand() and saGetVPDCommand */ 7167 tdsaVPDGet(tiRoot); 7168 #endif 7169 7170 } 7171 else 7172 { 7173 TI_DBG1(("ossaSetVPDResponseCB: fail or undefined staus %d\n", status)); 7174 } 7175 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yl"); 7176 return; 7177 } 7178 #endif 7179 7180 /*****************************************************************************/ 7181 /*! \brief ossaEchoCB 7182 * 7183 * 7184 * Purpose: This routine is called by lower layer to corresponding to 7185 * saEchoCommand() 7186 * 7187 * \param agRoot: Pointer to chip/driver Instance. 7188 * \param agContext: Context of the operation originally passed 7189 * into saEchoCommand() 7190 * \param echoPayload: Pointer to the echo payload 7191 * 7192 * 7193 * \return None. 7194 * 7195 */ 7196 /*****************************************************************************/ 7197 osGLOBAL void ossaEchoCB( 7198 agsaRoot_t *agRoot, 7199 agsaContext_t *agContext, 7200 void *echoPayload 7201 ) 7202 { 7203 #ifdef ECHO_TESTING 7204 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7205 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7206 bit8 payload[56]; 7207 #endif 7208 7209 TI_DBG2(("ossaEchoCB: start\n")); 7210 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ym"); 7211 7212 /* dumping received echo payload is 56 bytes */ 7213 tdhexdump("ossaEchoCB: echoPayload", (bit8 *)(echoPayload), 56); 7214 7215 #ifdef ECHO_TESTING 7216 /* temporary to test saEchoCommand() */ 7217 7218 /* new echo payload */ 7219 osti_memset(payload,0, sizeof(payload)); 7220 7221 payload[0] = gEcho; 7222 payload[55] = gEcho; 7223 7224 TI_DBG2(("ossaEchoCB: gEcho %d\n", gEcho)); 7225 7226 saEchoCommand(agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), (void *)&payload); 7227 7228 if (gEcho == 0xFF) 7229 { 7230 gEcho = 0; 7231 } 7232 else 7233 { 7234 gEcho++; 7235 } 7236 #endif 7237 7238 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ym"); 7239 return; 7240 } 7241 7242 /*****************************************************************************/ 7243 /*! \brief ossaGpioResponseCB 7244 * 7245 * 7246 * Purpose: This routine is called by lower layer to corresponding to 7247 * saGpioEventSetup(), saGpioPinSetup(), saGpioRead(), or 7248 * saGpioWrite() 7249 * 7250 * \param agRoot: Pointer to chip/driver Instance. 7251 * \param agContext: Context of the operation originally passed 7252 * in. 7253 * \param status: GPIO operation completion status 7254 * \param gpioReadValue: a bit map containing the corresponding 7255 * value for each GPIO pin. 7256 * \param gpioPinSetupInfo: Pointer to agsaGpioPinSetupInfo_t structure 7257 * describing the GPIO pin setup 7258 * \param gpioEventSetupInfo Pointer to agsaGpioEventSetupInfo_t structure 7259 * describing the GPIO event setups 7260 * 7261 * 7262 * \return None. 7263 * 7264 */ 7265 /*****************************************************************************/ 7266 osGLOBAL void ossaGpioResponseCB( 7267 agsaRoot_t *agRoot, 7268 agsaContext_t *agContext, 7269 bit32 status, 7270 bit32 gpioReadValue, 7271 agsaGpioPinSetupInfo_t *gpioPinSetupInfo, 7272 agsaGpioEventSetupInfo_t *gpioEventSetupInfo 7273 ) 7274 { 7275 TI_DBG2(("ossaGpioResponseCB: start\n")); 7276 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yn"); 7277 if (status == OSSA_SUCCESS) 7278 { 7279 TI_DBG2(("ossaGpioResponseCB: Success\n")); 7280 /* printing gpioReadValue, agsaGpioPinSetupInfo_t and agsaGpioEventSetupInfo_t */ 7281 TI_DBG2(("ossaGpioResponseCB: gpioReadValue 0x%x\n", gpioReadValue)); 7282 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioInputEnabled 0x%x\n", gpioPinSetupInfo->gpioInputEnabled)); 7283 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart1 0x%x\n", gpioPinSetupInfo->gpioTypePart1)); 7284 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart2 0x%x\n", gpioPinSetupInfo->gpioTypePart2)); 7285 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventLevel 0x%x\n", gpioEventSetupInfo->gpioEventLevel)); 7286 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventRisingEdge 0x%x\n", gpioEventSetupInfo->gpioEventRisingEdge)); 7287 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventFallingEdge 0x%x\n", gpioEventSetupInfo->gpioEventFallingEdge)); 7288 } 7289 else 7290 { 7291 TI_DBG1(("ossaGpioResponseCB: Failure\n")); 7292 } 7293 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yn"); 7294 return; 7295 } 7296 7297 /*****************************************************************************/ 7298 /*! \brief ossaGpioEvent 7299 * 7300 * 7301 * Purpose: This routine is called by lower layer to corresponding to 7302 * saGpioEventSetup(), saGpioPinSetup(), saGpioRead(), or 7303 * saGpioWrite() 7304 * 7305 * \param agRoot: Pointer to chip/driver Instance. 7306 * \param gpioEvent: a bit map that indicates which GPIO 7307 * input pins have generated the event. 7308 * 7309 * 7310 * \return None. 7311 * 7312 */ 7313 /*****************************************************************************/ 7314 osGLOBAL void ossaGpioEvent( 7315 agsaRoot_t *agRoot, 7316 bit32 gpioEvent 7317 ) 7318 { 7319 TI_DBG2(("ossaGpioEvent: start\n")); 7320 TI_DBG2(("ossaGpioEvent: gpioEvent 0x%x\n", gpioEvent)); 7321 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yo"); 7322 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yo"); 7323 return; 7324 } 7325 7326 7327 /*****************************************************************************/ 7328 /*! \brief ossaSASDiagExecuteCB 7329 * 7330 * 7331 * Purpose: This routine is called by lower layer to corresponding to 7332 * saSASDiagExecute() 7333 * 7334 * \param agRoot: Pointer to chip/driver Instance. 7335 * \param agContext: Context of the operation originally passed 7336 * in. 7337 * \param status: Diagnostic operation completion status 7338 * \param command: SAS diagnostic command field in agsaSASDiagExecute_t 7339 * structure passed in saSASDiagExecute(). 7340 * \param reportData: Report Diagnostic Data 7341 * 7342 * 7343 * \return None. 7344 * 7345 */ 7346 /*****************************************************************************/ 7347 osGLOBAL void ossaSASDiagExecuteCB( 7348 agsaRoot_t *agRoot, 7349 agsaContext_t *agContext, 7350 bit32 status, 7351 bit32 command, 7352 bit32 reportData) 7353 { 7354 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yq"); 7355 TI_DBG2(("ossaSASDiagExecuteCB: start\n")); 7356 TI_DBG2(("ossaSASDiagExecuteCB: status %d\n", status)); 7357 TI_DBG2(("ossaSASDiagExecuteCB: command %d\n", command)); 7358 TI_DBG2(("ossaSASDiagExecuteCB: reportData %d\n", reportData)); 7359 7360 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yq"); 7361 return; 7362 7363 } 7364 7365 7366 /*****************************************************************************/ 7367 /*! \brief ossaSASDiagStartEndCB 7368 * 7369 * 7370 * Purpose: This routine is called by lower layer to corresponding to 7371 * saSASDiagExecute() 7372 * 7373 * \param agRoot: Pointer to chip/driver Instance. 7374 * \param agContext: Context of the operation originally passed 7375 * in. 7376 * \param status: Diagnostic operation completion status 7377 * 7378 * 7379 * \return None. 7380 * 7381 */ 7382 /*****************************************************************************/ 7383 osGLOBAL void ossaSASDiagStartEndCB( 7384 agsaRoot_t *agRoot, 7385 agsaContext_t *agContext, 7386 bit32 status) 7387 { 7388 TI_DBG2(("ossaSASDiagStartEndCB: start\n")); 7389 TI_DBG2(("ossaSASDiagStartEndCB: status %d\n", status)); 7390 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yr"); 7391 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yr"); 7392 return; 7393 } 7394 7395 /*****************************************************************************/ 7396 /*! \brief ossaReconfigSASParamsCB 7397 * 7398 * 7399 * Purpose: This routine is called by lower layer to corresponding to 7400 * saReconfigSASParams() 7401 * 7402 * \param agRoot: Pointer to chip/driver Instance. 7403 * \param agContext: Context of the operation originally passed 7404 * in saReconfigSASParams(). 7405 * \param status: saReconfigSASParams() completion status 7406 * \param agSASConfig: Pointer to the data structure agsaSASReconfig_t 7407 * 7408 * 7409 * \return None. 7410 * 7411 */ 7412 /*****************************************************************************/ 7413 osGLOBAL void ossaReconfigSASParamsCB( 7414 agsaRoot_t *agRoot, 7415 agsaContext_t *agContext, 7416 bit32 status, 7417 agsaSASReconfig_t *agSASConfig) 7418 { 7419 TI_DBG2(("ossaReconfigSASParamsCB: status %d\n", status)); 7420 return; 7421 } 7422 7423 GLOBAL void ossaPCIeDiagExecuteCB( 7424 agsaRoot_t *agRoot, 7425 agsaContext_t *agContext, 7426 bit32 status, 7427 bit32 command, 7428 agsaPCIeDiagResponse_t *resp ) 7429 { 7430 TI_DBG2(("ossaPCIeDiagExecuteCB: status %d\n", status)); 7431 TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKH 0x%X\n",resp->ERR_BLKH )); 7432 TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKL 0x%X\n",resp->ERR_BLKL )); 7433 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord8 0x%X\n",resp->DWord8 )); 7434 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord9 0x%X\n",resp->DWord9 )); 7435 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord10 0x%X\n",resp->DWord10 )); 7436 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord11 0x%X\n",resp->DWord11 )); 7437 TI_DBG2(("ossaPCIeDiagExecuteCB: DIF_ERR 0x%X\n",resp->DIF_ERR )); 7438 7439 return; 7440 } 7441 7442 7443 #ifndef BIOS 7444 GLOBAL void ossaSGpioCB( 7445 agsaRoot_t *agRoot, 7446 agsaContext_t *agContext, 7447 agsaSGpioReqResponse_t *pSgpioResponse 7448 ) 7449 { 7450 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7451 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7452 7453 TI_DBG2(("ossaSGpioCB: smpFrameType: 0x%02x \n", pSgpioResponse->smpFrameType)); 7454 // printf("SS:ossaSGpioCB: smpFrameType: 0x%02x \n", pSgpioResponse->smpFrameType); 7455 TI_DBG2(("ossaSGpioCB: function: 0x%02x \n", pSgpioResponse->function)); 7456 TI_DBG2(("ossaSGpioCB: functionResult: 0x%02x \n", pSgpioResponse->functionResult)); 7457 //printf("SS:ossaSGpioCB: functionResult: 0x%02x \n", pSgpioResponse->functionResult); 7458 7459 tdhexdump("ossaSGpioCB Response", (bit8 *)pSgpioResponse, sizeof(agsaSGpioReqResponse_t)); 7460 ostiSgpioIoctlRsp(tiRoot, pSgpioResponse); 7461 } 7462 7463 #endif /* BIOS */ 7464 7465 /*****************************************************************************/ 7466 /*! \brief ossaLogDebugString 7467 * 7468 * 7469 * Purpose: This routine is called by lower layer to log. 7470 * 7471 * \param agRoot: Pointer to chip/driver Instance. 7472 * \param level: Detail of information desired. 7473 * \param string: Pointer to the character string. 7474 * \param ptr1: First pointer value. 7475 * \param ptr2: Second pointer value. 7476 * \param value1: First 32-bit value related to the specific information. 7477 * \param value2: Second 32-bit value related to the specific information. 7478 * 7479 * \return None. 7480 * 7481 */ 7482 /*****************************************************************************/ 7483 GLOBAL void ossaLogDebugString( 7484 agsaRoot_t *agRoot, 7485 bit32 level, 7486 char *string, 7487 void *ptr1, 7488 void *ptr2, 7489 bit32 value1, 7490 bit32 value2 7491 ) 7492 { 7493 #if defined(SALLSDK_DEBUG) 7494 TIDEBUG_MSG(gLLDebugLevel, level, ("%s %p %p %d %d\n", string, ptr1, ptr2, value1, value2)); 7495 #endif 7496 return; 7497 } 7498 7499 /*****************************************************************************/ 7500 /*! \brief ossaHwEventAckCB 7501 * 7502 * 7503 * Purpose: This routine is called by lower layer to corresponding to 7504 * saHwEventAck(() 7505 * 7506 * \param agRoot: Pointer to chip/driver Instance. 7507 * \param agContext: Context of the operation originally passed 7508 * in. 7509 * \param status: Status 7510 * 7511 * 7512 * \return None. 7513 * 7514 */ 7515 /*****************************************************************************/ 7516 GLOBAL void ossaHwEventAckCB( 7517 agsaRoot_t *agRoot, 7518 agsaContext_t *agContext, 7519 bit32 status 7520 ) 7521 { 7522 TI_DBG3(("ossaHwEventAckCB: start\n")); 7523 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ys"); 7524 if (status == tiSuccess) 7525 { 7526 TI_DBG3(("ossaHwEventAckCB: SUCCESS status\n")); 7527 } 7528 else 7529 { 7530 TI_DBG1(("ossaHwEventAckCB: FAIL status 0x%X\n", status)); 7531 TI_DBG1(("ossaHwEventAckCB: invalid event status bit0 %d\n", status & 0x01)); 7532 TI_DBG1(("ossaHwEventAckCB: invalid phyid status bit1 %d\n", (status & 0x02) >> 1 )); 7533 TI_DBG1(("ossaHwEventAckCB: invalid portcontext status bit2 %d\n", (status & 0x04) >> 2)); 7534 TI_DBG1(("ossaHwEventAckCB: invalid param0 status bit3 %d\n", (status & 0x08) >> 3)); 7535 } 7536 7537 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ys"); 7538 return; 7539 } 7540 7541 /*****************************************************************************/ 7542 /*! \brief ossaGetTimeStampCB 7543 * 7544 * 7545 * Purpose: This routine is called by lower layer to corresponding to 7546 * saGetTimeStamp() 7547 * 7548 * \param agRoot: Pointer to chip/driver Instance. 7549 * \param agContext: Context of the operation originally passed 7550 * in. 7551 * \param timeStampLower: The controller lower 32-bit of internal time 7552 * stamp associated with event log. 7553 * \param timeStampUpper: The controller upper 32-bit of internal time 7554 * stamp associated with event log. 7555 * 7556 * 7557 * \return None. 7558 * 7559 */ 7560 /*****************************************************************************/ 7561 GLOBAL void ossaGetTimeStampCB( 7562 agsaRoot_t *agRoot, 7563 agsaContext_t *agContext, 7564 bit32 timeStampLower, 7565 bit32 timeStampUpper 7566 ) 7567 { 7568 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yt"); 7569 TI_DBG4(("ossaGetTimeStampCB: start\n")); 7570 TI_DBG4(("ossaGetTimeStampCB: timeStampUpper 0x%x timeStampLower 0x%x\n", timeStampUpper, timeStampLower)); 7571 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yt"); 7572 return; 7573 } 7574 7575 7576 /*****************************************************************************/ 7577 /*! \brief ossaSMPAbortCB 7578 * 7579 * 7580 * Purpose: This routine is called by lower layer to corresponding to 7581 * saSMPAbort() 7582 * 7583 * \param agRoot: Pointer to chip/driver Instance. 7584 * \param agIORequest: This is the agIORequest parameter passed in 7585 * saSMPAbort() 7586 * \param status: Status of abort 7587 * 7588 * \return None. 7589 * 7590 */ 7591 /*****************************************************************************/ 7592 GLOBAL void ossaSMPAbortCB( 7593 agsaRoot_t *agRoot, 7594 agsaIORequest_t *agIORequest, 7595 bit32 flag, 7596 bit32 status) 7597 { 7598 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7599 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7600 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 7601 tdsaDeviceData_t *oneDeviceData = agNULL; 7602 tiDeviceHandle_t *tiDeviceHandle = agNULL; 7603 7604 TI_DBG4(("ossaSMPAbortCB: start\n")); 7605 TI_DBG4(("ossaSMPAbortCB: flag %d\n", flag)); 7606 TI_DBG4(("ossaSMPAbortCB: status %d\n", status)); 7607 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yu"); 7608 7609 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 7610 if (tdAbortIORequestBody == agNULL) 7611 { 7612 TI_DBG1(("ossaSMPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n")); 7613 return; 7614 } 7615 7616 if (flag == 2) 7617 { 7618 /* abort per port */ 7619 TI_DBG2(("ossaSMPAbortCB: abort per port\n")); 7620 } 7621 else if (flag == 1) 7622 { 7623 TI_DBG2(("ossaSMPAbortCB: abort all\n")); 7624 7625 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle; 7626 if (tiDeviceHandle == agNULL) 7627 { 7628 TI_DBG1(("ossaSMPAbortCB: tiDeviceHandle is NULL warning!!!!\n")); 7629 ostiFreeMemory( 7630 tiRoot, 7631 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7632 sizeof(tdIORequestBody_t) 7633 ); 7634 return; 7635 } 7636 7637 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 7638 if (oneDeviceData == agNULL) 7639 { 7640 TI_DBG1(("ossaSMPAbortCB: oneDeviceData is NULL warning!!!!\n")); 7641 ostiFreeMemory( 7642 tiRoot, 7643 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7644 sizeof(tdIORequestBody_t) 7645 ); 7646 return; 7647 } 7648 7649 if (status == OSSA_IO_SUCCESS) 7650 { 7651 TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n")); 7652 /* clean up TD layer's IORequestBody */ 7653 TI_DBG3(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7654 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7655 TI_DBG2(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7656 ostiFreeMemory( 7657 tiRoot, 7658 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7659 sizeof(tdIORequestBody_t) 7660 ); 7661 7662 } 7663 else if (status == OSSA_IO_NOT_VALID) 7664 { 7665 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n")); 7666 /* clean up TD layer's IORequestBody */ 7667 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7668 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7669 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7670 ostiFreeMemory( 7671 tiRoot, 7672 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7673 sizeof(tdIORequestBody_t) 7674 ); 7675 } 7676 else if (status == OSSA_IO_NO_DEVICE) 7677 { 7678 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n")); 7679 /* clean up TD layer's IORequestBody */ 7680 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7681 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7682 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7683 ostiFreeMemory( 7684 tiRoot, 7685 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7686 sizeof(tdIORequestBody_t) 7687 ); 7688 } 7689 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 7690 { 7691 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 7692 /* clean up TD layer's IORequestBody */ 7693 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7694 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7695 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7696 ostiFreeMemory( 7697 tiRoot, 7698 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7699 sizeof(tdIORequestBody_t) 7700 ); 7701 } 7702 #ifdef REMOVED 7703 else if (status == OSSA_IO_ABORT_DELAYED) 7704 { 7705 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 7706 /* clean up TD layer's IORequestBody */ 7707 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7708 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7709 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7710 ostiFreeMemory( 7711 tiRoot, 7712 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7713 sizeof(tdIORequestBody_t) 7714 ); 7715 } 7716 #endif 7717 else 7718 { 7719 TI_DBG1(("ossaSMPAbortCB: other status %d\n", status)); 7720 /* clean up TD layer's IORequestBody */ 7721 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n")); 7722 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 7723 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id)); 7724 ostiFreeMemory( 7725 tiRoot, 7726 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7727 sizeof(tdIORequestBody_t) 7728 ); 7729 } 7730 } 7731 else if (flag == 0) 7732 { 7733 TI_DBG2(("ossaSMPAbortCB: abort one\n")); 7734 if (status == OSSA_IO_SUCCESS) 7735 { 7736 TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n")); 7737 ostiFreeMemory( 7738 tiRoot, 7739 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7740 sizeof(tdIORequestBody_t) 7741 ); 7742 7743 } 7744 else if (status == OSSA_IO_NOT_VALID) 7745 { 7746 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n")); 7747 ostiFreeMemory( 7748 tiRoot, 7749 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7750 sizeof(tdIORequestBody_t) 7751 ); 7752 } 7753 else if (status == OSSA_IO_NO_DEVICE) 7754 { 7755 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n")); 7756 ostiFreeMemory( 7757 tiRoot, 7758 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7759 sizeof(tdIORequestBody_t) 7760 ); 7761 } 7762 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 7763 { 7764 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 7765 ostiFreeMemory( 7766 tiRoot, 7767 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7768 sizeof(tdIORequestBody_t) 7769 ); 7770 } 7771 #ifdef REMOVED 7772 else if (status == OSSA_IO_ABORT_DELAYED) 7773 { 7774 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n")); 7775 ostiFreeMemory( 7776 tiRoot, 7777 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7778 sizeof(tdIORequestBody_t) 7779 ); 7780 } 7781 #endif 7782 else 7783 { 7784 TI_DBG1(("ossaSMPAbortCB: other status %d\n", status)); 7785 ostiFreeMemory( 7786 tiRoot, 7787 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 7788 sizeof(tdIORequestBody_t) 7789 ); 7790 } 7791 } 7792 else 7793 { 7794 TI_DBG1(("ossaSMPAbortCB: wrong flag %d\n", flag)); 7795 } 7796 7797 7798 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yu"); 7799 return; 7800 } 7801 7802 /*****************************************************************************/ 7803 /*! \brief ossaGeneralEvent 7804 * 7805 * 7806 * Purpose: This is the event notification for debugging purposes sent to 7807 * inform the OS layer of some general error related to a specific 7808 * inbound operation. 7809 * 7810 * \param agRoot: Pointer to chip/driver Instance. 7811 * \param status: Status associated with this event 7812 * \param msg: Pointer to controller specific command 7813 * massage that caused the error 7814 * 7815 * \return None. 7816 * 7817 */ 7818 /*****************************************************************************/ 7819 GLOBAL void ossaGeneralEvent( 7820 agsaRoot_t *agRoot, 7821 bit32 status, 7822 agsaContext_t *agContext, 7823 bit32 *msg) 7824 { 7825 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7826 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7827 7828 TI_DBG1(("ossaGeneralEvent: start\n")); 7829 TI_DBG1(("ossaGeneralEvent: status %d\n", status)); 7830 7831 if(msg) 7832 { 7833 TI_DBG1(("ossaGeneralEvent: *msg %X\n", *msg)); 7834 } 7835 7836 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yv"); 7837 ostiGenEventIOCTLRsp(tiRoot, status); 7838 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yv"); 7839 return; 7840 } 7841 7842 GLOBAL void ossaGetForensicDataCB ( 7843 agsaRoot_t *agRoot, 7844 agsaContext_t *agContext, 7845 bit32 status, 7846 agsaForensicData_t *forensicData) 7847 { 7848 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7849 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7850 7851 ostiGetForensicDataIOCTLRsp(tiRoot, status, forensicData); 7852 return; 7853 } 7854 7855 7856 #ifdef INITIATOR_DRIVER 7857 7858 GLOBAL void ossaGetIOErrorStatsCB ( 7859 agsaRoot_t *agRoot, 7860 agsaContext_t *agContext, 7861 bit32 status, 7862 agsaIOErrorEventStats_t *stats) 7863 7864 { 7865 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7866 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7867 7868 ostiGetIoErrorStatsIOCTLRsp(tiRoot, status, stats); 7869 } 7870 #else 7871 GLOBAL void ossaGetIOErrorStatsCB ( 7872 agsaRoot_t *agRoot, 7873 agsaContext_t *agContext, 7874 bit32 status, 7875 agsaIOErrorEventStats_t *stats) 7876 7877 { 7878 7879 } 7880 7881 #endif 7882 7883 GLOBAL void ossaGetIOEventStatsCB ( 7884 agsaRoot_t *agRoot, 7885 agsaContext_t *agContext, 7886 bit32 status, 7887 agsaIOErrorEventStats_t *stats) 7888 7889 { 7890 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7891 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7892 7893 ostiGetIoEventStatsIOCTLRsp(tiRoot, status, stats); 7894 } 7895 7896 7897 /*****************************************************************************/ 7898 /*! \brief ossaGetRegisterDumpCB 7899 * 7900 * 7901 * Purpose: ossaGetRegisterDumpCB() is the response callback function 7902 * called by the LL Layer to indicate a response to 7903 * saGetRegisterDump() 7904 * 7905 * \param agRoot: Pointer to chip/driver Instance. 7906 * \param agContext: Context of the operation originally 7907 * passed into saGetRegisterDump() 7908 * \param status: status 7909 * 7910 * \return None. 7911 * 7912 */ 7913 /*****************************************************************************/ 7914 GLOBAL void ossaGetRegisterDumpCB( 7915 agsaRoot_t *agRoot, 7916 agsaContext_t *agContext, 7917 bit32 status 7918 ) 7919 { 7920 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7921 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7922 7923 TI_DBG4(("ossaGetRegisterDumpCB: start\n")); 7924 TI_DBG4(("ossaGetRegisterDumpCB: status %d\n", status)); 7925 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yw"); 7926 7927 ostiRegDumpIOCTLRsp(tiRoot, status); 7928 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yw"); 7929 return; 7930 } 7931 7932 /*****************************************************************************/ 7933 /*! \brief ossaSetDeviceStateCB 7934 * 7935 * 7936 * Purpose: ossaSetDeviceStateCB() is the response callback function 7937 * called by the LL Layer to indicate a response to 7938 * saSetDeviceState() 7939 * 7940 * \param agRoot: Pointer to chip/driver Instance. 7941 * \param agContext: Context of the operation originally 7942 * passed into saGetRegisterDump() 7943 * \param agDevHandle Pointer to the device handle of the device 7944 * \param status: status 7945 * \param newDeviceState: newly set device status 7946 * \param previousDeviceState: old device status 7947 * 7948 * \return None. 7949 * 7950 */ 7951 /*****************************************************************************/ 7952 GLOBAL void ossaSetDeviceStateCB( 7953 agsaRoot_t *agRoot, 7954 agsaContext_t *agContext, 7955 agsaDevHandle_t *agDevHandle, 7956 bit32 status, 7957 bit32 newDeviceState, 7958 bit32 previousDeviceState 7959 ) 7960 { 7961 tdsaDeviceData_t *oneDeviceData = agNULL; 7962 7963 TI_DBG2(("ossaSetDeviceStateCB: start\n")); 7964 TI_DBG2(("ossaSetDeviceStateCB: status %d\n", status)); 7965 TI_DBG2(("ossaSetDeviceStateCB: newDeviceState %d\n", newDeviceState)); 7966 TI_DBG2(("ossaSetDeviceStateCB: previousDeviceState %d\n", previousDeviceState)); 7967 7968 if (agDevHandle == agNULL) 7969 { 7970 TI_DBG4(("ossaSetDeviceStateCB: agDevHandle is NULL\n")); 7971 return; 7972 } 7973 7974 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 7975 7976 if (oneDeviceData == agNULL) 7977 { 7978 TI_DBG1(("ossaSetDeviceStateCB: wrong; oneDeviceData is NULL\n")); 7979 } 7980 else 7981 { 7982 TI_DBG2(("ossaSetDeviceStateCB: did %d\n", oneDeviceData->id)); 7983 } 7984 7985 return; 7986 } 7987 7988 /*****************************************************************************/ 7989 /*! \brief ossaGetDeviceStateCB 7990 * 7991 * 7992 * Purpose: ossaGetDeviceStateCB() is the response callback function 7993 * called by the LL Layer to indicate a response to 7994 * saGetDeviceState() 7995 * 7996 * \param agRoot: Pointer to chip/driver Instance. 7997 * \param agContext: Context of the operation originally 7998 * passed into saGetRegisterDump() 7999 * \param agDevHandle Pointer to the device handle of the device 8000 * \param status: status 8001 * \param deviceState: device status 8002 * 8003 * \return None. 8004 * 8005 */ 8006 /*****************************************************************************/ 8007 GLOBAL void ossaGetDeviceStateCB( 8008 agsaRoot_t *agRoot, 8009 agsaContext_t *agContext, 8010 agsaDevHandle_t *agDevHandle, 8011 bit32 status, 8012 bit32 deviceState 8013 ) 8014 { 8015 TI_DBG4(("ossaGetDeviceStateCB: start\n")); 8016 TI_DBG4(("ossaGetDeviceStateCB: status %d\n", status)); 8017 TI_DBG4(("ossaGetDeviceStateCB: deviceState %d\n", deviceState)); 8018 8019 return; 8020 } 8021 8022 #ifdef INITIATOR_DRIVER 8023 /*****************************************************************************/ 8024 /*! \brief ossaIniSetDeviceInfoCB 8025 * 8026 * 8027 * Purpose: ossaIniSetDeviceInfoCB() is the response callback function 8028 * called by the LL Layer to indicate a response to 8029 * saSetDeviceInfo() 8030 * 8031 * \param agRoot: Pointer to chip/driver Instance. 8032 * \param agContext: Context of the operation originally 8033 * passed into saSetDeviceInfo() 8034 * \param agDevHandle Pointer to the device handle of the device 8035 * \param status: status 8036 * \param option: option parameter passed in saSetDeviceInfo() 8037 * \param param: param parameter passed in saSetDeviceInfo() 8038 * 8039 * \return None. 8040 * 8041 */ 8042 /*****************************************************************************/ 8043 osGLOBAL void 8044 ossaIniSetDeviceInfoCB( 8045 agsaRoot_t *agRoot, 8046 agsaContext_t *agContext, 8047 agsaDevHandle_t *agDevHandle, 8048 bit32 status, 8049 bit32 option, 8050 bit32 param 8051 ) 8052 { 8053 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8054 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8055 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8056 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8057 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 8058 bit32 intContext = osData->IntContext; 8059 tdIORequestBody_t *tdIORequestBody = agNULL; 8060 agsaIORequest_t *agIORequest = agNULL; 8061 bit32 saStatus = AGSA_RC_FAILURE; 8062 bit8 devType_S_Rate; 8063 tdsaDeviceData_t *oneDeviceData = agNULL; 8064 8065 TI_DBG4(("ossaIniSetDeviceInfoCB: start\n")); 8066 TI_DBG4(("ossaIniSetDeviceInfoCB: status 0x%x\n", status)); 8067 TI_DBG4(("ossaIniSetDeviceInfoCB: option 0x%x\n", option)); 8068 TI_DBG4(("ossaIniSetDeviceInfoCB: param 0x%x\n", param)); 8069 8070 if (status != OSSA_SUCCESS) 8071 { 8072 TI_DBG1(("ossaIniSetDeviceInfoCB: status %d\n", status)); 8073 TI_DBG1(("ossaIniSetDeviceInfoCB: option 0x%x\n", option)); 8074 TI_DBG1(("ossaIniSetDeviceInfoCB: param 0x%x\n", param)); 8075 if (option == 32) /* set connection rate */ 8076 { 8077 TI_DBG1(("ossaIniSetDeviceInfoCB: IO failure\n")); 8078 agIORequest = (agsaIORequest_t *)agContext->osData; 8079 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 8080 ostiInitiatorIOCompleted( 8081 tiRoot, 8082 tdIORequestBody->tiIORequest, 8083 tiIOFailed, 8084 tiDetailOtherError, 8085 agNULL, 8086 intContext 8087 ); 8088 } 8089 } 8090 if (agDevHandle == agNULL) 8091 { 8092 TI_DBG4(("ossaIniSetDeviceInfoCB: agDevHandle is NULL\n")); 8093 return; 8094 } 8095 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 8096 if (oneDeviceData == agNULL) 8097 { 8098 TI_DBG1(("ossaIniSetDeviceInfoCB: wrong; oneDeviceData is NULL\n")); 8099 return; 8100 } 8101 else 8102 { 8103 TI_DBG4(("ossaIniSetDeviceInfoCB: did %d\n", oneDeviceData->id)); 8104 } 8105 8106 /* retry IOs */ 8107 if (option == 32) /* set connection rate */ 8108 { 8109 TI_DBG1(("ossaIniSetDeviceInfoCB: set connection rate option\n")); 8110 agIORequest = (agsaIORequest_t *)agContext->osData; 8111 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 8112 devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate; 8113 devType_S_Rate = (devType_S_Rate & 0xF0) | (param >> 28); 8114 oneDeviceData->agDeviceInfo.devType_S_Rate = devType_S_Rate; 8115 TI_DBG1(("ossaIniSetDeviceInfoCB: new rate is 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo))); 8116 if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE && 8117 oneDeviceData->tdPortContext != agNULL ) 8118 { 8119 saStatus = saSSPStart(agRoot, 8120 agIORequest, 8121 tdsaRotateQnumber(tiRoot, oneDeviceData), 8122 agDevHandle, 8123 tdIORequestBody->agRequestType, 8124 &(tdIORequestBody->transport.SAS.agSASRequestBody), 8125 agNULL, 8126 &ossaSSPCompleted); 8127 if (saStatus == AGSA_RC_SUCCESS) 8128 { 8129 TI_DBG1(("ossaIniSetDeviceInfoCB: retried\n")); 8130 Initiator->NumIOsActive++; 8131 tdIORequestBody->ioStarted = agTRUE; 8132 tdIORequestBody->ioCompleted = agFALSE; 8133 return; 8134 } 8135 else 8136 { 8137 TI_DBG1(("ossaIniSetDeviceInfoCB: retry failed\n")); 8138 tdIORequestBody->ioStarted = agFALSE; 8139 tdIORequestBody->ioCompleted = agTRUE; 8140 ostiInitiatorIOCompleted( 8141 tiRoot, 8142 tdIORequestBody->tiIORequest, 8143 tiIOFailed, 8144 tiDetailOtherError, 8145 agNULL, 8146 intContext 8147 ); 8148 } 8149 } 8150 } 8151 return; 8152 } 8153 #endif 8154 /*****************************************************************************/ 8155 /*! \brief ossaSetDeviceInfoCB 8156 * 8157 * 8158 * Purpose: ossaSetDeviceInfoCB() is the response callback function 8159 * called by the LL Layer to indicate a response to 8160 * saSetDeviceInfo() 8161 * 8162 * \param agRoot: Pointer to chip/driver Instance. 8163 * \param agContext: Context of the operation originally 8164 * passed into saSetDeviceInfo() 8165 * \param agDevHandle Pointer to the device handle of the device 8166 * \param status: status 8167 * \param option: option parameter passed in saSetDeviceInfo() 8168 * \param param: param parameter passed in saSetDeviceInfo() 8169 * 8170 * \return None. 8171 * 8172 */ 8173 /*****************************************************************************/ 8174 GLOBAL void ossaSetDeviceInfoCB( 8175 agsaRoot_t *agRoot, 8176 agsaContext_t *agContext, 8177 agsaDevHandle_t *agDevHandle, 8178 bit32 status, 8179 bit32 option, 8180 bit32 param 8181 ) 8182 { 8183 tdsaDeviceData_t *oneDeviceData = agNULL; 8184 8185 TI_DBG4(("ossaSetDeviceInfoCB: start\n")); 8186 TI_DBG4(("ossaSetDeviceInfoCB: status 0x%x\n", status)); 8187 TI_DBG4(("ossaSetDeviceInfoCB: option 0x%x\n", option)); 8188 TI_DBG4(("ossaSetDeviceInfoCB: param 0x%x\n", param)); 8189 8190 if (status != OSSA_SUCCESS) 8191 { 8192 TI_DBG1(("ossaSetDeviceInfoCB: status %d\n", status)); 8193 TI_DBG1(("ossaSetDeviceInfoCB: option 0x%x\n", option)); 8194 TI_DBG1(("ossaSetDeviceInfoCB: param 0x%x\n", param)); 8195 } 8196 8197 if (agDevHandle == agNULL) 8198 { 8199 TI_DBG4(("ossaSetDeviceInfoCB: agDevHandle is NULL\n")); 8200 return; 8201 } 8202 8203 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 8204 8205 if (oneDeviceData == agNULL) 8206 { 8207 TI_DBG1(("ossaSetDeviceInfoCB: wrong; oneDeviceData is NULL\n")); 8208 } 8209 else 8210 { 8211 TI_DBG4(("ossaSetDeviceInfoCB: did %d\n", oneDeviceData->id)); 8212 } 8213 8214 return; 8215 } 8216 8217 /*****************************************************************************/ 8218 /*! \brief ossaGetDFEDataCB 8219 * 8220 * 8221 * Purpose: ossaGetDFEDataCB() is the response callback function 8222 * called by the LL Layer to indicate a response to 8223 * saGetDFEData() 8224 * 8225 * \param agRoot: Pointer to chip/driver Instance. 8226 * \param agContext: Context of the operation originally 8227 * passed into saGetDFEData() 8228 * \param status: status 8229 * \param agInfoLen: length in bytes of DFE data captured and transferred 8230 * 8231 * \return None. 8232 * 8233 */ 8234 /*****************************************************************************/ 8235 GLOBAL void ossaGetDFEDataCB( 8236 agsaRoot_t *agRoot, 8237 agsaContext_t *agContext, 8238 bit32 status, 8239 bit32 agInfoLen) 8240 { 8241 TI_DBG1(("ossaGetDFEDataCB: start\n")); 8242 TI_DBG1(("ossaGetDFEDataCB: status 0x%x agInfoLen 0x%x\n", status, agInfoLen)); 8243 return; 8244 } 8245 8246 /*****************************************************************************/ 8247 /*! \brief ossaVhistCaptureCB 8248 * 8249 * 8250 * Purpose: ossaVhistCaptureCB() is the response callback function 8251 * called by the LL Layer to indicate a response to 8252 * saGetDFEData() 8253 * 8254 * \param agRoot: Pointer to chip/driver Instance. 8255 * \param agContext: Context of the operation originally 8256 * passed into () 8257 * \param status: status 8258 * \param len: length in bytes of Vis data captured and transferred 8259 * 8260 * \return None. 8261 * 8262 */ 8263 /*****************************************************************************/ 8264 8265 void ossaVhistCaptureCB( 8266 agsaRoot_t *agRoot, 8267 agsaContext_t *agContext, 8268 bit32 status, 8269 bit32 len) 8270 { 8271 TI_DBG1(("ossaVhistCaptureCB: start\n")); 8272 TI_DBG1(("ossaVhistCaptureCB: status 0x%x agInfoLen 0x%x\n", status,len )); 8273 return; 8274 } 8275 8276 GLOBAL void ossaOperatorManagementCB( 8277 agsaRoot_t *agRoot, 8278 agsaContext_t *agContext, 8279 bit32 status, 8280 bit32 eq 8281 ) 8282 { 8283 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8284 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8285 tiEncryptPort_t encryptEventData; 8286 8287 TI_DBG1(("ossaOperatorManagementCB: status 0x%x eq 0x%x\n", status, eq)); 8288 8289 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t)); 8290 encryptEventData.encryptEvent = tiEncryptOperatorManagement; 8291 encryptEventData.subEvent = eq; 8292 encryptEventData.pData = agNULL; 8293 8294 ostiPortEvent(tiRoot, 8295 tiEncryptOperation, 8296 status, 8297 &encryptEventData); 8298 } 8299 8300 GLOBAL void ossaEncryptSelftestExecuteCB ( 8301 agsaRoot_t *agRoot, 8302 agsaContext_t *agContext, 8303 bit32 status, 8304 bit32 type, 8305 bit32 length, 8306 void *TestResult 8307 ) 8308 { 8309 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8310 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8311 tiEncryptPort_t encryptEventData; 8312 8313 TI_DBG1(("ossaEncryptSelftestExecuteCB: status 0x%x type 0x%x length 0x%x\n", status, type, length)); 8314 8315 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t)); 8316 encryptEventData.encryptEvent = tiEncryptSelfTest; 8317 encryptEventData.subEvent = type; 8318 encryptEventData.pData = (void*)TestResult; 8319 8320 ostiPortEvent(tiRoot, 8321 tiEncryptOperation, 8322 status, 8323 &encryptEventData); 8324 } 8325 8326 GLOBAL void ossaGetOperatorCB( 8327 agsaRoot_t *agRoot, 8328 agsaContext_t *agContext, 8329 bit32 status, 8330 bit32 option, 8331 bit32 num, 8332 bit32 role, 8333 agsaID_t *id 8334 ) 8335 { 8336 8337 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8338 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8339 tiEncryptPort_t encryptEventData; 8340 8341 TI_DBG1(("ossaGetOperatorCB: status 0x%x option 0x%x num 0x%x role 0x%x\n", 8342 status, option, num, role)); 8343 TI_DBG1(("ossaGetOperatorCB: agContext %p id %p\n",agContext,id)); 8344 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t)); 8345 encryptEventData.encryptEvent = tiEncryptGetOperator; 8346 encryptEventData.subEvent = option; 8347 encryptEventData.pData = agNULL; 8348 8349 switch(status) 8350 { 8351 case OSSA_IO_SUCCESS: 8352 TI_DBG1(("ossaGetOperatorCB: OSSA_IO_SUCCESS option 0x%x\n", option)); 8353 if(option == 1) 8354 { 8355 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[0], id->ID[1], id->ID[2], id->ID[3])); 8356 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[4], id->ID[5], id->ID[6], id->ID[7])); 8357 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[8], id->ID[9], id->ID[10],id->ID[11])); 8358 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[12],id->ID[13],id->ID[14],id->ID[15])); 8359 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[16],id->ID[17],id->ID[18],id->ID[19])); 8360 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[20],id->ID[21],id->ID[22],id->ID[23])); 8361 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[24],id->ID[25],id->ID[26],id->ID[27])); 8362 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x\n", id->ID[28],id->ID[29],id->ID[30])); 8363 }else if(option == 2) 8364 { 8365 TI_DBG1(("ossaGetOperatorCB: number operators 0x%02x\n", num )); 8366 } 8367 8368 encryptEventData.pData = id; 8369 break; 8370 case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION: 8371 TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION 0x%x\n",option)); 8372 break; 8373 case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE: 8374 TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE 0x%x\n",option)); 8375 break; 8376 default: 8377 TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status)); 8378 } 8379 ostiPortEvent(tiRoot, 8380 tiEncryptOperation, 8381 status, 8382 &encryptEventData); 8383 8384 } 8385 8386 GLOBAL void ossaSetOperatorCB( 8387 agsaRoot_t *agRoot, 8388 agsaContext_t *agContext, 8389 bit32 status, 8390 bit32 eq 8391 ) 8392 { 8393 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8394 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8395 tiEncryptPort_t encryptEventData; 8396 8397 TI_DBG1(("ossaSetOperatorCB: agContext %p status 0x%x eq 0x%x\n",agContext, status, eq)); 8398 8399 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t)); 8400 encryptEventData.encryptEvent = tiEncryptSetOperator; 8401 encryptEventData.subEvent = 0; 8402 switch(status) 8403 { 8404 case OSSA_IO_SUCCESS: 8405 TI_DBG1(("ossaSetOperatorCB: OSSA_IO_SUCCESS\n")); 8406 encryptEventData.pData = agNULL; 8407 break; 8408 case OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE: 8409 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE\n")); 8410 break; 8411 case OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE: 8412 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE error qualifier 0x%x\n",eq)); 8413 break; 8414 case OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN: 8415 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN\n")); 8416 break; 8417 case OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER: 8418 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER\n")); 8419 break; 8420 case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION: 8421 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION\n")); 8422 break; 8423 case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE: 8424 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE\n")); 8425 break; 8426 default: 8427 TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status)); 8428 } 8429 ostiPortEvent(tiRoot, 8430 tiEncryptOperation, 8431 status, 8432 &encryptEventData); 8433 } 8434 8435 GLOBAL void ossaDIFEncryptionOffloadStartCB( 8436 agsaRoot_t *agRoot, 8437 agsaContext_t *agContext, 8438 bit32 status, 8439 agsaOffloadDifDetails_t *agsaOffloadDifDetails) 8440 { 8441 TI_DBG1(("ossaDIFEncryptionOffloadStartCB: start\n")); 8442 TI_DBG1(("ossaDIFEncryptionOffloadStartCB: status 0x%x agsaOffloadDifDetails=%p\n", status, agsaOffloadDifDetails)); 8443 return; 8444 } 8445 8446 GLOBAL bit32 ossaTimeStamp( agsaRoot_t *agRoot ) 8447 { 8448 tdsaRootOsData_t *osData= agNULL; 8449 tiRoot_t *tiRoot= agNULL; 8450 if(agRoot) 8451 { 8452 osData = (tdsaRootOsData_t *)agRoot->osData; 8453 } 8454 if(osData) 8455 { 8456 tiRoot = (tiRoot_t *)osData->tiRoot; 8457 } 8458 return(ostiTimeStamp(tiRoot)); 8459 } 8460 8461 GLOBAL bit64 ossaTimeStamp64( agsaRoot_t *agRoot) 8462 { 8463 tdsaRootOsData_t *osData= agNULL; 8464 tiRoot_t *tiRoot= agNULL; 8465 if(agRoot) 8466 { 8467 osData = (tdsaRootOsData_t *)agRoot->osData; 8468 } 8469 if(osData) 8470 { 8471 tiRoot = (tiRoot_t *)osData->tiRoot; 8472 } 8473 return(ostiTimeStamp64(tiRoot)); 8474 } 8475 8476 #ifdef FDS_SM 8477 osGLOBAL void 8478 tdIDStartTimer(tiRoot_t *tiRoot, 8479 smIORequest_t *smIORequest, 8480 tdsaDeviceData_t *oneDeviceData 8481 ) 8482 { 8483 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8484 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8485 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 8486 8487 TI_DBG1(("tdIDStartTimer: start\n")); 8488 8489 tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK); 8490 if (oneDeviceData->tdIDTimer.timerRunning == agTRUE) 8491 { 8492 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 8493 tdsaKillTimer( 8494 tiRoot, 8495 &oneDeviceData->tdIDTimer 8496 ); 8497 } 8498 else 8499 { 8500 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 8501 } 8502 8503 tdsaSetTimerRequest( 8504 tiRoot, 8505 &oneDeviceData->tdIDTimer, 8506 SATA_ID_DEVICE_DATA_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick, 8507 tdIDStartTimerCB, 8508 smIORequest, 8509 oneDeviceData, 8510 agNULL 8511 ); 8512 8513 tdsaAddTimer( 8514 tiRoot, 8515 &Initiator->timerlist, 8516 &oneDeviceData->tdIDTimer 8517 ); 8518 TI_DBG1(("tdIDStartTimer: end\n")); 8519 return; 8520 } 8521 8522 osGLOBAL void 8523 tdIDStartTimerCB( 8524 tiRoot_t * tiRoot, 8525 void * timerData1, 8526 void * timerData2, 8527 void * timerData3 8528 ) 8529 { 8530 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8531 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8532 smIORequest_t *smIORequest; 8533 tdsaDeviceData_t *oneDeviceData; 8534 smRoot_t *smRoot; 8535 tdIORequestBody_t *tdIORequestBody; 8536 smDeviceHandle_t *smDeviceHandle; 8537 tdsaPortContext_t *onePortContext; 8538 #ifdef REMOVED 8539 agsaRoot_t *agRoot; 8540 bit32 IDstatus; 8541 //#endif 8542 //#ifdef REMOVED 8543 agsaIORequest_t *agAbortIORequest = agNULL; 8544 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 8545 bit32 PhysUpper32; 8546 bit32 PhysLower32; 8547 bit32 memAllocStatus; 8548 void *osMemHandle; 8549 #endif // REMOVED 8550 #ifdef TD_DEBUG_ENABLE 8551 bit32 status = AGSA_RC_FAILURE; 8552 #endif 8553 8554 TI_DBG1(("tdIDStartTimerCB start\n")); 8555 smIORequest = (smIORequest_t *)timerData1; 8556 oneDeviceData = (tdsaDeviceData_t *)timerData2; 8557 smRoot = &(tdsaAllShared->smRoot); 8558 #ifdef REMOVED 8559 agRoot = oneDeviceData->agRoot; 8560 #endif // REMOVED 8561 8562 if (smIORequest == agNULL) 8563 { 8564 TI_DBG1(("tdIDStartTimerCB: smIORequest == agNULL !!!!!!\n")); 8565 return; 8566 } 8567 8568 if (oneDeviceData == agNULL) 8569 { 8570 TI_DBG1(("tdIDStartTimerCB: oneDeviceData == agNULL !!!!!!\n")); 8571 return; 8572 } 8573 8574 if (oneDeviceData->satDevData.IDPending == agFALSE || oneDeviceData->satDevData.IDDeviceValid == agTRUE) 8575 { 8576 /*the Identify Device command already normally completed, just return*/ 8577 return; 8578 } 8579 8580 tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData; 8581 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle); 8582 onePortContext = oneDeviceData->tdPortContext; 8583 if (tdIORequestBody == agNULL) 8584 { 8585 TI_DBG1(("tdIDStartTimerCB: tdIORequestBody == agNULL !!!!!!\n")); 8586 return; 8587 } 8588 8589 if (smDeviceHandle == agNULL) 8590 { 8591 TI_DBG1(("tdIDStartTimerCB: smDeviceHandle == agNULL !!!!!!\n")); 8592 return; 8593 } 8594 8595 if (onePortContext == agNULL) 8596 { 8597 TI_DBG1(("tdIDStartTimerCB: onePortContext == agNULL !!!!!!\n")); 8598 return; 8599 } 8600 8601 TI_DBG1(("tdIDStartTimerCB: did %d\n", oneDeviceData->id)); 8602 /* 8603 1. smIOabort() 8604 2. in tdsmIDCompletedCB(), retry 8605 */ 8606 if (oneDeviceData->valid == agFALSE) 8607 { 8608 TI_DBG1(("tdIDStartTimerCB: invalid device\n")); 8609 return; 8610 } 8611 #ifdef TD_DEBUG_ENABLE 8612 status = smIOAbort( smRoot, smIORequest ); 8613 #else 8614 smIOAbort( smRoot, smIORequest ); 8615 #endif 8616 8617 #ifdef REMOVED 8618 /* allocating agIORequest for abort itself */ 8619 memAllocStatus = ostiAllocMemory( 8620 tiRoot, 8621 &osMemHandle, 8622 (void **)&tdAbortIORequestBody, 8623 &PhysUpper32, 8624 &PhysLower32, 8625 8, 8626 sizeof(tdIORequestBody_t), 8627 agTRUE 8628 ); 8629 if (memAllocStatus != tiSuccess) 8630 { 8631 /* let os process IO */ 8632 TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory failed...; can't retry ID data \n")); 8633 return; 8634 } 8635 if (tdAbortIORequestBody == agNULL) 8636 { 8637 /* let os process IO */ 8638 TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory returned NULL tdAbortIORequestBody; can't retry ID data\n")); 8639 return; 8640 } 8641 /* setup task management structure */ 8642 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 8643 /* setting callback but not used later */ 8644 tdAbortIORequestBody->IOCompletionFunc = agNULL; 8645 //tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler; 8646 tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle); 8647 /* initialize agIORequest */ 8648 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 8649 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 8650 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 8651 //#endif 8652 //#ifdef REMOVED 8653 status = saSATAAbort(agRoot, 8654 agAbortIORequest, 8655 0, 8656 oneDeviceData->agDevHandle, 8657 1, /* abort all */ 8658 agNULL, 8659 ossaSATAIDAbortCB 8660 ); 8661 status = saSATAAbort(agRoot, 8662 agAbortIORequest, 8663 0, 8664 oneDeviceData->agDevHandle, 8665 0, /* abort one */ 8666 agIORequest, 8667 ossaSATAIDAbortCB 8668 ); 8669 //#endif 8670 //#ifdef REMOVED 8671 if (status != AGSA_RC_SUCCESS) 8672 { 8673 TI_DBG1(("tdIDStartTimerCB: saSATAAbort failed; can't retry ID data\n")); 8674 } 8675 if (oneDeviceData->satDevData.IDDeviceValid == agTRUE) 8676 { 8677 TI_DBG1(("tdIDStartTimerCB: IDDeviceValid is valid, no need to retry\n")); 8678 return; 8679 } 8680 if (tdIORequestBody->reTries <= SM_RETRIES) 8681 { 8682 tdIORequestBody->tiIORequest = agNULL; /* not in use */ 8683 tdIORequestBody->pid = onePortContext->id; 8684 smIORequest->tdData = tdIORequestBody; 8685 smIORequest->smData = &tdIORequestBody->smIORequestBody; 8686 smDeviceHandle->tdData = oneDeviceData; 8687 IDstatus = smIDStart(smRoot, smIORequest, smDeviceHandle ); 8688 if (IDstatus == SM_RC_SUCCESS) 8689 { 8690 TI_DBG1(("tdIDStartTimerCB: being retried!!!\n")); 8691 tdIORequestBody->reTries++; 8692 tdIORequestBody->ioCompleted = agFALSE; 8693 tdIORequestBody->ioStarted = agTRUE; 8694 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData); 8695 } 8696 else 8697 { 8698 /* identify device data is not valid */ 8699 TI_DBG1(("tdIDStartTimerCB: smIDStart fail or busy %d!!!\n", IDstatus)); 8700 tdIORequestBody->reTries = 0; 8701 tdIORequestBody->ioCompleted = agTRUE; 8702 tdIORequestBody->ioStarted = agFALSE; 8703 ostiFreeMemory( tiRoot, 8704 tdIORequestBody->osMemHandle, 8705 sizeof(tdIORequestBody_t) 8706 ); 8707 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 8708 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext); 8709 return; 8710 } 8711 } 8712 else 8713 { 8714 /* give up */ 8715 TI_DBG1(("tdIDStartTimerCB: retries are over!!!\n")); 8716 if (oneDeviceData->tdIDTimer.timerRunning == agTRUE) 8717 { 8718 tdsaKillTimer( tiRoot, &oneDeviceData->tdIDTimer ); 8719 } 8720 tdIORequestBody->reTries = 0; 8721 tdIORequestBody->ioCompleted = agTRUE; 8722 tdIORequestBody->ioStarted = agFALSE; 8723 ostiFreeMemory( 8724 tiRoot, 8725 tdIORequestBody->osMemHandle, 8726 sizeof(tdIORequestBody_t) 8727 ); 8728 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 8729 8730 if (oneDeviceData->SMNumOfID <= 0) /* does SMP HARD RESET only upto one time */ 8731 { 8732 TI_DBG1(("tdIDStartTimerCB: fail; sending HARD_RESET\n")); 8733 oneDeviceData->SMNumOfID++; 8734 if (oneDeviceData->directlyAttached == agTRUE) 8735 { 8736 saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL); 8737 } 8738 else 8739 { 8740 tdsaPhyControlSend(tiRoot, 8741 oneDeviceData, 8742 SMP_PHY_CONTROL_HARD_RESET, 8743 agNULL); 8744 } 8745 } 8746 else 8747 { 8748 /* given up after one time of SMP HARD RESET; */ 8749 TI_DBG1(("tdIDStartTimerCB: fail; but giving up sending HARD_RESET!!!\n")); 8750 if (oneDeviceData->directlyAttached == agTRUE) 8751 { 8752 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData); 8753 } 8754 else 8755 { 8756 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext); 8757 } 8758 } 8759 } 8760 #endif // REMOVED 8761 8762 TI_DBG1(("tdIDStartTimerCB: end, smIOAbort status %d\n", status)); 8763 return; 8764 } 8765 #endif // FDS_SM 8766 8767 8768 #if defined(FDS_DM) && defined(FDS_SM) 8769 //start here 8770 GLOBAL void 8771 tdIDStart( 8772 tiRoot_t *tiRoot, 8773 agsaRoot_t *agRoot, 8774 smRoot_t *smRoot, 8775 tdsaDeviceData_t *oneDeviceData, 8776 tdsaPortContext_t *onePortContext 8777 ) 8778 { 8779 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8780 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8781 bit32 SMstatus = SM_RC_FAILURE; 8782 tdIORequestBody_t *tdIORequestBody; 8783 smIORequest_t *smIORequest; 8784 smDeviceHandle_t *smDeviceHandle; 8785 bit32 PhysUpper32; 8786 bit32 PhysLower32; 8787 bit32 memAllocStatus; 8788 void *osMemHandle; 8789 8790 8791 TI_DBG1(("tdIDStart: start, did %d\n",oneDeviceData->id)); 8792 8793 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData)|| DEVICE_IS_STP_TARGET(oneDeviceData)) 8794 && 8795 oneDeviceData->satDevData.IDDeviceValid == agFALSE 8796 && 8797 oneDeviceData->satDevData.IDPending == agFALSE 8798 ) 8799 { 8800 TI_DBG2(("tdIDStart: in loop, did %d\n", oneDeviceData->id)); 8801 /* allocating tdIORequestBody */ 8802 memAllocStatus = ostiAllocMemory( 8803 tiRoot, 8804 &osMemHandle, 8805 (void **)&tdIORequestBody, 8806 &PhysUpper32, 8807 &PhysLower32, 8808 8, 8809 sizeof(tdIORequestBody_t), 8810 agTRUE 8811 ); 8812 if (memAllocStatus != tiSuccess || tdIORequestBody == agNULL) 8813 { 8814 /* let os process IO */ 8815 TI_DBG1(("tdIDStart: ostiAllocMemory failed... or ostiAllocMemory returned NULL tdIORequestBody!!!\n")); 8816 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 8817 if (oneDeviceData->directlyAttached == agTRUE) 8818 { 8819 /* notifying link up */ 8820 ostiPortEvent( 8821 tiRoot, 8822 tiPortLinkUp, 8823 tiSuccess, 8824 (void *)onePortContext->tiPortalContext 8825 ); 8826 #ifdef INITIATOR_DRIVER 8827 /* triggers discovery */ 8828 ostiPortEvent( 8829 tiRoot, 8830 tiPortDiscoveryReady, 8831 tiSuccess, 8832 (void *) onePortContext->tiPortalContext 8833 ); 8834 #endif 8835 } 8836 } 8837 else 8838 { 8839 /* initialize */ 8840 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t)); 8841 8842 tdIORequestBody->osMemHandle = osMemHandle; 8843 TI_DBG2(("tdIDStart: tdIORequestBody %p tdIORequestBody->osMemHandle %p\n", tdIORequestBody, tdIORequestBody->osMemHandle)); 8844 8845 /* not in use */ 8846 tdIORequestBody->IOCompletionFunc = agNULL; 8847 tdIORequestBody->tiDevHandle = agNULL; 8848 8849 tdIORequestBody->tiIORequest = agNULL; /* not in use */ 8850 tdIORequestBody->pid = onePortContext->id; 8851 tdIORequestBody->reTries = 0; 8852 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest); 8853 smIORequest->tdData = tdIORequestBody; 8854 smIORequest->smData = &tdIORequestBody->smIORequestBody; 8855 8856 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle); 8857 smDeviceHandle->tdData = oneDeviceData; 8858 8859 TI_DBG2(("tdIDStart: smIORequest %p\n", smIORequest)); 8860 8861 SMstatus = smIDStart(smRoot, 8862 smIORequest, 8863 &(oneDeviceData->smDeviceHandle) 8864 ); 8865 8866 if (SMstatus == SM_RC_SUCCESS) 8867 { 8868 if (oneDeviceData->directlyAttached == agTRUE) 8869 { 8870 TI_DBG2(("tdIDStart: successfully sent identify device data\n")); 8871 8872 /* Add the devicedata to the mainlink */ 8873 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 8874 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList)); 8875 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 8876 TI_DBG6(("tdIDStart: one case did %d \n", oneDeviceData->id)); 8877 } 8878 oneDeviceData->satDevData.IDPending = agTRUE; 8879 /* start a timer */ 8880 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData); 8881 } 8882 else 8883 { 8884 /* failed to send */ 8885 TI_DBG1(("tdIDStart: smIDStart fail or busy %d\n", SMstatus)); 8886 8887 /* free up allocated memory */ 8888 ostiFreeMemory( 8889 tiRoot, 8890 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 8891 sizeof(tdIORequestBody_t) 8892 ); 8893 8894 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 8895 if (oneDeviceData->directlyAttached == agTRUE) 8896 { 8897 TI_DBG1(("tdIDStart: failed in sending identify device data\n")); 8898 /* put onedevicedata back to free list */ 8899 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 8900 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 8901 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 8902 /* notifying link up */ 8903 ostiPortEvent( 8904 tiRoot, 8905 tiPortLinkUp, 8906 tiSuccess, 8907 (void *)onePortContext->tiPortalContext 8908 ); 8909 #ifdef INITIATOR_DRIVER 8910 /* triggers discovery */ 8911 ostiPortEvent( 8912 tiRoot, 8913 tiPortDiscoveryReady, 8914 tiSuccess, 8915 (void *) onePortContext->tiPortalContext 8916 ); 8917 #endif 8918 } 8919 else 8920 { 8921 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext); 8922 } 8923 } 8924 } 8925 } 8926 TI_DBG1(("tdIDStart: exit\n")); 8927 return; 8928 } 8929 8930 #endif 8931 8932 #ifdef SALLSDK_OS_IOMB_LOG_ENABLE 8933 GLOBAL void ossaLogIomb(agsaRoot_t *agRoot, 8934 bit32 queueNum, 8935 agBOOLEAN isInbound, 8936 void *pMsg, 8937 bit32 msgLength) 8938 { 8939 return; 8940 } 8941 #endif /* SALLSDK_OS_IOMB_LOG_ENABLE */ 8942 8943 #ifndef SATA_ENABLE 8944 /* 8945 * These callback routines are defined in ossasat.c which are included in the 8946 * compilation if SATA_ENABLED is defined. 8947 */ 8948 8949 /***************************************************************************** 8950 *! \brief ossaDiscoverSataCB 8951 * 8952 * Purpose: This function is called by lower layer to inform TD layer of 8953 * STP/SATA discovery results 8954 * 8955 * 8956 * \param agRoot Pointer to chip/driver Instance. 8957 * \param agPortContext Pointer to the port context of TD and Lower layer 8958 * \param event event type 8959 * \param pParm1 Pointer to data associated with event 8960 * \param pParm2 Pointer to data associated with event 8961 * 8962 * \return: none 8963 * 8964 * \note - For details, refer to SAS/SATA Low-Level API Specification 8965 * 8966 *****************************************************************************/ 8967 8968 osGLOBAL void ossaDiscoverSataCB( agsaRoot_t *agRoot, 8969 agsaPortContext_t *agPortContext, 8970 bit32 event, 8971 void *pParm1, 8972 void *pParm2 8973 ) 8974 { 8975 return; 8976 } 8977 8978 8979 /***************************************************************************** 8980 *! \brief ossaSATACompleted 8981 * 8982 * This routine is called to complete a SATA request previously issued to the 8983 * LL Layer in saSATAStart() 8984 * 8985 * \param agRoot: Handles for this instance of SAS/SATA hardware 8986 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 8987 * \param agIOStatus: Status of completed I/O. 8988 * \param agFirstDword:Pointer to the four bytes of FIS. 8989 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 8990 * length. 8991 * \param agParam: Additional info based on status. 8992 * 8993 * \return: none 8994 * 8995 *****************************************************************************/ 8996 GLOBAL void ossaSATACompleted( 8997 agsaRoot_t *agRoot, 8998 agsaIORequest_t *agIORequest, 8999 bit32 agIOStatus, 9000 void *agFirstDword, 9001 bit32 agIOInfoLen, 9002 void *agParam 9003 ) 9004 { 9005 return; 9006 } 9007 9008 9009 /***************************************************************************** 9010 *! \brief ossaSATAEvent 9011 * 9012 * This routine is called to notify the OS Layer of an event associated with 9013 * SATA port or SATA device 9014 * 9015 * \param agRoot: Handles for this instance of SAS/SATA hardware 9016 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 9017 * \param agPortContext Pointer to the port context of TD and Lower layer 9018 * \param agDevHandle: Pointer to a device handle 9019 * \param event: event type 9020 * 9021 * \return: none 9022 * 9023 *****************************************************************************/ 9024 osGLOBAL void ossaSATAEvent( 9025 agsaRoot_t *agRoot, 9026 agsaIORequest_t *agIORequest, 9027 agsaPortContext_t *agPortContext, 9028 agsaDevHandle_t *agDevHandle, 9029 bit32 event, 9030 bit32 agIOInfoLen, 9031 void *agParam 9032 ) 9033 { 9034 return; 9035 } 9036 9037 9038 /***************************************************************************** 9039 *! \brief ossaSATADeviceResetCB 9040 * 9041 * This routine is called to complete a SATA device reset request previously 9042 * issued to the LL Layer in saSATADeviceReset(). 9043 * 9044 * \param agRoot: Handles for this instance of SAS/SATA hardware 9045 * \param agDevHandle: Pointer to a device handle 9046 * \param resetStatus: Reset status: 9047 * OSSA_SUCCESS: The reset operation completed successfully. 9048 * OSSA_FAILURE: The reset operation failed. 9049 * \param resetparm: Pointer to the Device-To-Host FIS received from the device. 9050 * 9051 * \return: none 9052 * 9053 *****************************************************************************/ 9054 osGLOBAL void ossaSATADeviceResetCB( 9055 agsaRoot_t *agRoot, 9056 agsaDevHandle_t *agDevHandle, 9057 bit32 resetStatus, 9058 void *resetparm) 9059 { 9060 9061 return; 9062 9063 } 9064 9065 /***************************************************************************** 9066 *! \brief ossaDiscoverSasCB 9067 * 9068 * Purpose: This function is called by lower layer to inform TD layer of 9069 * SAS discovery results 9070 * 9071 * 9072 * \param agRoot Pointer to chip/driver Instance. 9073 * \param agPortContext Pointer to the port context of TD and Lower layer 9074 * \param event event type 9075 * \param pParm1 Pointer to data associated with event 9076 * \param pParm2 Pointer to data associated with event 9077 * 9078 * \return: none 9079 * 9080 * \note - For details, refer to SAS/SATA Low-Level API Specification 9081 * 9082 *****************************************************************************/ 9083 osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot, 9084 agsaPortContext_t *agPortContext, 9085 bit32 event, 9086 void *pParm1, 9087 void *pParm2 9088 ) 9089 { 9090 return; 9091 } 9092 #endif 9093 9094