sys/dev/pms/RefTisa/tisa/sassata/sas/ini/itddisc.c

   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  * This file contains initiator discover related functions
  26  *
  27  */
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30 #include <dev/pms/config.h>
  31
  32 #include <dev/pms/freebsd/driver/common/osenv.h>
  33 #include <dev/pms/freebsd/driver/common/ostypes.h>
  34 #include <dev/pms/freebsd/driver/common/osdebug.h>
  35
  36 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
  37 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
  38 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
  39
  40 #include <dev/pms/RefTisa/tisa/api/titypes.h>
  41 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
  42 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
  43 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
  44
  45 #ifdef FDS_SM
  46 #include <dev/pms/RefTisa/sat/api/sm.h>
  47 #include <dev/pms/RefTisa/sat/api/smapi.h>
  48 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
  49 #endif
  50
  51 #ifdef FDS_DM
  52 #include <dev/pms/RefTisa/discovery/api/dm.h>
  53 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
  54 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
  55 #endif
  56
  57 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
  58 #include <dev/pms/freebsd/driver/common/osstring.h>
  59 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
  60
  61 #ifdef INITIATOR_DRIVER
  62 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
  63 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
  64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
  65 #endif
  66
  67 #ifdef TARGET_DRIVER
  68 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
  69 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
  70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
  71 #endif
  72
  73 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
  74 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
  75
  76 /*****************************************************************************
  77 *! \brief  tiINIDiscoverTargets
  78 *
  79 *  Purpose:  This function is called to send a transport dependent discovery
  80 *            request. An implicit login will be started following the
  81 *            completion of discovery.
  82 *
  83 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
  84 *                   instance.
  85 *  \param   portalContext: Pointer to the portal context instance.
  86 *  \param   option: This is a bit field option on how the session is to be
  87 *                   created
  88 *  \return:
  89 *           tiSuccess    Discovery initiated.
  90 *           tiBusy       Discovery could not be initiated at this time.
  91 *
  92 *   \note:
  93 *
  94 *****************************************************************************/
  95 osGLOBAL bit32
  96 tiINIDiscoverTargets(
  97                      tiRoot_t            *tiRoot,
  98                      tiPortalContext_t   *portalContext,
  99                      bit32               option
 100                      )
 101 {
 102   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 103   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 104   tdList_t          *PortContextList;
 105   tdsaPortContext_t *onePortContext = agNULL;
 106   bit32             found = agFALSE;
 107
 108 #ifdef FDS_DM
 109   dmRoot_t          *dmRoot = &(tdsaAllShared->dmRoot);
 110   dmPortContext_t   *dmPortContext = agNULL;
 111 #endif
 112   /*
 113    this function is called after LINK_UP by ossaHWCB()
 114    Therefore, tdsaportcontext is ready at this point
 115   */
 116
 117   TI_DBG3(("tiINIDiscoverTargets: start\n"));
 118
 119   /* find a right tdsaPortContext using tiPortalContext
 120      then, check the status of tdsaPortContext
 121      then, if status is right, start the discovery
 122   */
 123
 124   TI_DBG6(("tiINIDiscoverTargets: portalContext %p\n", portalContext));
 125   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
 126   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
 127   {
 128     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 129     TI_DBG1(("tiINIDiscoverTargets: No tdsaPortContext\n"));
 130     return tiError;
 131   }
 132   else
 133   {
 134     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 135   }
 136
 137   /* find a right portcontext */
 138   PortContextList = tdsaAllShared->MainPortContextList.flink;
 139   if (PortContextList == agNULL)
 140   {
 141     TI_DBG1(("tiINIDiscoverTargets: PortContextList is NULL\n"));
 142     return tiError;
 143   }
 144   while (PortContextList != &(tdsaAllShared->MainPortContextList))
 145   {
 146     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
 147     if (onePortContext == agNULL)
 148     {
 149       TI_DBG1(("tiINIDiscoverTargets: onePortContext is NULL, PortContextList = %p\n", PortContextList));
 150       return tiError;
 151     }
 152     if (onePortContext->tiPortalContext == portalContext && onePortContext->valid == agTRUE)
 153     {
 154       TI_DBG6(("tiINIDiscoverTargets: found; oneportContext ID %d\n", onePortContext->id));
 155       found = agTRUE;
 156       break;
 157     }
 158     PortContextList = PortContextList->flink;
 159   }
 160
 161   if (found == agFALSE)
 162   {
 163     TI_DBG1(("tiINIDiscoverTargets: No corresponding tdsaPortContext\n"));
 164     return tiError;
 165   }
 166
 167   TI_DBG2(("tiINIDiscoverTargets: pid %d\n", onePortContext->id));
 168   if (onePortContext->DiscoveryState == ITD_DSTATE_NOT_STARTED)
 169   {
 170     TI_DBG6(("tiINIDiscoverTargets: calling Discovery\n"));
 171     /* start SAS discovery */
 172 #ifdef FDS_DM
 173     if (onePortContext->UseDM == agTRUE)
 174     {
 175       TI_DBG1(("tiINIDiscoverTargets: calling dmDiscover, pid %d\n", onePortContext->id));
 176       onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
 177       dmPortContext = &(onePortContext->dmPortContext);
 178       dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_FULL_START);
 179     }
 180     else
 181     {
 182       /* complete discovery */
 183       onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
 184       ostiInitiatorEvent(
 185                          tiRoot,
 186                          portalContext,
 187                          agNULL,
 188                          tiIntrEventTypeDiscovery,
 189                          tiDiscOK,
 190                          agNULL
 191                          );
 192
 193       return tiSuccess;
 194     }
 195
 196 #else
 197
 198 #ifdef TD_DISCOVER
 199     tdsaDiscover(
 200                  tiRoot,
 201                  onePortContext,
 202                  AG_SA_DISCOVERY_TYPE_SAS,
 203                  TDSA_DISCOVERY_OPTION_FULL_START
 204                  );
 205 #else
 206     saDiscover(onePortContext->agRoot, onePortContext->agPortContext, AG_SA_DISCOVERY_TYPE_SAS, onePortContext->discoveryOptions);
 207
 208
 209
 210 #endif
 211 #endif /* FDS_DM */
 212   }
 213   else
 214   {
 215     TI_DBG1(("tiINIDiscoverTargets: Discovery has started or incorrect initialization; state %d pid 0x%x\n",
 216                       onePortContext->DiscoveryState,
 217                       onePortContext->id));
 218     return tiError;
 219   }
 220
 221   return tiSuccess;
 222 }
 223
 224 /*****************************************************************************
 225 *! \brief  tiINIGetDeviceHandles
 226 *
 227 *  Purpose: This routine is called to to return the device handles for each
 228 *           device currently available.
 229 *
 230 *  \param  tiRoot:   Pointer to driver Instance.
 231 *  \param  tiPortalContext: Pointer to the portal context instance.
 232 *  \param  agDev[]:  Array to receive pointers to the device handles.
 233 *  \param  maxDevs:  Number of device handles which will fit in array pointed
 234 *                    by agDev.
 235 *  \return:
 236 *    Number of device handle slots present (however, only maxDevs
 237 *    are copied into tiDev[]) which may be greater than the number of
 238 *    handles actually present. In short, returns the number of devices that
 239 *    were found.
 240 *
 241 *  \note:
 242 *
 243 *****************************************************************************/
 244 osGLOBAL bit32
 245 tiINIGetDeviceHandles(
 246                       tiRoot_t          * tiRoot,
 247                       tiPortalContext_t * tiPortalContext,
 248                       tiDeviceHandle_t  * tiDev[],
 249                       bit32               maxDevs
 250                       )
 251 {
 252   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 253   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 254   tdList_t          *PortContextList;
 255   tdsaPortContext_t *onePortContext = agNULL;
 256   tdsaDeviceData_t  *oneDeviceData = agNULL;
 257   tdList_t          *DeviceListList;
 258   bit32             i;
 259   bit32             FoundDevices = 0;
 260   bit32             DeviceIndex = 0;
 261   bit32             found = agFALSE;
 262 #ifdef  TD_DEBUG_ENABLE
 263   satDeviceData_t   *pSatDevData;
 264 #endif
 265 #ifdef FDS_DM
 266   dmRoot_t          *dmRoot = &(tdsaAllShared->dmRoot);
 267 #endif
 268
 269   TI_DBG2(("tiINIGetDeviceHandles: start\n"));
 270   TI_DBG2(("tiINIGetDeviceHandles: tiPortalContext %p\n", tiPortalContext));
 271
 272
 273   if (maxDevs == 0)
 274   {
 275     TI_DBG1(("tiINIGetDeviceHandles: maxDevs is 0\n"));
 276     TI_DBG1(("tiINIGetDeviceHandles: first, returning 0\n"));
 277     /* nullify all device handles */
 278     for (i = 0 ; i < maxDevs ; i++)
 279     {
 280       tiDev[i] = agNULL;
 281     }
 282     return 0;
 283   }
 284
 285   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
 286   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
 287   {
 288     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 289     TI_DBG1(("tiINIGetDeviceHandles: No available tdsaPortContext\n"));
 290     TI_DBG1(("tiINIGetDeviceHandles: second, returning 0\n"));
 291     /* nullify all device handles */
 292     for (i = 0 ; i < maxDevs ; i++)
 293     {
 294       tiDev[i] = agNULL;
 295     }
 296     return 0;
 297   }
 298   else
 299   {
 300     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 301   }
 302   /* find a corresponding portcontext */
 303   PortContextList = tdsaAllShared->MainPortContextList.flink;
 304   while (PortContextList != &(tdsaAllShared->MainPortContextList))
 305   {
 306     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
 307     if(onePortContext == agNULL) continue;
 308
 309     TI_DBG3(("tiINIGetDeviceHandles: oneportContext pid %d\n", onePortContext->id));
 310     if (onePortContext->tiPortalContext == tiPortalContext && onePortContext->valid == agTRUE)
 311     {
 312       TI_DBG3(("tiINIGetDeviceHandles: found; oneportContext pid %d\n", onePortContext->id));
 313       found = agTRUE;
 314       break;
 315     }
 316     PortContextList = PortContextList->flink;
 317   }
 318
 319   if (found == agFALSE)
 320   {
 321     TI_DBG1(("tiINIGetDeviceHandles: First, No corresponding tdsaPortContext\n"));
 322     TI_DBG1(("tiINIGetDeviceHandles: third, returning 0\n"));
 323     /* nullify all device handles */
 324     for (i = 0 ; i < maxDevs ; i++)
 325     {
 326       tiDev[i] = agNULL;
 327     }
 328     return 0;
 329   }
 330
 331   if (onePortContext == agNULL)
 332   {
 333     TI_DBG1(("tiINIGetDeviceHandles: Second, No corressponding tdsaPortContext\n"));
 334     TI_DBG1(("tiINIGetDeviceHandles: fourth, returning 0\n"));
 335     /* nullify all device handles */
 336     for (i = 0 ; i < maxDevs ; i++)
 337     {
 338       tiDev[i] = agNULL;
 339     }
 340     return 0;
 341   }
 342
 343   if (onePortContext->valid == agFALSE)
 344   {
 345     TI_DBG1(("tiINIGetDeviceHandles: Third, tdsaPortContext is invalid, pid %d\n", onePortContext->id));
 346     TI_DBG1(("tiINIGetDeviceHandles: fifth, returning 0\n"));
 347     /* nullify all device handles */
 348     for (i = 0 ; i < maxDevs ; i++)
 349     {
 350       tiDev[i] = agNULL;
 351     }
 352     return 0;
 353   }
 354
 355   if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED &&  onePortContext->DMDiscoveryState == dmDiscFailed)
 356   {
 357     TI_DBG1(("tiINIGetDeviceHandles: forth, discovery failed, pid %d\n", onePortContext->id));
 358     TI_DBG1(("tiINIGetDeviceHandles: sixth, returning 0\n"));
 359     /* nullify all device handles */
 360     for (i = 0 ; i < maxDevs ; i++)
 361     {
 362       tiDev[i] = agNULL;
 363     }
 364     return 0;
 365   }
 366
 367   if (onePortContext->DiscoveryState != ITD_DSTATE_COMPLETED)
 368   {
 369     TI_DBG1(("tiINIGetDeviceHandles: discovery not completed\n"));
 370     TI_DBG1(("tiINIGetDeviceHandles: sixth, returning DISCOVERY_IN_PROGRESS, pid %d\n", onePortContext->id));
 371     onePortContext->discovery.forcedOK = agTRUE;
 372     return DISCOVERY_IN_PROGRESS;
 373   }
 374
 375   TI_DBG2(("tiINIGetDeviceHandles: pid %d\n", onePortContext->id));
 376
 377 #ifdef FDS_DM
 378   tdsaUpdateMCN(dmRoot, onePortContext);
 379 #endif
 380
 381   /* nullify all device handles */
 382   for (i = 0 ; i < maxDevs ; i++)
 383   {
 384     tiDev[i] = agNULL;
 385   }
 386
 387   /*
 388      From the device list, returns only valid devices
 389   */
 390   DeviceListList = tdsaAllShared->MainDeviceList.flink;
 391
 392   TD_ASSERT(DeviceListList, "DeviceListList NULL");
 393   if (DeviceListList == agNULL  )
 394   {
 395     TI_DBG1(("tiINIGetDeviceHandles: DeviceListList == agNULL\n"));
 396     TI_DBG1(("tiINIGetDeviceHandles: seventh, returning not found, pid %d\n", onePortContext->id));
 397     return 0;
 398   }
 399
 400   while ((DeviceIndex < maxDevs) &&
 401           DeviceListList != &(tdsaAllShared->MainDeviceList))
 402   {
 403     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
 404 #ifdef  TD_DEBUG_ENABLE
 405     pSatDevData = (satDeviceData_t *)&(oneDeviceData->satDevData);
 406     if (pSatDevData != agNULL)
 407     {
 408       TI_DBG3(("tiINIGetDeviceHandles: device %p satPendingIO %d satNCQMaxIO %d\n",pSatDevData, pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
 409       TI_DBG3(("tiINIGetDeviceHandles: device %p satPendingNCQIO %d satPendingNONNCQIO %d\n",pSatDevData, pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
 410     }
 411 #endif
 412     TI_DBG3(("tiINIGetDeviceHandles: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
 413     TI_DBG3(("tiINIGetDeviceHandles: device AddrHi 0x%08x AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
 414
 415     TI_DBG6(("tiINIGetDeviceHandles: handle %p\n",  &(oneDeviceData->tiDeviceHandle)));
 416     if (oneDeviceData->tdPortContext != onePortContext)
 417     {
 418       TI_DBG3(("tiINIGetDeviceHandles: different port\n"));
 419       DeviceListList = DeviceListList->flink;
 420     }
 421     else
 422     {
 423 #ifdef SATA_ENABLE
 424       if ((oneDeviceData->valid == agTRUE) &&
 425           (oneDeviceData->registered == agTRUE) &&
 426           (oneDeviceData->tdPortContext == onePortContext) &&
 427           ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)
 428             || DEVICE_IS_SATA_DEVICE(oneDeviceData) )
 429           )
 430 #else
 431       if ((oneDeviceData->valid == agTRUE) &&
 432           (oneDeviceData->registered == agTRUE) &&
 433           (oneDeviceData->tdPortContext == onePortContext) &&
 434           ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData) )
 435           )
 436 #endif
 437       {
 438         if (DEVICE_IS_SSP_TARGET(oneDeviceData))
 439         {
 440           TI_DBG2(("tiINIGetDeviceHandles: SSP DeviceIndex %d tiDeviceHandle %p\n",  DeviceIndex, &(oneDeviceData->tiDeviceHandle)));
 441           tiDev[DeviceIndex] = &(oneDeviceData->tiDeviceHandle);
 442           FoundDevices++;
 443         }
 444         else if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
 445                   &&
 446                   oneDeviceData->satDevData.IDDeviceValid == agTRUE )
 447         {
 448           TI_DBG2(("tiINIGetDeviceHandles: SATA DeviceIndex %d tiDeviceHandle %p\n",  DeviceIndex, &(oneDeviceData->tiDeviceHandle)));
 449           tiDev[DeviceIndex] = &(oneDeviceData->tiDeviceHandle);
 450           FoundDevices++;
 451         }
 452         else
 453         {
 454           TI_DBG3(("tiINIGetDeviceHandles: skip case !!!\n"));
 455           TI_DBG3(("tiINIGetDeviceHandles: valid %d SSP target %d STP target %d SATA device %d\n", oneDeviceData->valid, DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
 456           TI_DBG3(("tiINIGetDeviceHandles: oneDeviceData->satDevData.IDDeviceValid %d\n", oneDeviceData->satDevData.IDDeviceValid));
 457           TI_DBG3(("tiINIGetDeviceHandles: registered %d right port %d \n", oneDeviceData->registered, (oneDeviceData->tdPortContext == onePortContext)));
 458           TI_DBG3(("tiINIGetDeviceHandles: oneDeviceData->tdPortContext %p onePortContext %p\n", oneDeviceData->tdPortContext, onePortContext));
 459         }
 460         TI_DBG3(("tiINIGetDeviceHandles: valid FoundDevices %d\n", FoundDevices));
 461         TI_DBG3(("tiINIGetDeviceHandles: agDevHandle %p\n", oneDeviceData->agDevHandle));
 462       }
 463       else
 464       {
 465         TI_DBG3(("tiINIGetDeviceHandles: valid %d SSP target %d STP target %d SATA device %d\n", oneDeviceData->valid, DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
 466         TI_DBG3(("tiINIGetDeviceHandles: registered %d right port %d \n", oneDeviceData->registered, (oneDeviceData->tdPortContext == onePortContext)));
 467         TI_DBG3(("tiINIGetDeviceHandles: oneDeviceData->tdPortContext %p onePortContext %p\n", oneDeviceData->tdPortContext, onePortContext));
 468       }
 469       DeviceIndex++;
 470       DeviceListList = DeviceListList->flink;
 471     } /* else */
 472   }
 473
 474   if (DeviceIndex > maxDevs)
 475   {
 476     TI_DBG1(("tiINIGetDeviceHandles: DeviceIndex(%d) >= maxDevs(%d)\n", DeviceIndex, maxDevs));
 477     FoundDevices = maxDevs;
 478   }
 479
 480   TI_DBG1(("tiINIGetDeviceHandles: returning %d found devices, pid %d\n", FoundDevices, onePortContext->id));
 481
 482   return FoundDevices;
 483 }
 484
 485 /*****************************************************************************
 486 *! \brief  tiINIGetDeviceHandlesForWinIOCTL
 487 *
 488 *  Purpose: This routine is called to to return the device handles for each
 489 *           device currently available, this routine is only for Win IOCTL to display SAS topology.
 490 *
 491 *  \param  tiRoot:   Pointer to driver Instance.
 492 *  \param  tiPortalContext: Pointer to the portal context instance.
 493 *  \param  agDev[]:  Array to receive pointers to the device handles.
 494 *  \param  maxDevs:  Number of device handles which will fit in array pointed
 495 *                    by agDev.
 496 *  \return:
 497 *    Number of device handle slots present (however, only maxDevs
 498 *    are copied into tiDev[]) which may be greater than the number of
 499 *    handles actually present. In short, returns the number of devices that
 500 *    were found.
 501 *
 502 *  \note:
 503 *
 504 *****************************************************************************/
 505 osGLOBAL bit32
 506 tiINIGetDeviceHandlesForWinIOCTL(
 507                       tiRoot_t          * tiRoot,
 508                       tiPortalContext_t * tiPortalContext,
 509                       tiDeviceHandle_t  * tiDev[],
 510                       bit32               maxDevs
 511                       )
 512 {
 513   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 514   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 515   tdList_t          *PortContextList;
 516   tdsaPortContext_t *onePortContext = agNULL;
 517   tdsaDeviceData_t  *oneDeviceData = agNULL;
 518   tdList_t          *DeviceListList;
 519   bit32             i;
 520   bit32             FoundDevices = 0;
 521   bit32             DeviceIndex = 0;
 522   bit32             found = agFALSE;
 523 #ifdef  TD_DEBUG_ENABLE
 524   satDeviceData_t   *pSatDevData;
 525 #endif
 526 #ifdef FDS_DM
 527   dmRoot_t          *dmRoot = &(tdsaAllShared->dmRoot);
 528 #endif
 529
 530   TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: start\n"));
 531   TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: tiPortalContext %p\n", tiPortalContext));
 532
 533
 534   if (maxDevs == 0)
 535   {
 536     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: maxDevs is 0\n"));
 537     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: first, returning 0\n"));
 538     /* nullify all device handles */
 539     for (i = 0 ; i < maxDevs ; i++)
 540     {
 541       tiDev[i] = agNULL;
 542     }
 543     return 0;
 544   }
 545
 546   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
 547   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
 548   {
 549     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 550     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: No available tdsaPortContext\n"));
 551     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: second, returning 0\n"));
 552     /* nullify all device handles */
 553     for (i = 0 ; i < maxDevs ; i++)
 554     {
 555       tiDev[i] = agNULL;
 556     }
 557     return 0;
 558   }
 559   else
 560   {
 561     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 562   }
 563   /* find a corresponding portcontext */
 564   PortContextList = tdsaAllShared->MainPortContextList.flink;
 565   while (PortContextList != &(tdsaAllShared->MainPortContextList))
 566   {
 567     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
 568     if(onePortContext == agNULL) continue;
 569
 570     TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: oneportContext pid %d\n", onePortContext->id));
 571     if (onePortContext->tiPortalContext == tiPortalContext && onePortContext->valid == agTRUE)
 572     {
 573       TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: found; oneportContext pid %d\n", onePortContext->id));
 574       found = agTRUE;
 575       break;
 576     }
 577     PortContextList = PortContextList->flink;
 578   }
 579
 580   if (found == agFALSE)
 581   {
 582     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: First, No corresponding tdsaPortContext\n"));
 583     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: third, returning 0\n"));
 584     /* nullify all device handles */
 585     for (i = 0 ; i < maxDevs ; i++)
 586     {
 587       tiDev[i] = agNULL;
 588     }
 589     return 0;
 590   }
 591
 592   if (onePortContext == agNULL)
 593   {
 594     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: Second, No corressponding tdsaPortContext\n"));
 595     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: fourth, returning 0\n"));
 596     /* nullify all device handles */
 597     for (i = 0 ; i < maxDevs ; i++)
 598     {
 599       tiDev[i] = agNULL;
 600     }
 601     return 0;
 602   }
 603
 604   if (onePortContext->valid == agFALSE)
 605   {
 606     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: Third, tdsaPortContext is invalid, pid %d\n", onePortContext->id));
 607     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: fifth, returning 0\n"));
 608     /* nullify all device handles */
 609     for (i = 0 ; i < maxDevs ; i++)
 610     {
 611       tiDev[i] = agNULL;
 612     }
 613     return 0;
 614   }
 615
 616   if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED &&  onePortContext->DMDiscoveryState == dmDiscFailed)
 617   {
 618     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: forth, discovery failed, pid %d\n", onePortContext->id));
 619     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: sixth, returning 0\n"));
 620     /* nullify all device handles */
 621     for (i = 0 ; i < maxDevs ; i++)
 622     {
 623       tiDev[i] = agNULL;
 624     }
 625     return 0;
 626   }
 627
 628   if (onePortContext->DiscoveryState != ITD_DSTATE_COMPLETED)
 629   {
 630     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: discovery not completed\n"));
 631     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: sixth, returning DISCOVERY_IN_PROGRESS, pid %d\n", onePortContext->id));
 632     onePortContext->discovery.forcedOK = agTRUE;
 633     return DISCOVERY_IN_PROGRESS;
 634   }
 635
 636   TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: pid %d\n", onePortContext->id));
 637
 638 #ifdef FDS_DM
 639   tdsaUpdateMCN(dmRoot, onePortContext);
 640 #endif
 641
 642   /* nullify all device handles */
 643   for (i = 0 ; i < maxDevs ; i++)
 644   {
 645     tiDev[i] = agNULL;
 646   }
 647
 648   /*
 649      From the device list, returns only valid devices
 650   */
 651   DeviceListList = tdsaAllShared->MainDeviceList.flink;
 652
 653   TD_ASSERT(DeviceListList, "DeviceListList NULL");
 654   if (DeviceListList == agNULL  )
 655   {
 656     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: DeviceListList == agNULL\n"));
 657     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: seventh, returning not found, pid %d\n", onePortContext->id));
 658     return 0;
 659   }
 660
 661   while ((DeviceIndex < maxDevs) &&
 662           DeviceListList != &(tdsaAllShared->MainDeviceList))
 663   {
 664     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
 665     if(oneDeviceData == agNULL)
 666     {
 667         TI_DBG3(("tiINIGetDeviceHandles: OneDeviceData is NULL\n"));
 668         return 0;
 669     }
 670 #ifdef  TD_DEBUG_ENABLE
 671     pSatDevData = (satDeviceData_t *)&(oneDeviceData->satDevData);
 672     if (pSatDevData != agNULL)
 673     {
 674       TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: device %p satPendingIO %d satNCQMaxIO %d\n",pSatDevData, pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
 675       TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: device %p satPendingNCQIO %d satPendingNONNCQIO %d\n",pSatDevData, pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
 676     }
 677 #endif
 678     TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
 679     TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: device AddrHi 0x%08x AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
 680
 681     TI_DBG6(("tiINIGetDeviceHandlesForWinIOCTL: handle %p\n",  &(oneDeviceData->tiDeviceHandle)));
 682     if (oneDeviceData->tdPortContext != onePortContext)
 683     {
 684       TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: different port\n"));
 685       DeviceListList = DeviceListList->flink;
 686     }
 687     else
 688     {
 689 #ifdef SATA_ENABLE
 690       if ((oneDeviceData->valid == agTRUE) &&
 691           (oneDeviceData->registered == agTRUE) &&
 692           (oneDeviceData->tdPortContext == onePortContext) &&
 693           ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)
 694             || DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData))
 695           )
 696 #else
 697       if ((oneDeviceData->valid == agTRUE) &&
 698           (oneDeviceData->registered == agTRUE) &&
 699           (oneDeviceData->tdPortContext == onePortContext) &&
 700           ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
 701           )
 702 #endif
 703       {
 704         if (DEVICE_IS_SSP_TARGET(oneDeviceData))
 705         {
 706           TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: SSP DeviceIndex %d tiDeviceHandle %p\n",  DeviceIndex, &(oneDeviceData->tiDeviceHandle)));
 707           tiDev[DeviceIndex] = &(oneDeviceData->tiDeviceHandle);
 708           DeviceIndex++;
 709           FoundDevices++;
 710         }
 711         else if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
 712                   &&
 713                   oneDeviceData->satDevData.IDDeviceValid == agTRUE )
 714         {
 715           TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: SATA DeviceIndex %d tiDeviceHandle %p\n",  DeviceIndex, &(oneDeviceData->tiDeviceHandle)));
 716           tiDev[DeviceIndex] = &(oneDeviceData->tiDeviceHandle);
 717           DeviceIndex++;
 718           FoundDevices++;
 719         }
 720         else if (DEVICE_IS_SMP_TARGET(oneDeviceData))
 721         {
 722           TI_DBG2(("tiINIGetDeviceHandlesForWinIOCTL: SMP DeviceIndex %d tiDeviceHandle %p\n",  DeviceIndex, &(oneDeviceData->tiDeviceHandle)));
 723           tiDev[DeviceIndex] = &(oneDeviceData->tiDeviceHandle);
 724           DeviceIndex++;
 725           FoundDevices++;
 726         }
 727         else
 728         {
 729           TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: skip case !!!\n"));
 730           TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: valid %d SSP target %d STP target %d SATA device %d\n", oneDeviceData->valid, DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
 731           TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: oneDeviceData->satDevData.IDDeviceValid %d\n", oneDeviceData->satDevData.IDDeviceValid));
 732           TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: registered %d right port %d \n", oneDeviceData->registered, (oneDeviceData->tdPortContext == onePortContext)));
 733           TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: oneDeviceData->tdPortContext %p onePortContext %p\n", oneDeviceData->tdPortContext, onePortContext));
 734         }
 735         TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: valid FoundDevices %d\n", FoundDevices));
 736         TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: agDevHandle %p\n", oneDeviceData->agDevHandle));
 737       }
 738       else
 739       {
 740         TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: valid %d SSP target %d STP target %d SATA device %d\n", oneDeviceData->valid, DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
 741         TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: registered %d right port %d \n", oneDeviceData->registered, (oneDeviceData->tdPortContext == onePortContext)));
 742         TI_DBG3(("tiINIGetDeviceHandlesForWinIOCTL: oneDeviceData->tdPortContext %p onePortContext %p\n", oneDeviceData->tdPortContext, onePortContext));
 743       }
 744       //DeviceIndex++;
 745       DeviceListList = DeviceListList->flink;
 746     } /* else */
 747   }
 748
 749   if (DeviceIndex > maxDevs)
 750   {
 751     TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: DeviceIndex(%d) >= maxDevs(%d)\n", DeviceIndex, maxDevs));
 752     FoundDevices = maxDevs;
 753   }
 754
 755   TI_DBG1(("tiINIGetDeviceHandlesForWinIOCTL: returning %d found devices, pid %d\n", FoundDevices, onePortContext->id));
 756
 757   return FoundDevices;
 758 }
 759
 760
 761 /*****************************************************************************
 762 *! \brief  tiINIGetDeviceInfo
 763 *
 764 *  Purpose: This routine is called by the OS Layer find out
 765 *           the name associated with the device and where
 766 *           it is mapped (address1 and address2).
 767 *
 768 *  \param  tiRoot:          Pointer to driver Instance.
 769 *  \param  tiDeviceHandle:  device handle associated with the device
 770 *  \param  tiDeviceInfo:    pointer to structure where the information
 771 *                           needs to be copied.
 772 *  \return:
 773 *          tiSuccess - successful
 774 *          tiInvalidHandle - device handle passed is not a valid handle.
 775 *
 776 *  \note:
 777 *
 778 *****************************************************************************/
 779 osGLOBAL bit32
 780 tiINIGetDeviceInfo(
 781                    tiRoot_t            *tiRoot,
 782                    tiDeviceHandle_t    *tiDeviceHandle,
 783                    tiDeviceInfo_t      *tiDeviceInfo)
 784 {
 785   tdsaDeviceData_t     *oneDeviceData = agNULL;
 786   satDeviceData_t      *pSatDevData = agNULL;
 787   bit8                 id_limit[5];
 788   bit8                 SN_id_limit[25];
 789   agsaRoot_t           *agRoot = agNULL;
 790
 791   TI_DBG6(("tiINIGetDeviceInfo: start \n"));
 792
 793   if (tiDeviceHandle == agNULL)
 794   {
 795     TI_DBG6(("tiINIGetDeviceInfo: tiDeviceHandle NULL\n"));
 796     return tiInvalidHandle;
 797   }
 798
 799   if (tiDeviceHandle->tdData == agNULL)
 800   {
 801     TI_DBG6(("tiINIGetDeviceInfo: ^^^^^^^^^ tiDeviceHandle->tdData NULL\n"));
 802     return tiInvalidHandle;
 803   }
 804   else
 805   {
 806
 807     oneDeviceData = (tdsaDeviceData_t *)(tiDeviceHandle->tdData);
 808     agRoot = oneDeviceData->agRoot;
 809     TI_DBG6(("tiINIGetDeviceInfo: ^^^^^^^^^ tiDeviceHandle->tdData NOT NULL\n"));
 810   }
 811   if (oneDeviceData == agNULL)
 812   {
 813     TI_DBG6(("tiINIGetDeviceInfo: ^^^^^^^^^ oneDeviceData NULL\n"));
 814     return tiInvalidHandle;
 815   }
 816
 817
 818   /* filling in the link rate */
 819   if (oneDeviceData->registered == agTRUE)
 820   {
 821     tiDeviceInfo->info.devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate;
 822   }
 823   else
 824   {
 825     tiDeviceInfo->info.devType_S_Rate = (bit8)(oneDeviceData->agDeviceInfo.devType_S_Rate & 0x0f);
 826   }
 827
 828   /* just returning local and remote SAS address; doesn't have a name for SATA device, returns identify device data */
 829   if (DEVICE_IS_SATA_DEVICE(oneDeviceData) && (oneDeviceData->directlyAttached == agTRUE))
 830   {
 831     osti_memset(&id_limit, 0, sizeof(id_limit));
 832     osti_memset(&SN_id_limit, 0, sizeof(SN_id_limit));
 833
 834     /* SATA signature 0xABCD */
 835     id_limit[0] = 0xA;
 836     id_limit[1] = 0xB;
 837     id_limit[2] = 0xC;
 838     id_limit[3] = 0xD;
 839
 840     pSatDevData = &(oneDeviceData->satDevData);
 841     if (pSatDevData->satNCQ == agTRUE)
 842     {
 843       id_limit[4] = (bit8)pSatDevData->satNCQMaxIO;
 844     }
 845     else
 846     {
 847       /* no NCQ */
 848       id_limit[4] = 1;
 849     }
 850
 851     osti_memcpy(&SN_id_limit, &(oneDeviceData->satDevData.satIdentifyData.serialNumber), 20);
 852     osti_memcpy(&(SN_id_limit[20]), &id_limit, 5);
 853     osti_memcpy(oneDeviceData->satDevData.SN_id_limit, SN_id_limit, 25);
 854     /* serialNumber, 20 bytes + ABCD + NCQ LENGTH ; modelNumber, 40 bytes */
 855 //  tiDeviceInfo->remoteName    = (char *)&(oneDeviceData->satDevData.satIdentifyData.serialNumber);
 856     tiDeviceInfo->remoteName    = (char *)oneDeviceData->satDevData.SN_id_limit;
 857     tiDeviceInfo->remoteAddress = (char *)&(oneDeviceData->satDevData.satIdentifyData.modelNumber);
 858 //    TI_DBG1(("tiINIGetDeviceInfo: SATA device remote hi 0x%08x lo 0x%08x\n", oneDeviceData->tdPortContext->sasRemoteAddressHi, oneDeviceData->tdPortContext->sasRemoteAddressLo));
 859 //    tdhexdump("tiINIGetDeviceInfo remotename", (bit8 *)&(oneDeviceData->satDevData.satIdentifyData.serialNumber), 20);
 860 //    tdhexdump("tiINIGetDeviceInfo new name", (bit8 *)&(SN_id_limit), sizeof(SN_id_limit));
 861 //    tdhexdump("tiINIGetDeviceInfo remoteaddress", (bit8 *)&(oneDeviceData->satDevData.satIdentifyData.modelNumber),40);
 862     tiDeviceInfo->osAddress1 = 25;
 863     tiDeviceInfo->osAddress2 = 40;
 864
 865   }
 866   else if (DEVICE_IS_STP_TARGET(oneDeviceData))
 867   {
 868     /* serialNumber, 20 bytes; modelNumber, 40 bytes */
 869     tiDeviceInfo->remoteName    = (char *)&(oneDeviceData->satDevData.satIdentifyData.serialNumber);
 870     tiDeviceInfo->remoteAddress = (char *)&(oneDeviceData->satDevData.satIdentifyData.modelNumber);
 871 //    TI_DBG1(("tiINIGetDeviceInfo: SATA device remote hi 0x%08x lo 0x%08x\n", oneDeviceData->tdPortContext->sasRemoteAddressHi, oneDeviceData->tdPortContext->sasRemoteAddressLo));
 872 //    tdhexdump("tiINIGetDeviceInfo remotename", (bit8 *)&(oneDeviceData->satDevData.satIdentifyData.serialNumber), 20);
 873 //    tdhexdump("tiINIGetDeviceInfo remoteaddress", (bit8 *)&(oneDeviceData->satDevData.satIdentifyData.modelNumber),40);
 874     tiDeviceInfo->osAddress1 = 20;
 875     tiDeviceInfo->osAddress2 = 40;
 876   }
 877   else
 878   {
 879     tiDeviceInfo->remoteName    = (char *)&(oneDeviceData->SASAddressID.sasAddressHi);
 880     tiDeviceInfo->remoteAddress = (char *)&(oneDeviceData->SASAddressID.sasAddressLo);
 881     TI_DBG1(("tiINIGetDeviceInfo: SAS device remote hi 0x%08x lo 0x%08x\n", oneDeviceData->tdPortContext->sasRemoteAddressHi, oneDeviceData->tdPortContext->sasRemoteAddressLo));
 882     tiDeviceInfo->osAddress1 = 4;
 883     tiDeviceInfo->osAddress2 = 4;
 884   }
 885
 886   tiDeviceInfo->localName     = (char *)&(oneDeviceData->tdPortContext->sasLocalAddressHi);
 887   tiDeviceInfo->localAddress  = (char *)&(oneDeviceData->tdPortContext->sasLocalAddressLo);
 888
 889   TI_DBG6(("tiINIGetDeviceInfo: local hi 0x%08x lo 0x%08x\n", oneDeviceData->tdPortContext->sasLocalAddressHi, oneDeviceData->tdPortContext->sasLocalAddressLo));
 890
 891   if (oneDeviceData->agDevHandle == agNULL)
 892   {
 893     TI_DBG1(("tiINIGetDeviceInfo: Error! oneDeviceData->agDevHandle is NULL"));
 894     return tiError;
 895   }
 896   else
 897   {
 898     saGetDeviceInfo(agRoot, agNULL, 0, 0,oneDeviceData->agDevHandle);
 899   }
 900
 901
 902   return tiSuccess;
 903 }
 904
 905 /*****************************************************************************
 906 *! \brief  tiINILogin
 907 *
 908 *  Purpose: This function is called to request that the Transport Dependent
 909 *           Layer initiates login for a specific target.
 910 *
 911 *  \param tiRoot:          Pointer to driver Instance.
 912 *  \param tiDeviceHandle:  Pointer to a target device handle discovered
 913 *                          following the discovery.
 914 *
 915 *  \return:
 916 *        tiSuccess       Login initiated.
 917 *        tiError         Login failed.
 918 *        tiBusy          Login can not be initiated at this time.
 919 *        tiNotSupported  This API is currently not supported by this
 920 *                        Transport Layer
 921 *
 922 *
 923 *****************************************************************************/
 924 osGLOBAL bit32
 925 tiINILogin(
 926            tiRoot_t            *tiRoot,
 927            tiDeviceHandle_t    *tiDeviceHandle
 928            )
 929 {
 930   TI_DBG6(("tiINILogin: start\n"));
 931   return tiNotSupported;
 932 }
 933
 934 /*****************************************************************************
 935 *! \brief  tiINILogout
 936 *
 937 *  Purpose: This function is called to request that the Transport Dependent
 938 *           Layer initiates logout for a specific target from the previously
 939 *           successful login through tiINILogin() call.
 940 *
 941 *  \param   tiRoot      :  Pointer to the OS Specific module allocated tiRoot_t
 942 *                          instance.
 943 *  \param tiDeviceHandle:  Pointer to a target device handle.
 944 *
 945 *  \return:
 946 *         tiSuccess       Logout initiated.
 947 *         tiError         Logout failed.
 948 *         tiBusy          Logout can not be initiated at this time.
 949 *         tiNotSupported  This API is currently not supported by this
 950 *                         Transport Layer
 951 *
 952 *
 953 *****************************************************************************/
 954 osGLOBAL bit32
 955 tiINILogout(
 956             tiRoot_t            *tiRoot,
 957             tiDeviceHandle_t    *tiDeviceHandle
 958             )
 959 {
 960   TI_DBG6(("tiINILogout: start\n"));
 961   return tiNotSupported;
 962 }
 963 /*****************************************************************************
 964 *! \brief  tiINIGetExpander
 965 *
 966 *
 967 *  \note:
 968 *
 969 *****************************************************************************/
 970 osGLOBAL bit32
 971 tiINIGetExpander(
 972                   tiRoot_t          * tiRoot,
 973                   tiPortalContext_t * tiPortalContext,
 974                   tiDeviceHandle_t  * tiDev,
 975                   tiDeviceHandle_t  ** tiExp
 976                  )
 977 {
 978   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 979   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 980   tdList_t          *PortContextList;
 981   tdsaPortContext_t *onePortContext = agNULL;
 982   tdsaDeviceData_t  *oneDeviceData = agNULL;
 983   tdList_t          *DeviceListList;
 984   tdsaDeviceData_t  *oneTargetDeviceData = agNULL;
 985   tdsaDeviceData_t  *oneExpanderDeviceData = agNULL;
 986   bit32             found = agFALSE;
 987   oneTargetDeviceData = (tdsaDeviceData_t *)tiDev->tdData;
 988   if (oneTargetDeviceData == agNULL)
 989   {
 990     TI_DBG1(("tiINIGetExpander: oneTargetDeviceData is NULL\n"));
 991     return tiError;
 992   }
 993   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
 994   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
 995   {
 996     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
 997     TI_DBG1(("tiINIGetExpander: No available tdsaPortContext\n"));
 998     TI_DBG1(("tiINIGetExpander: second, returning 0\n"));
 999     return tiError;
1000   }
1001   else
1002   {
1003     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1004   }
1005   /* find a corresponding portcontext */
1006   PortContextList = tdsaAllShared->MainPortContextList.flink;
1007   while (PortContextList != &(tdsaAllShared->MainPortContextList))
1008   {
1009     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
1010     TI_DBG3(("tiINIGetExpander: oneportContext pid %d\n", onePortContext->id));
1011     if (onePortContext->tiPortalContext == tiPortalContext && onePortContext->valid == agTRUE)
1012     {
1013       TI_DBG3(("tiINIGetExpander: found; oneportContext pid %d\n", onePortContext->id));
1014       found = agTRUE;
1015       break;
1016     }
1017     PortContextList = PortContextList->flink;
1018   }
1019   if (found == agFALSE)
1020   {
1021     TI_DBG1(("tiINIGetExpander: First, No corresponding tdsaPortContext\n"));
1022     TI_DBG1(("tiINIGetExpander: third, returning 0\n"));
1023     return tiError;
1024   }
1025   if (onePortContext == agNULL)
1026   {
1027     TI_DBG1(("tiINIGetExpander: Second, No corressponding tdsaPortContext\n"));
1028     TI_DBG1(("tiINIGetExpander: fourth, returning 0\n"));
1029     return tiError;
1030   }
1031   if (onePortContext->valid == agFALSE)
1032   {
1033     TI_DBG1(("tiINIGetExpander: Third, tdsaPortContext is invalid, pid %d\n", onePortContext->id));
1034     TI_DBG1(("tiINIGetExpander: fifth, returning 0\n"));
1035     return tiError;
1036   }
1037   DeviceListList = tdsaAllShared->MainDeviceList.flink;
1038   while ( DeviceListList != &(tdsaAllShared->MainDeviceList) )
1039   {
1040     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
1041     if (oneDeviceData->tdPortContext != onePortContext)
1042     {
1043       TI_DBG3(("tiINIGetExpander: different port\n"));
1044       DeviceListList = DeviceListList->flink;
1045     }
1046     else
1047     {
1048       if (oneDeviceData == oneTargetDeviceData)
1049       {
1050         oneExpanderDeviceData = oneDeviceData->ExpDevice;
1051         if (oneExpanderDeviceData == agNULL)
1052         {
1053           TI_DBG1(("tiINIGetExpander: oneExpanderDeviceData is NULL\n"));
1054           return tiError;
1055         }
1056         *tiExp = &(oneExpanderDeviceData->tiDeviceHandle);
1057         return tiSuccess;
1058       }
1059       DeviceListList = DeviceListList->flink;
1060     }
1061   }
1062   return tiError;
1063 }
1064
1065
1066 osGLOBAL void tiIniGetDirectSataSasAddr(tiRoot_t * tiRoot, bit32 phyId, bit8 **sasAddressHi, bit8 **sasAddressLo)
1067 {
1068         tdsaRoot_t                *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
1069         tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1070         agsaRoot_t        *agRoot = &tdsaAllShared->agRootInt;
1071         tiIOCTLPayload_wwn_t   agIoctlPayload;
1072         bit8 nvmDev;
1073         bit32 status;
1074         int i;
1075         agIoctlPayload.Length = 4096;
1076         agIoctlPayload.Reserved = 0;
1077         agIoctlPayload.MinorFunction = IOCTL_MN_NVMD_GET_CONFIG;
1078         agIoctlPayload.MajorFunction = IOCTL_MJ_NVMD_GET;
1079           tiCOMDelayedInterruptHandler(tiRoot, 0,1, tiNonInterruptContext);
1080         if(tiIS_SPC(agRoot))
1081         {
1082           nvmDev = 4;
1083           status = tdsaNVMDGetIoctl(tiRoot, (tiIOCTLPayload_t *)&agIoctlPayload, agNULL, agNULL, &nvmDev);
1084         }
1085         else
1086         {
1087           nvmDev = 1;
1088           status = tdsaNVMDGetIoctl(tiRoot, (tiIOCTLPayload_t *)&agIoctlPayload, agNULL, agNULL, &nvmDev);
1089         }
1090         if(status == IOCTL_CALL_FAIL)
1091         {
1092 #if !(defined(__FreeBSD__))
1093            printk("Error getting Adapter WWN\n");
1094 #else
1095            printf("Error getting Adapter WWN\n");
1096 #endif
1097            return;
1098         }
1099         for(i=0; i< TD_MAX_NUM_PHYS; i++)
1100         {
1101            *(bit32 *)(tdsaAllShared->Ports[i].SASID.sasAddressHi) = *(bit32 *)&agIoctlPayload.FunctionSpecificArea[0];
1102            *(bit32 *)(tdsaAllShared->Ports[i].SASID.sasAddressLo) = *(bit32 *)&agIoctlPayload.FunctionSpecificArea[4];
1103         TI_DBG3(("SAS AddressHi is 0x%x\n",  *(bit32 *)(tdsaAllShared->Ports[i].SASID.sasAddressHi)));
1104         TI_DBG3(("SAS AddressLo is 0x%x\n",  *(bit32 *)(tdsaAllShared->Ports[i].SASID.sasAddressLo)));
1105         }
1106         *sasAddressHi = tdsaAllShared->Ports[phyId].SASID.sasAddressHi;
1107         *sasAddressLo = tdsaAllShared->Ports[phyId].SASID.sasAddressLo;
1108 }
1109 osGLOBAL tiDeviceHandle_t *
1110 tiINIGetExpDeviceHandleBySasAddress(
1111                       tiRoot_t          * tiRoot,
1112                       tiPortalContext_t * tiPortalContext,
1113                                           bit32 sas_addr_hi,
1114                                           bit32 sas_addr_lo,
1115                                           bit32               maxDevs
1116                       )
1117
1118 {
1119   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
1120   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1121   tdList_t          *PortContextList;
1122   tdsaPortContext_t *onePortContext = agNULL;
1123   tdsaDeviceData_t  *oneDeviceData = agNULL;
1124   tdList_t          *DeviceListList;
1125   //bit32             i;
1126   //bit32             FoundDevices = 0;
1127   bit32             DeviceIndex = 0;
1128   bit32             found = agFALSE;
1129
1130
1131   TI_DBG2(("tiINIGetExpDeviceHandleBySasAddress: start\n"));
1132   TI_DBG2(("tiINIGetExpDeviceHandleBySasAddress: tiPortalContext %p\n", tiPortalContext));
1133
1134
1135   if (maxDevs == 0)
1136   {
1137     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: maxDevs is 0\n"));
1138
1139     return agNULL;
1140   }
1141
1142   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1143   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
1144   {
1145     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1146     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: No available tdsaPortContext\n"));
1147     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: second, returning 0\n"));
1148     return agNULL;
1149   }
1150   else
1151   {
1152     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1153   }
1154   /* find a corresponding portcontext */
1155   PortContextList = tdsaAllShared->MainPortContextList.flink;
1156
1157   if(PortContextList == agNULL)
1158   {
1159         TI_DBG6(("tiINIGetExpDeviceHandleBySasAddress: PortContextList is NULL!!\n"));
1160         return agNULL;
1161   }
1162
1163   while (PortContextList != &(tdsaAllShared->MainPortContextList))
1164   {
1165     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
1166
1167         if(onePortContext == agNULL)
1168         {
1169           TI_DBG6(("tiINIGetExpDeviceHandleBySasAddress: onePortContext is NULL!!\n"));
1170           return agNULL;
1171     }
1172
1173     TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: oneportContext pid %d\n", onePortContext->id));
1174     if (onePortContext->tiPortalContext == tiPortalContext && onePortContext->valid == agTRUE)
1175     {
1176       TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: found; oneportContext pid %d\n", onePortContext->id));
1177       found = agTRUE;
1178       break;
1179     }
1180
1181         if(PortContextList != agNULL)
1182         {
1183       PortContextList = PortContextList->flink;
1184         }
1185
1186   }
1187
1188   if (found == agFALSE)
1189   {
1190     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: First, No corresponding tdsaPortContext\n"));
1191     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: third, returning 0\n"));
1192     /* nullify all device handles */
1193     return agNULL;
1194   }
1195
1196   if (onePortContext == agNULL)
1197   {
1198     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: Second, No corressponding tdsaPortContext\n"));
1199     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: fourth, returning 0\n"));
1200     /* nullify all device handles */
1201     return agNULL;
1202   }
1203
1204   if (onePortContext->valid == agFALSE)
1205   {
1206     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: Third, tdsaPortContext is invalid, pid %d\n", onePortContext->id));
1207     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: fifth, returning 0\n"));
1208     return agNULL;
1209   }
1210
1211
1212   TI_DBG2(("tiINIGetExpDeviceHandleBySasAddress: pid %d\n", onePortContext->id));
1213
1214
1215   /* to do: check maxdev and length of Mainlink */
1216   /*
1217      From the device list, returns only valid devices
1218   */
1219   DeviceListList = tdsaAllShared->MainDeviceList.flink;
1220
1221   if(DeviceListList == agNULL)
1222   {
1223     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: DeviceListList == agNULL\n"));
1224     TI_DBG1(("tiINIGetExpDeviceHandleBySasAddress: seventh, returning not found, pid %d\n", onePortContext->id));
1225     return agNULL;
1226   }
1227
1228   while ((DeviceIndex < maxDevs) &&
1229           DeviceListList != &(tdsaAllShared->MainDeviceList))
1230   {
1231     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
1232
1233         if(oneDeviceData == agNULL)
1234         {
1235           TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: oneDeviceData is NULL!!\n"));
1236           return agNULL;
1237         }
1238
1239
1240     TI_DBG6(("tiINIGetExpDeviceHandleBySasAddress: handle %p\n",  &(oneDeviceData->tiDeviceHandle)));
1241     if (oneDeviceData->tdPortContext != onePortContext)
1242     {
1243       TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: different port\n"));
1244
1245           if(DeviceListList != agNULL)
1246           {
1247         DeviceListList = DeviceListList->flink;
1248           }
1249
1250     }
1251     else
1252     {
1253
1254       if ((oneDeviceData->valid == agTRUE) &&
1255           (oneDeviceData->registered == agTRUE) &&
1256           (oneDeviceData->tdPortContext == onePortContext) &&
1257           (
1258           (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE) ||
1259           (oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE) ||
1260            DEVICE_IS_SMP_TARGET(oneDeviceData)
1261           )
1262          )
1263
1264       {
1265
1266                 if(oneDeviceData->SASAddressID.sasAddressLo == sas_addr_lo && oneDeviceData->SASAddressID.sasAddressHi == sas_addr_hi)
1267                 {
1268                   //TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: valid FoundDevices %d\n", FoundDevices));
1269               TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: agDevHandle %p\n", oneDeviceData->agDevHandle));
1270           TI_DBG3(("tiINIGetExpDeviceHandleBySasAddress: Matched sas address:  low %x and high %x\n", oneDeviceData->SASAddressID.sasAddressLo,  oneDeviceData->SASAddressID.sasAddressHi));
1271                   return &(oneDeviceData->tiDeviceHandle);
1272                 }
1273       }
1274       DeviceIndex++;
1275       DeviceListList = DeviceListList->flink;
1276     } /* else */
1277   }
1278
1279   return agNULL;
1280 }
1281
1282
1283
1284
1285 #ifdef TD_DISCOVER
1286 /*****************************************************************************
1287 *! \brief  tdsaDiscover
1288 *
1289 *  Purpose:  This function is called to trigger topology discovery within a
1290 *            portcontext.
1291 *
1292 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1293 *                   instance.
1294 *  \param   onePortContext: Pointer to the portal context instance.
1295 *  \param   type: Type of discovery. It can be SAS or SATA.
1296 *  \param   option: discovery option. It can be Full or Incremental discovery.
1297 *
1298 *  \return:
1299 *           tiSuccess    Discovery initiated.
1300 *           tiError      Discovery could not be initiated at this time.
1301 *
1302 *   \note:
1303 *
1304 *****************************************************************************/
1305 osGLOBAL bit32
1306 tdsaDiscover(
1307              tiRoot_t          *tiRoot,
1308              tdsaPortContext_t *onePortContext,
1309              bit32             type,
1310              bit32             option
1311              )
1312
1313 {
1314   bit32             ret = tiError;
1315   TI_DBG3(("tdsaDiscover: start\n"));
1316
1317   if (onePortContext->valid == agFALSE)
1318   {
1319     TI_DBG1(("tdsaDiscover: aborting discovery\n"));
1320     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1321     return ret;
1322   }
1323
1324   switch ( option )
1325   {
1326   case TDSA_DISCOVERY_OPTION_FULL_START:
1327     TI_DBG3(("tdsaDiscover: full\n"));
1328     onePortContext->discovery.type = TDSA_DISCOVERY_OPTION_FULL_START;
1329     if ( type == TDSA_DISCOVERY_TYPE_SAS )
1330     {
1331       ret = tdsaSASFullDiscover(tiRoot, onePortContext);
1332     }
1333 #ifdef SATA_ENABLE
1334     else if ( type == TDSA_DISCOVERY_TYPE_SATA )
1335     {
1336       if (onePortContext->discovery.status == DISCOVERY_SAS_DONE)
1337       {
1338         ret = tdsaSATAFullDiscover(tiRoot, onePortContext);
1339       }
1340     }
1341 #endif
1342     break;
1343   case TDSA_DISCOVERY_OPTION_INCREMENTAL_START:
1344     TI_DBG3(("tdsaDiscover: incremental\n"));
1345     onePortContext->discovery.type = TDSA_DISCOVERY_OPTION_INCREMENTAL_START;
1346     if ( type == TDSA_DISCOVERY_TYPE_SAS )
1347     {
1348       TI_DBG3(("tdsaDiscover: incremental SAS\n"));
1349       ret = tdsaSASIncrementalDiscover(tiRoot, onePortContext);
1350     }
1351 #ifdef SATA_ENABLE
1352     else if ( type == TDSA_DISCOVERY_TYPE_SATA )
1353     {
1354       if (onePortContext->discovery.status == DISCOVERY_SAS_DONE)
1355       {
1356         TI_DBG3(("tdsaDiscover: incremental SATA\n"));
1357         ret = tdsaSATAIncrementalDiscover(tiRoot, onePortContext);
1358       }
1359     }
1360 #endif
1361     break;
1362   case TDSA_DISCOVERY_OPTION_ABORT:
1363     TI_DBG1(("tdsaDiscover: abort\n"));
1364     break;
1365   default:
1366     break;
1367
1368   }
1369   if (ret != tiSuccess)
1370   {
1371     TI_DBG1(("tdsaDiscover: fail, error 0x%x\n", ret));
1372   }
1373   return ret;
1374 }
1375
1376 /*****************************************************************************
1377 *! \brief  tdsaSASFullDiscover
1378 *
1379 *  Purpose:  This function is called to trigger full SAS topology discovery
1380 *            within a portcontext.
1381 *
1382 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1383 *                   instance.
1384 *  \param   onePortContext: Pointer to the portal context instance.
1385 *
1386 *  \return:
1387 *           tiSuccess    Discovery initiated.
1388 *           tiError      Discovery could not be initiated at this time.
1389 *
1390 *   \note:
1391 *
1392 *****************************************************************************/
1393 osGLOBAL bit32
1394 tdsaSASFullDiscover(
1395                     tiRoot_t          *tiRoot,
1396                     tdsaPortContext_t *onePortContext
1397                     )
1398 {
1399   tdsaRoot_t           *tdsaRoot       = (tdsaRoot_t *) tiRoot->tdData;
1400   tdsaContext_t        *tdsaAllShared  = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1401   tdsaDeviceData_t     *oneDeviceData  = agNULL;
1402   tdList_t             *DeviceListList;
1403   int                  i, j;
1404   bit8                 portMaxRate;
1405   TI_DBG3(("tdsaSASFullDiscover: start\n"));
1406   if (onePortContext->valid == agFALSE)
1407   {
1408     TI_DBG1(("tdsaSASFullDiscover: aborting discovery\n"));
1409     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1410     return tiError;
1411   }
1412   /*
1413     1. abort all IO; may need a new LL API since TD does not queue IO's
1414     2. initializes(or invalidate) devices belonging to the port
1415     3. onePortContext->DiscoveryState == ITD_DSTATE_STARTED
1416     4. add directly connected one; if directed-SAS, spin-up
1417     5. tdsaSASUpStreamDiscoverStart(agRoot, pPort, pDevice)
1418   */
1419   /*
1420     invalidate all devices belonging to the portcontext except direct attached SAS/SATA
1421   */
1422   DeviceListList = tdsaAllShared->MainDeviceList.flink;
1423   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
1424   {
1425     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
1426     TI_DBG3(("tdsaSASFullDiscover: STARTED loop id %d\n", oneDeviceData->id));
1427     TI_DBG3(("tdsaSASFullDiscover: STARTED loop sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
1428     TI_DBG3(("tdsaSASFullDiscover: STARTED loop sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
1429     if (oneDeviceData->tdPortContext == onePortContext &&
1430         (onePortContext->nativeSATAMode == agFALSE && onePortContext->directAttatchedSAS == agFALSE)             )
1431
1432     {
1433       TI_DBG3(("tdsaSASFullDiscover: invalidate\n"));
1434       oneDeviceData->valid = agFALSE;
1435       oneDeviceData->processed = agFALSE;
1436     }
1437     else
1438     {
1439       TI_DBG3(("tdsaSASFullDiscover: not invalidate\n"));
1440       /* no changes */
1441     }
1442     DeviceListList = DeviceListList->flink;
1443   }
1444
1445   onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
1446   /* nativeSATAMode is set in ossaHwCB() in link up */
1447   if (onePortContext->nativeSATAMode == agFALSE) /* default: SAS and SAS/SATA mode */
1448   {
1449     if (SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe) == SAS_END_DEVICE &&
1450         SA_IDFRM_IS_SSP_TARGET(&onePortContext->sasIDframe) )
1451     {
1452       for(i=0;i<TD_MAX_NUM_PHYS;i++)
1453       {
1454         if (onePortContext->PhyIDList[i] == agTRUE)
1455         {
1456
1457            for (j=0;j<TD_MAX_NUM_NOTIFY_SPINUP;j++)
1458            {
1459              saLocalPhyControl(onePortContext->agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), i, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
1460            }
1461            break;
1462         }
1463       }
1464     }
1465     /*
1466       add the device
1467       1. add device in TD layer
1468       2. call saRegisterNewDevice
1469       3. update agDevHandle in ossaDeviceRegistrationCB()
1470     */
1471     portMaxRate = onePortContext->LinkRate;
1472     oneDeviceData = tdsaPortSASDeviceAdd(
1473                                          tiRoot,
1474                                          onePortContext,
1475                                          onePortContext->sasIDframe,
1476                                          agFALSE,
1477                                          portMaxRate,
1478                                          IT_NEXUS_TIMEOUT,
1479                                          0,
1480                                          SAS_DEVICE_TYPE,
1481                                          agNULL,
1482                                          0xFF
1483                                          );
1484     if (oneDeviceData)
1485     {
1486       if (oneDeviceData->registered == agFALSE)
1487       {
1488         /*
1489           set the timer and wait till the device(directly attached. eg Expander) to be registered.
1490          Then, in tdsaDeviceRegistrationTimerCB(), tdsaSASUpStreamDiscoverStart() is called
1491         */
1492         tdsaDeviceRegistrationTimer(tiRoot, onePortContext, oneDeviceData);
1493       }
1494       else
1495       {
1496         tdsaSASUpStreamDiscoverStart(tiRoot, onePortContext, oneDeviceData);
1497       }
1498     }
1499 #ifdef REMOVED
1500     // temp testing code
1501     tdsaReportManInfoSend(tiRoot, oneDeviceData);
1502     //end temp testing code
1503 #endif
1504   }
1505   else /* SATAOnlyMode*/
1506   {
1507     tdsaSASDiscoverDone(tiRoot, onePortContext, tiSuccess);
1508   }
1509
1510   return tiSuccess;
1511 }
1512
1513 /*****************************************************************************
1514 *! \brief  tdsaSASUpStreamDiscoverStart
1515 *
1516 *  Purpose:  This function is called to trigger upstream traverse in topology
1517 *            within a portcontext.
1518 *
1519 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1520 *                   instance.
1521 *  \param   onePortContext: Pointer to the portal context instance.
1522 *  \param   oneDeviceData: Pointer to the device data.
1523 *
1524 *  \return:
1525 *           None
1526 *
1527 *   \note:
1528 *
1529 *****************************************************************************/
1530 osGLOBAL void
1531 tdsaSASUpStreamDiscoverStart(
1532                              tiRoot_t             *tiRoot,
1533                              tdsaPortContext_t    *onePortContext,
1534                              tdsaDeviceData_t     *oneDeviceData
1535                              )
1536 {
1537   tdsaExpander_t        *oneExpander;
1538
1539   TI_DBG3(("tdsaSASUpStreamDiscoverStart: start\n"));
1540
1541   if (onePortContext->valid == agFALSE)
1542   {
1543     TI_DBG1(("tdsaSASUpStreamDiscoverStart: aborting discovery\n"));
1544     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1545     return;
1546   }
1547
1548   /*
1549     1. update discovery state to UP_STREAM
1550     2. if (expander) add it
1551     3. tdsaSASUpStreamDiscovering
1552
1553   */
1554   onePortContext->discovery.status = DISCOVERY_UP_STREAM;
1555   if (
1556       (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
1557        ||
1558       (oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE)
1559       )
1560   {
1561     oneExpander = tdssSASDiscoveringExpanderAlloc(tiRoot, onePortContext, oneDeviceData);
1562     if ( oneExpander != agNULL)
1563     {
1564       /* (2.2.1) Add to discovering list */
1565       tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, oneExpander);
1566     }
1567     else
1568     {
1569       TI_DBG1(("tdsaSASUpStreamDiscoverStart: failed to allocate expander or discovey aborted\n"));
1570       return;
1571     }
1572   }
1573
1574   tdsaSASUpStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
1575
1576   return;
1577 }
1578
1579 /*****************************************************************************
1580 *! \brief  tdsaSASUpStreamDiscovering
1581 *
1582 *  Purpose:  For each expander in the expander list, this function sends SMP to
1583 *            find information for discovery and calls
1584 *            tdsaSASDownStreamDiscoverStart() function.
1585 *
1586 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1587 *                   instance.
1588 *  \param   onePortContext: Pointer to the portal context instance.
1589 *  \param   oneDeviceData: Pointer to the device data.
1590 *
1591 *  \return:
1592 *           None
1593 *
1594 *   \note:
1595 *
1596 *****************************************************************************/
1597 osGLOBAL void
1598 tdsaSASUpStreamDiscovering(
1599                            tiRoot_t             *tiRoot,
1600                            tdsaPortContext_t    *onePortContext,
1601                            tdsaDeviceData_t     *oneDeviceData
1602                            )
1603 {
1604   tdList_t          *ExpanderList;
1605   tdsaExpander_t    *oneNextExpander = agNULL;
1606
1607   TI_DBG3(("tdsaSASUpStreamDiscovering: start\n"));
1608   if (onePortContext->valid == agFALSE)
1609   {
1610     TI_DBG1(("tdsaSASUpStreamDiscovering: aborting discovery\n"));
1611     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1612     return;
1613   }
1614   /*
1615     1. find the next expander
1616     2. if (there is next expander) send report general with saSMPStart
1617        else tdsaSASDownStreamDiscoverStart
1618
1619   */
1620   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1621   if (TDLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
1622   {
1623     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1624     TI_DBG3(("tdsaSASUpStreamDiscovering: should be the end\n"));
1625     oneNextExpander = agNULL;
1626   }
1627   else
1628   {
1629     TDLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(onePortContext->discovery.discoveringExpanderList));
1630     oneNextExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
1631     TDLIST_ENQUEUE_AT_HEAD(&(oneNextExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));
1632     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1633
1634     TI_DBG3(("tdssSASDiscoveringExpander tdsaSASUpStreamDiscovering: dequeue head\n"));
1635     TI_DBG3(("tdsaSASUpStreamDiscovering: expander id %d\n", oneNextExpander->id));
1636   }
1637
1638   if (oneNextExpander != agNULL)
1639   {
1640     tdsaReportGeneralSend(tiRoot, oneNextExpander->tdDevice);
1641   }
1642   else
1643   {
1644     TI_DBG3(("tdsaSASUpStreamDiscovering: No more expander list\n"));
1645     tdsaSASDownStreamDiscoverStart(tiRoot, onePortContext, oneDeviceData);
1646   }
1647
1648   return;
1649 }
1650
1651 /*****************************************************************************
1652 *! \brief  tdsaSASDownStreamDiscoverStart
1653 *
1654 *  Purpose:  This function is called to trigger downstream traverse in topology
1655 *            within a portcontext.
1656 *
1657 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1658 *                   instance.
1659 *  \param   onePortContext: Pointer to the portal context instance.
1660 *  \param   oneDeviceData: Pointer to the device data.
1661 *
1662 *  \return:
1663 *           None
1664 *
1665 *   \note:
1666 *
1667 *****************************************************************************/
1668 osGLOBAL void
1669 tdsaSASDownStreamDiscoverStart(
1670                                tiRoot_t             *tiRoot,
1671                                tdsaPortContext_t    *onePortContext,
1672                                tdsaDeviceData_t     *oneDeviceData
1673                                )
1674 {
1675   tdsaExpander_t        *oneExpander;
1676   tdsaExpander_t        *UpStreamExpander;
1677   TI_DBG3(("tdsaSASDownStreamDiscoverStart: start\n"));
1678
1679   if (onePortContext->valid == agFALSE)
1680   {
1681     TI_DBG1(("tdsaSASDownStreamDiscoverStart: aborting discovery\n"));
1682     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1683     return;
1684   }
1685   /*
1686     1. update discover state
1687     2. if (expander is root) add it
1688        else just add it
1689     3. tdsaSASDownStreamDiscovering
1690
1691   */
1692   /* set discovery status */
1693   onePortContext->discovery.status = DISCOVERY_DOWN_STREAM;
1694
1695   TI_DBG3(("tdsaSASDownStreamDiscoverStart: pPort=%p pDevice=%p\n", onePortContext, oneDeviceData));
1696
1697   /* If it's an expander */
1698   if ( (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
1699        || (oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE))
1700   {
1701     oneExpander = oneDeviceData->tdExpander;
1702     UpStreamExpander = oneExpander->tdUpStreamExpander;
1703
1704     /* If the two expanders are the root of two edge sets; sub-to-sub */
1705     if ( (UpStreamExpander != agNULL) && ( UpStreamExpander->tdUpStreamExpander == oneExpander ) )
1706     {
1707       TI_DBG3(("tdsaSASDownStreamDiscoverStart: Root found pExpander=%p pUpStreamExpander=%p\n",
1708                oneExpander, UpStreamExpander));
1709       //Saves the root expander
1710       onePortContext->discovery.RootExp = oneExpander;
1711       TI_DBG3(("tdsaSASDownStreamDiscoverStart: Root exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
1712       TI_DBG3(("tdsaSASDownStreamDiscoverStart: Root exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
1713
1714       /* reset up stream inform for pExpander */
1715       oneExpander->tdUpStreamExpander = agNULL;
1716       /* Add the pExpander to discovering list */
1717       tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, oneExpander);
1718
1719       /* reset up stream inform for oneExpander */
1720       UpStreamExpander->tdUpStreamExpander = agNULL;
1721       /* Add the UpStreamExpander to discovering list */
1722       tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, UpStreamExpander);
1723     }
1724     /* If the two expanders are not the root of two edge sets. eg) one root */
1725     else
1726     {
1727       //Saves the root expander
1728       onePortContext->discovery.RootExp = oneExpander;
1729
1730       TI_DBG3(("tdsaSASDownStreamDiscoverStart: NO Root pExpander=%p\n", oneExpander));
1731       TI_DBG3(("tdsaSASDownStreamDiscoverStart: Root exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
1732       TI_DBG3(("tdsaSASDownStreamDiscoverStart: Root exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
1733
1734       /* (2.2.2.1) Add the pExpander to discovering list */
1735       tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, oneExpander);
1736     }
1737   }
1738
1739   /* Continue down stream discovering */
1740   tdsaSASDownStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
1741
1742   return;
1743 }
1744
1745 /*****************************************************************************
1746 *! \brief  tdsaSASDownStreamDiscovering
1747 *
1748 *  Purpose:  For each expander in the expander list, this function sends SMP to
1749 *            find information for discovery and calls
1750 *            tdsaSASDownStreamDiscoverStart() function.
1751 *
1752 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1753 *                   instance.
1754 *  \param   onePortContext: Pointer to the portal context instance.
1755 *  \param   oneDeviceData: Pointer to the device data.
1756 *
1757 *  \return:
1758 *           None
1759 *
1760 *   \note:
1761 *
1762 *****************************************************************************/
1763 osGLOBAL void
1764 tdsaSASDownStreamDiscovering(
1765                                tiRoot_t             *tiRoot,
1766                                tdsaPortContext_t    *onePortContext,
1767                                tdsaDeviceData_t     *oneDeviceData
1768                                )
1769 {
1770   tdsaExpander_t    *NextExpander = agNULL;
1771   tdList_t          *ExpanderList;
1772
1773   TI_DBG3(("tdsaSASDownStreamDiscovering: start\n"));
1774
1775   TI_DBG3(("tdsaSASDownStreamDiscovering: pPort=%p  pDevice=%p\n", onePortContext, oneDeviceData));
1776
1777   if (onePortContext->valid == agFALSE)
1778   {
1779     TI_DBG1(("tdsaSASDownStreamDiscovering: aborting discovery\n"));
1780     tdsaSASDiscoverAbort(tiRoot, onePortContext);
1781     return;
1782   }
1783
1784   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1785   if (TDLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
1786   {
1787     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1788     TI_DBG3(("tdsaSASDownStreamDiscovering: should be the end\n"));
1789     NextExpander = agNULL;
1790   }
1791   else
1792   {
1793     TDLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(onePortContext->discovery.discoveringExpanderList));;
1794     NextExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
1795     TDLIST_ENQUEUE_AT_HEAD(&(NextExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));;
1796     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1797     TI_DBG3(("tdssSASDiscoveringExpander tdsaSASDownStreamDiscovering: dequeue head\n"));
1798     TI_DBG3(("tdsaSASDownStreamDiscovering: expander id %d\n", NextExpander->id));
1799
1800   }
1801
1802   /* If there is an expander for continue discoving */
1803   if ( NextExpander != agNULL)
1804   {
1805     TI_DBG3(("tdsaSASDownStreamDiscovering: Found pNextExpander=%p\n, discoveryStatus=0x%x",
1806              NextExpander, onePortContext->discovery.status));
1807
1808     switch (onePortContext->discovery.status)
1809     {
1810       /* If the discovery status is DISCOVERY_DOWN_STREAM */
1811     case DISCOVERY_DOWN_STREAM:
1812       /* Send report general for the next expander */
1813       TI_DBG3(("tdsaSASDownStreamDiscovering: DownStream pNextExpander->pDevice=%p\n", NextExpander->tdDevice));
1814       tdsaReportGeneralSend(tiRoot, NextExpander->tdDevice);
1815       break;
1816       /* If the discovery status is DISCOVERY_CONFIG_ROUTING */
1817     case DISCOVERY_CONFIG_ROUTING:
1818     case DISCOVERY_REPORT_PHY_SATA:
1819
1820       /* set discovery status */
1821       onePortContext->discovery.status = DISCOVERY_DOWN_STREAM;
1822
1823       TI_DBG3(("tdsaSASDownStreamDiscovering: pPort->discovery.status=DISCOVERY_CONFIG_ROUTING, nake it DOWN_STREAM\n"));
1824       /* If not the last phy */
1825       if ( NextExpander->discoveringPhyId < NextExpander->tdDevice->numOfPhys )
1826       {
1827         TI_DBG3(("tdsaSASDownStreamDiscovering: pNextExpander->discoveringPhyId=0x%x pNextExpander->pDevice->numOfPhys=0x%x.  Send More Discover\n",
1828                  NextExpander->discoveringPhyId, NextExpander->tdDevice->numOfPhys));
1829         /* Send discover for the next expander */
1830         tdsaDiscoverSend(tiRoot, NextExpander->tdDevice);
1831         }
1832       /* If it's the last phy */
1833       else
1834       {
1835         TI_DBG3(("tdsaSASDownStreamDiscovering: Last Phy, remove expander%p  start DownStream=%p\n",
1836                  NextExpander, NextExpander->tdDevice));
1837         tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, NextExpander);
1838         tdsaSASDownStreamDiscovering(tiRoot, onePortContext, NextExpander->tdDevice);
1839       }
1840       break;
1841
1842     default:
1843       TI_DBG3(("tdsaSASDownStreamDiscovering: *** Unknown pPort->discovery.status=0x%x\n", onePortContext->discovery.status));
1844     }
1845   }
1846   /* If no expander for continue discoving */
1847   else
1848   {
1849     TI_DBG3(("tdsaSASDownStreamDiscovering: No more expander DONE\n"));
1850     /* discover done */
1851     tdsaSASDiscoverDone(tiRoot, onePortContext, tiSuccess);
1852   }
1853
1854   return;
1855 }
1856
1857 /*****************************************************************************
1858 *! \brief  tdsaCleanAllExp
1859 *
1860 *  Purpose:  This function cleans up expander data structures after discovery
1861 *            is complete.
1862 *
1863 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1864 *                   instance.
1865 *  \param   onePortContext: Pointer to the portal context instance.
1866 *
1867 *  \return:
1868 *           None
1869 *
1870 *   \note:
1871 *
1872 *****************************************************************************/
1873 osGLOBAL void
1874 tdsaCleanAllExp(
1875                 tiRoot_t                 *tiRoot,
1876                 tdsaPortContext_t        *onePortContext
1877                 )
1878 {
1879   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
1880   tdsaContext_t     *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1881   tdList_t          *ExpanderList;
1882   tdsaExpander_t    *tempExpander;
1883   tdsaPortContext_t *tmpOnePortContext = onePortContext;
1884
1885   TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: start\n"));
1886
1887   TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: before all clean up\n"));
1888   tdsaDumpAllFreeExp(tiRoot);
1889
1890   /* clean up UpdiscoveringExpanderList*/
1891   TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: clean discoveringExpanderList\n"));
1892   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1893   if (!TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
1894   {
1895     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1896     ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
1897     while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
1898     {
1899       tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
1900       TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: exp addrHi 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressHi));
1901       TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: exp addrLo 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressLo));
1902       /* putting back to the free pool */
1903       tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1904       TDLIST_DEQUEUE_THIS(&(tempExpander->linkNode));
1905       TDLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(tdsaAllShared->freeExpanderList));
1906
1907       if (TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
1908       {
1909         tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1910         break;
1911       }
1912       else
1913       {
1914         tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1915       }
1916       ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
1917
1918 //      ExpanderList = ExpanderList->flink;
1919     }
1920   }
1921   else
1922   {
1923     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1924     TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: empty discoveringExpanderList\n"));
1925   }
1926
1927   /* reset UpdiscoveringExpanderList */
1928   TDLIST_INIT_HDR(&(tmpOnePortContext->discovery.UpdiscoveringExpanderList));
1929
1930   TI_DBG3(("tdssSASDiscoveringExpander tdsaCleanAllExp: after all clean up\n"));
1931   tdsaDumpAllFreeExp(tiRoot);
1932
1933   return;
1934 }
1935
1936 /*****************************************************************************
1937 *! \brief  tdsaFreeAllExp
1938 *
1939 *  Purpose:  This function frees up expander data structures as a part of
1940 *            soft reset.
1941 *
1942 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
1943 *                   instance.
1944 *  \param   onePortContext: Pointer to the portal context instance.
1945 *
1946 *  \return:
1947 *           None
1948 *
1949 *   \note:
1950 *
1951 *****************************************************************************/
1952 osGLOBAL void
1953 tdsaFreeAllExp(
1954                 tiRoot_t                 *tiRoot,
1955                 tdsaPortContext_t        *onePortContext
1956                 )
1957 {
1958   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
1959   tdsaContext_t     *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1960   tdList_t          *ExpanderList;
1961   tdsaExpander_t    *tempExpander;
1962   tdsaPortContext_t *tmpOnePortContext = onePortContext;
1963
1964   TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: start\n"));
1965
1966   TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: before all clean up\n"));
1967   tdsaDumpAllFreeExp(tiRoot);
1968
1969   /* clean up UpdiscoveringExpanderList*/
1970   TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: clean discoveringExpanderList\n"));
1971   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1972   if (!TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
1973   {
1974     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1975     ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
1976     while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
1977     {
1978       tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
1979       TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: exp addrHi 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressHi));
1980       TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: exp addrLo 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressLo));
1981       /* putting back to the free pool */
1982       tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
1983       TDLIST_DEQUEUE_THIS(&(tempExpander->linkNode));
1984       TDLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(tdsaAllShared->freeExpanderList));
1985
1986       if (TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
1987       {
1988         tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1989         break;
1990       }
1991       else
1992       {
1993         tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
1994       }
1995       ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
1996
1997 //      ExpanderList = ExpanderList->flink;
1998     }
1999   }
2000   else
2001   {
2002     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
2003     TI_DBG3(("tdssSASDiscoveringExpander tdsaFreeAllExp: empty discoveringExpanderList\n"));
2004   }
2005
2006   /* reset UpdiscoveringExpanderList */
2007   TDLIST_INIT_HDR(&(tmpOnePortContext->discovery.UpdiscoveringExpanderList));
2008
2009   return;
2010 }
2011 /*****************************************************************************
2012 *! \brief  tdsaResetValidDeviceData
2013 *
2014 *  Purpose:  This function resets valid and valid2 field for discovered devices
2015 *            in the device list. This is used only in incremental discovery.
2016 *
2017 *  \param   agRoot        :  Pointer to chip/driver Instance.
2018 *  \param   onePortContext: Pointer to the portal context instance.
2019 *  \param   oneDeviceData: Pointer to the device data.
2020 *
2021 *  \return:
2022 *           None
2023 *
2024 *   \note:
2025 *
2026 *****************************************************************************/
2027 osGLOBAL void
2028 tdsaResetValidDeviceData(
2029                                  agsaRoot_t           *agRoot,
2030                                  tdsaPortContext_t    *onePortContext
2031                                  )
2032 {
2033   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
2034   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
2035   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2036   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2037   tdList_t          *DeviceListList;
2038   tdsaDeviceData_t  *oneDeviceData;
2039
2040   TI_DBG3(("tdsaResetValidDeviceData: start\n"));
2041
2042   tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2043   if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2044   {
2045     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2046     TI_DBG1(("tdsaResetValidDeviceData: empty device list\n"));
2047   }
2048   else
2049   {
2050     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2051     DeviceListList = tdsaAllShared->MainDeviceList.flink;
2052     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2053     {
2054       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2055       oneDeviceData->valid = oneDeviceData->valid2;
2056       oneDeviceData->valid2 = agFALSE;
2057       DeviceListList = DeviceListList->flink;
2058       TI_DBG3(("tdsaResetValidDeviceData: valid %d valid2 %d\n", oneDeviceData->valid, oneDeviceData->valid2));
2059     }
2060   }
2061
2062   return;
2063 }
2064
2065 /*****************************************************************************
2066 *! \brief  tdssReportChanges
2067 *
2068 *  Purpose:  This function goes throuhg device list and finds out whether
2069 *            a device is removed and newly added. Based on the findings,
2070 *            this function notifies OS layer of the change.
2071 *
2072 *  \param   agRoot        :  Pointer to chip/driver Instance.
2073 *  \param   onePortContext: Pointer to the portal context instance.
2074 *
2075 *  \return:
2076 *           None
2077 *
2078 *   \note:
2079 *
2080 *****************************************************************************/
2081 osGLOBAL void
2082 tdssReportChanges(
2083                   agsaRoot_t           *agRoot,
2084                   tdsaPortContext_t    *onePortContext
2085                   )
2086 {
2087   tdsaDeviceData_t  *oneDeviceData = agNULL;
2088   tdList_t          *DeviceListList;
2089   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
2090   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
2091   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2092   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2093   bit32             added = agFALSE, removed = agFALSE;
2094
2095   TI_DBG1(("tdssReportChanges: start\n"));
2096
2097   tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2098   if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2099   {
2100     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2101     TI_DBG1(("tdssReportChanges: empty device list\n"));
2102     return;
2103   }
2104   else
2105   {
2106     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2107   }
2108   DeviceListList = tdsaAllShared->MainDeviceList.flink;
2109   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2110   {
2111     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2112     TI_DBG3(("tdssReportChanges: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2113     TI_DBG3(("tdssReportChanges: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2114     if ( oneDeviceData->tdPortContext == onePortContext)
2115     {
2116       TI_DBG3(("tdssReportChanges: right portcontext\n"));
2117       if ( (oneDeviceData->valid == agTRUE) && (oneDeviceData->valid2 == agTRUE) )
2118       {
2119         TI_DBG3(("tdssReportChanges: same\n"));
2120         /* reset valid bit */
2121         oneDeviceData->valid = oneDeviceData->valid2;
2122         oneDeviceData->valid2 = agFALSE;
2123       }
2124       else if ( (oneDeviceData->valid == agTRUE) && (oneDeviceData->valid2 == agFALSE) )
2125       {
2126         TI_DBG3(("tdssReportChanges: removed\n"));
2127         removed = agTRUE;
2128         /* reset valid bit */
2129         oneDeviceData->valid = oneDeviceData->valid2;
2130         oneDeviceData->valid2 = agFALSE;
2131         /* reset NumOfFCA */
2132         oneDeviceData->satDevData.NumOfFCA = 0;
2133
2134         if ( (oneDeviceData->registered == agTRUE) &&
2135              ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)
2136              || DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData) )
2137            )
2138         {
2139           tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
2140         }
2141         else if (oneDeviceData->registered == agTRUE)
2142         {
2143           TI_DBG1(("tdssReportChanges: calling saDeregisterDeviceHandle, did %d\n", oneDeviceData->id));
2144           saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0);
2145         }
2146
2147         oneDeviceData->registered = agFALSE;
2148
2149 #ifdef REMOVED  /* don't remove device from the device list. May screw up ordering of report */
2150         TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
2151         TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
2152 #endif
2153       }
2154       else if ( (oneDeviceData->valid == agFALSE) && (oneDeviceData->valid2 == agTRUE) )
2155       {
2156         TI_DBG3(("tdssReportChanges: added\n"));
2157         added = agTRUE;
2158         /* reset valid bit */
2159         oneDeviceData->valid = oneDeviceData->valid2;
2160         oneDeviceData->valid2 = agFALSE;
2161       }
2162       else
2163       {
2164         TI_DBG6(("tdssReportChanges: else\n"));
2165       }
2166     }
2167     else
2168     {
2169       TI_DBG1(("tdssReportChanges: different portcontext\n"));
2170     }
2171     DeviceListList = DeviceListList->flink;
2172   }
2173   /* arrival or removal at once */
2174   if (added == agTRUE)
2175   {
2176     TI_DBG3(("tdssReportChanges: added at the end\n"));
2177 #ifdef AGTIAPI_CTL
2178     if (tdsaAllShared->SASConnectTimeLimit)
2179       tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDeviceChange,
2180                  tiDeviceArrival);
2181     else
2182 #endif
2183       ostiInitiatorEvent(
2184                          tiRoot,
2185                          onePortContext->tiPortalContext,
2186                          agNULL,
2187                          tiIntrEventTypeDeviceChange,
2188                          tiDeviceArrival,
2189                          agNULL
2190                          );
2191
2192   }
2193   if (removed == agTRUE)
2194   {
2195     TI_DBG3(("tdssReportChanges: removed at the end\n"));
2196     ostiInitiatorEvent(
2197                        tiRoot,
2198                        onePortContext->tiPortalContext,
2199                        agNULL,
2200                        tiIntrEventTypeDeviceChange,
2201                        tiDeviceRemoval,
2202                        agNULL
2203                        );
2204   }
2205
2206   if (onePortContext->discovery.forcedOK == agTRUE && added == agFALSE && removed == agFALSE)
2207   {
2208     TI_DBG1(("tdssReportChanges: missed chance to report. forced to report OK\n"));
2209     onePortContext->discovery.forcedOK = agFALSE;
2210     ostiInitiatorEvent(
2211                        tiRoot,
2212                        onePortContext->tiPortalContext,
2213                        agNULL,
2214                        tiIntrEventTypeDiscovery,
2215                        tiDiscOK,
2216                        agNULL
2217                        );
2218   }
2219
2220   if (added == agFALSE && removed == agFALSE)
2221   {
2222     TI_DBG3(("tdssReportChanges: the same\n"));
2223   }
2224   return;
2225 }
2226 /*****************************************************************************
2227 *! \brief  tdssReportRemovals
2228 *
2229 *  Purpose:  This function goes through device list and removes all devices
2230 *            belong to the portcontext. This function also deregiters those
2231 *            devices. This function is called in case of incremental discovery
2232 *            failure.
2233 *
2234 *  \param   agRoot        :  Pointer to chip/driver Instance.
2235 *  \param   onePortContext: Pointer to the portal context instance.
2236 *  \param   oneDeviceData: Pointer to the device data.
2237 *
2238 *  \return:
2239 *           None
2240 *
2241 *   \note:
2242 *
2243 *****************************************************************************/
2244 osGLOBAL void
2245 tdssReportRemovals(
2246                   agsaRoot_t           *agRoot,
2247                   tdsaPortContext_t    *onePortContext,
2248                   bit32                flag
2249                   )
2250 {
2251   tdsaDeviceData_t  *oneDeviceData = agNULL;
2252   tdList_t          *DeviceListList;
2253   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
2254   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
2255   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2256   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2257   bit32             removed = agFALSE;
2258   agsaEventSource_t *eventSource;
2259   bit32             PhyID;
2260   bit32             HwAckSatus;
2261   agsaDevHandle_t   *agDevHandle = agNULL;
2262
2263   TI_DBG2(("tdssReportRemovals: start\n"));
2264   /* in case nothing was registered */
2265   PhyID = onePortContext->eventPhyID;
2266   if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
2267       onePortContext->RegisteredDevNums == 0 &&
2268       PhyID != 0xFF
2269       )
2270   {
2271     TI_DBG2(("tdssReportRemovals: calling saHwEventAck\n"));
2272     eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
2273     HwAckSatus = saHwEventAck(
2274                               agRoot,
2275                               agNULL, /* agContext */
2276                               0,
2277                               eventSource, /* agsaEventSource_t */
2278                               0,
2279                               0
2280                               );
2281     if ( HwAckSatus != AGSA_RC_SUCCESS)
2282     {
2283       TI_DBG1(("tdssReportRemovals: failing in saHwEventAck; status %d\n", HwAckSatus));
2284     }
2285
2286     /* toggle */
2287     tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
2288     if (onePortContext->valid == agFALSE)
2289     {
2290       /* put device belonging to the port to freedevice list */
2291       DeviceListList = tdsaAllShared->MainDeviceList.flink;
2292       while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2293       {
2294         oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2295         if (oneDeviceData->tdPortContext == onePortContext)
2296         {
2297           osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
2298           tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2299           TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
2300           TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
2301           if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2302           {
2303             tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2304             break;
2305           }
2306           tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2307           DeviceListList = tdsaAllShared->MainDeviceList.flink;
2308         }
2309         else
2310         {
2311           DeviceListList = DeviceListList->flink;
2312         }
2313       } /* while */
2314
2315       tdsaPortContextReInit(tiRoot, onePortContext);
2316       /*
2317         put all devices belonging to the onePortContext
2318         back to the free link
2319        */
2320       tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
2321       TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
2322       TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
2323       tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
2324     }
2325   }
2326
2327   else
2328   {
2329     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2330     if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2331     {
2332       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2333       TI_DBG1(("tdssReportRemovals: 1st empty device list\n"));
2334       return;
2335     }
2336     else
2337     {
2338       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2339     }
2340     DeviceListList = tdsaAllShared->MainDeviceList.flink;
2341     /* needs to clean up devices which were not removed in ossaDeregisterDeviceHandleCB() since port was in valid (discovery error) */
2342     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2343     {
2344       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2345       if (oneDeviceData == agNULL)
2346       {
2347         TI_DBG1(("tdssReportRemovals: oneDeviceData is NULL!!!\n"));
2348         return;
2349       }
2350       TI_DBG2(("tdssReportRemovals: 1st loop did %d\n", oneDeviceData->id));
2351       TI_DBG2(("tdssReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2352       TI_DBG2(("tdssReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2353       TI_DBG2(("tdssReportRemovals: valid %d\n", oneDeviceData->valid));
2354       TI_DBG2(("tdssReportRemovals: valid2 %d\n", oneDeviceData->valid2));
2355       TI_DBG2(("tdssReportRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
2356       TI_DBG2(("tdssReportRemovals: registered %d\n", oneDeviceData->registered));
2357       if ( oneDeviceData->tdPortContext == onePortContext && oneDeviceData->valid == agFALSE &&
2358            oneDeviceData->valid2 == agFALSE && oneDeviceData->registered == agFALSE
2359          )
2360       {
2361         /* remove oneDevice from MainLink */
2362         TI_DBG2(("tdssReportRemovals: delete from MainLink\n"));
2363         agDevHandle = oneDeviceData->agDevHandle;
2364         tdsaDeviceDataReInit(tiRoot, oneDeviceData);
2365         //save agDevHandle and tdPortContext
2366         oneDeviceData->agDevHandle = agDevHandle;
2367         oneDeviceData->tdPortContext = onePortContext;
2368         osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
2369         tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2370         TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
2371         TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
2372         tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2373         DeviceListList = tdsaAllShared->MainDeviceList.flink;
2374         tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2375         if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2376         {
2377           tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2378           break;
2379         }
2380         else
2381         {
2382           tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2383         }
2384       }
2385       else
2386       {
2387         DeviceListList = DeviceListList->flink;
2388       }
2389     } /* while */
2390
2391
2392     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2393     if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2394     {
2395       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2396       TI_DBG1(("tdssReportRemovals: 2nd empty device list\n"));
2397       return;
2398     }
2399     else
2400     {
2401       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2402     }
2403     DeviceListList = tdsaAllShared->MainDeviceList.flink;
2404     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2405     {
2406       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2407       if (oneDeviceData == agNULL)
2408       {
2409         TI_DBG1(("tdssReportRemovals: oneDeviceData is NULL!!!\n"));
2410         return;
2411       }
2412       TI_DBG2(("tdssReportRemovals: loop did %d\n", oneDeviceData->id));
2413       TI_DBG2(("tdssReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2414       TI_DBG2(("tdssReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2415       TI_DBG2(("tdssReportRemovals: valid %d\n", oneDeviceData->valid));
2416       TI_DBG2(("tdssReportRemovals: valid2 %d\n", oneDeviceData->valid2));
2417       TI_DBG2(("tdssReportRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
2418       TI_DBG2(("tdssReportRemovals: registered %d\n", oneDeviceData->registered));
2419       if ( oneDeviceData->tdPortContext == onePortContext)
2420       {
2421         TI_DBG2(("tdssReportRemovals: right portcontext pid %d\n", onePortContext->id));
2422         if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE)
2423         {
2424           TI_DBG2(("tdssReportRemovals: removing\n"));
2425
2426           /* notify only reported devices to OS layer*/
2427           if ( DEVICE_IS_SSP_TARGET(oneDeviceData) ||
2428                DEVICE_IS_STP_TARGET(oneDeviceData) ||
2429                DEVICE_IS_SATA_DEVICE(oneDeviceData)
2430               )
2431           {
2432             removed = agTRUE;
2433           }
2434
2435           if ( (oneDeviceData->registered == agTRUE) &&
2436                ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)
2437                || DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData) )
2438              )
2439           {
2440             /* all targets except expanders */
2441             TI_DBG2(("tdssReportRemovals: calling tdsaAbortAll\n"));
2442             TI_DBG2(("tdssReportRemovals: did %d\n", oneDeviceData->id));
2443             TI_DBG2(("tdssReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2444             TI_DBG2(("tdssReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2445             tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
2446           }
2447           else if (oneDeviceData->registered == agTRUE)
2448           {
2449             /* expanders */
2450             TI_DBG1(("tdssReportRemovals: calling saDeregisterDeviceHandle, did %d\n", oneDeviceData->id));
2451             TI_DBG2(("tdssReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2452             TI_DBG2(("tdssReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2453             saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0);
2454           }
2455
2456           /* reset valid bit */
2457           oneDeviceData->valid = agFALSE;
2458           oneDeviceData->valid2 = agFALSE;
2459           oneDeviceData->registered = agFALSE;
2460           /* reset NumOfFCA */
2461           oneDeviceData->satDevData.NumOfFCA = 0;
2462
2463         }
2464         /* called by port invalid case */
2465         if (flag == agTRUE)
2466         {
2467           oneDeviceData->tdPortContext = agNULL;
2468           TI_DBG1(("tdssReportRemovals: nulling-out tdPortContext; oneDeviceData did %d\n", oneDeviceData->id));
2469         }
2470 #ifdef REMOVED /* removed */
2471         /* directly attached SATA -> always remove it */
2472         if (oneDeviceData->DeviceType == TD_SATA_DEVICE &&
2473             oneDeviceData->directlyAttached == agTRUE)
2474         {
2475           TI_DBG1(("tdssReportRemovals: device did %d\n", oneDeviceData->id));
2476           TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
2477           TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceLis));
2478           DeviceListList = tdsaAllShared->MainDeviceList.flink;
2479           if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2480           {
2481             break;
2482           }
2483         }
2484         else
2485         {
2486           DeviceListList = DeviceListList->flink;
2487         }
2488 #endif /* REMOVED */
2489         DeviceListList = DeviceListList->flink;
2490       }
2491       else
2492       {
2493         if (oneDeviceData->tdPortContext != agNULL)
2494         {
2495           TI_DBG2(("tdssReportRemovals: different portcontext; oneDeviceData->tdPortContext pid %d oneportcontext pid %d oneDeviceData did %d\n",
2496           oneDeviceData->tdPortContext->id, onePortContext->id, oneDeviceData->id));
2497         }
2498         else
2499         {
2500           TI_DBG1(("tdssReportRemovals: different portcontext; oneDeviceData->tdPortContext pid NULL oneportcontext pid %d oneDeviceData did %d\n",
2501           onePortContext->id, oneDeviceData->id));
2502         }
2503         DeviceListList = DeviceListList->flink;
2504       }
2505     }
2506
2507     if (removed == agTRUE)
2508     {
2509       TI_DBG2(("tdssReportRemovals: removed at the end\n"));
2510       ostiInitiatorEvent(
2511                          tiRoot,
2512                          onePortContext->tiPortalContext,
2513                          agNULL,
2514                          tiIntrEventTypeDeviceChange,
2515                          tiDeviceRemoval,
2516                          agNULL
2517                          );
2518     }
2519   } /* big else */
2520   return;
2521 }
2522
2523 /*
2524   changes valid and valid2 based on discovery type
2525 */
2526 osGLOBAL void
2527 tdssInternalRemovals(
2528                      agsaRoot_t           *agRoot,
2529                      tdsaPortContext_t    *onePortContext
2530                      )
2531 {
2532   tdsaDeviceData_t  *oneDeviceData = agNULL;
2533   tdList_t          *DeviceListList;
2534   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
2535   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
2536   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2537   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2538
2539   TI_DBG2(("tdssInternalRemovals: start\n"));
2540
2541   tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2542   if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2543   {
2544     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2545     TI_DBG1(("tdssInternalRemovals: empty device list\n"));
2546     return;
2547   }
2548   else
2549   {
2550     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2551   }
2552   DeviceListList = tdsaAllShared->MainDeviceList.flink;
2553   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2554   {
2555     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2556     TI_DBG3(("tdssInternalRemovals: loop did %d\n", oneDeviceData->id));
2557     TI_DBG3(("tdssInternalRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2558     TI_DBG3(("tdssInternalRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2559     TI_DBG3(("tdssInternalRemovals: valid %d\n", oneDeviceData->valid));
2560     TI_DBG3(("tdssInternalRemovals: valid2 %d\n", oneDeviceData->valid2));
2561     TI_DBG3(("tdssInternalRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
2562     TI_DBG3(("tdssInternalRemovals: registered %d\n", oneDeviceData->registered));
2563     if ( oneDeviceData->tdPortContext == onePortContext)
2564     {
2565       TI_DBG3(("tdssInternalRemovals: right portcontext pid %d\n", onePortContext->id));
2566       if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_INCREMENTAL_START)
2567       {
2568         TI_DBG3(("tdssInternalRemovals: incremental discovery\n"));
2569         oneDeviceData->valid2 = agFALSE;
2570       }
2571       else
2572       {
2573         TI_DBG3(("tdssInternalRemovals: full discovery\n"));
2574         oneDeviceData->valid = agFALSE;
2575       }
2576       DeviceListList = DeviceListList->flink;
2577     }
2578     else
2579     {
2580       if (oneDeviceData->tdPortContext != agNULL)
2581       {
2582         TI_DBG3(("tdssInternalRemovals: different portcontext; oneDeviceData->tdPortContext pid %d oneportcontext pid %d\n", oneDeviceData->tdPortContext->id, onePortContext->id));
2583       }
2584       else
2585       {
2586         TI_DBG3(("tdssInternalRemovals: different portcontext; oneDeviceData->tdPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
2587       }
2588       DeviceListList = DeviceListList->flink;
2589     }
2590   }
2591
2592
2593   return;
2594 }
2595
2596 /* resets all valid and valid2 */
2597 osGLOBAL void
2598 tdssDiscoveryErrorRemovals(
2599                                  agsaRoot_t           *agRoot,
2600                                  tdsaPortContext_t    *onePortContext
2601                                  )
2602 {
2603   tdsaDeviceData_t  *oneDeviceData = agNULL;
2604   tdList_t          *DeviceListList;
2605   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
2606   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
2607   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2608   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2609
2610   TI_DBG1(("tdssDiscoveryErrorRemovals: start\n"));
2611
2612   tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
2613   if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
2614   {
2615     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2616     TI_DBG1(("tdssDiscoveryErrorRemovals: empty device list\n"));
2617     return;
2618   }
2619   else
2620   {
2621     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
2622   }
2623   DeviceListList = tdsaAllShared->MainDeviceList.flink;
2624   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2625   {
2626     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2627     TI_DBG2(("tdssDiscoveryErrorRemovals: loop did %d\n", oneDeviceData->id));
2628     TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2629     TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2630     TI_DBG2(("tdssDiscoveryErrorRemovals: valid %d\n", oneDeviceData->valid));
2631     TI_DBG2(("tdssDiscoveryErrorRemovals: valid2 %d\n", oneDeviceData->valid2));
2632     TI_DBG2(("tdssDiscoveryErrorRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
2633     TI_DBG2(("tdssDiscoveryErrorRemovals: registered %d\n", oneDeviceData->registered));
2634     if ( oneDeviceData->tdPortContext == onePortContext)
2635     {
2636       TI_DBG2(("tdssDiscoveryErrorRemovals: right portcontext pid %d\n", onePortContext->id));
2637       oneDeviceData->valid = agFALSE;
2638       oneDeviceData->valid2 = agFALSE;
2639       /* reset NumOfFCA */
2640       oneDeviceData->satDevData.NumOfFCA = 0;
2641
2642       if ( (oneDeviceData->registered == agTRUE) &&
2643            ( DEVICE_IS_SSP_TARGET(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData)
2644            || DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_SMP_TARGET(oneDeviceData) )
2645          )
2646       {
2647         /* all targets other than expanders */
2648         TI_DBG2(("tdssDiscoveryErrorRemovals: calling tdsaAbortAll\n"));
2649         TI_DBG2(("tdssDiscoveryErrorRemovals: did %d\n", oneDeviceData->id));
2650         TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2651         TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2652         tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
2653       }
2654       else if (oneDeviceData->registered == agTRUE)
2655       {
2656         /* expanders */
2657         TI_DBG2(("tdssDiscoveryErrorRemovals: calling saDeregisterDeviceHandle\n"));
2658         TI_DBG2(("tdssDiscoveryErrorRemovals: did %d\n", oneDeviceData->id));
2659         TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
2660         TI_DBG2(("tdssDiscoveryErrorRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
2661         saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0);
2662       }
2663
2664       oneDeviceData->registered = agFALSE;
2665       DeviceListList = DeviceListList->flink;
2666     }
2667     else
2668     {
2669       if (oneDeviceData->tdPortContext != agNULL)
2670       {
2671         TI_DBG2(("tdssDiscoveryErrorRemovals: different portcontext; oneDeviceData->tdPortContext pid %d oneportcontext pid %d\n", oneDeviceData->tdPortContext->id, onePortContext->id));
2672       }
2673       else
2674       {
2675         TI_DBG2(("tdssDiscoveryErrorRemovals: different portcontext; oneDeviceData->tdPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
2676       }
2677       DeviceListList = DeviceListList->flink;
2678     }
2679   }
2680
2681
2682   return;
2683 }
2684
2685 /*****************************************************************************
2686 *! \brief  tdsaSASDiscoverAbort
2687 *
2688 *  Purpose:  This function aborts on-going discovery.
2689 *
2690 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
2691 *                   instance.
2692 *  \param   onePortContext: Pointer to the portal context instance.
2693 *
2694 *  \return:
2695 *           None
2696 *
2697 *   \note:
2698 *
2699 *****************************************************************************/
2700 /* this called when discovery is aborted
2701    aborted by whom
2702 */
2703 osGLOBAL void
2704 tdsaSASDiscoverAbort(
2705                     tiRoot_t             *tiRoot,
2706                     tdsaPortContext_t    *onePortContext
2707                     )
2708 {
2709
2710   TI_DBG2(("tdsaSASDiscoverAbort: start\n"));
2711   TI_DBG2(("tdsaSASDiscoverAbort: pPort=%p  DONE\n", onePortContext));
2712   TI_DBG2(("tdsaSASDiscoverAbort: DiscoveryState %d\n", onePortContext->DiscoveryState));
2713
2714   onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
2715   /* clean up expanders data strucures; move to free exp when device is cleaned */
2716   tdsaCleanAllExp(tiRoot, onePortContext);
2717
2718   /* unregister devices */
2719   tdssReportRemovals(onePortContext->agRoot,
2720                      onePortContext,
2721                      agFALSE
2722                     );
2723 }
2724
2725 #ifdef AGTIAPI_CTL
2726
2727 STATIC void
2728 tdsaCTLNextDevice(
2729   tiRoot_t          *tiRoot,
2730   tdsaPortContext_t *onePortContext,
2731   tdIORequest_t     *tdIORequest,
2732   tdList_t          *DeviceList);
2733
2734 STATIC void
2735 tdsaCTLIOCompleted(
2736   agsaRoot_t      *agRoot,
2737   agsaIORequest_t *agIORequest,
2738   bit32           agIOStatus,
2739   bit32           agIOInfoLen,
2740   void            *agParam,
2741   bit16           sspTag,
2742   bit32           agOtherInfo)
2743 {
2744   tiRoot_t          *tiRoot = (tiRoot_t*)
2745                       ((tdsaRootOsData_t*)agRoot->osData)->tiRoot;
2746   tdIORequestBody_t *tdIORequestBody;
2747   tdIORequest_t     *tdIORequest;
2748   tdsaDeviceData_t  *oneDeviceData;
2749
2750   tdIORequest = (tdIORequest_t *)agIORequest->osData;
2751   tdIORequestBody = &tdIORequest->tdIORequestBody;
2752   tdIORequestBody->ioCompleted = agTRUE;
2753   tdIORequestBody->ioStarted = agFALSE;
2754   oneDeviceData = (tdsaDeviceData_t *)tdIORequestBody->tiDevHandle->tdData;
2755
2756   TI_DBG6(("tdsaCTLIOCompleted: stat x%x len %d id %d\n", agIOStatus,
2757            agIOInfoLen, oneDeviceData->id));
2758
2759   //if ((agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0))
2760   /* SCSI command was completed OK, this is the normal path. */
2761   if (agIOInfoLen)
2762   {
2763     TI_DBG6(("tdsaCTLIOCompleted: SASDevAddr 0x%x / 0x%x PhyId 0x%x WARN "
2764              "setting CTL\n",
2765              oneDeviceData->SASAddressID.sasAddressHi,
2766              oneDeviceData->SASAddressID.sasAddressLo,
2767              oneDeviceData->SASAddressID.phyIdentifier));
2768     tdhexdump("tdsaCTLIOCompleted: response", (bit8 *)agParam, agIOInfoLen);
2769   }
2770
2771   tdsaCTLNextDevice(tiRoot, oneDeviceData->tdPortContext, tdIORequest,
2772                     oneDeviceData->MainLink.flink);
2773 } /* tdsaCTLIOCompleted */
2774
2775 STATIC int
2776 tdsaCTLModeSelect(
2777   tiRoot_t                  *tiRoot,
2778   tiDeviceHandle_t          *tiDeviceHandle,
2779   tdIORequest_t             *tdIORequest)
2780 {
2781   tiIORequest_t             *tiIORequest;
2782   tdsaDeviceData_t          *oneDeviceData;
2783   agsaRoot_t                *agRoot = agNULL;
2784   tdsaRoot_t                *tdsaRoot = (tdsaRoot_t*)tiRoot->tdData;
2785   tdsaContext_t             *tdsaAllShared = (tdsaContext_t*)
2786                               &tdsaRoot->tdsaAllShared;
2787   agsaIORequest_t           *agIORequest = agNULL;
2788   agsaDevHandle_t           *agDevHandle = agNULL;
2789   agsaSASRequestBody_t      *agSASRequestBody = agNULL;
2790   bit32                     tiStatus;
2791   bit32                     saStatus;
2792   tdIORequestBody_t         *tdIORequestBody;
2793   agsaSSPInitiatorRequest_t *agSSPInitiatorRequest;
2794   unsigned char             *virtAddr;
2795   tiSgl_t                   agSgl;
2796   static unsigned char      cdb[6] =
2797   {
2798     MODE_SELECT,
2799     PAGE_FORMAT,
2800     0,
2801     0,
2802     DR_MODE_PG_SZ
2803   };
2804
2805   virtAddr = (unsigned char*)tdIORequest->virtAddr;
2806   virtAddr[0] = DR_MODE_PG_CODE; /* Disconnect-Reconnect mode page code */
2807   virtAddr[1] = DR_MODE_PG_LENGTH; /* DR Mode pg length */
2808   virtAddr[8] = tdsaAllShared->SASConnectTimeLimit >> 8;
2809   virtAddr[9] = tdsaAllShared->SASConnectTimeLimit & 0xff;
2810
2811   oneDeviceData = (tdsaDeviceData_t*)tiDeviceHandle->tdData;
2812   TI_DBG4(("tdsaCTLModeSelect: id %d\n", oneDeviceData->id));
2813
2814   agRoot = oneDeviceData->agRoot;
2815   agDevHandle = oneDeviceData->agDevHandle;
2816   tiIORequest = &tdIORequest->tiIORequest;
2817
2818   tdIORequestBody = &tdIORequest->tdIORequestBody;
2819
2820   //tdIORequestBody->IOCompletionFunc = tdsaCTLIOCompleted;//itdssIOCompleted;
2821   tdIORequestBody->tiDevHandle = tiDeviceHandle;
2822   tdIORequestBody->IOType.InitiatorRegIO.expDataLength = DR_MODE_PG_SZ;
2823
2824   agIORequest = &tdIORequestBody->agIORequest;
2825   agIORequest->sdkData = agNULL; /* LL takes care of this */
2826
2827   agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
2828   agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq);
2829
2830   osti_memcpy(agSSPInitiatorRequest->sspCmdIU.cdb, cdb, 6);
2831   agSSPInitiatorRequest->dataLength = DR_MODE_PG_SZ;
2832
2833   agSSPInitiatorRequest->firstBurstSize = 0;
2834
2835   tdIORequestBody->agRequestType = AGSA_SSP_INIT_WRITE;
2836   tdIORequestBody->ioStarted = agTRUE;
2837   tdIORequestBody->ioCompleted = agFALSE;
2838
2839   agSgl.lower = BIT32_TO_LEBIT32(tdIORequest->physLower32);
2840 #if (BITS_PER_LONG > 32)
2841   agSgl.upper = BIT32_TO_LEBIT32(tdIORequest->physUpper32);
2842 #else
2843   agSgl1.upper = 0;
2844 #endif
2845   agSgl.type = BIT32_TO_LEBIT32(tiSgl);
2846   agSgl.len = BIT32_TO_LEBIT32(DR_MODE_PG_SZ);
2847
2848   /* initializes "agsaSgl_t   agSgl" of "agsaDifSSPInitiatorRequest_t" */
2849   tiStatus = itdssIOPrepareSGL(tiRoot, tdIORequestBody, &agSgl,
2850                                tdIORequest->virtAddr);
2851   if (tiStatus != tiSuccess)
2852   {
2853     TI_DBG1(("tdsaCTLModeSelect: can't get SGL\n"));
2854     ostiFreeMemory(tiRoot, tdIORequest->osMemHandle2, DR_MODE_PG_SZ);
2855     ostiFreeMemory(tiRoot, tdIORequest->osMemHandle, sizeof(*tdIORequest));
2856     return tiError;
2857   }
2858
2859   saStatus = saSSPStart(agRoot, agIORequest,
2860                         tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle,
2861                         AGSA_SSP_INIT_WRITE, agSASRequestBody, agNULL,
2862                         &tdsaCTLIOCompleted);
2863   if (saStatus == AGSA_RC_SUCCESS)
2864   {
2865     tiStatus = tiSuccess;
2866     TI_DBG4(("tdsaCTLModeSelect: saSSPStart OK\n"));
2867   }
2868   else
2869   {
2870     tdIORequestBody->ioStarted = agFALSE;
2871     tdIORequestBody->ioCompleted = agTRUE;
2872     if (saStatus == AGSA_RC_BUSY)
2873     {
2874       tiStatus = tiBusy;
2875       TI_DBG4(("tdsaCTLModeSelect: saSSPStart busy\n"));
2876     }
2877     else
2878     {
2879       tiStatus = tiError;
2880       TI_DBG4(("tdsaCTLModeSelect: saSSPStart Error\n"));
2881     }
2882     tdsaCTLNextDevice(tiRoot, oneDeviceData->tdPortContext, tdIORequest,
2883                       oneDeviceData->MainLink.flink);
2884   }
2885   return tiStatus;
2886 } /* tdsaCTLModeSelect */
2887
2888 STATIC void
2889 tdsaCTLNextDevice(
2890   tiRoot_t          *tiRoot,
2891   tdsaPortContext_t *onePortContext,
2892   tdIORequest_t     *tdIORequest,
2893   tdList_t          *DeviceList)
2894 {
2895   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *)tiRoot->tdData;
2896   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2897   tdsaDeviceData_t  *oneDeviceData;
2898   tiIntrEventType_t eventType;
2899   bit32             eventStatus;
2900   int               rc;
2901
2902   /*
2903    * From the device list, returns only valid devices
2904    */
2905   for (; DeviceList && DeviceList != &(tdsaAllShared->MainDeviceList);
2906        DeviceList = DeviceList->flink)
2907   {
2908     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceList);
2909     TI_DBG6(("tdsaCTLNextDevice: devHandle %p\n",
2910              &(oneDeviceData->tiDeviceHandle)));
2911     if (oneDeviceData->tdPortContext != onePortContext)
2912       continue;
2913     if ((oneDeviceData->discovered == agFALSE) &&
2914         (oneDeviceData->registered == agTRUE) &&
2915         DEVICE_IS_SSP_TARGET(oneDeviceData) &&
2916         !DEVICE_IS_SSP_INITIATOR(oneDeviceData))
2917     {
2918       oneDeviceData->discovered = agTRUE;
2919       rc = tdsaCTLModeSelect(tiRoot, &oneDeviceData->tiDeviceHandle,
2920                               tdIORequest);
2921       TI_DBG1(("tdsaCTLNextDevice: ModeSelect ret %d\n", rc));
2922       return;
2923     }
2924   }
2925   TI_DBG2(("tdsaCTLNextDevice: no more devices found\n"));
2926
2927   eventType = tdIORequest->eventType;
2928   eventStatus = tdIORequest->eventStatus;
2929
2930   /* no more devices, free the memory */
2931   ostiFreeMemory(tiRoot, tdIORequest->osMemHandle2, DR_MODE_PG_SZ);
2932   ostiFreeMemory(tiRoot, tdIORequest->osMemHandle, sizeof(*tdIORequest));
2933
2934   /* send Discovery Done event */
2935   ostiInitiatorEvent(tiRoot, onePortContext->tiPortalContext, agNULL,
2936                      eventType, eventStatus, agNULL);
2937 } /* tdsaCTLNextDevice */
2938
2939 osGLOBAL void
2940 tdsaCTLSet(
2941   tiRoot_t          *tiRoot,
2942   tdsaPortContext_t *onePortContext,
2943   tiIntrEventType_t eventType,
2944   bit32             eventStatus)
2945 {
2946   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *)tiRoot->tdData;
2947   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2948   tdIORequest_t     *tdIORequest;
2949   tdIORequestBody_t *tdIORequestBody;
2950   tiIORequest_t     *tiIORequest;
2951   bit32             memAllocStatus;
2952   void              *osMemHandle;
2953   bit32             physUpper32;
2954   bit32             physLower32;
2955
2956   TI_DBG2(("tdsaCTLSet: tiPortalContext pid %d etyp %x stat %x\n",
2957            onePortContext->id, eventType, eventStatus));
2958
2959   if (onePortContext->DiscoveryState != ITD_DSTATE_COMPLETED)
2960   {
2961     TI_DBG1(("tdsaCTLSet: discovery not completed\n"));
2962     return;
2963   }
2964
2965   /* use the same memory for all valid devices */
2966   memAllocStatus = ostiAllocMemory(tiRoot, &osMemHandle, (void **)&tdIORequest,
2967                                    &physUpper32, &physLower32, 8,
2968                                    sizeof(*tdIORequest), agTRUE);
2969   if (memAllocStatus != tiSuccess || tdIORequest == agNULL)
2970   {
2971     TI_DBG1(("tdsaCTLSet: ostiAllocMemory failed\n"));
2972     return;// tiError;
2973   }
2974   osti_memset(tdIORequest, 0, sizeof(*tdIORequest));
2975
2976   tdIORequest->osMemHandle = osMemHandle;
2977   tdIORequest->eventType = eventType;
2978   tdIORequest->eventStatus = eventStatus;
2979
2980   tiIORequest = &tdIORequest->tiIORequest;
2981   tdIORequestBody = &tdIORequest->tdIORequestBody;
2982   /* save context if we need to abort later */
2983   tiIORequest->tdData = tdIORequestBody;
2984
2985   tdIORequestBody->IOCompletionFunc = NULL;//itdssIOCompleted;
2986   tdIORequestBody->tiIORequest = tiIORequest;
2987   tdIORequestBody->IOType.InitiatorRegIO.expDataLength = 16;
2988
2989   tdIORequestBody->agIORequest.osData = (void *)tdIORequest; //tdIORequestBody;
2990
2991   memAllocStatus = ostiAllocMemory(tiRoot, &tdIORequest->osMemHandle2,
2992                                    (void **)&tdIORequest->virtAddr,
2993                                    &tdIORequest->physUpper32,
2994                                    &tdIORequest->physLower32,
2995                                    8, DR_MODE_PG_SZ, agFALSE);
2996   if (memAllocStatus != tiSuccess || tdIORequest == agNULL)
2997   {
2998     TI_DBG1(("tdsaCTLSet: ostiAllocMemory noncached failed\n"));
2999     ostiFreeMemory(tiRoot, tdIORequest->osMemHandle, sizeof(*tdIORequest));
3000     return;// tiError;
3001   }
3002
3003   osti_memset(tdIORequest->virtAddr, 0, DR_MODE_PG_SZ);
3004   tdsaCTLNextDevice(tiRoot, onePortContext, tdIORequest,
3005                     tdsaAllShared->MainDeviceList.flink);
3006 } /* tdsaCTLSet*/
3007 #endif
3008
3009 /*****************************************************************************
3010 *! \brief  tdsaSASDiscoverDone
3011 *
3012 *  Purpose:  This function called to finish up SAS discovery.
3013 *
3014 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3015 *                   instance.
3016 *  \param   onePortContext: Pointer to the portal context instance.
3017 *
3018 *  \return:
3019 *           None
3020 *
3021 *   \note:
3022 *
3023 *****************************************************************************/
3024 osGLOBAL void
3025 tdsaSASDiscoverDone(
3026                     tiRoot_t             *tiRoot,
3027                     tdsaPortContext_t    *onePortContext,
3028                     bit32                flag
3029                     )
3030 {
3031 #ifndef SATA_ENABLE
3032   tdsaRoot_t    *tdsaRoot = (tdsaRoot_t *)tiRoot->tdData;
3033   tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3034 #endif
3035
3036   TI_DBG3(("tdsaSASDiscoverDone: start\n"));
3037   TI_DBG3(("tdsaSASDiscoverDone: pPort=%p  DONE\n", onePortContext));
3038   TI_DBG3(("tdsaSASDiscoverDone: pid %d\n", onePortContext->id));
3039
3040   /* Set discovery status */
3041   onePortContext->discovery.status = DISCOVERY_SAS_DONE;
3042
3043 #ifdef TD_INTERNAL_DEBUG /* debugging only */
3044   TI_DBG3(("tdsaSASDiscoverDone: BEFORE\n"));
3045   tdsaDumpAllExp(tiRoot, onePortContext, agNULL);
3046   tdsaDumpAllUpExp(tiRoot, onePortContext, agNULL);
3047 #endif
3048
3049   /* clean up expanders data strucures; move to free exp when device is cleaned */
3050   tdsaCleanAllExp(tiRoot, onePortContext);
3051
3052 #ifdef TD_INTERNAL_DEBUG /* debugging only */
3053   TI_DBG3(("tdsaSASDiscoverDone: AFTER\n"));
3054   tdsaDumpAllExp(tiRoot, onePortContext, agNULL);
3055   tdsaDumpAllUpExp(tiRoot, onePortContext, agNULL);
3056 #endif
3057
3058
3059   /* call back to notify discovery is done */
3060   /* SATA is NOT enbled */
3061 #ifndef SATA_ENABLE
3062   if (onePortContext->discovery.SeenBC == agTRUE)
3063   {
3064     TI_DBG3(("tdsaSASDiscoverDone: broadcast change; discover again\n"));
3065     tdssInternalRemovals(onePortContext->agRoot,
3066                          onePortContext
3067                          );
3068
3069     /* processed broadcast change */
3070     onePortContext->discovery.SeenBC = agFALSE;
3071     if (tdsaAllShared->ResetInDiscovery != 0 &&
3072         onePortContext->discovery.ResetTriggerred == agTRUE)
3073     {
3074       TI_DBG2(("tdsaSASDiscoverDone: tdsaBCTimer\n"));
3075       tdsaBCTimer(tiRoot, onePortContext);
3076     }
3077     else
3078     {
3079       tdsaDiscover(
3080                    tiRoot,
3081                    onePortContext,
3082                    TDSA_DISCOVERY_TYPE_SAS,
3083                    TDSA_DISCOVERY_OPTION_INCREMENTAL_START
3084                   );
3085     }
3086   }
3087   else
3088   {
3089     onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
3090
3091     if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
3092     {
3093       if (flag == tiSuccess)
3094       {
3095 #ifdef AGTIAPI_CTL
3096         if (tdsaAllShared->SASConnectTimeLimit)
3097           tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDiscovery,
3098                      tiDiscOK);
3099         else
3100 #endif
3101           ostiInitiatorEvent(
3102                              tiRoot,
3103                              onePortContext->tiPortalContext,
3104                              agNULL,
3105                              tiIntrEventTypeDiscovery,
3106                              tiDiscOK,
3107                              agNULL
3108                              );
3109       }
3110       else
3111       {
3112         TI_DBG1(("tdsaSASDiscoverDone: discovery failed\n"));
3113         tdssDiscoveryErrorRemovals(onePortContext->agRoot,
3114                                    onePortContext
3115                                    );
3116
3117         ostiInitiatorEvent(
3118                            tiRoot,
3119                            onePortContext->tiPortalContext,
3120                            agNULL,
3121                            tiIntrEventTypeDiscovery,
3122                            tiDiscFailed,
3123                            agNULL
3124                            );
3125       }
3126     }
3127     else
3128     {
3129       if (flag == tiSuccess)
3130       {
3131         tdssReportChanges(onePortContext->agRoot,
3132                           onePortContext
3133                           );
3134       }
3135       else
3136       {
3137         tdssReportRemovals(onePortContext->agRoot,
3138                            onePortContext,
3139                            agFALSE
3140                            );
3141       }
3142     }
3143   }
3144 #ifdef TBD
3145   /* ACKing BC */
3146   tdsaAckBC(tiRoot, onePortContext);
3147 #endif
3148
3149 #endif
3150
3151 #ifdef SATA_ENABLE
3152
3153   if (flag == tiSuccess)
3154   {
3155     TI_DBG3(("tdsaSASDiscoverDone: calling SATA discovery\n"));
3156     /*
3157        tdsaSATAFullDiscover() or tdsaincrementalDiscover()
3158        call sata discover
3159        when sata discover is done, call ostiInitiatorEvent
3160     */
3161     if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
3162     {
3163       TI_DBG3(("tdsaSASDiscoverDone: calling FULL SATA discovery\n"));
3164       tdsaDiscover(
3165                    tiRoot,
3166                    onePortContext,
3167                    AG_SA_DISCOVERY_TYPE_SATA,
3168                    TDSA_DISCOVERY_OPTION_FULL_START
3169                    );
3170     }
3171     else
3172     {
3173       TI_DBG3(("tdsaSASDiscoverDone: calling INCREMENTAL SATA discovery\n"));
3174       tdsaDiscover(
3175                    tiRoot,
3176                    onePortContext,
3177                    AG_SA_DISCOVERY_TYPE_SATA,
3178                    TDSA_DISCOVERY_OPTION_INCREMENTAL_START
3179                    );
3180     }
3181   }
3182   else
3183   {
3184     /* error case */
3185     TI_DBG1(("tdsaSASDiscoverDone: Error; clean up\n"));
3186     tdssDiscoveryErrorRemovals(onePortContext->agRoot,
3187                                onePortContext
3188                                );
3189
3190     onePortContext->discovery.SeenBC = agFALSE;
3191     onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
3192     ostiInitiatorEvent(
3193                        tiRoot,
3194                        onePortContext->tiPortalContext,
3195                        agNULL,
3196                        tiIntrEventTypeDiscovery,
3197                        tiDiscFailed,
3198                        agNULL
3199                        );
3200   }
3201 #endif
3202   return;
3203 }
3204
3205 //temp only for testing
3206 osGLOBAL void
3207 tdsaReportManInfoSend(
3208                       tiRoot_t             *tiRoot,
3209                       tdsaDeviceData_t     *oneDeviceData
3210                       )
3211 {
3212   agsaRoot_t            *agRoot;
3213
3214   agRoot = oneDeviceData->agRoot;
3215
3216   TI_DBG2(("tdsaReportManInfoSend: start\n"));
3217
3218   tdSMPStart(
3219              tiRoot,
3220              agRoot,
3221              oneDeviceData,
3222              SMP_REPORT_MANUFACTURE_INFORMATION,
3223              agNULL,
3224              0,
3225              AGSA_SMP_INIT_REQ,
3226              agNULL,
3227              0
3228              );
3229
3230   return;
3231 }
3232
3233
3234 osGLOBAL void
3235 tdsaReportManInfoRespRcvd(
3236                           tiRoot_t              *tiRoot,
3237                           agsaRoot_t            *agRoot,
3238                           tdsaDeviceData_t      *oneDeviceData,
3239                           tdssSMPFrameHeader_t  *frameHeader,
3240                           agsaFrameHandle_t     frameHandle
3241                           )
3242 {
3243   tdsaPortContext_t            *onePortContext;
3244   tdsaDiscovery_t              *discovery;
3245
3246   TI_DBG2(("tdsaReportManInfoRespRcvd: start\n"));
3247   TI_DBG2(("tdsaReportManInfoRespRcvd: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
3248   TI_DBG2(("tdsaReportManInfoRespRcvd: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
3249
3250   onePortContext = oneDeviceData->tdPortContext;
3251   discovery = &(onePortContext->discovery);
3252
3253   if (frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
3254   {
3255     TI_DBG2(("tdsaReportManInfoRespRcvd: SMP accepted\n"));
3256   }
3257   else
3258   {
3259     TI_DBG1(("tdsaReportManInfoRespRcvd: SMP NOT accepted; fn result 0x%x\n", frameHeader->smpFunctionResult));
3260   }
3261
3262   TI_DBG2(("tdsaReportManInfoRespRcvd: discovery retries %d\n", discovery->retries));
3263   discovery->retries++;
3264
3265   if (discovery->retries >= DISCOVERY_RETRIES)
3266   {
3267     TI_DBG1(("tdsaReportManInfoRespRcvd: retries are over\n"));
3268     discovery->retries = 0;
3269     /* failed the discovery */
3270   }
3271   else
3272   {
3273     TI_DBG1(("tdsaReportManInfoRespRcvd: keep retrying\n"));
3274     // start timer
3275     tdsaDiscoveryTimer(tiRoot, onePortContext, oneDeviceData);
3276   }
3277
3278   return;
3279 }
3280
3281 //end temp only for testing
3282
3283 /*****************************************************************************
3284 *! \brief  tdsaReportGeneralSend
3285 *
3286 *  Purpose:  This function sends Report General SMP to a device.
3287 *
3288 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3289 *                   instance.
3290 *  \param   oneDeviceData: Pointer to the device data.
3291 *
3292 *  \return:
3293 *           None
3294 *
3295 *   \note:
3296 *
3297 *****************************************************************************/
3298 osGLOBAL void
3299 tdsaReportGeneralSend(
3300                       tiRoot_t             *tiRoot,
3301                       tdsaDeviceData_t     *oneDeviceData
3302                       )
3303 {
3304   agsaRoot_t            *agRoot;
3305
3306   agRoot = oneDeviceData->agRoot;
3307
3308   TI_DBG3(("tdsaReportGeneralSend: start\n"));
3309
3310   tdSMPStart(
3311              tiRoot,
3312              agRoot,
3313              oneDeviceData,
3314              SMP_REPORT_GENERAL,
3315              agNULL,
3316              0,
3317              AGSA_SMP_INIT_REQ,
3318              agNULL,
3319              0
3320              );
3321
3322   return;
3323 }
3324
3325 /*****************************************************************************
3326 *! \brief  tdsaReportGeneralRespRcvd
3327 *
3328 *  Purpose:  This function processes Report General response.
3329 *
3330 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3331 *                   instance.
3332 *  \param   agRoot: Pointer to chip/driver Instance.
3333 *  \param   oneDeviceData: Pointer to the device data.
3334 *  \param   frameHeader: Pointer to SMP frame header.
3335 *  \param   frameHandle: A Handle used to refer to the response frame
3336 *
3337 *  \return:
3338 *           None
3339 *
3340 *   \note:
3341 *
3342 *****************************************************************************/
3343 osGLOBAL void
3344 tdsaReportGeneralRespRcvd(
3345                           tiRoot_t              *tiRoot,
3346                           agsaRoot_t            *agRoot,
3347                           agsaIORequest_t       *agIORequest,
3348                           tdsaDeviceData_t      *oneDeviceData,
3349                           tdssSMPFrameHeader_t  *frameHeader,
3350                           agsaFrameHandle_t     frameHandle
3351                           )
3352 {
3353   smpRespReportGeneral_t     tdSMPReportGeneralResp;
3354   smpRespReportGeneral_t    *ptdSMPReportGeneralResp;
3355   tdsaExpander_t            *oneExpander;
3356   tdsaPortContext_t         *onePortContext;
3357   tdsaDiscovery_t           *discovery;
3358 #ifdef REMOVED
3359   bit32                      i;
3360 #endif
3361 #ifndef DIRECT_SMP
3362   tdssSMPRequestBody_t      *tdSMPRequestBody;
3363   tdSMPRequestBody = (tdssSMPRequestBody_t *)agIORequest->osData;
3364 #endif
3365
3366   TI_DBG3(("tdsaReportGeneralRespRcvd: start\n"));
3367   TI_DBG3(("tdsaReportGeneralRespRcvd: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
3368   TI_DBG3(("tdsaReportGeneralRespRcvd: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
3369   ptdSMPReportGeneralResp = &tdSMPReportGeneralResp;
3370   osti_memset(&tdSMPReportGeneralResp, 0, sizeof(smpRespReportGeneral_t));
3371 #ifdef DIRECT_SMP
3372   saFrameReadBlock(agRoot, frameHandle, 4, ptdSMPReportGeneralResp, sizeof(smpRespReportGeneral_t));
3373 #else
3374   saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 4, ptdSMPReportGeneralResp, sizeof(smpRespReportGeneral_t));
3375 #endif
3376
3377   //tdhexdump("tdsaReportGeneralRespRcvd", (bit8 *)ptdSMPReportGeneralResp, sizeof(smpRespReportGeneral_t));
3378 #ifndef DIRECT_SMP
3379   ostiFreeMemory(
3380                  tiRoot,
3381                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
3382                  tdSMPRequestBody->IndirectSMPReqLen
3383                 );
3384   ostiFreeMemory(
3385                  tiRoot,
3386                  tdSMPRequestBody->IndirectSMPResposMemHandle,
3387                  tdSMPRequestBody->IndirectSMPRespLen
3388                 );
3389 #endif
3390
3391   onePortContext = oneDeviceData->tdPortContext;
3392   discovery = &(onePortContext->discovery);
3393
3394   if (onePortContext->valid == agFALSE)
3395   {
3396     TI_DBG1(("tdsaReportGeneralRespRcvd: aborting discovery\n"));
3397     tdsaSASDiscoverAbort(tiRoot, onePortContext);
3398     return;
3399   }
3400   if (frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
3401   {
3402     oneDeviceData->numOfPhys = (bit8) ptdSMPReportGeneralResp->numOfPhys;
3403     oneExpander = oneDeviceData->tdExpander;
3404     oneExpander->routingIndex = (bit16) REPORT_GENERAL_GET_ROUTEINDEXES(ptdSMPReportGeneralResp);
3405 #ifdef REMOVED
3406     for ( i = 0; i < oneDeviceData->numOfPhys; i++ )
3407     {
3408       oneExpander->currentIndex[i] = 0;
3409     }
3410 #endif
3411     oneExpander->configReserved = 0;
3412     oneExpander->configRouteTable = REPORT_GENERAL_IS_CONFIGURABLE(ptdSMPReportGeneralResp) ? 1 : 0;
3413     oneExpander->configuring = REPORT_GENERAL_IS_CONFIGURING(ptdSMPReportGeneralResp) ? 1 : 0;
3414     TI_DBG3(("tdsaReportGeneralRespRcvd: oneExpander=%p numberofPhys=0x%x RoutingIndex=0x%x\n",
3415       oneExpander, oneDeviceData->numOfPhys, oneExpander->routingIndex));
3416     TI_DBG3(("tdsaReportGeneralRespRcvd: configRouteTable=%d configuring=%d\n",
3417       oneExpander->configRouteTable, oneExpander->configuring));
3418     if (oneExpander->configuring == 1)
3419     {
3420       discovery->retries++;
3421       if (discovery->retries >= DISCOVERY_RETRIES)
3422       {
3423         TI_DBG1(("tdsaReportGeneralRespRcvd: retries are over\n"));
3424         discovery->retries = 0;
3425         /* failed the discovery */
3426         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3427       }
3428       else
3429       {
3430         TI_DBG1(("tdsaReportGeneralRespRcvd: keep retrying\n"));
3431         // start timer for sending ReportGeneral
3432         tdsaDiscoveryTimer(tiRoot, onePortContext, oneDeviceData);
3433       }
3434     }
3435     else
3436     {
3437       discovery->retries = 0;
3438       tdsaDiscoverSend(tiRoot, oneDeviceData);
3439     }
3440   }
3441   else
3442   {
3443      TI_DBG1(("tdsaReportGeneralRespRcvd: SMP failed; fn result 0x%x; stopping discovery\n", frameHeader->smpFunctionResult));
3444      tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3445   }
3446   return;
3447 }
3448
3449
3450 /*****************************************************************************
3451 *! \brief  tdsaDiscoverSend
3452 *
3453 *  Purpose:  This function sends Discovery SMP to a device.
3454 *
3455 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3456 *                   instance.
3457 *  \param   oneDeviceData: Pointer to the device data.
3458 *
3459 *  \return:
3460 *           None
3461 *
3462 *   \note:
3463 *
3464 *****************************************************************************/
3465 osGLOBAL void
3466 tdsaDiscoverSend(
3467                  tiRoot_t             *tiRoot,
3468                  tdsaDeviceData_t     *oneDeviceData
3469                  )
3470 {
3471   agsaRoot_t            *agRoot;
3472   tdsaExpander_t        *oneExpander;
3473   smpReqDiscover_t      smpDiscoverReq;
3474
3475   TI_DBG3(("tdsaDiscoverSend: start\n"));
3476   TI_DBG3(("tdsaDiscoverSend: device %p did %d\n", oneDeviceData, oneDeviceData->id));
3477   agRoot = oneDeviceData->agRoot;
3478   oneExpander = oneDeviceData->tdExpander;
3479   TI_DBG3(("tdsaDiscoverSend: phyID 0x%x\n", oneExpander->discoveringPhyId));
3480
3481
3482   osti_memset(&smpDiscoverReq, 0, sizeof(smpReqDiscover_t));
3483
3484   smpDiscoverReq.reserved1 = 0;
3485   smpDiscoverReq.reserved2 = 0;
3486   smpDiscoverReq.phyIdentifier = oneExpander->discoveringPhyId;
3487   smpDiscoverReq.reserved3 = 0;
3488
3489
3490   tdSMPStart(
3491              tiRoot,
3492              agRoot,
3493              oneDeviceData,
3494              SMP_DISCOVER,
3495              (bit8 *)&smpDiscoverReq,
3496              sizeof(smpReqDiscover_t),
3497              AGSA_SMP_INIT_REQ,
3498              agNULL,
3499              0
3500              );
3501   return;
3502 }
3503
3504
3505 /*****************************************************************************
3506 *! \brief  tdsaDiscoverRespRcvd
3507 *
3508 *  Purpose:  This function processes Discovery response.
3509 *
3510 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3511 *                   instance.
3512 *  \param   agRoot: Pointer to chip/driver Instance.
3513 *  \param   oneDeviceData: Pointer to the device data.
3514 *  \param   frameHeader: Pointer to SMP frame header.
3515 *  \param   frameHandle: A Handle used to refer to the response frame
3516 *
3517 *  \return:
3518 *           None
3519 *
3520 *   \note:
3521 *
3522 *****************************************************************************/
3523 osGLOBAL void
3524 tdsaDiscoverRespRcvd(
3525                      tiRoot_t              *tiRoot,
3526                      agsaRoot_t            *agRoot,
3527                      agsaIORequest_t       *agIORequest,
3528                      tdsaDeviceData_t      *oneDeviceData,
3529                      tdssSMPFrameHeader_t  *frameHeader,
3530                      agsaFrameHandle_t     frameHandle
3531                      )
3532 {
3533   smpRespDiscover_t   *ptdSMPDiscoverResp;
3534   tdsaPortContext_t   *onePortContext;
3535   tdsaExpander_t      *oneExpander;
3536   tdsaDiscovery_t     *discovery;
3537 #ifndef DIRECT_SMP
3538   tdssSMPRequestBody_t *tdSMPRequestBody;
3539 #endif
3540
3541   TI_DBG3(("tdsaDiscoverRespRcvd: start\n"));
3542   TI_DBG3(("tdsaDiscoverRespRcvd: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
3543   TI_DBG3(("tdsaDiscoverRespRcvd: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
3544
3545
3546   onePortContext = oneDeviceData->tdPortContext;
3547   oneExpander = oneDeviceData->tdExpander;
3548   discovery = &(onePortContext->discovery);
3549 #ifndef DIRECT_SMP
3550   tdSMPRequestBody = (tdssSMPRequestBody_t *)agIORequest->osData;
3551 #endif
3552
3553   if (onePortContext->valid == agFALSE)
3554   {
3555     TI_DBG1(("tdsaDiscoverRespRcvd: aborting discovery\n"));
3556     tdsaSASDiscoverAbort(tiRoot, onePortContext);
3557     return;
3558   }
3559   ptdSMPDiscoverResp = &(discovery->SMPDiscoverResp);
3560 #ifdef DIRECT_SMP
3561   saFrameReadBlock(agRoot, frameHandle, 4, ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
3562 #else
3563   saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 4, ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
3564 #endif
3565   //tdhexdump("tdsaDiscoverRespRcvd", (bit8 *)ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
3566
3567 #ifndef DIRECT_SMP
3568   ostiFreeMemory(
3569                  tiRoot,
3570                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
3571                  tdSMPRequestBody->IndirectSMPReqLen
3572                 );
3573   ostiFreeMemory(
3574                  tiRoot,
3575                  tdSMPRequestBody->IndirectSMPResposMemHandle,
3576                  tdSMPRequestBody->IndirectSMPRespLen
3577                 );
3578 #endif
3579
3580   if ( frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
3581   {
3582     if ( onePortContext->discovery.status == DISCOVERY_UP_STREAM)
3583     {
3584       tdsaSASUpStreamDiscoverExpanderPhy(tiRoot, onePortContext, oneExpander, ptdSMPDiscoverResp);
3585     }
3586     else if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
3587     {
3588       tdsaSASDownStreamDiscoverExpanderPhy(tiRoot, onePortContext, oneExpander, ptdSMPDiscoverResp);
3589     }
3590     else if (onePortContext->discovery.status == DISCOVERY_CONFIG_ROUTING)
3591     {
3592       /* not done with configuring routing
3593          1. set the timer
3594          2. on timer expiration, call tdsaSASDownStreamDiscoverExpanderPhy()
3595       */
3596       TI_DBG2(("tdsaDiscoverRespRcvd: still configuring routing; setting timer\n"));
3597       TI_DBG2(("tdsaDiscoverRespRcvd: onePortContext %p oneDeviceData %p ptdSMPDiscoverResp %p\n", onePortContext, oneDeviceData, ptdSMPDiscoverResp));
3598       tdhexdump("tdsaDiscoverRespRcvd", (bit8*)ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
3599
3600       tdsaConfigureRouteTimer(tiRoot, onePortContext, oneExpander, ptdSMPDiscoverResp);
3601     }
3602     else
3603     {
3604       /* nothing */
3605     }
3606   }
3607   else if (frameHeader->smpFunctionResult == PHY_VACANT)
3608   {
3609     TI_DBG3(("tdsaDiscoverRespRcvd: smpFunctionResult is PHY_VACANT, phyid %d\n",
3610     oneExpander->discoveringPhyId));
3611     if ( onePortContext->discovery.status == DISCOVERY_UP_STREAM)
3612     {
3613       tdsaSASUpStreamDiscoverExpanderPhySkip(tiRoot, onePortContext, oneExpander);
3614     }
3615     else if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
3616     {
3617       tdsaSASDownStreamDiscoverExpanderPhySkip(tiRoot, onePortContext, oneExpander);
3618     }
3619     else if (onePortContext->discovery.status == DISCOVERY_CONFIG_ROUTING)
3620     {
3621       /* not done with configuring routing
3622          1. set the timer
3623          2. on timer expiration, call tdsaSASDownStreamDiscoverExpanderPhy()
3624       */
3625       TI_DBG1(("tdsaDiscoverRespRcvd: still configuring routing; setting timer\n"));
3626       TI_DBG1(("tdsaDiscoverRespRcvd: onePortContext %p oneDeviceData %p ptdSMPDiscoverResp %p\n", onePortContext, oneDeviceData, ptdSMPDiscoverResp));
3627       tdhexdump("tdsaDiscoverRespRcvd", (bit8*)ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
3628
3629       tdsaConfigureRouteTimer(tiRoot, onePortContext, oneExpander, ptdSMPDiscoverResp);
3630     }
3631   }
3632   else
3633   {
3634     TI_DBG1(("tdsaDiscoverRespRcvd: Discovery Error SMP function return result error=%x\n",
3635              frameHeader->smpFunctionResult));
3636      tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3637   }
3638   return;
3639 }
3640
3641 /*****************************************************************************
3642 *! \brief  tdsaSASUpStreamDiscoverExpanderPhy
3643 *
3644 *  Purpose:  This function actully does upstream traverse and finds out detailed
3645 *            information about topology.
3646 *
3647 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
3648 *                   instance.
3649 *  \param   onePortContext: Pointer to the portal context instance.
3650 *  \param   oneExpander: Pointer to the expander data.
3651 *  \param   pDiscoverResp: Pointer to the Discovery SMP respsonse.
3652 *
3653 *  \return:
3654 *           None
3655 *
3656 *   \note:
3657 *
3658 *****************************************************************************/
3659 osGLOBAL void
3660 tdsaSASUpStreamDiscoverExpanderPhy(
3661                                    tiRoot_t              *tiRoot,
3662                                    tdsaPortContext_t     *onePortContext,
3663                                    tdsaExpander_t        *oneExpander,
3664                                    smpRespDiscover_t     *pDiscoverResp
3665                                    )
3666 {
3667   tdsaDeviceData_t        *oneDeviceData;
3668   tdsaDeviceData_t        *AttachedDevice = agNULL;
3669   tdsaExpander_t          *AttachedExpander;
3670   agsaSASIdentify_t       sasIdentify;
3671   bit8                    connectionRate;
3672   bit32                   attachedSasHi, attachedSasLo;
3673   tdsaSASSubID_t          agSASSubID;
3674
3675   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: start\n"));
3676   if (onePortContext->valid == agFALSE)
3677   {
3678     TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: aborting discovery\n"));
3679     tdsaSASDiscoverAbort(tiRoot, onePortContext);
3680     return;
3681   }
3682
3683   oneDeviceData = oneExpander->tdDevice;
3684   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Phy #%d of SAS %08x-%08x\n",
3685            oneExpander->discoveringPhyId,
3686            oneDeviceData->SASAddressID.sasAddressHi,
3687            oneDeviceData->SASAddressID.sasAddressLo));
3688   TI_DBG3(("   Attached device: %s\n",
3689            ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
3690              (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
3691               (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
3692
3693   if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
3694   {
3695     TI_DBG3(("   SAS address    : %08x-%08x\n",
3696       DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
3697               DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
3698     TI_DBG3(("   SSP Target     : %d\n", DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
3699     TI_DBG3(("   STP Target     : %d\n", DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
3700     TI_DBG3(("   SMP Target     : %d\n", DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
3701     TI_DBG3(("   SATA DEVICE    : %d\n", DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
3702     TI_DBG3(("   SSP Initiator  : %d\n", DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
3703     TI_DBG3(("   STP Initiator  : %d\n", DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
3704     TI_DBG3(("   SMP Initiator  : %d\n", DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
3705     TI_DBG3(("   Phy ID         : %d\n", pDiscoverResp->phyIdentifier));
3706     TI_DBG3(("   Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
3707   }
3708   /* end for debugging */
3709
3710   /* for debugging */
3711   if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
3712   {
3713     TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: !!! Incorrect SMP response !!!\n"));
3714     TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: Request PhyID #%d Response PhyID #%d\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
3715     tdhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover_t));
3716     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3717     return;
3718   }
3719
3720   /* saving routing attribute for non self-configuring expanders */
3721   oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
3722
3723   /* for debugging */
3724 //  dumpRoutingAttributes(tiRoot, oneExpander, pDiscoverResp->phyIdentifier);
3725
3726   if ( oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE )
3727   {
3728     TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: SA_SAS_DEV_TYPE_FANOUT_EXPANDER\n"));
3729     if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
3730     {
3731       TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: **** Topology Error subtractive routing on fanout expander device\n"));
3732
3733       /* discovery error */
3734       onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
3735         = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
3736       onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
3737         = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
3738       onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
3739
3740       /* (2.1.3) discovery done */
3741       tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3742       return;
3743     }
3744   }
3745   else
3746   {
3747     TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: SA_SAS_DEV_TYPE_EDGE_EXPANDER\n"));
3748
3749     if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
3750     {
3751       /* Setup sasIdentify for the attached device */
3752       sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
3753       sasIdentify.deviceType_addressFrameType = (bit8)(pDiscoverResp->attachedDeviceType & 0x70);
3754       sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
3755       sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
3756       *(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
3757       *(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
3758
3759       /* incremental discovery */
3760       agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
3761       agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
3762       agSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
3763       agSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
3764
3765       attachedSasHi = DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
3766       attachedSasLo = DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
3767
3768       /* If the phy has subtractive routing attribute */
3769       if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
3770       {
3771         TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: SA_SAS_ROUTING_SUBTRACTIVE\n"));
3772         /* Setup upstream phys */
3773         tdsaSASExpanderUpStreamPhyAdd(tiRoot, oneExpander, (bit8) pDiscoverResp->attachedPhyIdentifier);
3774         /* If the expander already has an upsteam device set up */
3775         if (oneExpander->hasUpStreamDevice == agTRUE)
3776         {
3777           /* If the sas address doesn't match */
3778           if ( ((oneExpander->upStreamSASAddressHi != attachedSasHi) ||
3779                 (oneExpander->upStreamSASAddressLo != attachedSasLo)) &&
3780                (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE ||
3781                 DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
3782               )
3783           {
3784             /* TODO: discovery error, callback */
3785             TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: **** Topology Error subtractive routing error - inconsistent SAS address\n"));
3786             /* call back to notify discovery error */
3787             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
3788               = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
3789             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
3790               = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
3791             onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
3792             /* discovery done */
3793             tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3794           }
3795         }
3796         else
3797         {
3798           /* Setup SAS address for up stream device */
3799           oneExpander->hasUpStreamDevice = agTRUE;
3800           oneExpander->upStreamSASAddressHi = attachedSasHi;
3801           oneExpander->upStreamSASAddressLo = attachedSasLo;
3802
3803           if ( (onePortContext->sasLocalAddressHi != attachedSasHi)
3804               || (onePortContext->sasLocalAddressLo != attachedSasLo) )
3805           {
3806             /* Find the device from the discovered list */
3807             AttachedDevice = tdsaPortSASDeviceFind(tiRoot, onePortContext, attachedSasLo, attachedSasHi);
3808             /* If the device has been discovered before */
3809             if ( AttachedDevice != agNULL)
3810             {
3811               TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Seen This Device Before\n"));
3812               /* If attached device is an edge expander */
3813               if ( AttachedDevice->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
3814               {
3815                 /* The attached device is an expander */
3816                 AttachedExpander = AttachedDevice->tdExpander;
3817                 /* If the two expanders are the root of the two edge expander sets */
3818                 if ( (AttachedExpander->upStreamSASAddressHi ==
3819                       DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
3820                      && (AttachedExpander->upStreamSASAddressLo ==
3821                         DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)) )
3822                 {
3823                   /* Setup upstream expander for the pExpander */
3824                   oneExpander->tdUpStreamExpander = AttachedExpander;
3825                 }
3826                 /* If the two expanders are not the root of the two edge expander sets */
3827                 else
3828                 {
3829                   /* TODO: loop found, discovery error, callback */
3830                   TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy: **** Topology Error loop detection\n"));
3831                   onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
3832                     = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
3833                   onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
3834                     = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
3835                   onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
3836                   /* discovery done */
3837                   tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3838                 }
3839               }
3840               /* If attached device is not an edge expander */
3841               else
3842               {
3843                 /*TODO: should not happen, ASSERT */
3844                 TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy, *** Attached Device is not Edge. Confused!!\n"));
3845               }
3846             }
3847             /* If the device has not been discovered before */
3848             else
3849             {
3850               /* Add the device */
3851               TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: New device\n"));
3852               /* read minimum rate from the configuration
3853                  onePortContext->LinkRate is SPC's local link rate
3854               */
3855               connectionRate = (bit8)(MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp)));
3856               TI_DBG3(("siSASUpStreamDiscoverExpanderPhy: link rate 0x%x\n", onePortContext->LinkRate));
3857               TI_DBG3(("siSASUpStreamDiscoverExpanderPhy: negotiatedPhyLinkRate 0x%x\n", DISCRSP_GET_LINKRATE(pDiscoverResp)));
3858               TI_DBG3(("siSASUpStreamDiscoverExpanderPhy: connectionRate 0x%x\n", connectionRate));
3859               //hhhhhhhh
3860               if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
3861               {
3862                 /* incremental discovery */
3863                 if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
3864                 {
3865                   AttachedDevice = tdsaPortSASDeviceAdd(
3866                                                     tiRoot,
3867                                                     onePortContext,
3868                                                     sasIdentify,
3869                                                     agFALSE,
3870                                                     connectionRate,
3871                                                     IT_NEXUS_TIMEOUT,
3872                                                     0,
3873                                                     STP_DEVICE_TYPE,
3874                                                     oneDeviceData,
3875                                                     pDiscoverResp->phyIdentifier
3876                                                     );
3877                 }
3878                 else
3879                 {
3880                   /* incremental discovery */
3881                   AttachedDevice = tdsaFindRegNValid(
3882                                                      onePortContext->agRoot,
3883                                                      onePortContext,
3884                                                      &agSASSubID
3885                                                      );
3886                   /* not registered and not valid; add this*/
3887                   if (AttachedDevice == agNULL)
3888                   {
3889                     AttachedDevice = tdsaPortSASDeviceAdd(
3890                                                     tiRoot,
3891                                                     onePortContext,
3892                                                     sasIdentify,
3893                                                     agFALSE,
3894                                                     connectionRate,
3895                                                     IT_NEXUS_TIMEOUT,
3896                                                     0,
3897                                                     STP_DEVICE_TYPE,
3898                                                     oneDeviceData,
3899                                                     pDiscoverResp->phyIdentifier
3900                                                     );
3901                   }
3902                 }
3903               }
3904               else
3905               {
3906                 /* incremental discovery */
3907                 if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
3908                 {
3909                   AttachedDevice = tdsaPortSASDeviceAdd(
3910                                                     tiRoot,
3911                                                     onePortContext,
3912                                                     sasIdentify,
3913                                                     agFALSE,
3914                                                     connectionRate,
3915                                                     IT_NEXUS_TIMEOUT,
3916                                                     0,
3917                                                     SAS_DEVICE_TYPE,
3918                                                     oneDeviceData,
3919                                                     pDiscoverResp->phyIdentifier
3920                                                     );
3921                 }
3922                 else
3923                 {
3924                   /* incremental discovery */
3925                   AttachedDevice = tdsaFindRegNValid(
3926                                                      onePortContext->agRoot,
3927                                                      onePortContext,
3928                                                      &agSASSubID
3929                                                      );
3930                   /* not registered and not valid; add this*/
3931                   if (AttachedDevice == agNULL)
3932                   {
3933                     AttachedDevice = tdsaPortSASDeviceAdd(
3934                                                     tiRoot,
3935                                                     onePortContext,
3936                                                     sasIdentify,
3937                                                     agFALSE,
3938                                                     connectionRate,
3939                                                     IT_NEXUS_TIMEOUT,
3940                                                     0,
3941                                                     SAS_DEVICE_TYPE,
3942                                                     oneDeviceData,
3943                                                     pDiscoverResp->phyIdentifier
3944                                                     );
3945                   }
3946                 }
3947               }
3948               /* If the device is added successfully */
3949               if ( AttachedDevice != agNULL)
3950               {
3951
3952                  /* (3.1.2.3.2.3.2.1) callback about new device */
3953                 if ( DISCRSP_IS_SSP_TARGET(pDiscoverResp)
3954                     || DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)
3955                     || DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)
3956                     || DISCRSP_IS_SMP_INITIATOR(pDiscoverResp) )
3957                 {
3958                   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Found SSP/SMP SAS %08x-%08x\n",
3959                       attachedSasHi, attachedSasLo));
3960                 }
3961                 else
3962                 {
3963                   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Found a SAS STP device.\n"));
3964                 }
3965                  /* If the attached device is an expander */
3966                 if ( (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
3967                     || (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE) )
3968                 {
3969                   /* Allocate an expander data structure */
3970                   AttachedExpander = tdssSASDiscoveringExpanderAlloc(
3971                                                                      tiRoot,
3972                                                                      onePortContext,
3973                                                                      AttachedDevice
3974                                                                      );
3975
3976                   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Found expander=%p\n", AttachedExpander));
3977                   /* If allocate successfully */
3978                   if ( AttachedExpander != agNULL)
3979                   {
3980                     /* Add the pAttachedExpander to discovering list */
3981                     tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, AttachedExpander);
3982                     /* Setup upstream expander for the pExpander */
3983                     oneExpander->tdUpStreamExpander = AttachedExpander;
3984                   }
3985                   /* If failed to allocate */
3986                   else
3987                   {
3988                     TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy, Failed to allocate expander data structure\n"));
3989                     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
3990                   }
3991                 }
3992                 /* If the attached device is an end device */
3993                 else
3994                 {
3995                   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: Found end device\n"));
3996                   /* LP2006-05-26 added upstream device to the newly found device */
3997                   AttachedDevice->tdExpander = oneExpander;
3998                   oneExpander->tdUpStreamExpander = agNULL;
3999                 }
4000               }
4001               else
4002               {
4003                 TI_DBG1(("tdsaSASUpStreamDiscoverExpanderPhy, Failed to add a device\n"));
4004                 tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4005               }
4006             }
4007           }
4008         }
4009       } /* substractive routing */
4010     }
4011   }
4012
4013
4014    oneExpander->discoveringPhyId ++;
4015    if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
4016      {
4017        if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
4018        {
4019          TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: DISCOVERY_UP_STREAM find more ...\n"));
4020          /* continue discovery for the next phy */
4021          tdsaDiscoverSend(tiRoot, oneDeviceData);
4022        }
4023        else
4024        {
4025          TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: DISCOVERY_UP_STREAM last phy continue upstream..\n"));
4026
4027          /* remove the expander from the discovering list */
4028          tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, oneExpander);
4029          /* continue upstream discovering */
4030          tdsaSASUpStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
4031        }
4032    }
4033    else
4034    {
4035       TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
4036
4037    }
4038
4039   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
4040
4041   return;
4042 }
4043
4044 // for debugging only
4045 osGLOBAL tdsaExpander_t *
4046 tdsaFindUpStreamConfigurableExp(tiRoot_t              *tiRoot,
4047                                                                 tdsaExpander_t        *oneExpander)
4048 {
4049   tdsaExpander_t    *ret=agNULL;
4050   tdsaExpander_t    *UpsreamExpander = oneExpander->tdUpStreamExpander;
4051
4052   TI_DBG3(("tdsaFindUpStreamConfigurableExp: start\n"));
4053   TI_DBG3(("tdsaFindUpStreamConfigurableExp: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4054   TI_DBG3(("tdsaFindUpStreamConfigurableExp: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4055
4056
4057   if (UpsreamExpander)
4058   {
4059     TI_DBG3(("tdsaFindUpStreamConfigurableExp: NO upsream expander\n"));
4060   }
4061   else
4062   {
4063     while (UpsreamExpander)
4064     {
4065       TI_DBG3(("tdsaFindUpStreamConfigurableExp: exp addrHi 0x%08x\n", UpsreamExpander->tdDevice->SASAddressID.sasAddressHi));
4066       TI_DBG3(("tdsaFindUpStreamConfigurableExp: exp addrLo 0x%08x\n", UpsreamExpander->tdDevice->SASAddressID.sasAddressLo));
4067
4068       UpsreamExpander = UpsreamExpander->tdUpStreamExpander;
4069     }
4070   }
4071   return ret;
4072 }
4073
4074 /*****************************************************************************
4075 *! \brief  tdsaSASUpStreamDiscoverExpanderPhySkip
4076 *
4077 *  Purpose:  This function skips a phy which returned PHY_VACANT in SMP
4078 *            response in upstream
4079 *
4080 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4081 *                   instance.
4082 *  \param   onePortContext: Pointer to the portal context instance.
4083 *  \param   oneExpander: Pointer to the expander data.
4084 *
4085 *  \return:
4086 *           None
4087 *
4088 *   \note:
4089 *
4090 *****************************************************************************/
4091 osGLOBAL void
4092 tdsaSASUpStreamDiscoverExpanderPhySkip(
4093                                    tiRoot_t              *tiRoot,
4094                                    tdsaPortContext_t     *onePortContext,
4095                                    tdsaExpander_t        *oneExpander
4096                                    )
4097 {
4098   tdsaDeviceData_t        *oneDeviceData;
4099   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: start\n"));
4100   oneDeviceData = oneExpander->tdDevice;
4101
4102   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
4103   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
4104
4105   oneExpander->discoveringPhyId ++;
4106   if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
4107   {
4108     if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
4109     {
4110       TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: More Phys to discover\n"));
4111       /* continue discovery for the next phy */
4112       tdsaDiscoverSend(tiRoot, oneDeviceData);
4113     }
4114     else
4115     {
4116        TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: No More Phys\n"));
4117
4118        /* remove the expander from the discovering list */
4119        tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, oneExpander);
4120        /* continue upstream discovering */
4121        tdsaSASUpStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
4122      }
4123   }
4124   else
4125   {
4126     TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
4127
4128   }
4129
4130   TI_DBG3(("tdsaSASUpStreamDiscoverExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
4131
4132
4133   return;
4134 }
4135
4136
4137 // for debugging only
4138 osGLOBAL tdsaExpander_t *
4139 tdsaFindDownStreamConfigurableExp(tiRoot_t              *tiRoot,
4140                                                                   tdsaExpander_t        *oneExpander)
4141 {
4142   tdsaExpander_t  *ret=agNULL;
4143   tdsaExpander_t  *DownsreamExpander = oneExpander->tdCurrentDownStreamExpander;
4144
4145   TI_DBG3(("tdsaFindDownStreamConfigurableExp: start\n"));
4146   TI_DBG3(("tdsaFindDownStreamConfigurableExp: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4147   TI_DBG3(("tdsaFindDownStreamConfigurableExp: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4148
4149
4150   if (DownsreamExpander)
4151   {
4152     TI_DBG3(("tdsaFindDownStreamConfigurableExp: NO downsream expander\n"));
4153   }
4154   else
4155   {
4156     while (DownsreamExpander)
4157     {
4158       TI_DBG3(("tdsaFindDownStreamConfigurableExp: exp addrHi 0x%08x\n", DownsreamExpander->tdDevice->SASAddressID.sasAddressHi));
4159       TI_DBG3(("tdsaFindDownStreamConfigurableExp: exp addrLo 0x%08x\n", DownsreamExpander->tdDevice->SASAddressID.sasAddressLo));
4160
4161       DownsreamExpander = DownsreamExpander->tdCurrentDownStreamExpander;
4162     }
4163   }
4164   return ret;
4165 }
4166
4167 // for debugging only
4168 osGLOBAL void
4169 dumpRoutingAttributes(
4170                       tiRoot_t                 *tiRoot,
4171                       tdsaExpander_t           *oneExpander,
4172                       bit8                     phyID
4173                       )
4174 {
4175   bit32 i;
4176
4177   TI_DBG3(("dumpRoutingAttributes: start\n"));
4178   TI_DBG3(("dumpRoutingAttributes: phyID %d\n", phyID));
4179   TI_DBG3(("dumpRoutingAttributes: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4180   TI_DBG3(("dumpRoutingAttributes: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4181
4182   for(i=0;i <= ((bit32)phyID + 1); i++)
4183   {
4184     TI_DBG3(("dumpRoutingAttributes: index %d routing attribute %d\n", i, oneExpander->routingAttribute[i]));
4185   }
4186   return;
4187 }
4188
4189 /*****************************************************************************
4190 *! \brief  tdsaDumpAllExp
4191 *
4192 *  Purpose:  This function prints out all expanders seen by discovery.
4193 *
4194 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4195 *                   instance.
4196 *  \param   onePortContext: Pointer to the portal context instance.
4197 *  \param   oneExpander: Pointer to the expander data.
4198 *
4199 *  \return:
4200 *           None
4201 *
4202 *   \note: For debugging only
4203 *
4204 *****************************************************************************/
4205 osGLOBAL void
4206 tdsaDumpAllExp(
4207                tiRoot_t                 *tiRoot,
4208                tdsaPortContext_t        *onePortContext,
4209                tdsaExpander_t           *oneExpander
4210               )
4211 {
4212 #if 0 /* for debugging only */
4213   tdList_t          *ExpanderList;
4214   tdsaExpander_t    *tempExpander;
4215   tdsaExpander_t    *UpsreamExpander;
4216   tdsaExpander_t    *DownsreamExpander;
4217   tdsaPortContext_t *tmpOnePortContext = onePortContext;
4218
4219   TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: start\n"));
4220   TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: onePortcontext %p oneExpander %p\n", onePortContext, oneExpander));
4221
4222   /* debugging */
4223   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
4224   if (TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
4225   {
4226     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
4227     TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: empty discoveringExpanderList\n"));
4228     return;
4229   }
4230   else
4231   {
4232     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
4233   }
4234   ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
4235   while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
4236   {
4237     tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
4238     UpsreamExpander = tempExpander->tdUpStreamExpander;
4239     DownsreamExpander = tempExpander->tdCurrentDownStreamExpander;
4240     TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: expander id %d\n", tempExpander->id));
4241     TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: exp addrHi 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressHi));
4242     TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: exp addrLo 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressLo));
4243     if (UpsreamExpander)
4244     {
4245       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: Up exp addrHi 0x%08x\n", UpsreamExpander->tdDevice->SASAddressID.sasAddressHi));
4246       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: Up exp addrLo 0x%08x\n", UpsreamExpander->tdDevice->SASAddressID.sasAddressLo));
4247     }
4248     else
4249     {
4250       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: No Upstream expander\n"));
4251     }
4252     if (DownsreamExpander)
4253     {
4254       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: Down exp addrHi 0x%08x\n", DownsreamExpander->tdDevice->SASAddressID.sasAddressHi));
4255       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: Down exp addrLo 0x%08x\n", DownsreamExpander->tdDevice->SASAddressID.sasAddressLo));
4256     }
4257     else
4258     {
4259       TI_DBG3(("tdssSASDiscoveringExpander tdsaDumpAllExp: No Downstream expander\n"));
4260     }
4261
4262     ExpanderList = ExpanderList->flink;
4263   }
4264 #endif
4265   return;
4266
4267 }
4268
4269 /*****************************************************************************
4270 *! \brief  tdsaDumpAllUpExp
4271 *
4272 *  Purpose:  This function prints out all upstream expanders seen by discovery.
4273 *
4274 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4275 *                   instance.
4276 *  \param   onePortContext: Pointer to the portal context instance.
4277 *  \param   oneExpander: Pointer to the expander data.
4278 *
4279 *  \return:
4280 *           None
4281 *
4282 *   \note: For debugging only
4283 *
4284 *****************************************************************************/
4285 osGLOBAL void
4286 tdsaDumpAllUpExp(
4287                               tiRoot_t                 *tiRoot,
4288                               tdsaPortContext_t        *onePortContext,
4289                               tdsaExpander_t           *oneExpander
4290                               )
4291 {
4292   return;
4293
4294 }
4295
4296 /*****************************************************************************
4297 *! \brief  tdsaDumpAllFreeExp
4298 *
4299 *  Purpose:  This function prints out all free expanders.
4300 *
4301 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4302 *                   instance.
4303 *  \return:
4304 *           None
4305 *
4306 *   \note: For debugging only
4307 *
4308 *****************************************************************************/
4309 osGLOBAL void
4310 tdsaDumpAllFreeExp(
4311                    tiRoot_t                 *tiRoot
4312                   )
4313 {
4314
4315   return;
4316 }
4317
4318 /*****************************************************************************
4319 *! \brief  tdsaDuplicateConfigSASAddr
4320 *
4321 *  Purpose:  This function finds whether SAS address has added to the routing
4322 *            table of expander or not.
4323 *
4324 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4325 *                   instance.
4326 *  \param   oneExpander: Pointer to the expander data.
4327 *  \param   configSASAddressHi: Upper 4 byte of SAS address.
4328 *  \param   configSASAddressLo: Lower 4 byte of SAS address.
4329 *
4330 *  \return:
4331 *           agTRUE  No need to add configSASAddress.
4332 *           agFALSE Need to add configSASAddress.
4333 *
4334 *   \note:
4335 *
4336 *****************************************************************************/
4337 osGLOBAL bit32
4338 tdsaDuplicateConfigSASAddr(
4339                       tiRoot_t                 *tiRoot,
4340                       tdsaExpander_t           *oneExpander,
4341                       bit32                    configSASAddressHi,
4342                       bit32                    configSASAddressLo
4343                       )
4344 {
4345   bit32 i;
4346   bit32 ret = agFALSE;
4347   TI_DBG3(("tdsaDuplicateConfigSASAddr: start\n"));
4348
4349   if (oneExpander == agNULL)
4350   {
4351     TI_DBG3(("tdsaDuplicateConfigSASAddr: NULL expander\n"));
4352     return agTRUE;
4353   }
4354
4355   if (oneExpander->tdDevice->SASAddressID.sasAddressHi == configSASAddressHi &&
4356       oneExpander->tdDevice->SASAddressID.sasAddressLo == configSASAddressLo
4357      )
4358   {
4359     TI_DBG3(("tdsaDuplicateConfigSASAddr: unnecessary\n"));
4360     return agTRUE;
4361   }
4362
4363   TI_DBG3(("tdsaDuplicateConfigSASAddr: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4364   TI_DBG3(("tdsaDuplicateConfigSASAddr: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4365   TI_DBG3(("tdsaDuplicateConfigSASAddr: configsasAddressHi 0x%08x\n", configSASAddressHi));
4366   TI_DBG3(("tdsaDuplicateConfigSASAddr: configsasAddressLo 0x%08x\n", configSASAddressLo));
4367   TI_DBG3(("tdsaDuplicateConfigSASAddr: configSASAddrTableIndex %d\n", oneExpander->configSASAddrTableIndex));
4368   for(i=0;i<oneExpander->configSASAddrTableIndex;i++)
4369   {
4370     if (oneExpander->configSASAddressHiTable[i] == configSASAddressHi &&
4371         oneExpander->configSASAddressLoTable[i] == configSASAddressLo
4372         )
4373     {
4374       TI_DBG3(("tdsaDuplicateConfigSASAddr: FOUND!!!\n"));
4375       ret = agTRUE;
4376       break;
4377     }
4378   }
4379   /* new one; let's add it */
4380   if (ret == agFALSE)
4381   {
4382     TI_DBG3(("tdsaDuplicateConfigSASAddr: adding configSAS Addr!!!\n"));
4383     TI_DBG3(("tdsaDuplicateConfigSASAddr: configSASAddrTableIndex %d\n", oneExpander->configSASAddrTableIndex));
4384     oneExpander->configSASAddressHiTable[oneExpander->configSASAddrTableIndex] = configSASAddressHi;
4385     oneExpander->configSASAddressLoTable[oneExpander->configSASAddrTableIndex] = configSASAddressLo;
4386     oneExpander->configSASAddrTableIndex++;
4387   }
4388
4389   return ret;
4390 }
4391 /*****************************************************************************
4392 *! \brief  tdsaFindConfigurableExp
4393 *
4394 *  Purpose:  This function finds whether there is a configurable expander in
4395 *            the upstream expander list.
4396 *
4397 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4398 *                   instance.
4399 *  \param   onePortContext: Pointer to the portal context instance.
4400 *  \param   oneExpander: Pointer to the expander data.
4401 *
4402 *  \return:
4403 *           agTRUE  There is configurable expander.
4404 *           agFALSE There is not configurable expander.
4405 *
4406 *   \note:
4407 *
4408 *****************************************************************************/
4409 osGLOBAL tdsaExpander_t *
4410 tdsaFindConfigurableExp(
4411                          tiRoot_t                 *tiRoot,
4412                          tdsaPortContext_t        *onePortContext,
4413                          tdsaExpander_t           *oneExpander
4414                         )
4415 {
4416   tdsaExpander_t    *tempExpander;
4417   tdsaPortContext_t *tmpOnePortContext = onePortContext;
4418   tdsaExpander_t    *ret = agNULL;
4419
4420   TI_DBG3(("tdsaFindConfigurableExp: start\n"));
4421
4422   if (oneExpander == agNULL)
4423   {
4424     TI_DBG3(("tdsaFindConfigurableExp: NULL expander\n"));
4425     return agNULL;
4426   }
4427
4428   TI_DBG3(("tdsaFindConfigurableExp: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4429   TI_DBG3(("tdsaFindConfigurableExp: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4430
4431   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
4432   if (TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
4433   {
4434     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
4435     TI_DBG3(("tdsaFindConfigurableExp: empty UpdiscoveringExpanderList\n"));
4436     return agNULL;
4437   }
4438   else
4439   {
4440     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
4441   }
4442   tempExpander = oneExpander->tdUpStreamExpander;
4443   while (tempExpander)
4444   {
4445     TI_DBG3(("tdsaFindConfigurableExp: loop exp addrHi 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressHi));
4446     TI_DBG3(("tdsaFindConfigurableExp: loop exp addrLo 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressLo));
4447     if (tempExpander->configRouteTable)
4448     {
4449       TI_DBG3(("tdsaFindConfigurableExp: found configurable expander\n"));
4450       ret = tempExpander;
4451       break;
4452     }
4453    tempExpander = tempExpander->tdUpStreamExpander;
4454   }
4455
4456   return ret;
4457 }
4458
4459 /*****************************************************************************
4460 *! \brief  tdsaSASDownStreamDiscoverExpanderPhy
4461 *
4462 *  Purpose:  This function actully does downstream traverse and finds out detailed
4463 *            information about topology.
4464 *
4465 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4466 *                   instance.
4467 *  \param   onePortContext: Pointer to the portal context instance.
4468 *  \param   oneExpander: Pointer to the expander data.
4469 *  \param   pDiscoverResp: Pointer to the Discovery SMP respsonse.
4470 *
4471 *  \return:
4472 *           None
4473 *
4474 *   \note:
4475 *
4476 *****************************************************************************/
4477 osGLOBAL void
4478 tdsaSASDownStreamDiscoverExpanderPhy(
4479                                      tiRoot_t              *tiRoot,
4480                                      tdsaPortContext_t     *onePortContext,
4481                                      tdsaExpander_t        *oneExpander,
4482                                      smpRespDiscover_t     *pDiscoverResp
4483                                      )
4484 {
4485   tdsaDeviceData_t        *oneDeviceData;
4486   tdsaExpander_t          *UpStreamExpander;
4487   tdsaDeviceData_t        *AttachedDevice = agNULL;
4488   tdsaExpander_t          *AttachedExpander;
4489   agsaSASIdentify_t       sasIdentify;
4490   bit8                    connectionRate;
4491   bit32                   attachedSasHi, attachedSasLo;
4492   tdsaSASSubID_t          agSASSubID;
4493   tdsaExpander_t          *ConfigurableExpander = agNULL;
4494   bit32                   dupConfigSASAddr = agFALSE;
4495   bit32                   configSASAddressHi;
4496   bit32                   configSASAddressLo;
4497
4498   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: start\n"));
4499   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
4500   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
4501
4502   TD_ASSERT(tiRoot, "(tdsaSASDownStreamDiscoverExpanderPhy) agRoot NULL");
4503   TD_ASSERT(onePortContext, "(tdsaSASDownStreamDiscoverExpanderPhy) pPort NULL");
4504   TD_ASSERT(oneExpander, "(tdsaSASDownStreamDiscoverExpanderPhy) pExpander NULL");
4505   TD_ASSERT(pDiscoverResp, "(tdsaSASDownStreamDiscoverExpanderPhy) pDiscoverResp NULL");
4506
4507   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: onePortContxt=%p  oneExpander=%p  oneDeviceData=%p\n", onePortContext, oneExpander, oneExpander->tdDevice));
4508
4509   if (onePortContext->valid == agFALSE)
4510   {
4511     TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: aborting discovery\n"));
4512     tdsaSASDiscoverAbort(tiRoot, onePortContext);
4513     return;
4514   }
4515 #ifdef TD_INTERNAL_DEBUG
4516     tdsaDumpAllExp(tiRoot, onePortContext, oneExpander);
4517     tdsaFindUpStreamConfigurableExp(tiRoot, oneExpander);
4518     tdsaFindDownStreamConfigurableExp(tiRoot, oneExpander);
4519 #endif
4520   /* (1) Find the device structure of the expander */
4521   oneDeviceData = oneExpander->tdDevice;
4522   TD_ASSERT(oneDeviceData, "(tdsaSASDownStreamDiscoverExpanderPhy) pDevice NULL");
4523
4524   /* for debugging */
4525   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Phy #%d of SAS %08x-%08x\n",
4526            oneExpander->discoveringPhyId,
4527            oneDeviceData->SASAddressID.sasAddressHi,
4528            oneDeviceData->SASAddressID.sasAddressLo));
4529   TI_DBG3(("   Attached device: %s\n",
4530            ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
4531              (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
4532               (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
4533   /* for debugging */
4534   if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
4535   {
4536     TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: !!! Incorrect SMP response !!!\n"));
4537     TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: Request PhyID #%d Response PhyID #%d\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
4538     tdhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover_t));
4539     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4540     return;
4541   }
4542
4543 #ifdef TD_INTERNAL_DEBUG  /* debugging only */
4544   if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_NO_DEVICE)
4545   {
4546     tdhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover_t));
4547   }
4548 #endif
4549   if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
4550   {
4551     TI_DBG3(("   SAS address    : %08x-%08x\n",
4552       DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
4553               DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
4554     TI_DBG3(("   SSP Target     : %d\n", DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
4555     TI_DBG3(("   STP Target     : %d\n", DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
4556     TI_DBG3(("   SMP Target     : %d\n", DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
4557     TI_DBG3(("   SATA DEVICE    : %d\n", DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
4558     TI_DBG3(("   SSP Initiator  : %d\n", DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
4559     TI_DBG3(("   STP Initiator  : %d\n", DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
4560     TI_DBG3(("   SMP Initiator  : %d\n", DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
4561     TI_DBG3(("   Phy ID         : %d\n", pDiscoverResp->phyIdentifier));
4562     TI_DBG3(("   Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
4563
4564   }
4565   /* end for debugging */
4566
4567   /* saving routing attribute for non self-configuring expanders */
4568   oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
4569
4570   /* for debugging */
4571 //  dumpRoutingAttributes(tiRoot, oneExpander, pDiscoverResp->phyIdentifier);
4572
4573   oneExpander->discoverSMPAllowed = agTRUE;
4574
4575   /* If a device is attached */
4576   if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) !=  SAS_NO_DEVICE)
4577   {
4578     /* Setup sasIdentify for the attached device */
4579     sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
4580     sasIdentify.deviceType_addressFrameType = (bit8)(pDiscoverResp->attachedDeviceType & 0x70);
4581     sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
4582     sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
4583     *(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
4584     *(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
4585
4586     /* incremental discovery */
4587     agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
4588     agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
4589     agSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
4590     agSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
4591
4592     attachedSasHi = DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
4593     attachedSasLo = DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
4594
4595     /* If it's a direct routing */
4596     if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_DIRECT)
4597     {
4598       /* If the attached device is an expander */
4599       if ( (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
4600           || (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE) )
4601
4602       {
4603         TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error direct routing can't connect to expander\n"));
4604         onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4605            = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4606         onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4607           = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4608         onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4609
4610         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4611
4612         return;
4613       }
4614     }
4615
4616     /* If the expander's attached device is not myself */
4617     if ( (attachedSasHi != onePortContext->sasLocalAddressHi)
4618          || (attachedSasLo != onePortContext->sasLocalAddressLo) )
4619     {
4620       /* Find the attached device from discovered list */
4621       AttachedDevice = tdsaPortSASDeviceFind(tiRoot, onePortContext, attachedSasLo, attachedSasHi);
4622       /* If the device has not been discovered before */
4623       if ( AttachedDevice == agNULL) //11
4624       {
4625         /* If the phy has subtractive routing attribute */
4626         if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE &&
4627              (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE ||
4628               DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
4629            )
4630         {
4631           /* TODO: discovery error, callback */
4632           TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error subtractive routing error - inconsistent SAS address\n"));
4633           onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4634             = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4635           onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4636             = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4637           onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4638           /* discovery done */
4639           tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4640         }
4641         else
4642         {
4643           /* Add the device */
4644           /* read minimum rate from the configuration
4645              onePortContext->LinkRate is SPC's local link rate
4646           */
4647           connectionRate = (bit8)(MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp)));
4648           TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: link rate 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo)));
4649           TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: negotiatedPhyLinkRate 0x%x\n", DISCRSP_GET_LINKRATE(pDiscoverResp)));
4650           TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: connectionRate 0x%x\n", connectionRate));
4651
4652           if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
4653           {
4654             if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
4655             {
4656               AttachedDevice = tdsaPortSASDeviceAdd(
4657                                                     tiRoot,
4658                                                     onePortContext,
4659                                                     sasIdentify,
4660                                                     agFALSE,
4661                                                     connectionRate,
4662                                                     IT_NEXUS_TIMEOUT,
4663                                                     0,
4664                                                     STP_DEVICE_TYPE,
4665                                                     oneDeviceData,
4666                                                     pDiscoverResp->phyIdentifier
4667                                                     );
4668             }
4669             else
4670             {
4671               /* incremental discovery */
4672               AttachedDevice = tdsaFindRegNValid(
4673                                                  onePortContext->agRoot,
4674                                                  onePortContext,
4675                                                  &agSASSubID
4676                                                  );
4677               /* not registered and not valid; add this*/
4678               if (AttachedDevice == agNULL)
4679               {
4680                 AttachedDevice = tdsaPortSASDeviceAdd(
4681                                                       tiRoot,
4682                                                       onePortContext,
4683                                                       sasIdentify,
4684                                                       agFALSE,
4685                                                       connectionRate,
4686                                                       IT_NEXUS_TIMEOUT,
4687                                                       0,
4688                                                       STP_DEVICE_TYPE,
4689                                                       oneDeviceData,
4690                                                       pDiscoverResp->phyIdentifier
4691                                                       );
4692               }
4693             }
4694           }
4695           else
4696           {
4697             if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
4698             {
4699               AttachedDevice = tdsaPortSASDeviceAdd(
4700                                                     tiRoot,
4701                                                     onePortContext,
4702                                                     sasIdentify,
4703                                                     agFALSE,
4704                                                     connectionRate,
4705                                                     IT_NEXUS_TIMEOUT,
4706                                                     0,
4707                                                     SAS_DEVICE_TYPE,
4708                                                     oneDeviceData,
4709                                                     pDiscoverResp->phyIdentifier
4710                                                     );
4711             }
4712             else
4713             {
4714               /* incremental discovery */
4715               AttachedDevice = tdsaFindRegNValid(
4716                                                  onePortContext->agRoot,
4717                                                  onePortContext,
4718                                                  &agSASSubID
4719                                                  );
4720               /* not registered and not valid; add this*/
4721               if (AttachedDevice == agNULL)
4722               {
4723                 AttachedDevice = tdsaPortSASDeviceAdd(
4724                                                       tiRoot,
4725                                                       onePortContext,
4726                                                       sasIdentify,
4727                                                       agFALSE,
4728                                                       connectionRate,
4729                                                       IT_NEXUS_TIMEOUT,
4730                                                       0,
4731                                                       SAS_DEVICE_TYPE,
4732                                                       oneDeviceData,
4733                                                       pDiscoverResp->phyIdentifier
4734                                                       );
4735               }
4736             }
4737           }
4738           TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: newDevice  pDevice=%p\n", AttachedDevice));
4739           /* If the device is added successfully */
4740           if ( AttachedDevice != agNULL)
4741           {
4742             if ( SA_IDFRM_IS_SSP_TARGET(&sasIdentify)
4743                  || SA_IDFRM_IS_SMP_TARGET(&sasIdentify)
4744                  || SA_IDFRM_IS_SSP_INITIATOR(&sasIdentify)
4745                  || SA_IDFRM_IS_SMP_INITIATOR(&sasIdentify) )
4746             {
4747               TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Report a new SAS device !!\n"));
4748
4749             }
4750             else
4751             {
4752               if ( SA_IDFRM_IS_STP_TARGET(&sasIdentify) ||
4753                    SA_IDFRM_IS_SATA_DEVICE(&sasIdentify) )
4754               {
4755
4756                 TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Found an STP or SATA device.\n"));
4757               }
4758               else
4759               {
4760                 TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Found Other type of device.\n"));
4761               }
4762             }
4763
4764             /* LP2006-05-26 added upstream device to the newly found device */
4765             AttachedDevice->tdExpander = oneExpander;
4766
4767             /* If the phy has table routing attribute */
4768             if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
4769             {
4770               /* If the attached device is a fan out expander */
4771               if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
4772               {
4773                 /* TODO: discovery error, callback */
4774                 TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys are connected\n"));
4775                 onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4776                   = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4777                 onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4778                   = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4779                 onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4780                 /* discovery done */
4781                 tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4782               }
4783               else if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
4784               {
4785                 /* Allocate an expander data structure */
4786                 AttachedExpander = tdssSASDiscoveringExpanderAlloc(tiRoot, onePortContext, AttachedDevice);
4787
4788                 TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Found a EDGE exp device.%p\n", AttachedExpander));
4789                 /* If allocate successfully */
4790                 if ( AttachedExpander != agNULL)
4791                 {
4792                   /* set up downstream information on configurable expander */
4793                   if (oneExpander->configRouteTable)
4794                   {
4795                     tdsaSASExpanderDownStreamPhyAdd(tiRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
4796                   }
4797                   /* Setup upstream information */
4798                   tdsaSASExpanderUpStreamPhyAdd(tiRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
4799                   AttachedExpander->hasUpStreamDevice = agTRUE;
4800                   AttachedExpander->upStreamSASAddressHi
4801                     = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4802                   AttachedExpander->upStreamSASAddressLo
4803                     = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4804                   AttachedExpander->tdUpStreamExpander = oneExpander;
4805                   /* (2.3.2.2.2.2.2.2.2) Add the pAttachedExpander to discovering list */
4806                   tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, AttachedExpander);
4807                 }
4808                 /* If failed to allocate */
4809                 else
4810                 {
4811                   TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy, Failed to allocate expander data structure\n"));
4812                   /*  discovery done */
4813                   tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4814                 }
4815               }
4816             }
4817             /* If status is still DISCOVERY_DOWN_STREAM */
4818             if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
4819             {
4820               TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 1st before\n"));
4821               tdsaDumpAllUpExp(tiRoot, onePortContext, oneExpander);
4822               UpStreamExpander = oneExpander->tdUpStreamExpander;
4823               ConfigurableExpander = tdsaFindConfigurableExp(tiRoot, onePortContext, oneExpander);
4824               configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
4825               configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
4826               if (ConfigurableExpander)
4827               {
4828                 if ( (ConfigurableExpander->tdDevice->SASAddressID.sasAddressHi
4829                       == DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
4830                      (ConfigurableExpander->tdDevice->SASAddressID.sasAddressLo
4831                       == DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
4832                    )
4833                 { /* directly attached between oneExpander and ConfigurableExpander */
4834                   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 1st before loc 1\n"));
4835                   configSASAddressHi = oneExpander->tdDevice->SASAddressID.sasAddressHi;
4836                   configSASAddressLo = oneExpander->tdDevice->SASAddressID.sasAddressLo;
4837                 }
4838                 else
4839                 {
4840                   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 1st before loc 2\n"));
4841                   configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
4842                   configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
4843                 }
4844               } /* if !ConfigurableExpander */
4845               dupConfigSASAddr = tdsaDuplicateConfigSASAddr(tiRoot,
4846                                                           ConfigurableExpander,
4847                                                           configSASAddressHi,
4848                                                           configSASAddressLo
4849                                                           );
4850
4851
4852               if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
4853               {
4854                 TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 1st q123\n"));
4855                 UpStreamExpander->tdCurrentDownStreamExpander = oneExpander;
4856                 ConfigurableExpander->currentDownStreamPhyIndex =
4857                         tdsaFindCurrentDownStreamPhyIndex(tiRoot, ConfigurableExpander);
4858                 ConfigurableExpander->tdReturnginExpander = oneExpander;
4859                 tdsaSASRoutingEntryAdd(tiRoot,
4860                                        ConfigurableExpander,
4861                                        ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
4862                                        configSASAddressHi,
4863                                        configSASAddressLo
4864                                        );
4865               }
4866             }
4867           }
4868           /*  If fail to add the device */
4869           else
4870           {
4871             TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy, Failed to add a device\n"));
4872             /*  discovery done */
4873             tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4874           }
4875         }
4876       }
4877       /* If the device has been discovered before */
4878       else /* haha discovered before */
4879       {
4880         /* If the phy has subtractive routing attribute */
4881         if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
4882         {
4883           /* If the expander doesn't have up stream device */
4884           if ( oneExpander->hasUpStreamDevice == agFALSE)
4885           {
4886             /* TODO: discovery error, callback */
4887             TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error loop, or end device connects to two expanders\n"));
4888             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4889               = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4890             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4891               = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4892             onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4893             /* discovery done */
4894             tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4895           }
4896           /* If the expander has up stream device */
4897           else
4898           {
4899             /* If sas address doesn't match */
4900             if ( (oneExpander->upStreamSASAddressHi != attachedSasHi)
4901                  || (oneExpander->upStreamSASAddressLo != attachedSasLo) )
4902             {
4903               /* TODO: discovery error, callback */
4904               TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error two subtractive phys\n"));
4905               onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4906                 = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4907               onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4908                 = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4909               onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4910               /* discovery done */
4911               tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4912             }
4913           }
4914         }
4915         /* If the phy has table routing attribute */
4916         else if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
4917         {
4918           /* If the attached device is a fan out expander */
4919           if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
4920           {
4921             /* (2.3.3.2.1.1) TODO: discovery error, callback */
4922             TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error fan out expander to routing table phy\n"));
4923             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4924               = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4925             onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4926               = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4927             onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4928             /* discovery done */
4929             tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4930           }
4931           /* If the attached device is an edge expander */
4932           else if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
4933           {
4934             /* Setup up stream inform */
4935             AttachedExpander = AttachedDevice->tdExpander;
4936             TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Found edge expander=%p\n", AttachedExpander));
4937             //hhhhhh
4938             /* If the attached expander has up stream device */
4939             if ( AttachedExpander->hasUpStreamDevice == agTRUE)
4940             {
4941               /* compare the sas address */
4942               if ( (AttachedExpander->upStreamSASAddressHi
4943                     != DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
4944                    || (AttachedExpander->upStreamSASAddressLo
4945                        != DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)))
4946               {
4947                 /* TODO: discovery error, callback */
4948                 TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys connected (1)\n"));
4949                 onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4950                   = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4951                 onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4952                   = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4953                 onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4954                 /* discovery done */
4955                 tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4956               }
4957               else
4958               {
4959                 TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Add edge expander=%p\n", AttachedExpander));
4960                 /* set up downstream information on configurable expander */
4961                 if (oneExpander->configRouteTable)
4962                 {
4963                   tdsaSASExpanderDownStreamPhyAdd(tiRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
4964                 }
4965                 /* haha */
4966                 tdsaSASExpanderUpStreamPhyAdd(tiRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
4967                 /* Add the pAttachedExpander to discovering list */
4968                 tdssSASDiscoveringExpanderAdd(tiRoot, onePortContext, AttachedExpander);
4969               }
4970             }
4971             /* If the attached expander doesn't have up stream device */
4972             else
4973             {
4974               /* TODO: discovery error, callback */
4975               TI_DBG1(("tdsaSASDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys connected (2)\n"));
4976               onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
4977                 = DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
4978               onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
4979                 = DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
4980               onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
4981               /* discovery done */
4982               tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
4983             }
4984           }
4985         } /* for else if (DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE) */
4986
4987         /* do this regradless of sub or table */
4988         /* If status is still DISCOVERY_DOWN_STREAM */
4989         if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
4990         {
4991           TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 2nd before\n"));
4992           tdsaDumpAllUpExp(tiRoot, onePortContext, oneExpander);
4993
4994           UpStreamExpander = oneExpander->tdUpStreamExpander;
4995           ConfigurableExpander = tdsaFindConfigurableExp(tiRoot, onePortContext, oneExpander);
4996           configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
4997           configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
4998           if (ConfigurableExpander)
4999           {
5000             if ( (ConfigurableExpander->tdDevice->SASAddressID.sasAddressHi
5001                  == DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
5002                  (ConfigurableExpander->tdDevice->SASAddressID.sasAddressLo
5003                    == DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
5004                )
5005             { /* directly attached between oneExpander and ConfigurableExpander */
5006               TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 2nd before loc 1\n"));
5007               configSASAddressHi = oneExpander->tdDevice->SASAddressID.sasAddressHi;
5008               configSASAddressLo = oneExpander->tdDevice->SASAddressID.sasAddressLo;
5009             }
5010             else
5011             {
5012               TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 2nd before loc 2\n"));
5013               configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
5014               configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
5015             }
5016           } /* if !ConfigurableExpander */
5017           dupConfigSASAddr = tdsaDuplicateConfigSASAddr(tiRoot,
5018                                                         ConfigurableExpander,
5019                                                         configSASAddressHi,
5020                                                         configSASAddressLo
5021                                                         );
5022
5023           if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
5024           {
5025             TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 2nd q123 \n"));
5026             UpStreamExpander->tdCurrentDownStreamExpander = oneExpander;
5027             ConfigurableExpander->currentDownStreamPhyIndex =
5028                         tdsaFindCurrentDownStreamPhyIndex(tiRoot, ConfigurableExpander);
5029             ConfigurableExpander->tdReturnginExpander = oneExpander;
5030             tdsaSASRoutingEntryAdd(tiRoot,
5031                                    ConfigurableExpander,
5032                                    ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
5033                                    configSASAddressHi,
5034                                    configSASAddressLo
5035                                    );
5036           }
5037         } /* if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM) */
5038         /* incremental discovery */
5039         if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_INCREMENTAL_START)
5040         {
5041           connectionRate = (bit8)(MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp)));
5042
5043           if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
5044           {
5045             TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: incremental SATA_STP\n"));
5046
5047             tdsaPortSASDeviceAdd(
5048                                                     tiRoot,
5049                                                     onePortContext,
5050                                                     sasIdentify,
5051                                                     agFALSE,
5052                                                     connectionRate,
5053                                                     IT_NEXUS_TIMEOUT,
5054                                                     0,
5055                                                     STP_DEVICE_TYPE,
5056                                                     oneDeviceData,
5057                                                     pDiscoverResp->phyIdentifier
5058                                                     );
5059           }
5060           else
5061           {
5062             TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: incremental SAS\n"));
5063
5064              tdsaPortSASDeviceAdd(
5065                                                     tiRoot,
5066                                                     onePortContext,
5067                                                     sasIdentify,
5068                                                     agFALSE,
5069                                                     connectionRate,
5070                                                     IT_NEXUS_TIMEOUT,
5071                                                     0,
5072                                                     SAS_DEVICE_TYPE,
5073                                                     oneDeviceData,
5074                                                     pDiscoverResp->phyIdentifier
5075                                                     );
5076
5077           }
5078         }
5079
5080
5081       }/* else; existing devce */
5082     } /* not attached to myself */
5083     /* If the attached device is myself */
5084     else
5085     {
5086       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: Found Self\n"));
5087       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 3rd before\n"));
5088       tdsaDumpAllUpExp(tiRoot, onePortContext, oneExpander);
5089
5090       UpStreamExpander = oneExpander->tdUpStreamExpander;
5091       ConfigurableExpander = tdsaFindConfigurableExp(tiRoot, onePortContext, oneExpander);
5092       dupConfigSASAddr = tdsaDuplicateConfigSASAddr(tiRoot,
5093                                                     ConfigurableExpander,
5094                                                     onePortContext->sasLocalAddressHi,
5095                                                     onePortContext->sasLocalAddressLo
5096                                                     );
5097
5098       if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
5099       {
5100         TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: 3rd q123 Setup routing table\n"));
5101         UpStreamExpander->tdCurrentDownStreamExpander = oneExpander;
5102         ConfigurableExpander->currentDownStreamPhyIndex =
5103                         tdsaFindCurrentDownStreamPhyIndex(tiRoot, ConfigurableExpander);
5104         ConfigurableExpander->tdReturnginExpander = oneExpander;
5105         tdsaSASRoutingEntryAdd(tiRoot,
5106                                ConfigurableExpander,
5107                                ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
5108                                onePortContext->sasLocalAddressHi,
5109                                onePortContext->sasLocalAddressLo
5110                                );
5111       }
5112     }
5113   }
5114   /* If no device is attached */
5115   else
5116   {
5117   }
5118
5119
5120   /* Increment the discovering phy id */
5121   oneExpander->discoveringPhyId ++;
5122
5123   /* If the discovery status is DISCOVERY_DOWN_STREAM */
5124   if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
5125   {
5126     /* If not the last phy */
5127     if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
5128     {
5129       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: More Phys to discover\n"));
5130       /* continue discovery for the next phy */
5131       tdsaDiscoverSend(tiRoot, oneDeviceData);
5132     }
5133     /* If the last phy */
5134     else
5135     {
5136       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: No More Phys\n"));
5137
5138       /* remove the expander from the discovering list */
5139       tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, oneExpander);
5140       /* continue downstream discovering */
5141       tdsaSASDownStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
5142     }
5143   }
5144   else
5145   {
5146     TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
5147   }
5148   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
5149
5150   return;
5151 }
5152
5153 /*****************************************************************************
5154 *! \brief  tdsaSASDownStreamDiscoverExpanderPhySkip
5155 *
5156 *  Purpose:  This function skips a phy which returned PHY_VACANT in SMP
5157 *            response in downstream
5158 *
5159 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5160 *                   instance.
5161 *  \param   onePortContext: Pointer to the portal context instance.
5162 *  \param   oneExpander: Pointer to the expander data.
5163 *
5164 *  \return:
5165 *           None
5166 *
5167 *   \note:
5168 *
5169 *****************************************************************************/
5170 osGLOBAL void
5171 tdsaSASDownStreamDiscoverExpanderPhySkip(
5172                                      tiRoot_t              *tiRoot,
5173                                      tdsaPortContext_t     *onePortContext,
5174                                      tdsaExpander_t        *oneExpander
5175                                      )
5176 {
5177   tdsaDeviceData_t        *oneDeviceData;
5178   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: start\n"));
5179   oneDeviceData = oneExpander->tdDevice;
5180
5181   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
5182   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
5183
5184   /* Increment the discovering phy id */
5185   oneExpander->discoveringPhyId ++;
5186
5187   /* If the discovery status is DISCOVERY_DOWN_STREAM */
5188   if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
5189   {
5190     /* If not the last phy */
5191     if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
5192     {
5193       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: More Phys to discover\n"));
5194       /* continue discovery for the next phy */
5195       tdsaDiscoverSend(tiRoot, oneDeviceData);
5196     }
5197     /* If the last phy */
5198     else
5199     {
5200       TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: No More Phys\n"));
5201
5202       /* remove the expander from the discovering list */
5203       tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, oneExpander);
5204       /* continue downstream discovering */
5205       tdsaSASDownStreamDiscovering(tiRoot, onePortContext, oneDeviceData);
5206     }
5207   }
5208   else
5209   {
5210     TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
5211   }
5212   TI_DBG3(("tdsaSASDownStreamDiscoverExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
5213
5214   return;
5215 }
5216
5217 /*****************************************************************************
5218 *! \brief  tdsaSASRoutingEntryAdd
5219 *
5220 *  Purpose:  This function adds a routing entry in the configurable expander.
5221 *
5222 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5223 *                   instance.
5224 *  \param   oneExpander: Pointer to the expander data.
5225 *  \param   phyId: Phy identifier.
5226 *  \param   configSASAddressHi: Upper 4 byte of SAS address.
5227 *  \param   configSASAddressLo: Lower 4 byte of SAS address.
5228 *
5229 *  \return:
5230 *           agTRUE   Routing entry is added successfully
5231 *           agFALSE  Routing entry is not added successfully
5232 *
5233 *   \note:
5234 *
5235 *****************************************************************************/
5236 osGLOBAL bit32
5237 tdsaSASRoutingEntryAdd(
5238                        tiRoot_t          *tiRoot,
5239                        tdsaExpander_t    *oneExpander,
5240                        bit32             phyId,
5241                        bit32             configSASAddressHi,
5242                        bit32             configSASAddressLo
5243                        )
5244 {
5245   bit32                                   ret = agTRUE;
5246   smpReqConfigureRouteInformation_t       confRoutingInfo;
5247   tdsaPortContext_t                       *onePortContext;
5248   bit32                                   i;
5249   agsaRoot_t                              *agRoot;
5250
5251   TI_DBG3(("tdsaSASRoutingEntryAdd: start\n"));
5252   TI_DBG3(("tdsaSASRoutingEntryAdd: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
5253   TI_DBG3(("tdsaSASRoutingEntryAdd: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
5254   TI_DBG3(("tdsaSASRoutingEntryAdd: phyid %d\n", phyId));
5255
5256   /* needs to compare the location of oneExpander and configSASAddress
5257      add only if
5258      oneExpander
5259           |
5260      configSASaddress
5261
5262   */
5263   if (oneExpander->tdDevice->SASAddressID.sasAddressHi == configSASAddressHi &&
5264       oneExpander->tdDevice->SASAddressID.sasAddressLo == configSASAddressLo
5265      )
5266   {
5267     TI_DBG3(("tdsaSASRoutingEntryAdd: unnecessary\n"));
5268     return ret;
5269   }
5270   if (oneExpander->routingAttribute[phyId] != SAS_ROUTING_TABLE)
5271   {
5272     TI_DBG3(("tdsaSASRoutingEntryAdd: not table routing, routing is %d\n", oneExpander->routingAttribute[phyId]));
5273     return ret;
5274   }
5275
5276   agRoot = oneExpander->tdDevice->agRoot;
5277   onePortContext = oneExpander->tdDevice->tdPortContext;
5278
5279   onePortContext->discovery.status = DISCOVERY_CONFIG_ROUTING;
5280
5281   /* reset smpReqConfigureRouteInformation_t */
5282   osti_memset(&confRoutingInfo, 0, sizeof(smpReqConfigureRouteInformation_t));
5283   if ( oneExpander->currentIndex[phyId] < oneExpander->routingIndex )
5284   {
5285     TI_DBG3(("tdsaSASRoutingEntryAdd: adding sasAddressHi 0x%08x\n", configSASAddressHi));
5286     TI_DBG3(("tdsaSASRoutingEntryAdd: adding sasAddressLo 0x%08x\n", configSASAddressLo));
5287     TI_DBG3(("tdsaSASRoutingEntryAdd: phyid %d currentIndex[phyid] %d\n", phyId, oneExpander->currentIndex[phyId]));
5288
5289     oneExpander->configSASAddressHi = configSASAddressHi;
5290     oneExpander->configSASAddressLo = configSASAddressLo;
5291     confRoutingInfo.reserved1[0] = 0;
5292     confRoutingInfo.reserved1[1] = 0;
5293     OSSA_WRITE_BE_16(agRoot, confRoutingInfo.expanderRouteIndex, 0, (oneExpander->currentIndex[phyId]));
5294     confRoutingInfo.reserved2 = 0;
5295     confRoutingInfo.phyIdentifier = (bit8)phyId;
5296     confRoutingInfo.reserved3[0] = 0;
5297     confRoutingInfo.reserved3[1] = 0;
5298     confRoutingInfo.disabledBit_reserved4 = 0;
5299     confRoutingInfo.reserved5[0] = 0;
5300     confRoutingInfo.reserved5[1] = 0;
5301     confRoutingInfo.reserved5[2] = 0;
5302     OSSA_WRITE_BE_32(agRoot, confRoutingInfo.routedSasAddressHi, 0, configSASAddressHi);
5303     OSSA_WRITE_BE_32(agRoot, confRoutingInfo.routedSasAddressLo, 0, configSASAddressLo);
5304     for ( i = 0; i < 16; i ++ )
5305     {
5306       confRoutingInfo.reserved6[i] = 0;
5307     }
5308     tdSMPStart(tiRoot, agRoot, oneExpander->tdDevice, SMP_CONFIGURE_ROUTING_INFORMATION, (bit8 *)&confRoutingInfo, sizeof(smpReqConfigureRouteInformation_t), AGSA_SMP_INIT_REQ, agNULL, 0);
5309
5310     oneExpander->currentIndex[phyId] ++;
5311   }
5312   else
5313   {
5314     TI_DBG1(("tdsaSASRoutingEntryAdd: Discovery Error routing index overflow for currentIndex=%d, routingIndex=%d\n", oneExpander->currentIndex[phyId], oneExpander->routingIndex));
5315     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
5316
5317     ret = agFALSE;
5318   }
5319
5320
5321   return ret;
5322 }
5323 /*****************************************************************************
5324 *! \brief  tdsaConfigRoutingInfoRespRcvd
5325 *
5326 *  Purpose:  This function processes Configure Routing Information response.
5327 *
5328 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5329 *                   instance.
5330 *  \param   agRoot: Pointer to chip/driver Instance.
5331 *  \param   oneDeviceData: Pointer to the device data.
5332 *  \param   frameHeader: Pointer to SMP frame header.
5333 *  \param   frameHandle: A Handle used to refer to the response frame
5334 *
5335 *  \return:
5336 *           None
5337 *
5338 *   \note:
5339 *
5340 *****************************************************************************/
5341 /* needs to traverse only upstream not downstream */
5342 osGLOBAL void
5343 tdsaConfigRoutingInfoRespRcvd(
5344                               tiRoot_t              *tiRoot,
5345                               agsaRoot_t            *agRoot,
5346                               agsaIORequest_t       *agIORequest,
5347                               tdsaDeviceData_t      *oneDeviceData,
5348                               tdssSMPFrameHeader_t  *frameHeader,
5349                               agsaFrameHandle_t     frameHandle
5350                               )
5351 {
5352   tdsaExpander_t                          *oneExpander = oneDeviceData->tdExpander;
5353   tdsaExpander_t                          *UpStreamExpander;
5354   tdsaExpander_t                          *DownStreamExpander;
5355   tdsaExpander_t                          *ReturningExpander;
5356   tdsaExpander_t                          *ConfigurableExpander;
5357
5358   tdsaPortContext_t                       *onePortContext;
5359   tdsaDeviceData_t                        *ReturningExpanderDeviceData;
5360   bit32                                   dupConfigSASAddr = agFALSE;
5361
5362   TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: start\n"));
5363   TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
5364   TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
5365
5366   onePortContext = oneDeviceData->tdPortContext;
5367
5368   if (onePortContext->valid == agFALSE)
5369   {
5370     TI_DBG1(("tdsaConfigRoutingInfoRespRcvd: aborting discovery\n"));
5371     tdsaSASDiscoverAbort(tiRoot, onePortContext);
5372     return;
5373   }
5374
5375   if ( frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED ||
5376        frameHeader->smpFunctionResult == PHY_VACANT
5377      )
5378   {
5379     DownStreamExpander = oneExpander->tdCurrentDownStreamExpander;
5380     if (DownStreamExpander != agNULL)
5381     {
5382       DownStreamExpander->currentUpStreamPhyIndex ++;
5383       TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander->currentUpStreamPhyIndex %d\n", DownStreamExpander->currentUpStreamPhyIndex));
5384       TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander->numOfUpStreamPhys %d\n", DownStreamExpander->numOfUpStreamPhys));
5385       TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander addrHi 0x%08x\n", DownStreamExpander->tdDevice->SASAddressID.sasAddressHi));
5386       TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander addrLo 0x%08x\n", DownStreamExpander->tdDevice->SASAddressID.sasAddressLo));
5387
5388     }
5389
5390     oneExpander->currentDownStreamPhyIndex++;
5391     TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: oneExpander->currentDownStreamPhyIndex %d oneExpander->numOfDownStreamPhys %d\n", oneExpander->currentDownStreamPhyIndex, oneExpander->numOfDownStreamPhys));
5392
5393     if ( DownStreamExpander != agNULL)
5394     {
5395       if (DownStreamExpander->currentUpStreamPhyIndex < DownStreamExpander->numOfUpStreamPhys)
5396       {
5397         TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: first if\n"));
5398         TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander->currentUpStreamPhyIndex %d\n", DownStreamExpander->currentUpStreamPhyIndex));
5399
5400         TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: DownStreamExpander->upStreamPhys[] %d\n", DownStreamExpander->upStreamPhys[DownStreamExpander->currentUpStreamPhyIndex]));
5401
5402         tdsaSASRoutingEntryAdd(tiRoot,
5403                                oneExpander,
5404                                DownStreamExpander->upStreamPhys[DownStreamExpander->currentUpStreamPhyIndex],
5405                                oneExpander->configSASAddressHi,
5406                                oneExpander->configSASAddressLo
5407                                );
5408       }
5409       else
5410       {
5411         /* traversing up till discovery Root onePortContext->discovery.RootExp */
5412         TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: else\n"));
5413
5414         UpStreamExpander = oneExpander->tdUpStreamExpander;
5415         ConfigurableExpander = tdsaFindConfigurableExp(tiRoot, onePortContext, oneExpander);
5416         if (UpStreamExpander != agNULL)
5417         {
5418           TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: UpStreamExpander addrHi 0x%08x\n", UpStreamExpander->tdDevice->SASAddressID.sasAddressHi));
5419           TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: UpStreamExpander addrLo 0x%08x\n", UpStreamExpander->tdDevice->SASAddressID.sasAddressLo));
5420           dupConfigSASAddr = tdsaDuplicateConfigSASAddr(tiRoot,
5421                                                       ConfigurableExpander,
5422                                                       oneExpander->configSASAddressHi,
5423                                                       oneExpander->configSASAddressLo
5424                                                       );
5425
5426           if ( ConfigurableExpander != agNULL && dupConfigSASAddr == agFALSE)
5427           {
5428             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: else if\n"));
5429
5430             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ConfigurableExpander addrHi 0x%08x\n", ConfigurableExpander->tdDevice->SASAddressID.sasAddressHi));
5431             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ConfigurableExpander addrLo 0x%08x\n", ConfigurableExpander->tdDevice->SASAddressID.sasAddressLo));
5432
5433             UpStreamExpander->tdCurrentDownStreamExpander = oneExpander;
5434             ConfigurableExpander->currentDownStreamPhyIndex =
5435                     tdsaFindCurrentDownStreamPhyIndex(tiRoot, ConfigurableExpander);
5436             ConfigurableExpander->tdReturnginExpander = oneExpander->tdReturnginExpander;
5437             DownStreamExpander->currentUpStreamPhyIndex = 0;
5438             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ConfigurableExpander->currentDownStreamPhyIndex %d\n", ConfigurableExpander->currentDownStreamPhyIndex));
5439
5440             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ConfigurableExpander->downStreamPhys[] %d\n", ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex]));
5441             tdsaSASRoutingEntryAdd(tiRoot,
5442                                    ConfigurableExpander,
5443                                    ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
5444                                    oneExpander->configSASAddressHi,
5445                                    oneExpander->configSASAddressLo
5446                                    );
5447           }
5448           else
5449           {
5450             /* going back to where it was */
5451             /* ConfigRoutingInfo is done for a target */
5452             TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: $$$$$$ my change $$$$$ \n"));
5453             ReturningExpander = oneExpander->tdReturnginExpander;
5454             DownStreamExpander->currentUpStreamPhyIndex = 0;
5455             /* debugging */
5456             if (ReturningExpander != agNULL)
5457             {
5458               TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ReturningExpander addrHi 0x%08x\n", ReturningExpander->tdDevice->SASAddressID.sasAddressHi));
5459               TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ReturningExpander addrLo 0x%08x\n", ReturningExpander->tdDevice->SASAddressID.sasAddressLo));
5460
5461               ReturningExpanderDeviceData = ReturningExpander->tdDevice;
5462
5463               /* No longer in DISCOVERY_CONFIG_ROUTING */
5464               onePortContext->discovery.status = DISCOVERY_DOWN_STREAM;
5465
5466               /* If not the last phy */
5467               if ( ReturningExpander->discoveringPhyId < ReturningExpanderDeviceData->numOfPhys )
5468               {
5469                 TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: More Phys to discover\n"));
5470                 /* continue discovery for the next phy */
5471                 /* needs to send only one Discovery not multiple times */
5472                 if (ReturningExpander->discoverSMPAllowed == agTRUE)
5473                 {
5474                   tdsaDiscoverSend(tiRoot, ReturningExpanderDeviceData);
5475                 }
5476                 ReturningExpander->discoverSMPAllowed = agFALSE;
5477               }
5478               /* If the last phy */
5479               else
5480               {
5481                 TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: No More Phys\n"));
5482                 ReturningExpander->discoverSMPAllowed = agTRUE;
5483
5484                 /* remove the expander from the discovering list */
5485                 tdssSASDiscoveringExpanderRemove(tiRoot, onePortContext, ReturningExpander);
5486                 /* continue downstream discovering */
5487                 tdsaSASDownStreamDiscovering(tiRoot, onePortContext, ReturningExpanderDeviceData);
5488
5489                 //DownStreamExpander
5490               }
5491             }
5492             else
5493             {
5494               TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: ReturningExpander is NULL\n"));
5495             }
5496           }
5497         }
5498         else
5499         {
5500           TI_DBG3(("tdsaConfigRoutingInfoRespRcvd: UpStreamExpander is NULL\n"));
5501         }
5502       }
5503     }
5504   }
5505   else
5506   {
5507     TI_DBG1(("tdsaConfigRoutingInfoRespRcvd: Discovery Error SMP function return result error=%x\n", frameHeader->smpFunctionResult));
5508     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
5509   }
5510   return;
5511 }
5512
5513 /*****************************************************************************
5514 *! \brief  tdsaReportPhySataSend
5515 *
5516 *  Purpose:  This function sends Report Phy SATA to a device.
5517 *
5518 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5519 *                   instance.
5520 *  \param   oneDeviceData: Pointer to the device data.
5521 *  \param   phyId: Phy Identifier.
5522 *
5523 *  \return:
5524 *           None
5525 *
5526 *   \note:
5527 *
5528 *****************************************************************************/
5529 osGLOBAL void
5530 tdsaReportPhySataSend(
5531                       tiRoot_t             *tiRoot,
5532                       tdsaDeviceData_t     *oneDeviceData,
5533                       bit8                 phyId
5534                       )
5535 {
5536   agsaRoot_t            *agRoot;
5537   tdsaExpander_t        *oneExpander;
5538   tdsaPortContext_t     *onePortContext;
5539   smpReqReportPhySata_t smpReportPhySataReq;
5540
5541   TI_DBG3(("tdsaReportPhySataSend: start\n"));
5542
5543   agRoot = oneDeviceData->agRoot;
5544   onePortContext = oneDeviceData->tdPortContext;
5545   oneExpander = oneDeviceData->tdExpander;
5546
5547   if (onePortContext == agNULL)
5548   {
5549     TI_DBG1(("tdsaReportPhySataSend: Error!!! portcontext is NULL\n"));
5550   }
5551
5552   if (oneExpander == agNULL)
5553   {
5554     TI_DBG1(("tdsaReportPhySataSend: Error!!! expander is NULL\n"));
5555     return;
5556   }
5557   TI_DBG3(("tdsaReportPhySataSend: device %p did %d\n", oneDeviceData, oneDeviceData->id));
5558   TI_DBG3(("tdsaReportPhySataSend: phyid %d\n", phyId));
5559
5560   oneExpander->tdDeviceToProcess = oneDeviceData;
5561
5562   osti_memset(&smpReportPhySataReq, 0, sizeof(smpReqReportPhySata_t));
5563
5564   smpReportPhySataReq.phyIdentifier = phyId;
5565
5566
5567   tdSMPStart(
5568              tiRoot,
5569              agRoot,
5570              oneExpander->tdDevice,
5571              SMP_REPORT_PHY_SATA,
5572              (bit8 *)&smpReportPhySataReq,
5573              sizeof(smpReqReportPhySata_t),
5574              AGSA_SMP_INIT_REQ,
5575              agNULL,
5576              0
5577              );
5578
5579   return;
5580 }
5581
5582 /*****************************************************************************
5583 *! \brief  tdsaReportPhySataRcvd
5584 *
5585 *  Purpose:  This function processes Report Phy SATA response.
5586 *
5587 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5588 *                   instance.
5589 *  \param   agRoot: Pointer to chip/driver Instance.
5590 *  \param   oneDeviceData: Pointer to the device data.
5591 *  \param   frameHeader: Pointer to SMP frame header.
5592 *  \param   frameHandle: A Handle used to refer to the response frame
5593 *
5594 *  \return:
5595 *           None
5596 *
5597 *   \note:
5598 *
5599 *****************************************************************************/
5600 osGLOBAL void
5601 tdsaReportPhySataRcvd(
5602                       tiRoot_t              *tiRoot,
5603                       agsaRoot_t            *agRoot,
5604                       agsaIORequest_t       *agIORequest,
5605                       tdsaDeviceData_t      *oneDeviceData,
5606                       tdssSMPFrameHeader_t  *frameHeader,
5607                       agsaFrameHandle_t     frameHandle
5608                       )
5609 {
5610   smpRespReportPhySata_t      SMPreportPhySataResp;
5611   smpRespReportPhySata_t      *pSMPReportPhySataResp;
5612   tdsaExpander_t              *oneExpander = oneDeviceData->tdExpander;
5613   tdsaPortContext_t           *onePortContext;
5614   agsaFisRegDeviceToHost_t    *fis;
5615   tdsaDeviceData_t            *SataDevice;
5616 #ifndef DIRECT_SMP
5617   tdssSMPRequestBody_t        *tdSMPRequestBody;
5618 #endif
5619
5620   TI_DBG3(("tdsaReportPhySataRcvd: start\n"));
5621   TI_DBG3(("tdsaReportPhySataRcvd: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
5622   TI_DBG3(("tdsaReportPhySataRcvd: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
5623 #ifndef DIRECT_SMP
5624   tdSMPRequestBody = (tdssSMPRequestBody_t *)agIORequest->osData;
5625 #endif
5626   /* get the current sata device hanlde stored in the expander structure */
5627   SataDevice = oneExpander->tdDeviceToProcess;
5628   pSMPReportPhySataResp = &SMPreportPhySataResp;
5629 #ifdef DIRECT_SMP
5630   saFrameReadBlock(agRoot, frameHandle, 4, pSMPReportPhySataResp, sizeof(smpRespReportPhySata_t));
5631 #else
5632   saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 4, pSMPReportPhySataResp, sizeof(smpRespReportPhySata_t));
5633 #endif
5634
5635   //tdhexdump("tdsaReportPhySataRcvd", (bit8 *)pSMPReportPhySataResp, sizeof(smpRespReportPhySata_t));
5636
5637 #ifndef DIRECT_SMP
5638   ostiFreeMemory(
5639                  tiRoot,
5640                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
5641                  tdSMPRequestBody->IndirectSMPReqLen
5642                 );
5643   ostiFreeMemory(
5644                  tiRoot,
5645                  tdSMPRequestBody->IndirectSMPResposMemHandle,
5646                  tdSMPRequestBody->IndirectSMPRespLen
5647                 );
5648 #endif
5649
5650   onePortContext = oneDeviceData->tdPortContext;
5651
5652   if (onePortContext->valid == agFALSE)
5653   {
5654     TI_DBG1(("tdsaReportPhySataRcvd: aborting discovery\n"));
5655     tdsaSASDiscoverAbort(tiRoot, onePortContext);
5656     return;
5657   }
5658   if (SataDevice == agNULL)
5659   {
5660     TI_DBG1(("tdsaReportPhySataRcvd: SataDevice is NULL, wrong\n"));
5661     tdsaSASDiscoverAbort(tiRoot, onePortContext);
5662     return;
5663   }
5664   if ( frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED ||
5665        frameHeader->smpFunctionResult == PHY_VACANT
5666      )
5667   {
5668     fis = (agsaFisRegDeviceToHost_t*) &SMPreportPhySataResp.regDevToHostFis;
5669     if (fis->h.fisType == REG_DEV_TO_HOST_FIS)
5670     {
5671       /* save signature */
5672       TI_DBG3(("tdsaReportPhySataRcvd: saves the signature\n"));
5673       /* saves signature */
5674       SataDevice->satDevData.satSignature[0] = fis->d.sectorCount;
5675       SataDevice->satDevData.satSignature[1] = fis->d.lbaLow;
5676       SataDevice->satDevData.satSignature[2] = fis->d.lbaMid;
5677       SataDevice->satDevData.satSignature[3] = fis->d.lbaHigh;
5678       SataDevice->satDevData.satSignature[4] = fis->d.device;
5679       SataDevice->satDevData.satSignature[5] = 0;
5680       SataDevice->satDevData.satSignature[6] = 0;
5681       SataDevice->satDevData.satSignature[7] = 0;
5682
5683       TI_DBG3(("tdsaReportPhySataRcvd: SATA Signature = %02x %02x %02x %02x %02x\n",
5684         SataDevice->satDevData.satSignature[0],
5685         SataDevice->satDevData.satSignature[1],
5686         SataDevice->satDevData.satSignature[2],
5687         SataDevice->satDevData.satSignature[3],
5688         SataDevice->satDevData.satSignature[4]));
5689       /*
5690         no longer, discovery sends sata identify device command
5691         tdsaSATAIdentifyDeviceCmdSend(tiRoot, SataDevice);
5692       */
5693       SataDevice = tdsaFindRightDevice(tiRoot, onePortContext, SataDevice);
5694       tdsaDiscoveringStpSATADevice(tiRoot, onePortContext, SataDevice);
5695     }
5696     else
5697     {
5698       TI_DBG3(("tdsaReportPhySataRcvd: getting next stp bride\n"));
5699       SataDevice = tdsaFindRightDevice(tiRoot, onePortContext, SataDevice);
5700       tdsaDiscoveringStpSATADevice(tiRoot, onePortContext, SataDevice);
5701     }
5702   }
5703   else
5704   {
5705     TI_DBG3(("tdsaReportPhySataRcvd: siReportPhySataRcvd SMP function return result %x\n",
5706              frameHeader->smpFunctionResult));
5707     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
5708   }
5709   return;
5710 }
5711
5712 /*****************************************************************************
5713 *! \brief  tdsaSASExpanderUpStreamPhyAdd
5714 *
5715 *  Purpose:  This function adds upstream expander to a specfic phy.
5716 *
5717 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5718 *                   instance.
5719 *  \param   oneExpander: Pointer to the expander data.
5720 *  \param   phyId: Phy Identifier.
5721 *
5722 *  \return:
5723 *           None
5724 *
5725 *   \note:
5726 *
5727 *****************************************************************************/
5728 osGLOBAL void
5729 tdsaSASExpanderUpStreamPhyAdd(
5730                               tiRoot_t          *tiRoot,
5731                               tdsaExpander_t    *oneExpander,
5732                               bit8              phyId
5733                               )
5734 {
5735   bit32   i;
5736   bit32   hasSet = agFALSE;
5737
5738   TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: start, phyid %d\n", phyId));
5739   TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
5740   TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
5741   TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: phyid %d  numOfUpStreamPhys %d\n", phyId, oneExpander->numOfUpStreamPhys));
5742
5743   for ( i = 0; i < oneExpander->numOfUpStreamPhys; i ++ )
5744   {
5745     if ( oneExpander->upStreamPhys[i] == phyId )
5746     {
5747       hasSet = agTRUE;
5748       break;
5749     }
5750   }
5751
5752   if ( hasSet == agFALSE )
5753   {
5754     oneExpander->upStreamPhys[oneExpander->numOfUpStreamPhys ++] = phyId;
5755   }
5756
5757   TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: AFTER phyid %d  numOfUpStreamPhys %d\n", phyId, oneExpander->numOfUpStreamPhys));
5758
5759   /* for debugging */
5760   for ( i = 0; i < oneExpander->numOfUpStreamPhys; i ++ )
5761   {
5762     TI_DBG3(("tdsaSASExpanderUpStreamPhyAdd: index %d upstream[index] %d\n", i, oneExpander->upStreamPhys[i]));
5763   }
5764   return;
5765 }
5766
5767 /*
5768   just add phys in downstream in configurable expnader
5769 */
5770 /*****************************************************************************
5771 *! \brief  tdsaSASExpanderDownStreamPhyAdd
5772 *
5773 *  Purpose:  This function adds downstream expander to a specfic phy.
5774 *
5775 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5776 *                   instance.
5777 *  \param   oneExpander: Pointer to the expander data.
5778 *  \param   phyId: Phy Identifier.
5779 *
5780 *  \return:
5781 *           None
5782 *
5783 *   \note:
5784 *
5785 *****************************************************************************/
5786 osGLOBAL void
5787 tdsaSASExpanderDownStreamPhyAdd(
5788                               tiRoot_t          *tiRoot,
5789                               tdsaExpander_t    *oneExpander,
5790                               bit8              phyId
5791                               )
5792 {
5793   bit32   i;
5794   bit32   hasSet = agFALSE;
5795
5796   TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: start, phyid %d\n", phyId));
5797   TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
5798   TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
5799   TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: phyid %d  numOfDownStreamPhys %d\n", phyId, oneExpander->numOfDownStreamPhys));
5800
5801   for ( i = 0; i < oneExpander->numOfDownStreamPhys; i ++ )
5802   {
5803     if ( oneExpander->downStreamPhys[i] == phyId )
5804     {
5805       hasSet = agTRUE;
5806       break;
5807     }
5808   }
5809
5810   if ( hasSet == agFALSE )
5811   {
5812     oneExpander->downStreamPhys[oneExpander->numOfDownStreamPhys ++] = phyId;
5813   }
5814
5815   TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: AFTER phyid %d  numOfDownStreamPhys %d\n", phyId, oneExpander->numOfDownStreamPhys));
5816
5817   /* for debugging */
5818   for ( i = 0; i < oneExpander->numOfDownStreamPhys; i ++ )
5819   {
5820      TI_DBG3(("tdsaSASExpanderDownStreamPhyAdd: index %d downstream[index] %d\n", i, oneExpander->downStreamPhys[i]));
5821   }
5822   return;
5823 }
5824
5825 /* oneExpander is the configurable expander of interest
5826    phyId is the first phyID in upStreamPhys[0] of downExpander
5827 */
5828 /*****************************************************************************
5829 *! \brief  tdsaFindCurrentDownStreamPhyIndex
5830 *
5831 *  Purpose:  This function finds CurrentDownStreamPhyIndex from a configurable
5832 *            expander.
5833 *
5834 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5835 *                   instance.
5836 *  \param   oneExpander: Pointer to the configuralbe expander data.
5837 *
5838 *  \return:
5839 *           CurrentDownStreamPhyIndex
5840 *
5841 *
5842 *****************************************************************************/
5843 osGLOBAL bit16
5844 tdsaFindCurrentDownStreamPhyIndex(
5845                               tiRoot_t          *tiRoot,
5846                               tdsaExpander_t    *oneExpander
5847                               )
5848 {
5849   tdsaExpander_t    *DownStreamExpander;
5850   bit16              index = 0;
5851   bit16              i;
5852   bit8               phyId = 0;
5853
5854   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: start\n"));
5855
5856   if (oneExpander == agNULL)
5857   {
5858     TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: wrong!!! oneExpander is NULL\n"));
5859     return 0;
5860   }
5861
5862   DownStreamExpander = oneExpander->tdCurrentDownStreamExpander;
5863
5864   if (DownStreamExpander == agNULL)
5865   {
5866     TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: wrong!!! DownStreamExpander is NULL\n"));
5867     return 0;
5868   }
5869
5870   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
5871   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
5872   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: downstream exp addrHi 0x%08x\n", DownStreamExpander->tdDevice->SASAddressID.sasAddressHi));
5873   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: downstream exp addrLo 0x%08x\n", DownStreamExpander->tdDevice->SASAddressID.sasAddressLo));
5874   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: numOfDownStreamPhys %d\n", oneExpander->numOfDownStreamPhys));
5875
5876   phyId = DownStreamExpander->upStreamPhys[0];
5877
5878   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: phyId %d\n", phyId));
5879
5880   for (i=0; i<oneExpander->numOfDownStreamPhys;i++)
5881   {
5882     if (oneExpander->downStreamPhys[i] == phyId)
5883     {
5884       index = i;
5885       break;
5886     }
5887   }
5888   TI_DBG3(("tdsaFindCurrentDownStreamPhyIndex: index %d\n", index));
5889   return index;
5890 }
5891 /*****************************************************************************
5892 *! \brief  tdsaPortSASDeviceFind
5893 *
5894 *  Purpose:  Given SAS address, this function finds a device with that SAS address
5895 *            in the device list.
5896 *
5897 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5898 *                   instance.
5899 *  \param   onePortContext: Pointer to the portal context instance.
5900 *  \param   sasAddrLo: Lower 4 byte of SAS address.
5901 *  \param   sasAddrHi: Upper 4 byte of SAS address.
5902 *
5903 *  \return:
5904 *           agNULL  When no device found
5905 *           Pointer to device   When device is found
5906 *
5907 *   \note:
5908 *
5909 *****************************************************************************/
5910 osGLOBAL tdsaDeviceData_t *
5911 tdsaPortSASDeviceFind(
5912                       tiRoot_t           *tiRoot,
5913                       tdsaPortContext_t  *onePortContext,
5914                       bit32              sasAddrLo,
5915                       bit32              sasAddrHi
5916                       )
5917 {
5918   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
5919   tdsaContext_t     *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5920   tdsaDeviceData_t  *oneDeviceData, *RetDeviceData=agNULL;
5921   tdList_t          *DeviceListList;
5922
5923   TI_DBG3(("tdsaPortSASDeviceFind: start\n"));
5924
5925   TD_ASSERT((agNULL != tiRoot), "");
5926   TD_ASSERT((agNULL != onePortContext), "");
5927
5928   tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
5929
5930   /* find a device's existence */
5931   DeviceListList = tdsaAllShared->MainDeviceList.flink;
5932   if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
5933   {
5934     TI_DBG3(("tdsaPortSASDeviceFind: Full discovery\n"));
5935     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
5936     {
5937       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
5938       if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) &&
5939           (oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) &&
5940           (oneDeviceData->valid == agTRUE) &&
5941           (oneDeviceData->tdPortContext == onePortContext)
5942         )
5943       {
5944         TI_DBG3(("tdsaPortSASDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
5945         TI_DBG3(("tdsaPortSASDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
5946         TI_DBG3(("tdsaPortSASDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
5947         RetDeviceData = oneDeviceData;
5948         break;
5949       }
5950       DeviceListList = DeviceListList->flink;
5951     }
5952   }
5953   else
5954   {
5955     /* incremental discovery */
5956     TI_DBG3(("tdsaPortSASDeviceFind: Incremental discovery\n"));
5957     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
5958     {
5959       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
5960       if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) &&
5961           (oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) &&
5962           (oneDeviceData->valid2 == agTRUE) &&
5963           (oneDeviceData->tdPortContext == onePortContext)
5964           )
5965       {
5966         TI_DBG3(("tdsaPortSASDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
5967         TI_DBG3(("tdsaPortSASDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
5968         TI_DBG3(("tdsaPortSASDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
5969
5970         RetDeviceData = oneDeviceData;
5971         break;
5972       }
5973       DeviceListList = DeviceListList->flink;
5974     }
5975   }
5976
5977   tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
5978
5979   return RetDeviceData;
5980 }
5981
5982 /* include both sas and stp-sata targets*/
5983 /*****************************************************************************
5984 *! \brief  tdsaPortSASDeviceAdd
5985 *
5986 *  Purpose:  This function adds the SAS device to the device list.
5987 *
5988 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
5989 *                   instance.
5990 *  \param   onePortContext: Pointer to the portal context instance.
5991 *  \param   sasIdentify: SAS identify address frame.
5992 *  \param   sasInitiator: SAS initiator.
5993 *  \param   connectionRate: Connection Rate.
5994 *  \param   itNexusTimeout: IT NEXUS timeout value.
5995 *  \param   firstBurstSize: First Burst Size.
5996 *  \param   deviceType: Device Type.
5997 *
5998 *  \return:
5999 *           Pointer to device data.
6000 *
6001 *   \note:
6002 *
6003 *****************************************************************************/
6004 GLOBAL tdsaDeviceData_t *
6005 tdsaPortSASDeviceAdd(
6006                      tiRoot_t            *tiRoot,
6007                      tdsaPortContext_t   *onePortContext,
6008                      agsaSASIdentify_t   sasIdentify,
6009                      bit32               sasInitiator,
6010                      bit8                connectionRate,
6011                      bit32               itNexusTimeout,
6012                      bit32               firstBurstSize,
6013                      bit32               deviceType,
6014                      tdsaDeviceData_t    *oneExpDeviceData,
6015                      bit8                phyID
6016                      )
6017 {
6018   tdsaDeviceData_t  *oneDeviceData = agNULL;
6019   bit8              dev_s_rate = 0;
6020   bit8              sasorsata = 1;
6021 //  bit8              devicetype;
6022   tdsaSASSubID_t    agSASSubID;
6023   tdsaDeviceData_t  *oneAttachedExpDeviceData = agNULL;
6024
6025   TI_DBG3(("tdsaPortSASDeviceAdd: start\n"));
6026   TI_DBG3(("tdsaPortSASDeviceAdd: connectionRate %d\n", connectionRate));
6027
6028   agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
6029   agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
6030   agSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
6031   agSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
6032
6033   /* old device and already registered to LL; added by link-up event */
6034   if ( agFALSE == tdssNewSASorNot(
6035                                    onePortContext->agRoot,
6036                                    onePortContext,
6037                                    &agSASSubID
6038                                    )
6039        )
6040   {
6041     /* old device and already registered to LL; added by link-up event */
6042     TI_DBG3(("tdsaPortSASDeviceAdd: OLD qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", agSASSubID.initiator_ssp_stp_smp, agSASSubID.target_ssp_stp_smp));
6043     /* find the old device */
6044     oneDeviceData = tdssNewAddSASToSharedcontext(
6045                                                  onePortContext->agRoot,
6046                                                  onePortContext,
6047                                                  &agSASSubID,
6048                                                  oneExpDeviceData,
6049                                                  phyID
6050                                                  );
6051
6052     if (oneDeviceData == agNULL)
6053     {
6054       TI_DBG1(("tdsaPortSASDeviceAdd: no more device!!! oneDeviceData is null\n"));
6055     }
6056
6057     /* If a device is allocated */
6058     if ( oneDeviceData != agNULL )
6059     {
6060
6061       TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify)));
6062       TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify)));
6063
6064       oneDeviceData->sasIdentify = sasIdentify;
6065
6066       TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
6067       TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
6068
6069       /* parse sasIDframe to fill in agDeviceInfo */
6070       DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
6071       DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)itNexusTimeout);
6072       DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, (bit16)firstBurstSize);
6073       DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
6074
6075       oneDeviceData->SASSpecDeviceType = (bit8)(SA_IDFRM_GET_DEVICETTYPE(&sasIdentify));
6076
6077       /* adjusting connectionRate */
6078       oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
6079       if (oneAttachedExpDeviceData != agNULL)
6080       {
6081         connectionRate = (bit8)(MIN(connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6082         TI_DBG3(("tdsaPortSASDeviceAdd: 1st connectionRate 0x%x  DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo) 0x%x\n",
6083                  connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6084       }
6085       else
6086       {
6087        TI_DBG3(("tdsaPortSASDeviceAdd: 1st oneAttachedExpDeviceData is NULL\n"));
6088       }
6089
6090       /* Device Type, SAS or SATA, connection rate; bit7 --- bit0 */
6091       sasorsata = (bit8)deviceType;
6092       /* sTSDK spec device typ */
6093       dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4));
6094       dev_s_rate = (bit8)(dev_s_rate | connectionRate);
6095       DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
6096
6097
6098       DEVINFO_PUT_SAS_ADDRESSLO(
6099                                 &oneDeviceData->agDeviceInfo,
6100                                 SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)
6101                                 );
6102       DEVINFO_PUT_SAS_ADDRESSHI(
6103                                 &oneDeviceData->agDeviceInfo,
6104                                 SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)
6105                                 );
6106       oneDeviceData->agContext.osData = oneDeviceData;
6107       oneDeviceData->agContext.sdkData = agNULL;
6108
6109     }
6110     return oneDeviceData;
6111   } /* old device */
6112
6113   /* new device */
6114
6115   TI_DBG3(("tdsaPortSASDeviceAdd: NEW qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", agSASSubID.initiator_ssp_stp_smp, agSASSubID.target_ssp_stp_smp));
6116
6117   /* allocate a new device and set the valid bit */
6118   oneDeviceData = tdssNewAddSASToSharedcontext(
6119                                                onePortContext->agRoot,
6120                                                onePortContext,
6121                                                &agSASSubID,
6122                                                oneExpDeviceData,
6123                                                phyID
6124                                                );
6125
6126   if (oneDeviceData == agNULL)
6127   {
6128     TI_DBG1(("tdsaPortSASDeviceAdd: no more device!!! oneDeviceData is null\n"));
6129   }
6130
6131    /* If a device is allocated */
6132   if ( oneDeviceData != agNULL )
6133   {
6134
6135     TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify)));
6136     TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify)));
6137
6138     oneDeviceData->sasIdentify = sasIdentify;
6139
6140     TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
6141     TI_DBG3(("tdsaPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
6142
6143
6144     /* parse sasIDframe to fill in agDeviceInfo */
6145     DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
6146     DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)itNexusTimeout);
6147     DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, (bit16)firstBurstSize);
6148     DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
6149
6150     oneDeviceData->SASSpecDeviceType = (bit8)(SA_IDFRM_GET_DEVICETTYPE(&sasIdentify));
6151
6152     /* adjusting connectionRate */
6153     oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
6154     if (oneAttachedExpDeviceData != agNULL)
6155     {
6156       connectionRate = (bit8)(MIN(connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6157       TI_DBG3(("tdsaPortSASDeviceAdd: 2nd connectionRate 0x%x  DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo) 0x%x\n",
6158                 connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6159     }
6160     else
6161     {
6162      TI_DBG3(("tdsaPortSASDeviceAdd: 2nd oneAttachedExpDeviceData is NULL\n"));
6163     }
6164
6165     /* Device Type, SAS or SATA, connection rate; bit7 --- bit0 */
6166     sasorsata = (bit8)deviceType;
6167     dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4));
6168     dev_s_rate = (bit8)(dev_s_rate | connectionRate);
6169     DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
6170
6171
6172     DEVINFO_PUT_SAS_ADDRESSLO(
6173                               &oneDeviceData->agDeviceInfo,
6174                               SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)
6175                               );
6176     DEVINFO_PUT_SAS_ADDRESSHI(
6177                               &oneDeviceData->agDeviceInfo,
6178                               SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)
6179                               );
6180     oneDeviceData->agContext.osData = oneDeviceData;
6181     oneDeviceData->agContext.sdkData = agNULL;
6182
6183     TI_DBG3(("tdsaPortSASDeviceAdd: did %d\n", oneDeviceData->id));
6184
6185     /* don't add and register initiator for T2D */
6186     if ( (((sasIdentify.initiator_ssp_stp_smp & DEVICE_SSP_BIT) == DEVICE_SSP_BIT) &&
6187          ((sasIdentify.target_ssp_stp_smp & DEVICE_SSP_BIT) != DEVICE_SSP_BIT))
6188         ||
6189          (((sasIdentify.initiator_ssp_stp_smp & DEVICE_STP_BIT) == DEVICE_STP_BIT) &&
6190          ((sasIdentify.target_ssp_stp_smp & DEVICE_SSP_BIT) != DEVICE_SSP_BIT))
6191        )
6192     {
6193       TI_DBG1(("tdsaPortSASDeviceAdd: initiator. no add and registration\n"));
6194       TI_DBG1(("tdsaPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
6195       TI_DBG1(("tdsaPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
6196
6197     }
6198     else
6199     {
6200       if (oneDeviceData->registered == agFALSE)
6201       {
6202         TI_DBG2(("tdsaPortSASDeviceAdd: did %d\n", oneDeviceData->id));
6203         saRegisterNewDevice( /* tdsaPortSASDeviceAdd  */
6204                             onePortContext->agRoot,
6205                             &oneDeviceData->agContext,
6206                             tdsaRotateQnumber(tiRoot, oneDeviceData),
6207                             &oneDeviceData->agDeviceInfo,
6208                             onePortContext->agPortContext,
6209                             0
6210                             );
6211       }
6212     }
6213   }
6214
6215   return oneDeviceData;
6216 }
6217
6218 /*****************************************************************************
6219 *! \brief  tdsaDiscoveryResetProcessed
6220 *
6221 *  Purpose:  This function called to reset "processed flag" of device belong to
6222 *            a specified port.
6223 *
6224 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6225 *                   instance.
6226 *  \param   onePortContext: Pointer to the portal context instance.
6227 *
6228 *  \return:
6229 *           None
6230 *
6231 *   \note:
6232 *
6233 *****************************************************************************/
6234
6235 osGLOBAL void
6236 tdsaDiscoveryResetProcessed(
6237                     tiRoot_t             *tiRoot,
6238                     tdsaPortContext_t    *onePortContext
6239                     )
6240 {
6241   tdsaDeviceData_t  *oneDeviceData = agNULL;
6242   tdList_t          *DeviceListList;
6243   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6244   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6245
6246   TI_DBG6(("tdsaDiscoveryResetProcessed: start\n"));
6247
6248   /* reinitialize the device data belonging to this portcontext */
6249   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6250   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6251   {
6252     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6253     TI_DBG6(("tdsaDiscoveryResetProcessed: loop did %d\n", oneDeviceData->id));
6254     if (oneDeviceData->tdPortContext == onePortContext)
6255     {
6256       TI_DBG6(("tdsaDiscoveryResetProcessed: resetting procssed flag\n"));
6257       oneDeviceData->processed = agFALSE;
6258     }
6259     DeviceListList = DeviceListList->flink;
6260   }
6261
6262   return;
6263 }
6264
6265 /*****************************************************************************
6266 *! \brief  tdsaSATADiscoverDone
6267 *
6268 *  Purpose:  This function called to finish up SATA discovery.
6269 *
6270 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6271 *                   instance.
6272 *  \param   onePortContext: Pointer to the portal context instance.
6273 *  \param   flag: status of discovery (success or failure).
6274 *
6275 *  \return:
6276 *           None
6277 *
6278 *   \note:
6279 *
6280 *****************************************************************************/
6281 osGLOBAL void
6282 tdsaSATADiscoverDone(
6283                     tiRoot_t             *tiRoot,
6284                     tdsaPortContext_t    *onePortContext,
6285                     bit32                flag
6286                     )
6287 {
6288   tdsaRoot_t           *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
6289   tdsaContext_t        *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6290   TI_DBG3(("tdsaSATADiscoverDone: start\n"));
6291   tdsaDiscoveryResetProcessed(tiRoot, onePortContext);
6292
6293   if (onePortContext->discovery.SeenBC == agTRUE)
6294   {
6295     TI_DBG3(("tdsaSATADiscoverDone: broadcast change; discover again\n"));
6296     tdssInternalRemovals(onePortContext->agRoot,
6297                          onePortContext
6298                          );
6299
6300     /* processed broadcast change */
6301     onePortContext->discovery.SeenBC = agFALSE;
6302     if (tdsaAllShared->ResetInDiscovery != 0 &&
6303         onePortContext->discovery.ResetTriggerred == agTRUE)
6304     {
6305       TI_DBG1(("tdsaSATADiscoverDone: tdsaBCTimer\n"));
6306       tdsaBCTimer(tiRoot, onePortContext);
6307     }
6308     else
6309     {
6310       tdsaDiscover(
6311                    tiRoot,
6312                    onePortContext,
6313                    TDSA_DISCOVERY_TYPE_SAS,
6314                    TDSA_DISCOVERY_OPTION_INCREMENTAL_START
6315                   );
6316     }
6317   }
6318   else
6319   {
6320     onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
6321
6322     if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
6323     {
6324       if (flag == tiSuccess)
6325       {
6326 #ifdef AGTIAPI_CTL
6327         tdsaContext_t *tdsaAllShared =
6328                         &((tdsaRoot_t*)tiRoot->tdData)->tdsaAllShared;
6329
6330         if (tdsaAllShared->SASConnectTimeLimit)
6331           tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDiscovery,
6332                      tiDiscOK);
6333         else
6334 #endif
6335           ostiInitiatorEvent(
6336                              tiRoot,
6337                              onePortContext->tiPortalContext,
6338                              agNULL,
6339                              tiIntrEventTypeDiscovery,
6340                              tiDiscOK,
6341                              agNULL
6342                              );
6343       }
6344       else
6345       {
6346         TI_DBG1(("tdsaSATADiscoverDone: Error; clean up\n"));
6347         tdssDiscoveryErrorRemovals(onePortContext->agRoot,
6348                                    onePortContext
6349                                    );
6350
6351         ostiInitiatorEvent(
6352                            tiRoot,
6353                            onePortContext->tiPortalContext,
6354                            agNULL,
6355                            tiIntrEventTypeDiscovery,
6356                            tiDiscFailed,
6357                            agNULL
6358                            );
6359       }
6360     }
6361     else
6362     {
6363       if (flag == tiSuccess)
6364       {
6365         tdssReportChanges(onePortContext->agRoot,
6366                           onePortContext
6367                           );
6368       }
6369       else
6370       {
6371         tdssReportRemovals(onePortContext->agRoot,
6372                            onePortContext,
6373                            agFALSE
6374                            );
6375       }
6376     }
6377   }
6378 #ifdef TBD
6379   /* ACKing BC */
6380   tdsaAckBC(tiRoot, onePortContext);
6381 #endif
6382   return;
6383 }
6384
6385 osGLOBAL void
6386 tdsaAckBC(
6387                     tiRoot_t             *tiRoot,
6388                     tdsaPortContext_t    *onePortContext
6389                     )
6390 {
6391 #ifdef TBD /* not yet */
6392   agsaEventSource_t        eventSource[TD_MAX_NUM_PHYS];
6393   bit32                    HwAckSatus = AGSA_RC_SUCCESS;
6394   int                      i;
6395   TI_DBG3(("tdsaAckBC: start\n"));
6396
6397   for (i=0;i<TD_MAX_NUM_PHYS;i++)
6398   {
6399     if (onePortContext->BCPhyID[i] == agTRUE)
6400     {
6401       /* saHwEventAck() */
6402       eventSource[i].agPortContext = onePortContext->agPortContext;
6403       eventSource[i].event = OSSA_HW_EVENT_BROADCAST_CHANGE;
6404       /* phy ID */
6405       eventSource[i].param = i;
6406       HwAckSatus = saHwEventAck(
6407                                 onePortContext->agRoot,
6408                                 agNULL, /* agContext */
6409                                 0,
6410                                 &eventSource[i], /* agsaEventSource_t */
6411                                 0,
6412                                 0
6413                                 );
6414       TI_DBG3(("tdsaAckBC: calling saHwEventAck\n"));
6415
6416       if ( HwAckSatus != AGSA_RC_SUCCESS)
6417       {
6418         TI_DBG1(("tdsaAckBC: failing in saHwEventAck; status %d\n", HwAckSatus));
6419         return;
6420       }
6421     }
6422     onePortContext->BCPhyID[i] = agFALSE;
6423   }
6424 #endif
6425 }
6426
6427 #ifdef SATA_ENABLE
6428
6429 /*****************************************************************************
6430 *! \brief  tdsaSATAFullDiscover
6431 *
6432 *  Purpose:  This function is called to trigger full SATA topology discovery
6433 *            within a portcontext.
6434 *
6435 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6436 *                   instance.
6437 *  \param   onePortContext: Pointer to the portal context instance.
6438 *
6439 *  \return:
6440 *           tiSuccess    Discovery initiated.
6441 *           tiError      Discovery could not be initiated at this time.
6442 *
6443 *   \note:
6444 *
6445 *****************************************************************************/
6446 osGLOBAL bit32
6447 tdsaSATAFullDiscover(
6448                      tiRoot_t          *tiRoot,
6449                      tdsaPortContext_t *onePortContext
6450                      )
6451 {
6452   bit32                 ret = tiSuccess;
6453   tdsaDeviceData_t      *oneDeviceData = agNULL;
6454   bit32                 deviceType;
6455   bit8                  phyRate = SAS_CONNECTION_RATE_3_0G;
6456   bit32                 i;
6457   tdsaRoot_t            *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6458   tdsaContext_t         *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6459 //  tdsaDeviceData_t      *tdsaDeviceData  = (tdsaDeviceData_t *)tdsaAllShared->DeviceMem;
6460   tdsaDeviceData_t      *tdsaDeviceData;
6461   tdList_t              *DeviceListList;
6462
6463   TI_DBG3(("tdsaSATAFullDiscover: start\n"));
6464   if (onePortContext->valid == agFALSE)
6465   {
6466     TI_DBG1(("tdsaSATAFullDiscover: aborting discovery\n"));
6467     tdsaSASDiscoverAbort(tiRoot, onePortContext);
6468     return tiError;
6469   }
6470   phyRate = onePortContext->LinkRate;
6471   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6472   tdsaDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6473   /*  If port is SATA mode */
6474   /*
6475     Native SATA mode is decided in ossaHWCB() SAS_LINK_UP or SATA_LINK_UP
6476    */
6477   if (onePortContext->nativeSATAMode == agTRUE)
6478   {
6479     /* Decode device type */
6480     deviceType = tdssSATADeviceTypeDecode(onePortContext->remoteSignature);
6481     /* Create a device descriptor for the SATA device attached to the port */
6482     if ( deviceType == SATA_PM_DEVICE)
6483     {
6484       TI_DBG3(("tdsaSATAFullDiscover: Found a PM device\n"));
6485       oneDeviceData = tdsaPortSATADeviceAdd(
6486                                             tiRoot,
6487                                             onePortContext,
6488                                             agNULL,
6489                                             onePortContext->remoteSignature,
6490                                             agTRUE,
6491                                             0xF,
6492                                             phyRate,
6493                                             agNULL,
6494                                             0xFF
6495                                             );
6496     }
6497     else
6498     {
6499       /* already added in ossahwcb() in SATA link up */
6500       TI_DBG3(("tdsaSATAFullDiscover: Found a DIRECT SATA device\n"));
6501     }
6502
6503     /* Process for different device type */
6504     switch ( deviceType )
6505     {
6506       /* if it's PM */
6507       case SATA_PM_DEVICE:
6508       {
6509
6510         TI_DBG3(("tdsaSATAFullDiscover: Process a PM device\n"));
6511         /* For each port of the PM */
6512         for ( i = 0; i < SATA_MAX_PM_PORTS; i ++ )
6513         {
6514           /* Read the signature */
6515           /* Decode the device type */
6516           /* Create device descriptor */
6517           /* Callback with the discovered devices */
6518         }
6519         break;
6520       }
6521       /* if it's ATA device */
6522       case SATA_ATA_DEVICE:
6523       case SATA_ATAPI_DEVICE:
6524       {
6525         TI_DBG3(("tdsaSATAFullDiscover: Process an ATA device. Sending Identify Device cmd\n"));
6526
6527         /* to-check: for this direct attached one, already added and do nothing */
6528         /* no longer, discovery sends sata identify device command */
6529         //tdsaSATAIdentifyDeviceCmdSend(tiRoot, oneDeviceData);
6530         tdsaSATADiscoverDone(tiRoot, onePortContext, tiSuccess);
6531         break;
6532       }
6533       /* Other devices */
6534       default:
6535       {
6536         /* callback */
6537         TI_DBG3(("siSATAFullDiscover: Process OTHER SATA device. Just report the device\n"));
6538         break;
6539       }
6540     }
6541   }
6542   /* If port is SAS mode */
6543   else
6544   {
6545     TI_DBG3(("tdsaSATAFullDiscover: Discovering attached STP devices  starts....\n"));
6546     oneDeviceData = tdsaFindRightDevice(tiRoot, onePortContext, tdsaDeviceData);
6547     tdsaDiscoveringStpSATADevice(tiRoot, onePortContext, oneDeviceData);
6548   }
6549   return ret;
6550 }
6551
6552 /* adding only direct attached SATA such as PM
6553   Other directly attached SATA device such as disk is reported by ossahwcb() in link up
6554   used in sata native mode
6555   */
6556 /*****************************************************************************
6557 *! \brief  tdsaPortSATADeviceAdd
6558 *
6559 *  Purpose:  This function adds the SATA device to the device list.
6560 *
6561 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6562 *                   instance.
6563 *  \param   onePortContext: Pointer to the portal context instance.
6564 *  \param   oneSTPBridge: STP bridge.
6565 *  \param   Signature: SATA signature.
6566 *  \param   pm: Port Multiplier.
6567 *  \param   pmField: Port Multiplier field.
6568 *  \param   connectionRate: Connection Rate.
6569 *
6570 *  \return:
6571 *           Pointer to device data.
6572 *
6573 *   \note:
6574 *
6575 *****************************************************************************/
6576 GLOBAL tdsaDeviceData_t *
6577 tdsaPortSATADeviceAdd(
6578                       tiRoot_t                *tiRoot,
6579                       tdsaPortContext_t       *onePortContext,
6580                       tdsaDeviceData_t        *oneSTPBridge,
6581                       bit8                    *Signature,
6582                       bit8                    pm,
6583                       bit8                    pmField,
6584                       bit8                    connectionRate,
6585                       tdsaDeviceData_t        *oneExpDeviceData,
6586                       bit8                    phyID
6587                       )
6588 {
6589   tdsaDeviceData_t      *oneDeviceData = agNULL;
6590   agsaRoot_t            *agRoot = onePortContext->agRoot;
6591   bit8                  dev_s_rate = 0;
6592   bit8                  sasorsata = SATA_DEVICE_TYPE;
6593 //  bit8                  devicetype = 0;
6594   bit8                  flag = 0;
6595   bit8                  TLR = 0;
6596   tdsaDeviceData_t      *oneAttachedExpDeviceData = agNULL;
6597
6598   TI_DBG3(("tdsaPortSATADeviceAdd: start\n"));
6599
6600   /* sanity check */
6601   TD_ASSERT((agNULL != tiRoot), "");
6602   TD_ASSERT((agNULL != agRoot), "");
6603   TD_ASSERT((agNULL != onePortContext), "");
6604   TD_ASSERT((agNULL != Signature), "");
6605
6606   oneDeviceData = tdssNewAddSATAToSharedcontext(
6607                                                 tiRoot,
6608                                                 agRoot,
6609                                                 onePortContext,
6610                                                 agNULL,
6611                                                 Signature,
6612                                                 pm,
6613                                                 pmField,
6614                                                 connectionRate,
6615                                                 oneExpDeviceData,
6616                                                 phyID
6617                                                 );
6618   if (oneDeviceData == agNULL)
6619   {
6620     TI_DBG1(("tdsaPortSATADeviceAdd: no more device!!! oneDeviceData is null\n"));
6621     return agNULL;
6622   }
6623
6624   flag = (bit8)((phyID << 4) | TLR);
6625   DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
6626   DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, 0xFFF);
6627   DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, 0);
6628   DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, flag);
6629
6630   /* adjusting connectionRate */
6631   oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
6632   if (oneAttachedExpDeviceData != agNULL)
6633   {
6634     connectionRate = (bit8)(MIN(connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6635     TI_DBG3(("tdsaPortSATADeviceAdd: 1st connectionRate 0x%x  DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo) 0x%x\n",
6636               connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
6637   }
6638   else
6639   {
6640     TI_DBG3(("tdsaPortSATADeviceAdd: 1st oneAttachedExpDeviceData is NULL\n"));
6641   }
6642
6643    /* Device Type, SAS or SATA, connection rate; bit7 --- bit0*/
6644 //   dev_s_rate = dev_s_rate | (devicetype << 6);
6645    dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4));
6646    dev_s_rate = (bit8)(dev_s_rate | connectionRate);
6647    DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
6648
6649    osti_memset(&oneDeviceData->agDeviceInfo.sasAddressHi, 0, 4);
6650    osti_memset(&oneDeviceData->agDeviceInfo.sasAddressLo, 0, 4);
6651
6652    oneDeviceData->agContext.osData = oneDeviceData;
6653    oneDeviceData->agContext.sdkData = agNULL;
6654
6655    TI_DBG1(("tdsaPortSATADeviceAdd: did %d\n", oneDeviceData->id));
6656    if (oneDeviceData->registered == agFALSE)
6657    {
6658      TI_DBG2(("tdsaPortSATADeviceAdd: did %d\n", oneDeviceData->id));
6659      saRegisterNewDevice( /* tdsaPortSATADeviceAdd */
6660                          onePortContext->agRoot,
6661                          &oneDeviceData->agContext,
6662                          tdsaRotateQnumber(tiRoot, oneDeviceData),
6663                          &oneDeviceData->agDeviceInfo,
6664                          onePortContext->agPortContext,
6665                          0
6666                          );
6667    }
6668
6669    return oneDeviceData;
6670 }
6671 #endif
6672
6673 /*****************************************************************************
6674 *! \brief  tdsaFindRightDevice
6675 *
6676 *  Purpose:  This function returns device-to-be processed.
6677 *
6678 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6679 *                   instance.
6680 *  \param   onePortContext: Pointer to the portal context instance.
6681 *  \param   tdsaDeviceData: Pointer to the starting device data.
6682 *
6683 *  \return:
6684 *           Pointer to device data.
6685 *
6686 *   \note:
6687 *
6688 *****************************************************************************/
6689 osGLOBAL tdsaDeviceData_t  *
6690 tdsaFindRightDevice(
6691                    tiRoot_t               *tiRoot,
6692                    tdsaPortContext_t      *onePortContext,
6693                    tdsaDeviceData_t       *tdsaDeviceData
6694                    )
6695 {
6696   tdList_t          *DeviceListList;
6697   tdsaDeviceData_t  *oneDeviceData = agNULL;
6698   bit32             found = agFALSE;
6699
6700   TI_DBG3(("tdsaFindHeadDevice: start\n"));
6701
6702   DeviceListList = tdsaDeviceData->MainLink.flink;
6703
6704   while (DeviceListList != &(tdsaDeviceData->MainLink))
6705   {
6706     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6707     TI_DBG3(("tdsaFindRightDevice: did %d STP %d SATA %d \n", onePortContext->id, DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
6708     DeviceListList = DeviceListList->flink;
6709   }
6710
6711   DeviceListList = tdsaDeviceData->MainLink.flink;
6712
6713   while (DeviceListList != &(tdsaDeviceData->MainLink))
6714   {
6715     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6716     if ((oneDeviceData->registered == agTRUE) &&
6717         (oneDeviceData->tdPortContext == onePortContext) &&
6718         (oneDeviceData->processed == agFALSE) &&
6719         (SA_IDFRM_IS_STP_TARGET(&oneDeviceData->sasIdentify) ||
6720          SA_IDFRM_IS_SATA_DEVICE(&oneDeviceData->sasIdentify))
6721         )
6722     {
6723       TI_DBG3(("tdsaFindRightDevice: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
6724       oneDeviceData->processed = agTRUE;
6725       found = agTRUE;
6726       break;
6727     }
6728     DeviceListList = DeviceListList->flink;
6729   }
6730
6731   if (found == agTRUE)
6732   {
6733     return oneDeviceData;
6734   }
6735   else
6736   {
6737     return agNULL;
6738   }
6739 }
6740
6741
6742
6743 // tdsaDeviceData is head of list
6744 /*****************************************************************************
6745 *! \brief  tdsaDiscoveringStpSATADevice
6746 *
6747 *  Purpose:  For each device in the device list, this function peforms
6748 *            SATA discovery.
6749 *
6750 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6751 *                   instance.
6752 *  \param   onePortContext: Pointer to the portal context instance.
6753 *  \param   oneDeviceData: Pointer to the heade of device list.
6754 *
6755 *  \return:
6756 *           None
6757 *
6758 *   \note:
6759 *
6760 *****************************************************************************/
6761 osGLOBAL void
6762 tdsaDiscoveringStpSATADevice(
6763                              tiRoot_t               *tiRoot,
6764                              tdsaPortContext_t      *onePortContext,
6765                              tdsaDeviceData_t       *oneDeviceData
6766                              )
6767 {
6768   bit32                 status;
6769   tdsaRoot_t            *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6770   tdsaContext_t         *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6771 //  tdsaDeviceData_t      *tdsaDeviceData  = (tdsaDeviceData_t *)tdsaAllShared->DeviceMem;
6772   tdsaDeviceData_t      *tdsaDeviceData;
6773   tdList_t              *DeviceListList;
6774
6775   TI_DBG3(("tdsaDiscoveringStpSATADevice: start\n"));
6776
6777   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6778   tdsaDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6779
6780   if (oneDeviceData)
6781   {
6782     TI_DBG3(("tdsaDiscoveringStpSATADevice: Found STP-SATA Device=%p\n", oneDeviceData));
6783     if ((SA_IDFRM_IS_SATA_DEVICE(&oneDeviceData->sasIdentify) || SA_IDFRM_IS_STP_TARGET(&oneDeviceData->sasIdentify))
6784          &&
6785         ((onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START &&
6786           oneDeviceData->valid == agTRUE) ||
6787         (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_INCREMENTAL_START &&
6788          oneDeviceData->valid2 == agTRUE)) &&
6789         (oneDeviceData->tdPortContext == onePortContext)
6790        )
6791     {
6792       /* if found an STP bridges */
6793       /* in order to get sata signature and etc */
6794       TI_DBG3(("tdsaDiscoveringStpSATADevice: sending report phy sata\n"));
6795       tdsaReportPhySataSend(tiRoot, oneDeviceData, oneDeviceData->sasIdentify.phyIdentifier);
6796       //send ID in every discovery? No
6797       if (oneDeviceData->satDevData.IDDeviceValid == agFALSE)
6798       {
6799         TI_DBG3(("tdsaDiscoveringStpSATADevice: sending identify device data\n"));
6800         /* all internal */
6801         status = tdsaDiscoveryStartIDDev(tiRoot,
6802                                          agNULL,
6803                                          &(oneDeviceData->tiDeviceHandle),
6804                                          agNULL,
6805                                          oneDeviceData);
6806
6807         if (status != tiSuccess)
6808         {
6809           /* identify device data is not valid */
6810           TI_DBG1(("tdsaDiscoveringStpSATADevice: fail or busy %d\n", status));
6811           oneDeviceData->satDevData.IDDeviceValid = agFALSE;
6812         }
6813       }
6814     }
6815     else
6816     {
6817       TI_DBG2(("tdsaDiscoveringStpSATADevice: moving to the next\n"));
6818       oneDeviceData = tdsaFindRightDevice(tiRoot, onePortContext, tdsaDeviceData);
6819       tdsaDiscoveringStpSATADevice(tiRoot, onePortContext, oneDeviceData);
6820     }
6821   }
6822   else
6823   {
6824     /* otherwise, there is no more SATA device found */
6825     TI_DBG3(("tdsaDiscoveringStpSATADevice: No More Device; SATA discovery finished\n"));
6826
6827     tdsaSATADiscoverDone(tiRoot, onePortContext, tiSuccess);
6828   }
6829
6830   return;
6831 }
6832
6833 /*****************************************************************************
6834 *! \brief  tdsaSASIncrementalDiscover
6835 *
6836 *  Purpose:  This function is called to trigger incremental SAS topology discovery
6837 *            within a portcontext.
6838 *
6839 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6840 *                   instance.
6841 *  \param   onePortContext: Pointer to the portal context instance.
6842 *
6843 *  \return:
6844 *           tiSuccess    Discovery initiated.
6845 *           tiError      Discovery could not be initiated at this time.
6846 *
6847 *   \note:
6848 *
6849 *****************************************************************************/
6850 osGLOBAL bit32
6851 tdsaSASIncrementalDiscover(
6852                     tiRoot_t          *tiRoot,
6853                     tdsaPortContext_t *onePortContext
6854                     )
6855 {
6856   tdsaDeviceData_t     *oneDeviceData  = agNULL;
6857   int                  i,j;
6858   bit8                 portMaxRate;
6859
6860   TI_DBG3(("tdsaSASIncrementalDiscover: start\n"));
6861
6862   if (onePortContext->valid == agFALSE)
6863   {
6864     TI_DBG1(("tdsaSASIncrementalDiscover: aborting discovery\n"));
6865     tdsaSASDiscoverAbort(tiRoot, onePortContext);
6866     return tiError;
6867   }
6868
6869   onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
6870
6871   /* nativeSATAMode is set in ossaHwCB() in link up */
6872   if (onePortContext->nativeSATAMode == agFALSE) /* default: SAS and SAS/SATA mode */
6873   {
6874     if (SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe) == SAS_END_DEVICE &&
6875         SA_IDFRM_IS_SSP_TARGET(&onePortContext->sasIDframe) )
6876     {
6877       for(i=0;i<TD_MAX_NUM_PHYS;i++)
6878       {
6879         if (onePortContext->PhyIDList[i] == agTRUE)
6880         {
6881
6882           for (j=0;j<TD_MAX_NUM_NOTIFY_SPINUP;j++)
6883           {
6884             saLocalPhyControl(onePortContext->agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), i, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
6885           }
6886           break;
6887         }
6888       }
6889     }
6890     /*
6891       add the device
6892       1. add device in TD layer
6893       2. call saRegisterNewDevice
6894       3. update agDevHandle in ossaDeviceRegistrationCB()
6895     */
6896     portMaxRate = onePortContext->LinkRate;
6897     oneDeviceData = tdsaPortSASDeviceAdd(
6898                                          tiRoot,
6899                                          onePortContext,
6900                                          onePortContext->sasIDframe,
6901                                          agFALSE,
6902                                          portMaxRate,
6903                                          IT_NEXUS_TIMEOUT,
6904                                          0,
6905                                          SAS_DEVICE_TYPE,
6906                                          agNULL,
6907                                          0xFF
6908                                          );
6909     if (oneDeviceData)
6910     {
6911       if (oneDeviceData->registered == agFALSE)
6912       {
6913         /*
6914           set the timer and wait till the device(directly attached. eg Expander) to be registered.
6915           Then, in tdsaDeviceRegistrationTimerCB(), tdsaSASUpStreamDiscoverStart() is called
6916         */
6917         tdsaDeviceRegistrationTimer(tiRoot, onePortContext, oneDeviceData);
6918       }
6919       else
6920       {
6921         tdsaSASUpStreamDiscoverStart(tiRoot, onePortContext, oneDeviceData);
6922       }
6923     }
6924   }
6925   else /* SATAOnlyMode*/
6926   {
6927     tdsaSASDiscoverDone(tiRoot, onePortContext, tiSuccess);
6928   }
6929   return tiSuccess;
6930 }
6931
6932 #ifdef SATA_ENABLE
6933 /* For the sake of completness; this is the same as  tdsaSATAFullDiscover*/
6934 /*****************************************************************************
6935 *! \brief  tdsaSATAIncrementalDiscover
6936 *
6937 *  Purpose:  This function is called to trigger incremental SATA topology discovery
6938 *            within a portcontext.
6939 *
6940 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
6941 *                   instance.
6942 *  \param   onePortContext: Pointer to the portal context instance.
6943 *
6944 *  \return:
6945 *           tiSuccess    Discovery initiated.
6946 *           tiError      Discovery could not be initiated at this time.
6947 *
6948 *   \note:
6949 *
6950 *****************************************************************************/
6951 osGLOBAL bit32
6952 tdsaSATAIncrementalDiscover(
6953                             tiRoot_t          *tiRoot,
6954                             tdsaPortContext_t *onePortContext
6955                            )
6956 {
6957   bit32                 ret = tiSuccess;
6958   tdsaDeviceData_t      *oneDeviceData = agNULL;
6959   bit32                 deviceType;
6960   bit8                  phyRate = SAS_CONNECTION_RATE_3_0G;
6961   bit32                 i;
6962   tdsaRoot_t            *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6963   tdsaContext_t         *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6964 //  tdsaDeviceData_t      *tdsaDeviceData  = (tdsaDeviceData_t *)tdsaAllShared->DeviceMem;
6965   tdsaDeviceData_t      *tdsaDeviceData;
6966   tdList_t              *DeviceListList;
6967
6968   TI_DBG3(("tdsaSATAIncrementalDiscover: start\n"));
6969
6970   if (onePortContext->valid == agFALSE)
6971   {
6972     TI_DBG1(("tdsaSATAIncrementalDiscover: aborting discovery\n"));
6973     tdsaSASDiscoverAbort(tiRoot, onePortContext);
6974     return tiError;
6975   }
6976
6977   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6978   tdsaDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6979
6980   /*  If port is SATA mode */
6981   /*
6982     Native SATA mode is decided in ossaHWCB() SAS_LINK_UP or SATA_LINK_UP
6983    */
6984   if (onePortContext->nativeSATAMode == agTRUE)
6985   {
6986     /* Decode device type */
6987     deviceType = tdssSATADeviceTypeDecode(onePortContext->remoteSignature);
6988     /* Create a device descriptor for the SATA device attached to the port */
6989     if ( deviceType == SATA_PM_DEVICE)
6990     {
6991       TI_DBG3(("tdsaSATAIncrementalDiscover: Found a PM device\n"));
6992       oneDeviceData = tdsaPortSATADeviceAdd(
6993                                             tiRoot,
6994                                             onePortContext,
6995                                             agNULL,
6996                                             onePortContext->remoteSignature,
6997                                             agTRUE,
6998                                             0xF,
6999                                             phyRate,
7000                                             agNULL,
7001                                             0xFF);
7002     }
7003     else
7004     {
7005       /* already added in ossahwcb() in SATA link up */
7006       TI_DBG3(("tdsaSATAIncrementalDiscover: Found a DIRECT SATA device\n"));
7007     }
7008
7009     /* Process for different device type */
7010     switch ( deviceType )
7011     {
7012       /* if it's PM */
7013       case SATA_PM_DEVICE:
7014       {
7015
7016         TI_DBG3(("tdsaSATAIncrementalDiscover: Process a PM device\n"));
7017         /* For each port of the PM */
7018         for ( i = 0; i < SATA_MAX_PM_PORTS; i ++ )
7019         {
7020           /* Read the signature */
7021           /* Decode the device type */
7022           /* Create device descriptor */
7023           /* Callback with the discovered devices */
7024         }
7025         break;
7026       }
7027       /* if it's ATA device */
7028       case SATA_ATA_DEVICE:
7029       case SATA_ATAPI_DEVICE:
7030       {
7031         TI_DBG3(("tdsaSATAIncrementalDiscover: Process an ATA device. Sending Identify Device cmd\n"));
7032
7033         /* to-check: for this direct attached one, already added and do nothing */
7034         /* no longer, discovery sends sata identify device command */
7035         //tdsaSATAIdentifyDeviceCmdSend(tiRoot, oneDeviceData);
7036
7037         tdsaSATADiscoverDone(tiRoot, onePortContext, tiSuccess);
7038
7039         break;
7040       }
7041       /* Other devices */
7042       default:
7043       {
7044         /* callback */
7045         TI_DBG3(("siSATAIncrementalDiscover: Process OTHER SATA device. Just report the device\n"));
7046
7047         break;
7048       }
7049     }
7050   }
7051   /* If port is SAS mode */
7052   else
7053   {
7054     TI_DBG3(("tdsaSATAIncrementalDiscover: Discovering attached STP devices  starts....\n"));
7055     oneDeviceData = tdsaFindRightDevice(tiRoot, onePortContext, tdsaDeviceData);
7056
7057     tdsaDiscoveringStpSATADevice(tiRoot, onePortContext, oneDeviceData);
7058   }
7059   return ret;
7060
7061 }
7062 #endif
7063
7064
7065 /********************  SMP *******************************/
7066
7067 /*****************************************************************************
7068 *! \brief  tdSMPStart
7069 *
7070 *  Purpose:  This function sends SMP request.
7071 *
7072 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7073 *                   instance.
7074 *  \param   agRoot: Pointer to chip/driver Instance.
7075 *  \param   oneDeviceData: Pointer to the device data.
7076 *  \param   functionCode: SMP function code.
7077 *  \param   pSmpBody: Pointer to SMP payload.
7078 *  \param   smpBodySize: Size of SMP request without SMP header.
7079 *  \param   agRequestType: SPC-specfic request type
7080 *
7081 *  \return:
7082 *           tiSuccess  SMP is sent successfully
7083 *           tiError    SMP is not sent successfully
7084 *
7085 *   \note:
7086 *
7087 *****************************************************************************/
7088 osGLOBAL bit32
7089 tdSMPStart(
7090            tiRoot_t              *tiRoot,
7091            agsaRoot_t            *agRoot,
7092            tdsaDeviceData_t      *oneDeviceData,
7093            bit32                 functionCode,
7094            bit8                  *pSmpBody, /* smp payload itself w/o first 4 bytes(header) */
7095            bit32                 smpBodySize, /* smp payload size w/o first 4 bytes(header) */
7096            bit32                 agRequestType,
7097            tiIORequest_t         *CurrentTaskTag,
7098            bit32                 queueNumber
7099            )
7100 {
7101   void                        *osMemHandle;
7102   bit32                       PhysUpper32;
7103   bit32                       PhysLower32;
7104   bit32                       memAllocStatus;
7105   bit32                       expectedRspLen = 0;
7106
7107 #ifdef REMOVED
7108   tdsaRoot_t                  *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
7109   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
7110 #endif
7111   tdssSMPRequestBody_t        *tdSMPRequestBody;
7112   agsaSASRequestBody_t        *agSASRequestBody;
7113   agsaSMPFrame_t              *agSMPFrame;
7114   agsaIORequest_t             *agIORequest;
7115   agsaDevHandle_t             *agDevHandle;
7116   tdssSMPFrameHeader_t        tdSMPFrameHeader;
7117   tdsaPortContext_t           *onePortContext = agNULL;
7118   bit32                       status;
7119
7120 #ifndef DIRECT_SMP
7121   void                        *IndirectSMPReqosMemHandle;
7122   bit32                       IndirectSMPReqPhysUpper32;
7123   bit32                       IndirectSMPReqPhysLower32;
7124   bit32                       IndirectSMPReqmemAllocStatus;
7125   bit8                        *IndirectSMPReq;
7126
7127   void                        *IndirectSMPResposMemHandle;
7128   bit32                       IndirectSMPRespPhysUpper32;
7129   bit32                       IndirectSMPRespPhysLower32;
7130   bit32                       IndirectSMPRespmemAllocStatus;
7131   bit8                        *IndirectSMPResp;
7132 #endif
7133
7134   TI_DBG3(("tdSMPStart: start\n"));
7135   TI_DBG3(("tdSMPStart: oneDeviceData %p\n", oneDeviceData));
7136   TI_DBG3(("tdSMPStart: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
7137   TI_DBG3(("tdSMPStart: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
7138   TI_DBG3(("tdSMPStart: 2nd sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
7139   TI_DBG3(("tdSMPStart: 2nd sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
7140
7141   onePortContext = oneDeviceData->tdPortContext;
7142
7143   if (onePortContext != agNULL)
7144   {
7145     TI_DBG3(("tdSMPStart: pid %d\n", onePortContext->id));
7146     /* increment the number of pending SMP */
7147     onePortContext->discovery.pendingSMP++;
7148   }
7149   else
7150   {
7151     TI_DBG1(("tdSMPStart: Wrong!!! onePortContext is NULL\n"));
7152     return tiError;
7153   }
7154
7155
7156
7157   memAllocStatus = ostiAllocMemory(
7158                                    tiRoot,
7159                                    &osMemHandle,
7160                                    (void **)&tdSMPRequestBody,
7161                                    &PhysUpper32,
7162                                    &PhysLower32,
7163                                    8,
7164                                    sizeof(tdssSMPRequestBody_t),
7165                                    agTRUE
7166                                    );
7167
7168   if (memAllocStatus != tiSuccess)
7169   {
7170     TI_DBG1(("tdSMPStart: ostiAllocMemory failed...\n"));
7171     return tiError;
7172   }
7173
7174   if (tdSMPRequestBody == agNULL)
7175   {
7176     TI_DBG1(("tdSMPStart: ostiAllocMemory returned NULL tdSMPRequestBody\n"));
7177     return tiError;
7178   }
7179   /* saves mem handle for freeing later */
7180   tdSMPRequestBody->osMemHandle = osMemHandle;
7181
7182   /* saves tdsaDeviceData */
7183   tdSMPRequestBody->tdDevice = oneDeviceData;
7184
7185   /* saving port id */
7186   tdSMPRequestBody->tdPortContext = onePortContext;
7187
7188
7189   agDevHandle = oneDeviceData->agDevHandle;
7190
7191   /* save the callback funtion */
7192   tdSMPRequestBody->SMPCompletionFunc = itdssSMPCompleted; /* in itdcb.c */
7193
7194   /* for simulate warm target reset */
7195   tdSMPRequestBody->CurrentTaskTag = CurrentTaskTag;
7196
7197   /* initializes the number of SMP retries */
7198   tdSMPRequestBody->retries = 0;
7199
7200 #ifdef TD_INTERNAL_DEBUG  /* debugging */
7201   TI_DBG4(("tdSMPStart: SMPRequestbody %p\n", tdSMPRequestBody));
7202   TI_DBG4(("tdSMPStart: callback fn %p\n", tdSMPRequestBody->SMPCompletionFunc));
7203 #endif
7204
7205   agIORequest = &(tdSMPRequestBody->agIORequest);
7206   agIORequest->osData = (void *) tdSMPRequestBody;
7207   agIORequest->sdkData = agNULL; /* SALL takes care of this */
7208
7209
7210   agSASRequestBody = &(tdSMPRequestBody->agSASRequestBody);
7211   agSMPFrame = &(agSASRequestBody->smpFrame);
7212
7213   TI_DBG3(("tdSMPStart: agIORequest %p\n", agIORequest));
7214   TI_DBG3(("tdSMPStart: SMPRequestbody %p\n", tdSMPRequestBody));
7215
7216   /*
7217     depending on functionCode, set expectedRspLen in smp
7218   */
7219   switch (functionCode)
7220   {
7221   case SMP_REPORT_GENERAL:
7222     expectedRspLen = sizeof(smpRespReportGeneral_t) + 4;
7223     break;
7224   case SMP_REPORT_MANUFACTURE_INFORMATION:
7225     expectedRspLen = sizeof(smpRespReportManufactureInfo_t) + 4;
7226     break;
7227   case SMP_DISCOVER:
7228     expectedRspLen = sizeof(smpRespDiscover_t) + 4;
7229     break;
7230   case SMP_REPORT_PHY_ERROR_LOG:
7231     expectedRspLen = 32 - 4;
7232     break;
7233   case SMP_REPORT_PHY_SATA:
7234     expectedRspLen = sizeof(smpRespReportPhySata_t) + 4;
7235     break;
7236   case SMP_REPORT_ROUTING_INFORMATION:
7237     expectedRspLen = sizeof(smpRespReportRouteTable_t) + 4;
7238     break;
7239   case SMP_CONFIGURE_ROUTING_INFORMATION:
7240     expectedRspLen = 4;
7241     break;
7242   case SMP_PHY_CONTROL:
7243     expectedRspLen = 4;
7244     break;
7245   case SMP_PHY_TEST_FUNCTION:
7246     expectedRspLen = 4;
7247     break;
7248   case SMP_PMC_SPECIFIC:
7249     expectedRspLen = 4;
7250     break;
7251   default:
7252     expectedRspLen = 0;
7253     TI_DBG1(("tdSMPStart: error!!! undefined or unused smp function code 0x%x\n", functionCode));
7254     return tiError;
7255   }
7256
7257   if (tiIS_SPC(agRoot))
7258   {
7259 #ifdef DIRECT_SMP  /* direct SMP with 48 or less payload */
7260   if ( (smpBodySize + 4) <= SMP_DIRECT_PAYLOAD_LIMIT) /* 48 */
7261   {
7262     TI_DBG3(("tdSMPStart: DIRECT smp payload\n"));
7263     osti_memset(&tdSMPFrameHeader, 0, sizeof(tdssSMPFrameHeader_t));
7264     osti_memset(tdSMPRequestBody->smpPayload, 0, SMP_DIRECT_PAYLOAD_LIMIT);
7265
7266     /* SMP header */
7267     tdSMPFrameHeader.smpFrameType = SMP_REQUEST; /* SMP request */
7268     tdSMPFrameHeader.smpFunction = (bit8)functionCode;
7269     tdSMPFrameHeader.smpFunctionResult = 0;
7270     tdSMPFrameHeader.smpReserved = 0;
7271
7272     osti_memcpy(tdSMPRequestBody->smpPayload, &tdSMPFrameHeader, 4);
7273 //    osti_memcpy((tdSMPRequestBody->smpPayload)+4, pSmpBody, smpBodySize);
7274     osti_memcpy(&(tdSMPRequestBody->smpPayload[4]), pSmpBody, smpBodySize);
7275
7276     /* direct SMP payload eg) REPORT_GENERAL, DISCOVER etc */
7277     agSMPFrame->outFrameBuf = tdSMPRequestBody->smpPayload;
7278     agSMPFrame->outFrameLen = smpBodySize + 4; /* without last 4 byte crc */
7279     /* to specify DIRECT SMP response */
7280     agSMPFrame->inFrameLen = 0;
7281
7282     /* temporary solution for T2D Combo*/
7283 #if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER)
7284     /* force smp repsonse to be direct */
7285     agSMPFrame->expectedRespLen = 0;
7286 #else
7287     agSMPFrame->expectedRespLen = expectedRspLen;
7288 #endif
7289 //    tdhexdump("tdSMPStart", (bit8*)agSMPFrame->outFrameBuf, agSMPFrame->outFrameLen);
7290 //    tdhexdump("tdSMPStart new", (bit8*)tdSMPRequestBody->smpPayload, agSMPFrame->outFrameLen);
7291 //    tdhexdump("tdSMPStart - tdSMPRequestBody", (bit8*)tdSMPRequestBody, sizeof(tdssSMPRequestBody_t));
7292   }
7293   else
7294   {
7295     TI_DBG3(("tdSMPStart: INDIRECT smp payload\n"));
7296   }
7297
7298 #else
7299
7300   /* indirect SMP */
7301   /* allocate Direct SMP request payload */
7302   IndirectSMPReqmemAllocStatus = ostiAllocMemory(
7303                                    tiRoot,
7304                                    &IndirectSMPReqosMemHandle,
7305                                    (void **)&IndirectSMPReq,
7306                                    &IndirectSMPReqPhysUpper32,
7307                                    &IndirectSMPReqPhysLower32,
7308                                    8,
7309                                    smpBodySize + 4,
7310                                    agFALSE
7311                                    );
7312
7313   if (IndirectSMPReqmemAllocStatus != tiSuccess)
7314   {
7315     TI_DBG1(("tdSMPStart: ostiAllocMemory failed for indirect SMP request...\n"));
7316     return tiError;
7317   }
7318
7319   if (IndirectSMPReq == agNULL)
7320   {
7321     TI_DBG1(("tdSMPStart: ostiAllocMemory returned NULL IndirectSMPReq\n"));
7322     return tiError;
7323   }
7324
7325   /* allocate indirect SMP response payload */
7326   IndirectSMPRespmemAllocStatus = ostiAllocMemory(
7327                                    tiRoot,
7328                                    &IndirectSMPResposMemHandle,
7329                                    (void **)&IndirectSMPResp,
7330                                    &IndirectSMPRespPhysUpper32,
7331                                    &IndirectSMPRespPhysLower32,
7332                                    8,
7333                                    expectedRspLen,
7334                                    agFALSE
7335                                    );
7336
7337   if (IndirectSMPRespmemAllocStatus != tiSuccess)
7338   {
7339     TI_DBG1(("tdSMPStart: ostiAllocMemory failed for indirect SMP reponse...\n"));
7340     return tiError;
7341   }
7342
7343   if (IndirectSMPResp == agNULL)
7344   {
7345     TI_DBG1(("tdSMPStart: ostiAllocMemory returned NULL IndirectSMPResp\n"));
7346     return tiError;
7347   }
7348
7349   /* saves mem handle for freeing later */
7350   tdSMPRequestBody->IndirectSMPReqosMemHandle = IndirectSMPReqosMemHandle;
7351   tdSMPRequestBody->IndirectSMPResposMemHandle = IndirectSMPResposMemHandle;
7352
7353   /* saves Indirect SMP request/repsonse pointer and length for free them later */
7354   tdSMPRequestBody->IndirectSMPReq = IndirectSMPReq;
7355   tdSMPRequestBody->IndirectSMPResp = IndirectSMPResp;
7356   tdSMPRequestBody->IndirectSMPReqLen = smpBodySize + 4;
7357   tdSMPRequestBody->IndirectSMPRespLen = expectedRspLen;
7358
7359   /* fill in indirect SMP request fields */
7360   TI_DBG3(("tdSMPStart: INDIRECT smp payload\n"));
7361
7362   /* SMP request and response initialization */
7363   osti_memset(&tdSMPFrameHeader, 0, sizeof(tdssSMPFrameHeader_t));
7364   osti_memset(IndirectSMPReq, 0, smpBodySize + 4);
7365   osti_memset(IndirectSMPResp, 0, expectedRspLen);
7366
7367   /* SMP request header */
7368   tdSMPFrameHeader.smpFrameType = SMP_REQUEST; /* SMP request */
7369   tdSMPFrameHeader.smpFunction = (bit8)functionCode;
7370   tdSMPFrameHeader.smpFunctionResult = 0;
7371   tdSMPFrameHeader.smpReserved = 0;
7372
7373   osti_memcpy(IndirectSMPReq, &tdSMPFrameHeader, 4);
7374   osti_memcpy(IndirectSMPReq+4, pSmpBody, smpBodySize);
7375
7376   /* Indirect SMP request */
7377   agSMPFrame->outFrameBuf = agNULL;
7378   agSMPFrame->outFrameAddrUpper32 = IndirectSMPReqPhysUpper32;
7379   agSMPFrame->outFrameAddrLower32 = IndirectSMPReqPhysLower32;
7380   agSMPFrame->outFrameLen = smpBodySize + 4; /* without last 4 byte crc */
7381
7382   /* Indirect SMP response */
7383   agSMPFrame->expectedRespLen = expectedRspLen;
7384   agSMPFrame->inFrameLen = expectedRspLen; /* without last 4 byte crc */
7385   agSMPFrame->inFrameAddrUpper32 = IndirectSMPRespPhysUpper32;
7386   agSMPFrame->inFrameAddrLower32 = IndirectSMPRespPhysLower32;
7387 #endif
7388   }
7389   else /* SPCv controller */
7390   {
7391     /* only direct mode for both request and response */
7392     TI_DBG3(("tdSMPStart: DIRECT smp payload\n"));
7393     agSMPFrame->flag = 0;
7394     osti_memset(&tdSMPFrameHeader, 0, sizeof(tdssSMPFrameHeader_t));
7395     osti_memset(tdSMPRequestBody->smpPayload, 0, SMP_DIRECT_PAYLOAD_LIMIT);
7396
7397     /* SMP header */
7398     tdSMPFrameHeader.smpFrameType = SMP_REQUEST; /* SMP request */
7399     tdSMPFrameHeader.smpFunction = (bit8)functionCode;
7400     tdSMPFrameHeader.smpFunctionResult = 0;
7401     tdSMPFrameHeader.smpReserved = 0;
7402
7403     osti_memcpy(tdSMPRequestBody->smpPayload, &tdSMPFrameHeader, 4);
7404 //    osti_memcpy((tdSMPRequestBody->smpPayload)+4, pSmpBody, smpBodySize);
7405     osti_memcpy(&(tdSMPRequestBody->smpPayload[4]), pSmpBody, smpBodySize);
7406
7407     /* direct SMP payload eg) REPORT_GENERAL, DISCOVER etc */
7408     agSMPFrame->outFrameBuf = tdSMPRequestBody->smpPayload;
7409     agSMPFrame->outFrameLen = smpBodySize + 4; /* without last 4 byte crc */
7410     /* to specify DIRECT SMP response */
7411     agSMPFrame->inFrameLen = 0;
7412
7413     /* temporary solution for T2D Combo*/
7414 #if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER)
7415     /* force smp repsonse to be direct */
7416     agSMPFrame->expectedRespLen = 0;
7417 #else
7418     agSMPFrame->expectedRespLen = expectedRspLen;
7419 #endif
7420 //    tdhexdump("tdSMPStart", (bit8*)agSMPFrame->outFrameBuf, agSMPFrame->outFrameLen);
7421 //    tdhexdump("tdSMPStart new", (bit8*)tdSMPRequestBody->smpPayload, agSMPFrame->outFrameLen);
7422 //    tdhexdump("tdSMPStart - tdSMPRequestBody", (bit8*)tdSMPRequestBody, sizeof(tdssSMPRequestBody_t));
7423   }
7424
7425
7426   if (agDevHandle == agNULL)
7427   {
7428     TI_DBG1(("tdSMPStart: !!! agDevHandle is NULL !!! \n"));
7429     return tiError;
7430   }
7431
7432   tdSMPRequestBody->queueNumber = queueNumber;
7433   status = saSMPStart(
7434                       agRoot,
7435                       agIORequest,
7436                       queueNumber, //tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
7437                       agDevHandle,
7438                       agRequestType,
7439                       agSASRequestBody,
7440                       &ossaSMPCompleted
7441                       );
7442
7443   if (status == AGSA_RC_SUCCESS)
7444   {
7445     /* start SMP timer */
7446     if (functionCode == SMP_REPORT_GENERAL || functionCode == SMP_DISCOVER ||
7447         functionCode == SMP_REPORT_PHY_SATA || functionCode == SMP_CONFIGURE_ROUTING_INFORMATION
7448         )
7449     {
7450       tdsaDiscoverySMPTimer(tiRoot, onePortContext, functionCode, tdSMPRequestBody);
7451     }
7452     return tiSuccess;
7453   }
7454   else if (status == AGSA_RC_BUSY)
7455   {
7456     /* set timer */
7457     if (functionCode == SMP_REPORT_GENERAL || functionCode == SMP_DISCOVER ||
7458         functionCode == SMP_REPORT_PHY_SATA || functionCode == SMP_CONFIGURE_ROUTING_INFORMATION)
7459     {
7460       /* only for discovery related SMPs*/
7461       tdsaSMPBusyTimer(tiRoot, onePortContext, oneDeviceData, tdSMPRequestBody);
7462       return tiSuccess;
7463     }
7464     else if (functionCode == SMP_PHY_CONTROL)
7465     {
7466       ostiFreeMemory(
7467                      tiRoot,
7468                      osMemHandle,
7469                      sizeof(tdssSMPRequestBody_t)
7470                      );
7471       return tiBusy;
7472     }
7473     else
7474     {
7475       ostiFreeMemory(
7476                      tiRoot,
7477                      osMemHandle,
7478                      sizeof(tdssSMPRequestBody_t)
7479                      );
7480       return tiBusy;
7481     }
7482   }
7483   else /* AGSA_RC_FAILURE */
7484   {
7485     /* discovery failure or task management failure */
7486     if (functionCode == SMP_REPORT_GENERAL || functionCode == SMP_DISCOVER ||
7487         functionCode == SMP_REPORT_PHY_SATA || functionCode == SMP_CONFIGURE_ROUTING_INFORMATION)
7488     {
7489       tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
7490     }
7491     ostiFreeMemory(
7492                    tiRoot,
7493                    osMemHandle,
7494                    sizeof(tdssSMPRequestBody_t)
7495                    );
7496
7497     return tiError;
7498   }
7499 }
7500
7501 #ifdef REMOVED
7502 /*****************************************************************************
7503 *! \brief  tdsaFindLocalLinkRate
7504 *
7505 *  Purpose:  This function finds local link rate.
7506 *
7507 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7508 *                   instance.
7509 *  \param   tdsaPortStartInfo: Pointer to the port start information.
7510 *
7511 *  \return:
7512 *           None
7513 *
7514 *   \note:
7515 *
7516 *****************************************************************************/
7517 osGLOBAL bit8
7518 tdsaFindLocalLinkRate(
7519                     tiRoot_t                  *tiRoot,
7520                     tdsaPortStartInfo_t       *tdsaPortStartInfo
7521                     )
7522 {
7523   bit8 ans = SAS_CONNECTION_RATE_3_0G; /* default */
7524   bit32 phyProperties;
7525
7526   phyProperties = tdsaPortStartInfo->agPhyConfig.phyProperties;
7527
7528   TI_DBG3(("tdsaFindLocalLinkRate: start\n"));
7529   if (phyProperties & 0x4)
7530   {
7531     ans = SAS_CONNECTION_RATE_6_0G;
7532   }
7533   if (phyProperties & 0x2)
7534   {
7535     ans = SAS_CONNECTION_RATE_3_0G;
7536   }
7537   if (phyProperties & 0x1)
7538   {
7539     ans = SAS_CONNECTION_RATE_1_5G;
7540   }
7541   TI_DBG3(("tdsaFindLocalLinkRate: ans 0x%x\n", ans));
7542   return ans;
7543 }
7544 #endif
7545 /*****************************************************************************
7546 *! \brief  tdsaConfigureRouteTimer
7547 *
7548 *  Purpose:  This function sets timers for configuring routing of discovery and
7549 *            its callback function.
7550 *
7551 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7552 *                   instance.
7553 *  \param   onePortContext: Pointer to the portal context instance.
7554 *  \param   oneExpander: Pointer to the expander.
7555 *  \param   ptdSMPDiscoverResp: Pointer to SMP discover repsonse data.
7556 *
7557 *  \return:
7558 *           None
7559 *
7560 *   \note: called by tdsaDiscoverRespRcvd()
7561 *
7562 *****************************************************************************/
7563 osGLOBAL void
7564 tdsaConfigureRouteTimer(tiRoot_t                 *tiRoot,
7565                         tdsaPortContext_t        *onePortContext,
7566                         tdsaExpander_t           *oneExpander,
7567                         smpRespDiscover_t        *ptdSMPDiscoverResp
7568                         )
7569 {
7570   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7571   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7572   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
7573   tdsaDiscovery_t             *discovery;
7574
7575   TI_DBG1(("tdsaConfigureRouteTimer: start\n"));
7576   TI_DBG1(("tdsaConfigureRouteTimer: pid %d\n", onePortContext->id));
7577
7578   discovery = &(onePortContext->discovery);
7579
7580   TI_DBG1(("tdsaConfigureRouteTimer: onePortContext %p oneExpander %p ptdSMPDiscoverResp %p\n", onePortContext, oneExpander, ptdSMPDiscoverResp));
7581
7582   TI_DBG1(("tdsaConfigureRouteTimer: discovery %p \n", discovery));
7583
7584   TI_DBG1(("tdsaConfigureRouteTimer:  pid %d configureRouteRetries %d\n", onePortContext->id, discovery->configureRouteRetries));
7585
7586   TI_DBG1(("tdsaConfigureRouteTimer: discovery->status %d\n", discovery->status));
7587
7588   if (discovery->configureRouteTimer.timerRunning == agTRUE)
7589   {
7590     tdsaKillTimer(
7591               tiRoot,
7592               &discovery->configureRouteTimer
7593               );
7594   }
7595
7596   TI_DBG1(("tdsaConfigureRouteTimer: UsecsPerTick %d\n", Initiator->OperatingOption.UsecsPerTick));
7597   TI_DBG1(("tdsaConfigureRouteTimer: Timervalue %d\n", CONFIGURE_ROUTE_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick));
7598
7599   tdsaSetTimerRequest(
7600                     tiRoot,
7601                     &discovery->configureRouteTimer,
7602                     CONFIGURE_ROUTE_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
7603                     tdsaConfigureRouteTimerCB,
7604                     (void *)onePortContext,
7605                     (void *)oneExpander,
7606                     (void *)ptdSMPDiscoverResp
7607                    );
7608
7609   tdsaAddTimer (
7610               tiRoot,
7611               &Initiator->timerlist,
7612               &discovery->configureRouteTimer
7613               );
7614
7615   return;
7616 }
7617
7618 /*****************************************************************************
7619 *! \brief  tdsaConfigureRouteTimerCB
7620 *
7621 *  Purpose:  This function is callback function for tdsaConfigureRouteTimer.
7622 *
7623 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7624 *                   instance.
7625 *  \param   timerData1: Pointer to timer-related data structure
7626 *  \param   timerData2: Pointer to timer-related data structure
7627 *  \param   timerData3: Pointer to timer-related data structure
7628 *
7629 *  \return:
7630 *           None
7631 *
7632 *   \note:
7633 *
7634 *****************************************************************************/
7635 osGLOBAL void
7636 tdsaConfigureRouteTimerCB(
7637                           tiRoot_t    * tiRoot,
7638                           void        * timerData1,
7639                           void        * timerData2,
7640                           void        * timerData3
7641                          )
7642 {
7643   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7644   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7645   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
7646   tdsaPortContext_t           *onePortContext;
7647   tdsaExpander_t              *oneExpander;
7648   smpRespDiscover_t           *ptdSMPDiscoverResp;
7649   tdsaDiscovery_t             *discovery;
7650
7651   TI_DBG1(("tdsaConfigureRouteTimerCB: start\n"));
7652
7653   onePortContext = (tdsaPortContext_t *)timerData1;
7654   oneExpander = (tdsaExpander_t *)timerData2;
7655   ptdSMPDiscoverResp = (smpRespDiscover_t *)timerData3;
7656
7657   discovery = &(onePortContext->discovery);
7658
7659   TI_DBG1(("tdsaConfigureRouteTimerCB: onePortContext %p oneExpander %p ptdSMPDiscoverResp %p\n", onePortContext, oneExpander, ptdSMPDiscoverResp));
7660
7661   TI_DBG1(("tdsaConfigureRouteTimerCB: discovery %p\n", discovery));
7662
7663   TI_DBG1(("tdsaConfigureRouteTimerCB: pid %d configureRouteRetries %d\n", onePortContext->id, discovery->configureRouteRetries));
7664
7665   TI_DBG1(("tdsaConfigureRouteTimerCB: discovery.status %d\n", discovery->status));
7666
7667   discovery->configureRouteRetries++;
7668   if (discovery->configureRouteRetries >= DISCOVERY_RETRIES)
7669   {
7670     TI_DBG1(("tdsaConfigureRouteTimerCB: retries are over\n"));
7671     discovery->configureRouteRetries = 0;
7672     /* failed the discovery */
7673     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
7674     if (discovery->configureRouteTimer.timerRunning == agTRUE)
7675     {
7676       tdsaKillTimer(
7677                     tiRoot,
7678                     &discovery->configureRouteTimer
7679                    );
7680     }
7681     return;
7682   }
7683
7684
7685   if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
7686   {
7687     TI_DBG1(("tdsaConfigureRouteTimerCB: proceed by calling tdsaSASDownStreamDiscoverExpanderPhy\n"));
7688     tdhexdump("tdsaConfigureRouteTimerCB", (bit8*)ptdSMPDiscoverResp, sizeof(smpRespDiscover_t));
7689     discovery->configureRouteRetries = 0;
7690
7691     tdsaSASDownStreamDiscoverExpanderPhy(tiRoot, onePortContext, oneExpander, ptdSMPDiscoverResp);
7692   }
7693   else
7694   {
7695     TI_DBG1(("tdsaConfigureRouteTimerCB: setting timer again\n"));
7696     /* set the timer again */
7697     tdsaSetTimerRequest(
7698                         tiRoot,
7699                         &discovery->configureRouteTimer,
7700                         CONFIGURE_ROUTE_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
7701                         tdsaConfigureRouteTimerCB,
7702                         (void *)onePortContext,
7703                         (void *)oneExpander,
7704                         (void *)ptdSMPDiscoverResp
7705                        );
7706
7707     tdsaAddTimer (
7708                   tiRoot,
7709                   &Initiator->timerlist,
7710                   &discovery->configureRouteTimer
7711                   );
7712    }
7713 //  tdsaReportGeneralSend(tiRoot, oneDeviceData);
7714   return;
7715 }
7716
7717 /*****************************************************************************
7718 *! \brief  tdsaDiscoveryTimer
7719 *
7720 *  Purpose:  This function sets timers for discovery and its callback
7721 *            function.
7722 *
7723 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7724 *                   instance.
7725 *  \param   onePortContext: Pointer to the portal context instance.
7726 *  \param   oneDeviceData: Pointer to the device data.
7727 *
7728 *  \return:
7729 *           None
7730 *
7731 *   \note:
7732 *
7733 *****************************************************************************/
7734 osGLOBAL void
7735 tdsaDiscoveryTimer(tiRoot_t                 *tiRoot,
7736                    tdsaPortContext_t        *onePortContext,
7737                    tdsaDeviceData_t         *oneDeviceData
7738                    )
7739 {
7740   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7741   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7742   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
7743   tdsaDiscovery_t             *discovery;
7744
7745   TI_DBG1(("tdsaDiscoveryTimer: start\n"));
7746   TI_DBG1(("tdsaDiscoveryTimer: pid %d\n", onePortContext->id));
7747
7748   discovery = &(onePortContext->discovery);
7749
7750   if (discovery->discoveryTimer.timerRunning == agTRUE)
7751   {
7752     tdsaKillTimer(
7753               tiRoot,
7754               &discovery->discoveryTimer
7755               );
7756   }
7757
7758   TI_DBG1(("tdsaDiscoveryTimer: UsecsPerTick %d\n", Initiator->OperatingOption.UsecsPerTick));
7759   TI_DBG1(("tdsaDiscoveryTimer: Timervalue %d\n", DISCOVERY_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick));
7760
7761   tdsaSetTimerRequest(
7762                     tiRoot,
7763                     &discovery->discoveryTimer,
7764                     DISCOVERY_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
7765                     tdsaDiscoveryTimerCB,
7766                     oneDeviceData,
7767                     agNULL,
7768                     agNULL
7769                    );
7770
7771   tdsaAddTimer (
7772               tiRoot,
7773               &Initiator->timerlist,
7774               &discovery->discoveryTimer
7775               );
7776
7777   return;
7778 }
7779
7780 /*****************************************************************************
7781 *! \brief  tdsaDiscoveryTimerCB
7782 *
7783 *  Purpose:  This function is callback function for discovery timer.
7784 *
7785 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7786 *                   instance.
7787 *  \param   timerData1: Pointer to timer-related data structure
7788 *  \param   timerData2: Pointer to timer-related data structure
7789 *  \param   timerData3: Pointer to timer-related data structure
7790 *
7791 *  \return:
7792 *           None
7793 *
7794 *   \note:
7795 *
7796 *****************************************************************************/
7797 osGLOBAL void
7798 tdsaDiscoveryTimerCB(
7799                        tiRoot_t    * tiRoot,
7800                        void        * timerData1,
7801                        void        * timerData2,
7802                        void        * timerData3
7803                       )
7804 {
7805   tdsaDeviceData_t            *oneDeviceData;
7806   oneDeviceData = (tdsaDeviceData_t *)timerData1;
7807
7808   TI_DBG1(("tdsaDiscoveryTimerCB: start\n"));
7809
7810   if (oneDeviceData->registered == agTRUE)
7811   {
7812     TI_DBG1(("tdsaDiscoveryTimerCB: resumes discovery\n"));
7813     tdsaReportGeneralSend(tiRoot, oneDeviceData);
7814   }
7815
7816   return;
7817 }
7818
7819 /*****************************************************************************
7820 *! \brief  tdsaDeviceRegistrationTimer
7821 *
7822 *  Purpose:  This function sets timers for device registration in discovery
7823 *
7824 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7825 *                   instance.
7826 *  \param   onePortContext: Pointer to the portal context instance.
7827 *  \param   oneDeviceData: Pointer to the device data.
7828 *  \return:
7829 *           None
7830 *
7831 *   \note: called by tdsaSASFullDiscover() or tdsaSASIncrementalDiscover()
7832 *          or tdsaDeviceRegistrationTimerCB()
7833 *
7834 *****************************************************************************/
7835 osGLOBAL void
7836 tdsaDeviceRegistrationTimer(tiRoot_t                 *tiRoot,
7837                             tdsaPortContext_t        *onePortContext,
7838                             tdsaDeviceData_t         *oneDeviceData
7839                             )
7840 {
7841   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7842   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7843   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
7844   tdsaDiscovery_t             *discovery;
7845
7846   TI_DBG1(("tdsaDeviceRegistrationTimer: start\n"));
7847   TI_DBG1(("tdsaDeviceRegistrationTimer: pid %d\n", onePortContext->id));
7848
7849   discovery = &(onePortContext->discovery);
7850
7851   if (discovery->deviceRegistrationTimer.timerRunning == agTRUE)
7852   {
7853     tdsaKillTimer(
7854               tiRoot,
7855               &discovery->deviceRegistrationTimer
7856               );
7857   }
7858
7859   TI_DBG1(("tdsaDeviceRegistrationTimer: UsecsPerTick %d\n", Initiator->OperatingOption.UsecsPerTick));
7860   TI_DBG1(("tdsaDeviceRegistrationTimer: Timervalue %d\n", DEVICE_REGISTRATION_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick));
7861
7862   tdsaSetTimerRequest(
7863                     tiRoot,
7864                     &discovery->deviceRegistrationTimer,
7865                     DEVICE_REGISTRATION_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
7866                     tdsaDeviceRegistrationTimerCB,
7867                     onePortContext,
7868                     oneDeviceData,
7869                     agNULL
7870                    );
7871
7872   tdsaAddTimer (
7873               tiRoot,
7874               &Initiator->timerlist,
7875               &discovery->deviceRegistrationTimer
7876               );
7877   return;
7878 }
7879
7880 /*****************************************************************************
7881 *! \brief  tdsaDeviceRegistrationTimerCB
7882 *
7883 *  Purpose:  This function is callback function for tdsaDeviceRegistrationTimer.
7884 *
7885 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7886 *                   instance.
7887 *  \param   timerData1: Pointer to timer-related data structure
7888 *  \param   timerData2: Pointer to timer-related data structure
7889 *  \param   timerData3: Pointer to timer-related data structure
7890 *
7891 *  \return:
7892 *           None
7893 *
7894 *   \note:
7895 *
7896 *****************************************************************************/
7897 osGLOBAL void
7898 tdsaDeviceRegistrationTimerCB(
7899                        tiRoot_t    * tiRoot,
7900                        void        * timerData1,
7901                        void        * timerData2,
7902                        void        * timerData3
7903                       )
7904 {
7905   tdsaPortContext_t        *onePortContext;
7906   tdsaDeviceData_t         *oneDeviceData;
7907   tdsaDiscovery_t          *discovery;
7908
7909   TI_DBG1(("tdsaDeviceRegistrationTimerCB: start\n"));
7910
7911   onePortContext = (tdsaPortContext_t *)timerData1;
7912   oneDeviceData = (tdsaDeviceData_t *)timerData2;
7913   discovery = &(onePortContext->discovery);
7914
7915   if (oneDeviceData->registered == agFALSE)
7916   {
7917     discovery->deviceRetistrationRetries++;
7918     if (discovery->deviceRetistrationRetries >= DISCOVERY_RETRIES)
7919     {
7920       TI_DBG1(("tdsaDeviceRegistrationTimerCB: retries are over\n"));
7921       discovery->deviceRetistrationRetries = 0;
7922       /* failed the discovery */
7923       tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
7924       if (discovery->deviceRegistrationTimer.timerRunning == agTRUE)
7925       {
7926         tdsaKillTimer(
7927                       tiRoot,
7928                       &discovery->deviceRegistrationTimer
7929                      );
7930       }
7931     }
7932     else
7933     {
7934       TI_DBG1(("tdsaDeviceRegistrationTimerCB: keep retrying\n"));
7935       /* start timer for device registration */
7936       tdsaDeviceRegistrationTimer(tiRoot, onePortContext, oneDeviceData);
7937     }
7938   }
7939   else
7940   {
7941     /* go ahead; continue the discovery */
7942     discovery->deviceRetistrationRetries = 0;
7943     tdsaSASUpStreamDiscoverStart(tiRoot, onePortContext, oneDeviceData);
7944   }
7945 }
7946
7947 /*****************************************************************************
7948 *! \brief  tdsaSMPBusyTimer
7949 *
7950 *  Purpose:  This function sets timers for busy of saSMPStart.
7951 *
7952 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7953 *                   instance.
7954 *  \param   onePortContext: Pointer to the portal context instance.
7955 *  \param   oneDeviceData: Pointer to the device data.
7956 *  \param   tdSMPRequestBody: Pointer to the SMP request body.
7957 *
7958 *  \return:
7959 *           None
7960 *
7961 *   \note:
7962 *
7963 *****************************************************************************/
7964 osGLOBAL void
7965 tdsaSMPBusyTimer(tiRoot_t                 *tiRoot,
7966                  tdsaPortContext_t        *onePortContext,
7967                  tdsaDeviceData_t         *oneDeviceData,
7968                  tdssSMPRequestBody_t     *tdSMPRequestBody
7969                  )
7970 {
7971   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7972   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7973   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
7974   tdsaDiscovery_t             *discovery;
7975
7976   TI_DBG1(("tdsaSMPBusyTimer: start\n"));
7977   TI_DBG1(("tdsaSMPBusyTimer: pid %d\n", onePortContext->id));
7978
7979   discovery = &(onePortContext->discovery);
7980
7981   if (discovery->SMPBusyTimer.timerRunning == agTRUE)
7982   {
7983     tdsaKillTimer(
7984               tiRoot,
7985               &discovery->SMPBusyTimer
7986               );
7987   }
7988
7989   tdsaSetTimerRequest(
7990                     tiRoot,
7991                     &discovery->SMPBusyTimer,
7992                     SMP_BUSY_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
7993                     tdsaSMPBusyTimerCB,
7994                     onePortContext,
7995                     oneDeviceData,
7996                     tdSMPRequestBody
7997                    );
7998
7999   tdsaAddTimer (
8000               tiRoot,
8001               &Initiator->timerlist,
8002               &discovery->SMPBusyTimer
8003               );
8004   return;
8005 }
8006
8007 /*****************************************************************************
8008 *! \brief  tdsaSMPBusyTimerCB
8009 *
8010 *  Purpose:  This function is callback function for SMP busy timer.
8011 *
8012 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8013 *                   instance.
8014 *  \param   timerData1: Pointer to timer-related data structure
8015 *  \param   timerData2: Pointer to timer-related data structure
8016 *  \param   timerData3: Pointer to timer-related data structure
8017 *
8018 *  \return:
8019 *           None
8020 *
8021 *   \note:
8022 *
8023 *****************************************************************************/
8024 osGLOBAL void
8025 tdsaSMPBusyTimerCB(
8026                        tiRoot_t    * tiRoot,
8027                        void        * timerData1,
8028                        void        * timerData2,
8029                        void        * timerData3
8030                        )
8031 {
8032   tdsaRoot_t                  *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8033   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
8034   agsaRoot_t                  *agRoot;
8035   tdsaPortContext_t           *onePortContext;
8036   tdsaDeviceData_t            *oneDeviceData;
8037   tdssSMPRequestBody_t        *tdSMPRequestBody;
8038   agsaSASRequestBody_t        *agSASRequestBody;
8039   agsaIORequest_t             *agIORequest;
8040   agsaDevHandle_t             *agDevHandle;
8041   tdsaDiscovery_t             *discovery;
8042   bit32                       status = AGSA_RC_FAILURE;
8043
8044   TI_DBG1(("tdsaSMPBusyTimerCB: start\n"));
8045
8046   onePortContext = (tdsaPortContext_t *)timerData1;
8047   oneDeviceData = (tdsaDeviceData_t *)timerData2;
8048   tdSMPRequestBody = (tdssSMPRequestBody_t *)timerData3;
8049   agRoot = oneDeviceData->agRoot;
8050   agIORequest = &(tdSMPRequestBody->agIORequest);
8051   agDevHandle = oneDeviceData->agDevHandle;
8052   agSASRequestBody = &(tdSMPRequestBody->agSASRequestBody);
8053   discovery = &(onePortContext->discovery);
8054
8055   discovery->SMPRetries++;
8056
8057   if (discovery->SMPRetries < SMP_BUSY_RETRIES)
8058   {
8059     status = saSMPStart(
8060                          agRoot,
8061                          agIORequest,
8062                          tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
8063                          agDevHandle,
8064                          AGSA_SMP_INIT_REQ,
8065                          agSASRequestBody,
8066                          &ossaSMPCompleted
8067                          );
8068   }
8069
8070   if (status == AGSA_RC_SUCCESS)
8071   {
8072     discovery->SMPRetries = 0;
8073     if (discovery->SMPBusyTimer.timerRunning == agTRUE)
8074     {
8075       tdsaKillTimer(
8076                     tiRoot,
8077                     &discovery->SMPBusyTimer
8078                    );
8079     }
8080   }
8081   else if (status == AGSA_RC_FAILURE)
8082   {
8083     discovery->SMPRetries = 0;
8084     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
8085     if (discovery->SMPBusyTimer.timerRunning == agTRUE)
8086     {
8087       tdsaKillTimer(
8088                     tiRoot,
8089                     &discovery->SMPBusyTimer
8090                    );
8091     }
8092   }
8093   else /* AGSA_RC_BUSY */
8094   {
8095     if (discovery->SMPRetries >= SMP_BUSY_RETRIES)
8096     {
8097       /* done with retris; give up */
8098       TI_DBG1(("tdsaSMPBusyTimerCB: retries are over\n"));
8099       discovery->SMPRetries = 0;
8100       tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
8101       if (discovery->SMPBusyTimer.timerRunning == agTRUE)
8102       {
8103         tdsaKillTimer(
8104                       tiRoot,
8105                       &discovery->SMPBusyTimer
8106                      );
8107       }
8108     }
8109     else
8110     {
8111       /* keep retrying */
8112       tdsaSMPBusyTimer(tiRoot, onePortContext, oneDeviceData, tdSMPRequestBody);
8113     }
8114   }
8115
8116   return;
8117 }
8118
8119 /*****************************************************************************
8120 *! \brief  tdsaBCTimer
8121 *
8122 *  Purpose:  This function sets timers for sending ID device data only for
8123 *            directly attached SATA device.
8124 *
8125 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8126 *                   instance.
8127 *  \param   onePortContext: Pointer to the portal context instance.
8128 *  \param   oneDeviceData: Pointer to the device data.
8129 *  \param   tdSMPRequestBody: Pointer to the SMP request body.
8130 *
8131 *  \return:
8132 *           None
8133 *
8134 *   \note:
8135 *
8136 *****************************************************************************/
8137 osGLOBAL void
8138 tdsaBCTimer(tiRoot_t                 *tiRoot,
8139             tdsaPortContext_t        *onePortContext
8140            )
8141 {
8142   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
8143   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8144   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
8145   tdsaDiscovery_t             *discovery;
8146
8147
8148   TI_DBG1(("tdsaBCTimer: start\n"));
8149
8150   discovery = &(onePortContext->discovery);
8151
8152   if (discovery->BCTimer.timerRunning == agTRUE)
8153   {
8154     tdsaKillTimer(
8155               tiRoot,
8156               &discovery->BCTimer
8157               );
8158   }
8159
8160   if (onePortContext->valid == agTRUE)
8161   {
8162     tdsaSetTimerRequest(
8163                         tiRoot,
8164                         &discovery->BCTimer,
8165                         BC_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
8166                         tdsaBCTimerCB,
8167                         onePortContext,
8168                         agNULL,
8169                         agNULL
8170                         );
8171
8172     tdsaAddTimer(
8173                  tiRoot,
8174                  &Initiator->timerlist,
8175                  &discovery->BCTimer
8176                 );
8177
8178   }
8179
8180   return;
8181 }
8182
8183 /*****************************************************************************
8184 *! \brief  tdsaBCTimerCB
8185 *
8186 *  Purpose:  This function is callback function for SATA ID device data.
8187 *
8188 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8189 *                   instance.
8190 *  \param   timerData1: Pointer to timer-related data structure
8191 *  \param   timerData2: Pointer to timer-related data structure
8192 *  \param   timerData3: Pointer to timer-related data structure
8193 *
8194 *  \return:
8195 *           None
8196 *
8197 *   \note:
8198 *
8199 *****************************************************************************/
8200 osGLOBAL void
8201 tdsaBCTimerCB(
8202               tiRoot_t    * tiRoot,
8203               void        * timerData1,
8204               void        * timerData2,
8205               void        * timerData3
8206               )
8207 {
8208   tdsaPortContext_t           *onePortContext;
8209   tdsaDiscovery_t             *discovery;
8210
8211   TI_DBG1(("tdsaBCTimerCB: start\n"));
8212
8213   onePortContext = (tdsaPortContext_t *)timerData1;
8214   discovery = &(onePortContext->discovery);
8215
8216   discovery->ResetTriggerred = agFALSE;
8217
8218   if (onePortContext->valid == agTRUE)
8219   {
8220     tdsaDiscover(
8221                  tiRoot,
8222                  onePortContext,
8223                  TDSA_DISCOVERY_TYPE_SAS,
8224                  TDSA_DISCOVERY_OPTION_INCREMENTAL_START
8225                 );
8226   }
8227   if (discovery->BCTimer.timerRunning == agTRUE)
8228   {
8229     tdsaKillTimer(
8230               tiRoot,
8231               &discovery->BCTimer
8232               );
8233   }
8234
8235   return;
8236 }
8237
8238 /*****************************************************************************
8239 *! \brief  tdsaDiscoverySMPTimer
8240 *
8241 *  Purpose:  This function sets timers for sending discovery-related SMP
8242 *
8243 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8244 *                   instance.
8245 *  \param   onePortContext: Pointer to the portal context instance.
8246 *  \param   functionCode: SMP function.
8247 *  \param   tdSMPRequestBody: Pointer to the SMP request body.
8248 *
8249 *  \return:
8250 *           None
8251 *
8252 *   \note:
8253 *
8254 *****************************************************************************/
8255 osGLOBAL void
8256 tdsaDiscoverySMPTimer(tiRoot_t                 *tiRoot,
8257                       tdsaPortContext_t        *onePortContext,
8258                       bit32                    functionCode, /* smp function code */
8259                       tdssSMPRequestBody_t     *tdSMPRequestBody
8260                      )
8261 {
8262   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
8263   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8264   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
8265   tdsaDiscovery_t             *discovery;
8266
8267   TI_DBG3(("tdsaDiscoverySMPTimer: start\n"));
8268   TI_DBG3(("tdsaDiscoverySMPTimer: pid %d SMPFn 0x%x\n", onePortContext->id, functionCode));
8269
8270   /* start the SMP timer which works as SMP application timer */
8271   discovery = &(onePortContext->discovery);
8272
8273   if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
8274   {
8275     tdsaKillTimer(
8276               tiRoot,
8277               &discovery->DiscoverySMPTimer
8278               );
8279   }
8280   tdsaSetTimerRequest(
8281                     tiRoot,
8282                     &discovery->DiscoverySMPTimer,
8283                     SMP_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
8284                     tdsaDiscoverySMPTimerCB,
8285                     onePortContext,
8286                     tdSMPRequestBody,
8287                     agNULL
8288                    );
8289
8290   tdsaAddTimer (
8291               tiRoot,
8292               &Initiator->timerlist,
8293               &discovery->DiscoverySMPTimer
8294               );
8295
8296   return;
8297 }
8298
8299 /*****************************************************************************
8300 *! \brief  tdsaDiscoverySMPTimerCB
8301 *
8302 *  Purpose:  This function is callback function for tdsaDiscoverySMPTimer.
8303 *
8304 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8305 *                   instance.
8306 *  \param   timerData1: Pointer to timer-related data structure
8307 *  \param   timerData2: Pointer to timer-related data structure
8308 *  \param   timerData3: Pointer to timer-related data structure
8309 *
8310 *  \return:
8311 *           None
8312 *
8313 *   \note:
8314 *
8315 *****************************************************************************/
8316 osGLOBAL void
8317 tdsaDiscoverySMPTimerCB(
8318                         tiRoot_t    * tiRoot,
8319                         void        * timerData1,
8320                         void        * timerData2,
8321                         void        * timerData3
8322                        )
8323 {
8324   agsaRoot_t                  *agRoot;
8325   tdsaPortContext_t           *onePortContext;
8326   bit8                        SMPFunction;
8327 #ifndef DIRECT_SMP
8328   tdssSMPFrameHeader_t        *tdSMPFrameHeader;
8329   bit8                        smpHeader[4];
8330 #endif
8331   tdssSMPRequestBody_t        *tdSMPRequestBody;
8332   tdsaDiscovery_t             *discovery;
8333   tdsaDeviceData_t            *oneDeviceData;
8334   agsaIORequest_t             *agAbortIORequest = agNULL;
8335   tdIORequestBody_t           *tdAbortIORequestBody = agNULL;
8336   bit32                       PhysUpper32;
8337   bit32                       PhysLower32;
8338   bit32                       memAllocStatus;
8339   void                        *osMemHandle;
8340   agsaIORequest_t             *agToBeAbortIORequest = agNULL;
8341
8342   TI_DBG1(("tdsaDiscoverySMPTimerCB: start\n"));
8343
8344   /* no retry
8345      if discovery related SMP, fail the discovery
8346      else ....
8347      be sure to abort SMP
8348   */
8349   onePortContext = (tdsaPortContext_t *)timerData1;
8350   tdSMPRequestBody = (tdssSMPRequestBody_t *)timerData2;
8351
8352   discovery = &(onePortContext->discovery);
8353   oneDeviceData = tdSMPRequestBody->tdDevice;
8354   agToBeAbortIORequest = &(tdSMPRequestBody->agIORequest);
8355   agRoot = oneDeviceData->agRoot;
8356
8357 #ifdef DIRECT_SMP
8358   SMPFunction = tdSMPRequestBody->smpPayload[1];
8359 #else
8360   saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 0, smpHeader, 4);
8361   tdSMPFrameHeader = (tdssSMPFrameHeader_t *)smpHeader;
8362   SMPFunction = tdSMPFrameHeader->smpFunction;
8363 #endif
8364
8365   TI_DBG1(("tdsaDiscoverySMPTimerCB: SMP function 0x%x\n", SMPFunction));
8366
8367   if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
8368   {
8369     tdsaKillTimer(
8370                   tiRoot,
8371                   &discovery->DiscoverySMPTimer
8372                  );
8373   }
8374   switch (SMPFunction)
8375   {
8376   case SMP_REPORT_GENERAL: /* fall through */
8377   case SMP_DISCOVER:  /* fall through */
8378   case SMP_CONFIGURE_ROUTING_INFORMATION:  /* fall through */
8379     TI_DBG1(("tdsaDiscoverySMPTimerCB: failing discovery, SMP function 0x%x\n", SMPFunction));
8380     tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
8381     return;
8382   case SMP_REPORT_PHY_SATA:
8383     TI_DBG1(("tdsaDiscoverySMPTimerCB: failing discovery, SMP function SMP_REPORT_PHY_SATA\n"));
8384     tdsaSATADiscoverDone(tiRoot, onePortContext, tiError);
8385     break;
8386   default:
8387     /* do nothing */
8388     TI_DBG1(("tdsaDiscoverySMPTimerCB: Error!!!! not allowed case\n"));
8389     break;
8390   }
8391
8392   if (onePortContext->discovery.SeenBC == agTRUE)
8393   {
8394     /* allocating agIORequest for abort itself */
8395     memAllocStatus = ostiAllocMemory(
8396                                      tiRoot,
8397                                      &osMemHandle,
8398                                      (void **)&tdAbortIORequestBody,
8399                                      &PhysUpper32,
8400                                      &PhysLower32,
8401                                      8,
8402                                      sizeof(tdIORequestBody_t),
8403                                      agTRUE
8404                                      );
8405     if (memAllocStatus != tiSuccess)
8406     {
8407       /* let os process IO */
8408       TI_DBG1(("tdsaDiscoverySMPTimerCB: ostiAllocMemory failed...\n"));
8409       return;
8410     }
8411
8412     if (tdAbortIORequestBody == agNULL)
8413     {
8414       /* let os process IO */
8415       TI_DBG1(("tdsaDiscoverySMPTimerCB: ostiAllocMemory returned NULL tdAbortIORequestBody\n"));
8416       return;
8417     }
8418
8419     /* setup task management structure */
8420     tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
8421     /* setting callback */
8422     tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;
8423
8424     tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle);
8425
8426     /* initialize agIORequest */
8427     agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
8428     agAbortIORequest->osData = (void *) tdAbortIORequestBody;
8429     agAbortIORequest->sdkData = agNULL; /* LL takes care of this */
8430
8431     /* SMPAbort - abort one */
8432     saSMPAbort(agRoot,
8433                agAbortIORequest,
8434                0,
8435                oneDeviceData->agDevHandle,
8436                0, /* abort one */
8437                agToBeAbortIORequest,
8438                agNULL
8439                );
8440
8441   }
8442   return;
8443 }
8444
8445
8446 /*****************************************************************************
8447 *! \brief  tdsaSATAIDDeviceTimer
8448 *
8449 *  Purpose:  This function sets timers for sending ID device data only for
8450 *            directly attached SATA device.
8451 *
8452 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8453 *                   instance.
8454 *  \param   onePortContext: Pointer to the portal context instance.
8455 *  \param   oneDeviceData: Pointer to the device data.
8456 *  \param   tdSMPRequestBody: Pointer to the SMP request body.
8457 *
8458 *  \return:
8459 *           None
8460 *
8461 *   \note:
8462 *
8463 *****************************************************************************/
8464 osGLOBAL void
8465 tdsaSATAIDDeviceTimer(tiRoot_t                 *tiRoot,
8466                       tdsaDeviceData_t         *oneDeviceData
8467                      )
8468 {
8469   tdsaRoot_t                  *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
8470   tdsaContext_t               *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8471   itdsaIni_t                  *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
8472
8473   TI_DBG1(("tdsaSATAIDDeviceTimer: start\n"));
8474
8475   if (oneDeviceData->SATAIDDeviceTimer.timerRunning == agTRUE)
8476   {
8477     tdsaKillTimer(
8478               tiRoot,
8479               &oneDeviceData->SATAIDDeviceTimer
8480               );
8481   }
8482
8483   tdsaSetTimerRequest(
8484                     tiRoot,
8485                     &oneDeviceData->SATAIDDeviceTimer,
8486                     SATA_ID_DEVICE_DATA_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
8487                     tdsaSATAIDDeviceTimerCB,
8488                     oneDeviceData,
8489                     agNULL,
8490                     agNULL
8491                    );
8492
8493   tdsaAddTimer (
8494               tiRoot,
8495               &Initiator->timerlist,
8496               &oneDeviceData->SATAIDDeviceTimer
8497               );
8498
8499   return;
8500 }
8501
8502 /*****************************************************************************
8503 *! \brief  tdsaSATAIDDeviceTimerCB
8504 *
8505 *  Purpose:  This function is callback function for SATA ID device data.
8506 *
8507 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
8508 *                   instance.
8509 *  \param   timerData1: Pointer to timer-related data structure
8510 *  \param   timerData2: Pointer to timer-related data structure
8511 *  \param   timerData3: Pointer to timer-related data structure
8512 *
8513 *  \return:
8514 *           None
8515 *
8516 *   \note:
8517 *
8518 *****************************************************************************/
8519 osGLOBAL void
8520 tdsaSATAIDDeviceTimerCB(
8521                        tiRoot_t    * tiRoot,
8522                        void        * timerData1,
8523                        void        * timerData2,
8524                        void        * timerData3
8525                        )
8526 {
8527   tdsaDeviceData_t            *oneDeviceData;
8528
8529   TI_DBG1(("tdsaSATAIDDeviceTimerCB: start\n"));
8530
8531   oneDeviceData = (tdsaDeviceData_t *)timerData1;
8532
8533   /* send identify device data */
8534   tdssSubAddSATAToSharedcontext(tiRoot, oneDeviceData);
8535
8536   if (oneDeviceData->SATAIDDeviceTimer.timerRunning == agTRUE)
8537   {
8538     tdsaKillTimer(
8539               tiRoot,
8540               &oneDeviceData->SATAIDDeviceTimer
8541               );
8542   }
8543
8544   return;
8545 }
8546
8547 #endif /* TD_DISCOVER */