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 #include <sys/cdefs.h> 23 __FBSDID("$FreeBSD$"); 24 #include <dev/pms/config.h> 25 26 #include <dev/pms/freebsd/driver/common/osenv.h> 27 #include <dev/pms/freebsd/driver/common/ostypes.h> 28 #include <dev/pms/freebsd/driver/common/osdebug.h> 29 30 #include <dev/pms/RefTisa/tisa/api/titypes.h> 31 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 32 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 33 /* for TIDEBUG_MSG */ 34 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 35 36 #ifdef FDS_DM 37 38 #include <dev/pms/RefTisa/discovery/api/dm.h> 39 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 40 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 41 42 #ifdef FDS_SM 43 #include <dev/pms/RefTisa/sat/api/sm.h> 44 #include <dev/pms/RefTisa/sat/api/smapi.h> 45 #endif 46 47 #ifdef INITIATOR_DRIVER 48 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 49 #endif 50 51 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 52 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 53 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 54 55 #if defined(DM_DEBUG) 56 extern bit32 gDMDebugLevel; 57 #endif 58 59 osGLOBAL bit32 60 tddmRotateQnumber( 61 dmRoot_t *dmRoot, 62 agsaDevHandle_t *agDevHandle 63 ) 64 { 65 tdsaRoot_t *tdsaRoot; 66 tdsaContext_t *tdsaAllShared; 67 tiRoot_t *tiRoot; 68 tdsaDeviceData_t *oneDeviceData = agNULL; 69 TI_DBG1(("tddmRotateQnumber: start\n")); 70 if (agDevHandle == agNULL) 71 { 72 TI_DBG1(("tddmRotateQnumber: agDevHandle is NULL!!!\n")); 73 return 0; 74 } 75 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData; 76 if (oneDeviceData == agNULL) 77 { 78 TI_DBG1(("tddmRotateQnumber: oneDeviceData is NULL!!!\n")); 79 return 0; 80 } 81 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 82 if (tdsaRoot == agNULL) 83 { 84 TI_DBG1(("tddmRotateQnumber: tdsaRoot is NULL\n")); 85 return 0; 86 } 87 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 88 if (tdsaAllShared == agNULL) 89 { 90 TI_DBG1(("tddmRotateQnumber: tdsaAllShared is NULL\n")); 91 return 0; 92 } 93 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 94 if (tiRoot == agNULL) 95 { 96 TI_DBG1(("tddmRotateQnumber: tiRoot is NULL\n")); 97 return 0; 98 } 99 return tdsaRotateQnumber(tiRoot, oneDeviceData); 100 } 101 osGLOBAL bit32 102 tdsaFindLocalMCN( 103 tiRoot_t *tiRoot, 104 tdsaPortContext_t *onePortContext 105 ) 106 { 107 bit32 i, localMCN = 0; 108 109 TI_DBG2(("tdsaFindLocalMCN: start\n")); 110 111 if (onePortContext->valid == agFALSE) 112 { 113 TI_DBG1(("tdsaFindLocalMCN: invalid portcontext id %d\n", onePortContext->id)); 114 return 0; 115 } 116 117 for(i=0;i<TD_MAX_NUM_PHYS;i++) 118 { 119 if (onePortContext->PhyIDList[i] == agTRUE) 120 { 121 localMCN++; 122 } 123 } 124 125 return localMCN; 126 } 127 128 129 /* 130 on success, 131 ostiInitiatorEvent( 132 tiRoot, 133 onePortContext->tiPortalContext, 134 agNULL, 135 tiIntrEventTypeDiscovery, 136 tiDiscOK, 137 agNULL 138 ); 139 else 140 remove(de-register) all devices 141 ostiInitiatorEvent( 142 tiRoot, 143 onePortContext->tiPortalContext, 144 agNULL, 145 tiIntrEventTypeDiscovery, 146 tiDiscFailed, 147 agNULL 148 ); 149 150 151 dmRoot->tdData is tdsaRoot_t (just like current TD layer) 152 dmPortContext->tdData is tdsaPortContext_t 153 154 */ 155 osGLOBAL void 156 tddmDiscoverCB( 157 dmRoot_t *dmRoot, 158 dmPortContext_t *dmPortContext, 159 bit32 eventStatus 160 ) 161 { 162 tdsaRoot_t *tdsaRoot; 163 tdsaContext_t *tdsaAllShared; 164 tiRoot_t *tiRoot; 165 tdsaPortContext_t *onePortContext; 166 agsaRoot_t *agRoot; 167 agsaPortContext_t *agPortContext; 168 169 TI_DBG1(("tddmDiscoverCB: start\n")); 170 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 171 if (tdsaRoot == agNULL) 172 { 173 TI_DBG1(("tddmDiscoverCB: tdsaRoot is NULL\n")); 174 return; 175 } 176 177 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 178 if (tdsaAllShared == agNULL) 179 { 180 TI_DBG1(("tddmDiscoverCB: tdsaAllShared is NULL\n")); 181 return; 182 } 183 184 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 185 if (tiRoot == agNULL) 186 { 187 TI_DBG1(("tddmDiscoverCB: tiRoot is NULL\n")); 188 return; 189 } 190 191 onePortContext = (tdsaPortContext_t *)dmPortContext->tdData; 192 if (onePortContext == agNULL) 193 { 194 TI_DBG1(("tddmDiscoverCB: onePortContext is NULL\n")); 195 return; 196 } 197 198 TI_DBG2(("tddmDiscoverCB: localMCN 0x%x\n", tdsaFindLocalMCN(tiRoot, onePortContext))); 199 200 if (eventStatus == dmDiscCompleted) 201 { 202 TI_DBG1(("tddmDiscoverCB: dmDiscCompleted\n")); 203 onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED; 204 onePortContext->DMDiscoveryState = dmDiscCompleted; 205 TI_DBG1(("tddmDiscoverCB: pid %d tiPortalContext %p\n", onePortContext->id, onePortContext->tiPortalContext)); 206 207 /* update onePortContext->UpdateMCN = agFALSE */ 208 if ( onePortContext->UpdateMCN == agTRUE) 209 { 210 TI_DBG2(("tddmDiscoverCB: calling tdsaUpdateMCN\n")); 211 onePortContext->UpdateMCN = agFALSE; 212 tdsaUpdateMCN(dmRoot, onePortContext); 213 } 214 215 ostiInitiatorEvent( 216 tiRoot, 217 onePortContext->tiPortalContext, 218 agNULL, 219 tiIntrEventTypeDiscovery, 220 tiDiscOK, 221 agNULL 222 ); 223 } 224 else if (eventStatus == dmDiscFailed ) 225 { 226 TI_DBG1(("tddmDiscoverCB: dmDiscFailed \n")); 227 onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED; 228 onePortContext->DMDiscoveryState = dmDiscFailed; 229 TI_DBG1(("tddmDiscoverCB: pid %d tiPortalContext %p\n", onePortContext->id, onePortContext->tiPortalContext)); 230 agRoot = &(tdsaAllShared->agRootNonInt); 231 if (agRoot == agNULL) 232 { 233 TI_DBG1(("tddmDiscoverCB: agRoot is NULL\n")); 234 return; 235 } 236 agPortContext = onePortContext->agPortContext; 237 if (agPortContext == agNULL) 238 { 239 TI_DBG1(("tddmDiscoverCB: agPortContext is NULL\n")); 240 return; 241 } 242 /* 243 invalidate all devices in this port 244 */ 245 tddmInvalidateDevicesInPort(tiRoot, onePortContext); 246 247 saPortControl(agRoot, 248 agNULL, 249 0, 250 agPortContext, 251 AGSA_PORT_IO_ABORT, 252 0 /*quarantine */, 253 0 /* unused */); 254 255 256 ostiInitiatorEvent( 257 tiRoot, 258 onePortContext->tiPortalContext, 259 agNULL, 260 tiIntrEventTypeDiscovery, 261 tiDiscFailed, 262 agNULL 263 ); 264 } 265 else if (eventStatus == dmDiscAborted ) 266 { 267 TI_DBG1(("tddmDiscoverCB: dmDiscAborted \n")); 268 onePortContext->DMDiscoveryState = dmDiscAborted; 269 } 270 else if (eventStatus == dmDiscAbortFailed ) 271 { 272 TI_DBG1(("tddmDiscoverCB: dmDiscAbortFailed \n")); 273 onePortContext->DMDiscoveryState = dmDiscAbortFailed; 274 } 275 else if (eventStatus == dmDiscAbortInvalid ) 276 { 277 TI_DBG1(("tddmDiscoverCB: dmDiscAbortInvalid \n")); 278 onePortContext->DMDiscoveryState = dmDiscAbortInvalid; 279 } 280 else if (eventStatus == dmDiscAbortInProgress ) 281 { 282 TI_DBG1(("tddmDiscoverCB: dmDiscAbortInProgress \n")); 283 onePortContext->DMDiscoveryState = dmDiscAbortInProgress; 284 } 285 else 286 { 287 TI_DBG1(("tddmDiscoverCB: undefined eventStatus 0x%x\n", eventStatus)); 288 onePortContext->DMDiscoveryState = dmDiscFailed; 289 } 290 291 return; 292 } 293 294 295 osGLOBAL void 296 tddmQueryDiscoveryCB( 297 dmRoot_t *dmRoot, 298 dmPortContext_t *dmPortContext, 299 bit32 discType, 300 bit32 discState 301 ) 302 { 303 tdsaPortContext_t *onePortContext = agNULL; 304 305 TI_DBG2(("tddmQueryDiscoveryCB: start\n")); 306 onePortContext = (tdsaPortContext_t *)dmPortContext->tdData; 307 if (onePortContext == agNULL) 308 { 309 TI_DBG1(("tddmQueryDiscoveryCB: onePortContext is NULL\n")); 310 return; 311 } 312 TI_DBG2(("tddmQueryDiscoveryCB: discType %d discState %d\n", discType, discState)); 313 314 onePortContext->DMDiscoveryState = discState; 315 return; 316 } 317 318 osGLOBAL void 319 tddmInvalidateDevicesInPort( 320 tiRoot_t *tiRoot, 321 tdsaPortContext_t *onePortContext 322 ) 323 { 324 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 325 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 326 tdsaDeviceData_t *oneDeviceData = agNULL; 327 tdList_t *DeviceListList; 328 329 TI_DBG1(("tddmInvalidateDevicesInPort: start\n")); 330 331 /* find a device's existence */ 332 DeviceListList = tdsaAllShared->MainDeviceList.flink; 333 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 334 { 335 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 336 if (oneDeviceData == agNULL) 337 { 338 TI_DBG1(("tddmInvalidateDevicesInPort: oneDeviceData is NULL!!!\n")); 339 return; 340 } 341 if ((oneDeviceData->registered == agTRUE) && 342 (oneDeviceData->tdPortContext == onePortContext) 343 ) 344 { 345 346 TI_DBG3(("tddmInvalidateDevicesInPort: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id)); 347 if (oneDeviceData->SASAddressID.sasAddressHi == onePortContext->sasRemoteAddressHi && 348 oneDeviceData->SASAddressID.sasAddressLo == onePortContext->sasRemoteAddressLo 349 ) 350 { 351 TI_DBG1(("tddmInvalidateDevicesInPort: keeping\n")); 352 oneDeviceData->valid = agTRUE; 353 oneDeviceData->valid2 = agFALSE; 354 } 355 else if (oneDeviceData->valid == agTRUE) 356 { 357 oneDeviceData->valid = agFALSE; 358 oneDeviceData->valid2 = agFALSE; 359 oneDeviceData->registered = agFALSE; 360 } 361 } 362 DeviceListList = DeviceListList->flink; 363 } 364 365 TI_DBG3(("tddmInvalidateDevicesInPort: end\n")); 366 367 return; 368 } 369 370 osGLOBAL bit32 371 tddmNewSASorNot( 372 tiRoot_t *tiRoot, 373 tdsaPortContext_t *onePortContext, 374 tdsaSASSubID_t *agSASSubID 375 ) 376 { 377 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 378 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 379 tdsaDeviceData_t *oneDeviceData = agNULL; 380 tdList_t *DeviceListList; 381 bit32 ret = agTRUE; 382 383 TI_DBG3(("tddmNewSASorNot: start\n")); 384 385 /* find a device's existence */ 386 DeviceListList = tdsaAllShared->MainDeviceList.flink; 387 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 388 { 389 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 390 if (oneDeviceData == agNULL) 391 { 392 TI_DBG1(("tddmNewSASorNot: oneDeviceData is NULL!!!\n")); 393 return agFALSE; 394 } 395 if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) && 396 (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) && 397 (oneDeviceData->registered == agTRUE) && 398 (oneDeviceData->tdPortContext == onePortContext) 399 ) 400 { 401 TI_DBG3(("tddmNewSASorNot: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id)); 402 ret = agFALSE; 403 break; 404 } 405 DeviceListList = DeviceListList->flink; 406 } 407 408 409 410 TI_DBG3(("tddmNewSASorNot: end\n")); 411 412 return ret; 413 } 414 415 osGLOBAL tdsaDeviceData_t * 416 tddmPortSASDeviceFind( 417 tiRoot_t *tiRoot, 418 tdsaPortContext_t *onePortContext, 419 bit32 sasAddrLo, 420 bit32 sasAddrHi 421 ) 422 { 423 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 424 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 425 tdsaDeviceData_t *oneDeviceData, *RetDeviceData=agNULL; 426 tdList_t *DeviceListList; 427 428 TI_DBG2(("tddmPortSASDeviceFind: start\n")); 429 430 TD_ASSERT((agNULL != tiRoot), ""); 431 TD_ASSERT((agNULL != onePortContext), ""); 432 433 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 434 435 /* find a device's existence */ 436 DeviceListList = tdsaAllShared->MainDeviceList.flink; 437 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 438 { 439 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 440 if (oneDeviceData == agNULL) 441 { 442 TI_DBG1(("tddmPortSASDeviceFind: oneDeviceData is NULL!!!\n")); 443 return agNULL; 444 } 445 if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) && 446 (oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) && 447 (oneDeviceData->valid == agTRUE) && 448 (oneDeviceData->tdPortContext == onePortContext) 449 ) 450 { 451 TI_DBG2(("tddmPortSASDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id)); 452 TI_DBG2(("tddmPortSASDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi)); 453 TI_DBG2(("tddmPortSASDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo)); 454 RetDeviceData = oneDeviceData; 455 break; 456 } 457 DeviceListList = DeviceListList->flink; 458 } 459 460 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 461 462 return RetDeviceData; 463 } 464 465 /* not in use yet */ 466 osGLOBAL tdsaDeviceData_t * 467 tddmAddToSharedcontext( 468 agsaRoot_t *agRoot, 469 tdsaPortContext_t *onePortContext, 470 tdsaSASSubID_t *agSASSubID, 471 tdsaDeviceData_t *oneExpDeviceData, 472 bit8 phyID 473 ) 474 { 475 tdsaDeviceData_t *oneDeviceData = agNULL; 476 tdList_t *DeviceListList; 477 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 478 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 479 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 480 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 481 bit32 new_device = agTRUE; 482 483 TI_DBG1(("tddmAddToSharedcontext: start\n")); 484 485 TI_DBG1(("tddmAddToSharedcontext: oneportContext ID %d\n", onePortContext->id)); 486 /* find a device's existence */ 487 DeviceListList = tdsaAllShared->MainDeviceList.flink; 488 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 489 { 490 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 491 if (oneDeviceData == agNULL) 492 { 493 TI_DBG1(("tddmAddToSharedcontext: oneDeviceData is NULL!!!\n")); 494 return agNULL; 495 } 496 if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) && 497 (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) && 498 (oneDeviceData->tdPortContext == onePortContext) 499 ) 500 { 501 TI_DBG1(("tddmAddToSharedcontext: pid %dtddmAddToSharedcontext did %d\n", onePortContext->id, oneDeviceData->id)); 502 new_device = agFALSE; 503 break; 504 } 505 DeviceListList = DeviceListList->flink; 506 } 507 508 /* new device */ 509 if (new_device == agTRUE) 510 { 511 TI_DBG1(("tddmAddToSharedcontext: new device\n")); 512 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 513 if (!TDLIST_NOT_EMPTY(&(tdsaAllShared->FreeDeviceList))) 514 { 515 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 516 TI_DBG1(("tddmAddToSharedcontext: empty DeviceData FreeLink\n")); 517 return agNULL; 518 } 519 520 TDLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(tdsaAllShared->FreeDeviceList)); 521 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 522 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, DeviceListList); 523 524 TI_DBG1(("tddmAddToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id)); 525 526 onePortContext->Count++; 527 oneDeviceData->agRoot = agRoot; 528 /* saving sas address */ 529 oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo; 530 oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi; 531 oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp; 532 oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp; 533 oneDeviceData->tdPortContext = onePortContext; 534 /* handles both SAS target and STP-target, SATA-device */ 535 if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData)) 536 { 537 oneDeviceData->DeviceType = TD_SAS_DEVICE; 538 } 539 else 540 { 541 oneDeviceData->DeviceType = TD_SATA_DEVICE; 542 } 543 544 oneDeviceData->ExpDevice = oneExpDeviceData; 545 /* set phyID only when it has initial value of 0xFF */ 546 if (oneDeviceData->phyID == 0xFF) 547 { 548 oneDeviceData->phyID = phyID; 549 } 550 551 oneDeviceData->valid = agTRUE; 552 553 /* add the devicedata to the portcontext */ 554 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 555 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList)); 556 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 557 TI_DBG1(("tddmAddToSharedcontext: one case pid %d did %d \n", onePortContext->id, oneDeviceData->id)); 558 TI_DBG1(("tddmAddToSharedcontext: new case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID)); 559 } 560 else /* old device */ 561 { 562 TI_DBG1(("tddmAddToSharedcontext: old device\n")); 563 TI_DBG1(("tddmAddToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id)); 564 565 oneDeviceData->agRoot = agRoot; 566 /* saving sas address */ 567 oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo; 568 oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi; 569 oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp; 570 oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp; 571 oneDeviceData->tdPortContext = onePortContext; 572 /* handles both SAS target and STP-target, SATA-device */ 573 if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData)) 574 { 575 oneDeviceData->DeviceType = TD_SAS_DEVICE; 576 } 577 else 578 { 579 oneDeviceData->DeviceType = TD_SATA_DEVICE; 580 } 581 582 oneDeviceData->ExpDevice = oneExpDeviceData; 583 /* set phyID only when it has initial value of 0xFF */ 584 if (oneDeviceData->phyID == 0xFF) 585 { 586 oneDeviceData->phyID = phyID; 587 } 588 589 oneDeviceData->valid = agTRUE; 590 TI_DBG1(("tddmAddToSharedcontext: old case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID)); 591 592 } 593 return oneDeviceData; 594 595 } 596 597 598 /* 599 calls saRegisterNewDevice() 600 in ossaDeviceRegistrationCB(), if an expander, register to DM 601 #define DEVICE_IS_SMP_TARGET(DeviceData) \ 602 (((DeviceData)->target_ssp_stp_smp & DEVICE_SMP_BIT) == DEVICE_SMP_BIT) 603 */ 604 osGLOBAL tdsaDeviceData_t * 605 tddmPortDeviceAdd( 606 tiRoot_t *tiRoot, 607 tdsaPortContext_t *onePortContext, 608 dmDeviceInfo_t *dmDeviceInfo, 609 tdsaDeviceData_t *oneExpDeviceData 610 ) 611 { 612 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 613 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 614 tdsaDeviceData_t *oneDeviceData = agNULL; 615 tdsaSASSubID_t agSASSubID; 616 bit8 phyID; 617 618 TI_DBG2(("tddmPortDeviceAdd: start\n")); 619 620 621 agSASSubID.sasAddressHi = TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi); 622 agSASSubID.sasAddressLo = TD_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo); 623 agSASSubID.initiator_ssp_stp_smp = dmDeviceInfo->initiator_ssp_stp_smp; 624 agSASSubID.target_ssp_stp_smp = dmDeviceInfo->target_ssp_stp_smp; 625 phyID = (dmDeviceInfo->ext) & 0xFF; 626 627 /* old device and already registered to LL; added by link-up event */ 628 if ( agFALSE == tdssNewSASorNot( 629 onePortContext->agRoot, 630 onePortContext, 631 &agSASSubID 632 ) 633 ) 634 { 635 /* old device and already registered to LL; added by link-up event */ 636 TI_DBG2(("tddmPortDeviceAdd: OLD qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", agSASSubID.initiator_ssp_stp_smp, agSASSubID.target_ssp_stp_smp)); 637 /* find the old device */ 638 oneDeviceData = tdssNewAddSASToSharedcontext( 639 onePortContext->agRoot, 640 onePortContext, 641 &agSASSubID, 642 oneExpDeviceData, 643 phyID 644 ); 645 646 if (oneDeviceData == agNULL) 647 { 648 TI_DBG1(("tddmPortDeviceAdd: no more device!!! oneDeviceData is null\n")); 649 } 650 651 /* If a device is allocated */ 652 if ( oneDeviceData != agNULL ) 653 { 654 655 TI_DBG2(("tddmPortDeviceAdd: sasAddressHi 0x%08x\n", agSASSubID.sasAddressHi)); 656 TI_DBG2(("tddmPortDeviceAdd: sasAddressLo 0x%08x\n", agSASSubID.sasAddressLo)); 657 TI_DBG2(("tddmPortDeviceAdd: phyID 0x%x\n", phyID)); 658 659 /* copy dmDeviceInfo to oneDeviceData->agDeviceInfo except ext field */ 660 oneDeviceData->agDeviceInfo.smpTimeout = dmDeviceInfo->smpTimeout; 661 oneDeviceData->agDeviceInfo.it_NexusTimeout = dmDeviceInfo->it_NexusTimeout; 662 oneDeviceData->agDeviceInfo.firstBurstSize = dmDeviceInfo->firstBurstSize; 663 oneDeviceData->agDeviceInfo.devType_S_Rate = dmDeviceInfo->devType_S_Rate; 664 osti_memcpy(&(oneDeviceData->agDeviceInfo.sasAddressHi), &(dmDeviceInfo->sasAddressHi), 4); 665 osti_memcpy(&(oneDeviceData->agDeviceInfo.sasAddressLo), &(dmDeviceInfo->sasAddressLo), 4); 666 if (dmDeviceInfo->sataDeviceType == SATA_ATAPI_DEVICE) 667 { 668 oneDeviceData->agDeviceInfo.flag |= ATAPI_DEVICE_FLAG; 669 } 670 671 oneDeviceData->satDevData.satDeviceType = dmDeviceInfo->sataDeviceType; 672 673 674 675 oneDeviceData->agContext.osData = oneDeviceData; 676 oneDeviceData->agContext.sdkData = agNULL; 677 678 } 679 return oneDeviceData; 680 } /* old device */ 681 682 /* new device */ 683 684 TI_DBG2(("tddmPortDeviceAdd: NEW qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", agSASSubID.initiator_ssp_stp_smp, agSASSubID.target_ssp_stp_smp)); 685 686 /* allocate a new device and set the valid bit */ 687 oneDeviceData = tdssNewAddSASToSharedcontext( 688 onePortContext->agRoot, 689 onePortContext, 690 &agSASSubID, 691 oneExpDeviceData, 692 phyID 693 ); 694 695 if (oneDeviceData == agNULL) 696 { 697 TI_DBG1(("tddmPortDeviceAdd: no more device!!! oneDeviceData is null\n")); 698 } 699 700 /* If a device is allocated */ 701 if ( oneDeviceData != agNULL ) 702 { 703 704 TI_DBG2(("tddmPortDeviceAdd: sasAddressHi 0x%08x\n", agSASSubID.sasAddressHi)); 705 TI_DBG2(("tddmPortDeviceAdd: sasAddressLo 0x%08x\n", agSASSubID.sasAddressLo)); 706 TI_DBG2(("tddmPortDeviceAdd: phyID 0x%x\n", phyID)); 707 708 /* copy dmDeviceInfo to oneDeviceData->agDeviceInfo except ext field */ 709 oneDeviceData->agDeviceInfo.smpTimeout = dmDeviceInfo->smpTimeout; 710 oneDeviceData->agDeviceInfo.it_NexusTimeout = dmDeviceInfo->it_NexusTimeout; 711 oneDeviceData->agDeviceInfo.firstBurstSize = dmDeviceInfo->firstBurstSize; 712 oneDeviceData->agDeviceInfo.devType_S_Rate = dmDeviceInfo->devType_S_Rate; 713 osti_memcpy(&(oneDeviceData->agDeviceInfo.sasAddressHi), &(dmDeviceInfo->sasAddressHi), 4); 714 osti_memcpy(&(oneDeviceData->agDeviceInfo.sasAddressLo), &(dmDeviceInfo->sasAddressLo), 4); 715 716 oneDeviceData->satDevData.satDeviceType = dmDeviceInfo->sataDeviceType; 717 if (dmDeviceInfo->sataDeviceType == SATA_ATAPI_DEVICE) 718 { 719 oneDeviceData->agDeviceInfo.flag |= ATAPI_DEVICE_FLAG; 720 } 721 722 oneDeviceData->agContext.osData = oneDeviceData; 723 oneDeviceData->agContext.sdkData = agNULL; 724 725 TI_DBG2(("tddmPortDeviceAdd: did %d\n", oneDeviceData->id)); 726 727 /* don't add and register initiator for T2D */ 728 if ( (((oneDeviceData->initiator_ssp_stp_smp & DEVICE_SSP_BIT) == DEVICE_SSP_BIT) && 729 ((oneDeviceData->target_ssp_stp_smp & DEVICE_SSP_BIT) != DEVICE_SSP_BIT)) 730 || 731 (((oneDeviceData->initiator_ssp_stp_smp & DEVICE_STP_BIT) == DEVICE_STP_BIT) && 732 ((oneDeviceData->target_ssp_stp_smp & DEVICE_SSP_BIT) != DEVICE_SSP_BIT)) 733 ) 734 { 735 TI_DBG1(("tddmPortDeviceAdd: initiator. no add and registration\n")); 736 TI_DBG1(("tddmPortDeviceAdd: sasAddressHi 0x%08x\n", agSASSubID.sasAddressHi)); 737 TI_DBG1(("tddmPortDeviceAdd: sasAddressLo 0x%08x\n", agSASSubID.sasAddressLo)); 738 739 } 740 else 741 { 742 if (oneDeviceData->registered == agFALSE) 743 { 744 #ifdef REMOVED 745 //temp; setting MCN to tdsaAllShared->MCN 746 oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | (tdsaAllShared->MCN << 16); 747 //end temp 748 #endif 749 if( tdsaAllShared->sflag ) 750 { 751 if( ! DEVICE_IS_SMP_TARGET(oneDeviceData)) 752 { 753 TI_DBG1(("tddmPortDeviceAdd: saRegisterNewDevice sflag %d\n", tdsaAllShared->sflag)); 754 oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | TD_XFER_RDY_PRIORTY_DEVICE_FLAG; 755 } 756 } 757 saRegisterNewDevice( /* tddmPortDeviceAdd */ 758 onePortContext->agRoot, 759 &oneDeviceData->agContext, 760 0, 761 &oneDeviceData->agDeviceInfo, 762 onePortContext->agPortContext, 763 0 764 ); 765 } 766 } 767 } 768 769 return oneDeviceData; 770 } 771 772 773 /* 774 each call, add the device to the device list 775 typedef struct{ 776 bit16 smpTimeout; 777 bit16 it_NexusTimeout; 778 bit16 firstBurstSize; 779 bit8 flag; 780 bit8 devType_S_Rate; 781 bit8 sasAddressHi[4]; 782 bit8 sasAddressLo[4]; 783 } dmDeviceInfo_t; 784 785 find oneExpDeviceData (expander device data) from dmExpDeviceInfo and 786 pass it to tddmPortDeviceAdd() 787 start here - change spec from bit32 to void 788 789 phyID = ((dmDeviceInfo->flag) & 0xFC) >> 2; 790 Initiators are not registered 791 */ 792 //start here 793 osGLOBAL void 794 tddmReportDevice( 795 dmRoot_t *dmRoot, 796 dmPortContext_t *dmPortContext, 797 dmDeviceInfo_t *dmDeviceInfo, /* device */ 798 dmDeviceInfo_t *dmExpDeviceInfo, /* expander the device is attached to */ 799 bit32 flag 800 801 ) 802 { 803 agsaRoot_t *agRoot; 804 tdsaRoot_t *tdsaRoot; 805 tdsaContext_t *tdsaAllShared; 806 tiRoot_t *tiRoot; 807 tdsaDeviceData_t *oneExpDeviceData = agNULL; 808 bit32 sasAddressHi, sasAddressLo; 809 tdsaPortContext_t *onePortContext; 810 tdsaDeviceData_t *oneDeviceData = agNULL; 811 bit32 localMCN = 0, finalMCN = 0; 812 bit32 devMCN = 1; 813 bit32 DLR = 0xA; 814 bit32 option; 815 bit32 param; 816 817 #ifdef FDS_SM 818 smRoot_t *smRoot; 819 #endif 820 821 TI_DBG2(("tddmReportDevice: start\n")); 822 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 823 if (tdsaRoot == agNULL) 824 { 825 TI_DBG1(("tddmReportDevice: tdsaRoot is NULL\n")); 826 return; 827 } 828 829 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 830 if (tdsaAllShared == agNULL) 831 { 832 TI_DBG1(("tddmReportDevice: tdsaAllShared is NULL\n")); 833 return; 834 } 835 836 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 837 if (tiRoot == agNULL) 838 { 839 TI_DBG1(("tddmReportDevice: tiRoot is NULL\n")); 840 return; 841 } 842 843 onePortContext = (tdsaPortContext_t *)dmPortContext->tdData; 844 if (onePortContext == agNULL) 845 { 846 TI_DBG1(("tddmReportDevice: onePortContext is NULL\n")); 847 return; 848 } 849 850 #ifdef FDS_SM 851 smRoot = &(tdsaAllShared->smRoot); 852 #endif 853 854 TI_DBG2(("tddmReportDevice: device addrHi 0x%08x addrLo 0x%08x\n", 855 TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi), TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressLo))); 856 857 if (dmExpDeviceInfo != agNULL) 858 { 859 TI_DBG2(("tddmReportDevice: attached expander addrHi 0x%08x addrLo 0x%08x\n", 860 TD_GET_SAS_ADDRESSHI(dmExpDeviceInfo->sasAddressHi), TD_GET_SAS_ADDRESSLO(dmExpDeviceInfo->sasAddressLo))); 861 } 862 else 863 { 864 TI_DBG2(("tddmReportDevice: No attached expander\n")); 865 } 866 867 /* initiators only (e.g. SPC or SPCv) are discarded */ 868 if ( (dmDeviceInfo->target_ssp_stp_smp == 0) && 869 ( DEVICE_IS_SSP_INITIATOR(dmDeviceInfo) || DEVICE_IS_STP_INITIATOR(dmDeviceInfo) || DEVICE_IS_SMP_INITIATOR(dmDeviceInfo)) 870 ) 871 { 872 TI_DBG3(("tddmReportDevice: Initiators are not added\n")); 873 TI_DBG3(("tddmReportDevice: device addrHi 0x%08x addrLo 0x%08x\n", 874 TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi), TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressLo))); 875 return; 876 } 877 878 if (flag == dmDeviceArrival) 879 { 880 TI_DBG2(("tddmReportDevice: arrival\n")); 881 if (dmExpDeviceInfo != agNULL) 882 { 883 sasAddressHi = TD_GET_SAS_ADDRESSHI(dmExpDeviceInfo->sasAddressHi); 884 sasAddressLo = TD_GET_SAS_ADDRESSLO(dmExpDeviceInfo->sasAddressLo); 885 886 oneExpDeviceData = tddmPortSASDeviceFind(tiRoot, onePortContext, sasAddressLo, sasAddressHi); 887 } 888 889 tddmPortDeviceAdd(tiRoot, onePortContext, dmDeviceInfo, oneExpDeviceData); 890 891 } 892 else if (flag == dmDeviceRemoval) 893 { 894 TI_DBG2(("tddmReportDevice: removal\n")); 895 sasAddressHi = TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi); 896 sasAddressLo = TD_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo); 897 oneDeviceData = tddmPortSASDeviceFind(tiRoot, onePortContext, sasAddressLo, sasAddressHi); 898 if (oneDeviceData == agNULL) 899 { 900 TI_DBG2(("tddmReportDevice: oneDeviceData is NULL!!!\n")); 901 } 902 else 903 { 904 /* invalidate device */ 905 TI_DBG2(("tddmReportDevice: invalidating\n")); 906 TI_DBG2(("tddmReportDevice: agDevHandle %p\n", oneDeviceData->agDevHandle)); 907 if ( oneDeviceData->agDevHandle != agNULL) 908 { 909 TI_DBG2(("tddmReportDevice: agDevHandle->sdkData %p\n", oneDeviceData->agDevHandle->sdkData)); 910 } 911 else 912 { 913 TI_DBG2(("tddmReportDevice: agDevHandle->sdkData is NULL\n")); 914 } 915 oneDeviceData->valid = agFALSE; 916 //to do; to be tested 917 agRoot = oneDeviceData->agRoot; 918 if ( (oneDeviceData->registered == agTRUE) && 919 ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData) 920 || DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData) ) 921 ) 922 { 923 if ( !( DEVICE_IS_SMP_TARGET(oneDeviceData) && oneDeviceData->directlyAttached == agTRUE)) 924 { 925 tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 926 oneDeviceData->registered = agFALSE; 927 } 928 else 929 { 930 TI_DBG2(("tddmReportDevice: keeping\n")); 931 oneDeviceData->registered = agTRUE; 932 } 933 } 934 else if (oneDeviceData->registered == agTRUE) 935 { 936 if ( oneDeviceData->agDevHandle == agNULL) 937 { 938 TI_DBG1(("tddmReportDevice: agDevHandle->sdkData is NULL. Error!!! \n")); 939 } 940 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 941 oneDeviceData->registered = agFALSE; 942 } 943 //to do remove 944 #ifdef FDS_SM_WRONG 945 if (DEVICE_IS_SATA_DEVICE(oneDeviceData)) 946 { 947 TI_DBG2(("tddmReportDevice: smDeregisterDevice\n")); 948 smDeregisterDevice(smRoot, agNULL, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle)); 949 oneDeviceData->satDevData.IDDeviceValid = agFALSE; 950 } 951 #endif 952 } 953 } 954 else if (flag == dmDeviceNoChange) 955 { 956 TI_DBG2(("tddmReportDevice: no change; do nothing \n")); 957 #ifdef FDS_SM 958 sasAddressHi = TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi); 959 sasAddressLo = TD_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo); 960 oneDeviceData = tddmPortSASDeviceFind(tiRoot, onePortContext, sasAddressLo, sasAddressHi); 961 if (oneDeviceData == agNULL) 962 { 963 TI_DBG2(("tddmReportDevice: oneDeviceData is NULL!!!\n")); 964 } 965 else 966 { 967 agRoot = oneDeviceData->agRoot; 968 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)) 969 && 970 oneDeviceData->satDevData.IDDeviceValid == agFALSE) 971 { 972 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext); 973 } 974 } 975 #endif 976 } 977 else if (flag == dmDeviceMCNChange) 978 { 979 TI_DBG2(("tddmReportDevice: dmDeviceMCNChange \n")); 980 localMCN = tdsaFindLocalMCN(tiRoot, onePortContext); 981 devMCN = DEVINFO_GET_EXT_MCN(dmDeviceInfo); 982 TI_DBG2(("tddmReportDevice: devMCN 0x%08x localMCN 0x%08x\n", devMCN, localMCN)); 983 984 sasAddressHi = TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi); 985 sasAddressLo = TD_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo); 986 oneDeviceData = tddmPortSASDeviceFind(tiRoot, onePortContext, sasAddressLo, sasAddressHi); 987 if (oneDeviceData == agNULL) 988 { 989 TI_DBG1(("tddmReportDevice: oneDeviceData is NULL!!!\n")); 990 } 991 else 992 { 993 agRoot = oneDeviceData->agRoot; 994 oneDeviceData->devMCN = devMCN; 995 TI_DBG2(("tddmReportDevice: sasAddrHi 0x%08x sasAddrLo 0x%08x\n", sasAddressHi, sasAddressLo)); 996 if (oneDeviceData->directlyAttached == agTRUE) 997 { 998 finalMCN = localMCN; 999 TI_DBG2(("tddmReportDevice: directlyAttached, Final MCN 0x%08x\n", finalMCN)); 1000 } 1001 else 1002 { 1003 finalMCN = MIN(devMCN, localMCN); 1004 TI_DBG2(("tddmReportDevice: Not directlyAttached, Final MCN 0x%08x\n", finalMCN)); 1005 } 1006 if ( oneDeviceData->registered == agTRUE) 1007 { 1008 /* saSetDeviceInfo to change MCN, using finalMCN */ 1009 option = 8; /* setting only MCN 1000b */ 1010 param = finalMCN << 24; 1011 TI_DBG2(("tddmReportDevice: option 0x%x param 0x%x MCN 0x%x\n", option, param, finalMCN)); 1012 saSetDeviceInfo(agRoot, agNULL, 0, oneDeviceData->agDevHandle, option, param, ossaSetDeviceInfoCB); 1013 } 1014 else 1015 { 1016 TI_DBG1(("tddmReportDevice: oneDeviceData is not yet registered !!!\n")); 1017 } 1018 oneDeviceData->finalMCN = finalMCN; 1019 } 1020 } 1021 else if (flag == dmDeviceRateChange) 1022 { 1023 TI_DBG1(("tddmReportDevice: dmDeviceRateChange \n")); 1024 sasAddressHi = TD_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi); 1025 sasAddressLo = TD_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo); 1026 oneDeviceData = tddmPortSASDeviceFind(tiRoot, onePortContext, sasAddressLo, sasAddressHi); 1027 if (oneDeviceData == agNULL) 1028 { 1029 TI_DBG1(("tddmReportDevice: oneDeviceData is NULL!!!\n")); 1030 } 1031 else 1032 { 1033 agRoot = oneDeviceData->agRoot; 1034 if ( oneDeviceData->registered == agTRUE) 1035 { 1036 option = 0x20; /* bit 5 */ 1037 DLR = DEVINFO_GET_LINKRATE(dmDeviceInfo); 1038 param = DLR << 28; 1039 TI_DBG1(("tddmReportDevice: option 0x%x param 0x%x DLR 0x%x\n", option, param, DLR)); 1040 saSetDeviceInfo(agRoot, agNULL, 0, oneDeviceData->agDevHandle, option, param, ossaSetDeviceInfoCB); 1041 1042 } 1043 else 1044 { 1045 TI_DBG1(("tddmReportDevice: oneDeviceData is not yet registered !!!\n")); 1046 } 1047 1048 } 1049 } 1050 else 1051 { 1052 TI_DBG1(("tddmReportDevice: unknown flag 0x%x, wrong\n", flag)); 1053 } 1054 1055 return; 1056 } 1057 1058 osGLOBAL void 1059 tdsaUpdateMCN( 1060 dmRoot_t *dmRoot, 1061 tdsaPortContext_t *onePortContext 1062 ) 1063 { 1064 tdsaRoot_t *tdsaRoot; 1065 tdsaContext_t *tdsaAllShared; 1066 tiRoot_t *tiRoot; 1067 tdsaDeviceData_t *oneDeviceData = agNULL; 1068 tdList_t *DeviceListList; 1069 bit32 localMCN = 0, finalMCN = 0; 1070 bit32 devMCN = 1; 1071 bit32 option; 1072 bit32 param; 1073 1074 TI_DBG3(("tdsaUpdateMCN: start\n")); 1075 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 1076 if (tdsaRoot == agNULL) 1077 { 1078 TI_DBG1(("tdsaUpdateMCN: tdsaRoot is NULL\n")); 1079 return; 1080 } 1081 1082 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 1083 if (tdsaAllShared == agNULL) 1084 { 1085 TI_DBG1(("tdsaUpdateMCN: tdsaAllShared is NULL\n")); 1086 return; 1087 } 1088 1089 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 1090 if (tiRoot == agNULL) 1091 { 1092 TI_DBG1(("tdsaUpdateMCN: tiRoot is NULL\n")); 1093 return; 1094 } 1095 1096 if (onePortContext->valid == agFALSE) 1097 { 1098 TI_DBG1(("tdsaUpdateMCN: onePortContext is invalid\n")); 1099 return; 1100 } 1101 1102 TI_DBG3(("tdsaUpdateMCN: pid %d\n", onePortContext->id)); 1103 1104 localMCN = tdsaFindLocalMCN(tiRoot, onePortContext); 1105 1106 if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList))) 1107 { 1108 TI_DBG1(("tdsaUpdateMCN: empty device list\n")); 1109 return; 1110 } 1111 1112 /* update directly and behind expander device */ 1113 DeviceListList = tdsaAllShared->MainDeviceList.flink; 1114 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 1115 { 1116 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 1117 if (oneDeviceData == agNULL) 1118 { 1119 TI_DBG1(("tdsaUpdateMCN: oneDeviceData is NULL!!!\n")); 1120 return; 1121 } 1122 TI_DBG3(("tdsaUpdateMCN: loop did %d\n", oneDeviceData->id)); 1123 TI_DBG3(("tdsaUpdateMCN: sasAddrHi 0x%08x sasAddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo)); 1124 devMCN = oneDeviceData->devMCN; 1125 if ( oneDeviceData->tdPortContext == onePortContext) 1126 { 1127 if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE && oneDeviceData->directlyAttached == agTRUE) 1128 { 1129 TI_DBG3(("tdsaUpdateMCN: found directly attached\n")); 1130 finalMCN = localMCN; 1131 TI_DBG3(("tdsaUpdateMCN: devMCN 0x%08x localMCN 0x%08x\n", devMCN, localMCN)); 1132 TI_DBG3(("tdsaUpdateMCN: finalMCN 0x%08x\n", finalMCN)); 1133 if (oneDeviceData->finalMCN != finalMCN) 1134 { 1135 /* saSetDeviceInfo using finalMCN */ 1136 option = 8; /* setting only MCN 1000b */ 1137 param = finalMCN << 24; 1138 TI_DBG3(("tdsaUpdateMCN: option 0x%x param 0x%x MCN 0x%x\n", option, param, finalMCN)); 1139 saSetDeviceInfo(oneDeviceData->agRoot, agNULL, 0, oneDeviceData->agDevHandle, option, param, ossaSetDeviceInfoCB); 1140 oneDeviceData->finalMCN = finalMCN; 1141 } 1142 1143 } 1144 else if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE && oneDeviceData->directlyAttached == agFALSE) 1145 { 1146 TI_DBG3(("tdsaUpdateMCN: found behind expander device\n")); 1147 finalMCN = MIN(localMCN, devMCN); 1148 TI_DBG3(("tdsaUpdateMCN: devMCN 0x%08x localMCN 0x%08x\n", devMCN, localMCN)); 1149 TI_DBG3(("tdsaUpdateMCN: finalMCN 0x%08x\n", finalMCN)); 1150 if (oneDeviceData->finalMCN != finalMCN) 1151 { 1152 /* saSetDeviceInfo using finalMCN */ 1153 option = 8; /* setting only MCN 1000b */ 1154 param = finalMCN << 24; 1155 TI_DBG3(("tdsaUpdateMCN: option 0x%x param 0x%x MCN 0x%x\n", option, param, finalMCN)); 1156 saSetDeviceInfo(oneDeviceData->agRoot, agNULL, 0, oneDeviceData->agDevHandle, option, param, ossaSetDeviceInfoCB); 1157 oneDeviceData->finalMCN = finalMCN; 1158 } 1159 1160 } 1161 DeviceListList = DeviceListList->flink; 1162 } 1163 else 1164 { 1165 if (oneDeviceData->tdPortContext != agNULL) 1166 { 1167 TI_DBG3(("tdsaUpdateMCN: different portcontext; oneDeviceData->tdPortContext pid %d oneportcontext pid %d\n", oneDeviceData->tdPortContext->id, onePortContext->id)); 1168 } 1169 else 1170 { 1171 TI_DBG3(("tdsaUpdateMCN: different portcontext; oneDeviceData->tdPortContext pid NULL oneportcontext pid %d\n", onePortContext->id)); 1172 } 1173 DeviceListList = DeviceListList->flink; 1174 } 1175 } /* while */ 1176 1177 return; 1178 } 1179 1180 osGLOBAL bit8 1181 tddmSATADeviceTypeDecode(bit8 * pSignature) 1182 { 1183 return (bit8)tdssSATADeviceTypeDecode(pSignature); 1184 } 1185 1186 1187 osGLOBAL void 1188 tddmSingleThreadedEnter( 1189 dmRoot_t *dmRoot, 1190 bit32 syncLockId 1191 ) 1192 { 1193 tdsaRoot_t *tdsaRoot; 1194 tdsaContext_t *tdsaAllShared; 1195 tiRoot_t *tiRoot; 1196 bit32 offset = 0; 1197 1198 TI_DBG7(("tddmSingleThreadedEnter: start\n")); 1199 1200 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 1201 if (tdsaRoot == agNULL) 1202 { 1203 TI_DBG1(("tddmSingleThreadedEnter: tdsaRoot is NULL\n")); 1204 return; 1205 } 1206 1207 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 1208 if (tdsaAllShared == agNULL) 1209 { 1210 TI_DBG1(("tddmSingleThreadedEnter: tdsaAllShared is NULL\n")); 1211 return; 1212 } 1213 1214 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 1215 if (tiRoot == agNULL) 1216 { 1217 TI_DBG1(("tddmSingleThreadedEnter: tiRoot is NULL\n")); 1218 return; 1219 } 1220 offset = tdsaAllShared->MaxNumLLLocks + tdsaAllShared->MaxNumOSLocks + TD_MAX_LOCKS; 1221 1222 ostiSingleThreadedEnter(tiRoot, syncLockId + offset); 1223 return; 1224 } 1225 1226 osGLOBAL void 1227 tddmSingleThreadedLeave( 1228 dmRoot_t *dmRoot, 1229 bit32 syncLockId 1230 ) 1231 { 1232 tdsaRoot_t *tdsaRoot; 1233 tdsaContext_t *tdsaAllShared; 1234 tiRoot_t *tiRoot; 1235 bit32 offset = 0; 1236 1237 TI_DBG7(("tddmSingleThreadedLeave: start\n")); 1238 1239 tdsaRoot = (tdsaRoot_t *)dmRoot->tdData; 1240 if (tdsaRoot == agNULL) 1241 { 1242 TI_DBG1(("tddmSingleThreadedLeave: tdsaRoot is NULL\n")); 1243 return; 1244 } 1245 1246 tdsaAllShared = &(tdsaRoot->tdsaAllShared); 1247 if (tdsaAllShared == agNULL) 1248 { 1249 TI_DBG1(("tddmSingleThreadedLeave: tdsaAllShared is NULL\n")); 1250 return; 1251 } 1252 1253 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot; 1254 if (tiRoot == agNULL) 1255 { 1256 TI_DBG1(("tddmSingleThreadedLeave: tiRoot is NULL\n")); 1257 return; 1258 } 1259 offset = tdsaAllShared->MaxNumLLLocks + tdsaAllShared->MaxNumOSLocks + TD_MAX_LOCKS; 1260 1261 ostiSingleThreadedLeave(tiRoot, syncLockId + offset); 1262 1263 return; 1264 } 1265 1266 osGLOBAL bit32 tddmGetTransportParam( 1267 dmRoot_t *dmRoot, 1268 char *key, 1269 char *subkey1, 1270 char *subkey2, 1271 char *subkey3, 1272 char *subkey4, 1273 char *subkey5, 1274 char *valueName, 1275 char *buffer, 1276 bit32 bufferLen, 1277 bit32 *lenReceived 1278 ) 1279 { 1280 bit32 ret = tiError; 1281 1282 TI_DBG7(("tddmGetTransportParam: start\n")); 1283 ret = ostiGetTransportParam(agNULL, 1284 key, 1285 subkey1, 1286 subkey2, 1287 subkey3, 1288 subkey4, 1289 subkey5, 1290 valueName, 1291 buffer, 1292 bufferLen, 1293 lenReceived 1294 ); 1295 1296 return ret; 1297 } 1298 1299 #endif /* FDS_DM */ 1300 1301