sys/dev/pms/RefTisa/tisa/sassata/common/tdinit.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 /*******************************************************************************/
  24 /** \file
  25  *
  26  * This file contains the SAS/SATA TD layer initialization functions
  27  *
  28  */
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31 #include <dev/pms/config.h>
  32
  33 #include <dev/pms/freebsd/driver/common/osenv.h>
  34 #include <dev/pms/freebsd/driver/common/ostypes.h>
  35 #include <dev/pms/freebsd/driver/common/osdebug.h>
  36
  37 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
  38 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
  39 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
  40
  41 #include <dev/pms/RefTisa/tisa/api/titypes.h>
  42 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
  43 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
  44 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
  45
  46 #ifdef FDS_SM
  47 #include <dev/pms/RefTisa/sat/api/sm.h>
  48 #include <dev/pms/RefTisa/sat/api/smapi.h>
  49 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
  50 #endif
  51
  52 #ifdef FDS_DM
  53 #include <dev/pms/RefTisa/discovery/api/dm.h>
  54 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
  55 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
  56 #endif
  57
  58 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
  59 #include <dev/pms/freebsd/driver/common/osstring.h>
  60 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
  61
  62 #ifdef INITIATOR_DRIVER
  63 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
  64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
  65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
  66 #endif
  67
  68 #ifdef TARGET_DRIVER
  69 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
  70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
  71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
  72 #endif
  73
  74 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
  75 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
  76
  77 LOCAL bit32 tdsaGetCardID(tiRoot_t * tiRoot);
  78
  79
  80 bit32 tdCardIDList[TD_MAX_CARD_NUM] = {
  81   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  82   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  83   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  84   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  85   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  86   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  87   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  88   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  89   TD_CARD_ID_FREE , TD_CARD_ID_FREE ,
  90   TD_CARD_ID_FREE , TD_CARD_ID_FREE
  91 };
  92
  93 /*****************************************************************************
  94 *
  95 * tdsaGetCardID
  96 *
  97 *  Purpose:
  98 *
  99 *  Parameters:
 100 *
 101 *    tiRoot:        Pointer to driver/port instance.
 102 *
 103 *  Return:
 104 *   tiSuccess : CardIDString was successfully read
 105 *   tiError   : CardIDString reading failed
 106 *
 107 *****************************************************************************/
 108 bit32 tdsaGetCardID(tiRoot_t * tiRoot)
 109 {
 110   bit32 i;
 111   bit32 RetVal = 0xFFFFFFFF;
 112
 113   for (i = 0 ; i < TD_MAX_CARD_NUM ; i++)
 114   {
 115     if (tdCardIDList[i] == TD_CARD_ID_FREE)
 116     {
 117       tdCardIDList[i] = TD_CARD_ID_ALLOC;
 118       RetVal = i;
 119       break;
 120     }
 121   }
 122
 123   return RetVal;
 124
 125 } /* tdsaGetCardID() */
 126
 127 /*****************************************************************************
 128 *
 129 * tdsaFreeCardID
 130 *
 131 *  Purpose:
 132 *
 133 *  Parameters:
 134 *
 135 *    tiRoot:        Pointer to driver/port instance.
 136 *
 137 *  Return:
 138 *   tiSuccess : CardIDString was successfully read
 139 *   tiError   : CardIDString reading failed
 140 *
 141 *****************************************************************************/
 142 osGLOBAL void
 143 tdsaFreeCardID(tiRoot_t *tiRoot, bit32 CardID)
 144 {
 145   OS_ASSERT(CardID < TD_MAX_CARD_NUM, "Invalid CardID\n");
 146
 147   tdCardIDList[CardID] = TD_CARD_ID_FREE;
 148
 149   return;
 150
 151 } /* tdFreeCardID() */
 152
 153 /*****************************************************************************
 154 *
 155 * tdsaGetCardIDString
 156 *
 157 *  Purpose:
 158 *
 159 *  Parameters:
 160 *
 161 *    tiRoot:        Pointer to driver/port instance.
 162 *
 163 *  Return:
 164 *   tiSuccess : CardIDString was successfully read
 165 *   tiError   : CardIDString reading failed
 166 *
 167 *****************************************************************************/
 168 bit32 tdsaGetCardIDString(tiRoot_t *tiRoot)
 169 {
 170   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
 171   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
 172   bit32          ret = tiError;
 173   bit32          thisCardID = tdsaGetCardID(tiRoot);
 174   char           CardNum[10];
 175
 176   TI_DBG3(("tdsaGetCardIDString: start\n"));
 177
 178   TI_DBG3(("tdsaGetCardIDString: thisCardID 0x%x\n", thisCardID));
 179
 180
 181   if (thisCardID == 0xFFFFFFFF)
 182   {
 183     TI_DBG1(("tdGetCardIDString: No more CardIDs available\n"));
 184     ret = tiError;
 185   }
 186   else
 187   {
 188     tdsaAllShared->CardID = thisCardID;
 189     osti_sprintf(CardNum,"CardNum%d", thisCardID);
 190     TI_DBG3(("tdsaGetCardIDString: CardNum is %s\n", CardNum));
 191     osti_strcpy(tdsaAllShared->CardIDString, CardNum);
 192     TI_DBG3(("tdsaGetCardIDString: tdsaAllShared->CardIDString is %s\n", tdsaAllShared->CardIDString));
 193     ret = tiSuccess;
 194
 195   }
 196   return ret;
 197 }
 198 /*****************************************************************************
 199 *! \brief tiCOMGetResource
 200 *
 201 *  Purpose:  This function is called to determine the Transport
 202 *            Dependent Layer internal resource requirement.
 203 *            This function will internally call the initiator specific,
 204 *            target specific and shared TD resource requirement calls.
 205 *
 206 * \param   tiRoot:             Pointer to driver/port instance.
 207 * \param   loResource:         Pointer to low level TSDK resource requirement.
 208 * \param   initiatorResource:  Pointer to initiator functionality memory and
 209 *                              option requirement.
 210 * \param  targetResource:      Pointer to target functionality memory and
 211 *                              option requirement.
 212 * \param  tdSharedMem:         Pointer to cached memory required by the
 213 *                              target/initiator shared functionality.
 214 *
 215 *  \return None
 216 *
 217 *  \note - This function only return the memory requirement in the tiMem_t
 218 *          structure in loResource, initiatorResource, targetResource
 219 *          and tdSharedMem. It does not allocate memory, so the address
 220 *          fields in tiMem_t are not used.
 221 *
 222 *****************************************************************************/
 223 osGLOBAL void
 224 tiCOMGetResource(
 225                  tiRoot_t              *tiRoot,
 226                  tiLoLevelResource_t   *loResource,
 227                  tiInitiatorResource_t *initiatorResource,
 228                  tiTargetResource_t    *targetResource,
 229                  tiTdSharedMem_t       *tdSharedMem
 230                  )
 231 {
 232   TI_DBG6(("tiCOMGetResource start\n"));
 233   TI_DBG6(("tiCOMGetResource: loResource %p\n", loResource));
 234
 235   if(loResource != agNULL)
 236   {
 237     tdsaLoLevelGetResource(tiRoot, loResource);
 238   }
 239   if(tdSharedMem != agNULL)
 240   {
 241     tdsaSharedMemCalculate(tiRoot, loResource, tdSharedMem);
 242   }
 243
 244 #ifdef INITIATOR_DRIVER
 245   /* initiator */
 246   if(initiatorResource != agNULL)
 247   {
 248     itdssGetResource(tiRoot, initiatorResource);
 249     /*
 250      * for the time being set the initiator usecsPerTick
 251      * same as lolevel usecsPerTick
 252      */
 253     if (loResource == agNULL)
 254     {
 255       TI_DBG1(("tiCOMGetResource: loResource is NULL, wrong\n"));
 256       return;
 257     }
 258   }
 259 #endif
 260
 261 #ifdef TARGET_DRIVER
 262   /* target */
 263   if(targetResource != agNULL)
 264   {
 265     ttdssGetResource(tiRoot, targetResource);
 266   }
 267 #endif
 268
 269   return;
 270 }
 271
 272
 273 /*****************************************************************************
 274 *! \brief tiCOMInit
 275 *
 276 *  Purpose:  This function is called to initialize Transport Dependent Layer.
 277 *            This function will internally call the initiator specific,
 278 *            target specific and shared TD initialization calls.
 279 *
 280 *  \param  tiRoot:             Pointer to target driver/port instance.
 281 *  \param  loResource:         Pointer to low level TSDK resource requirement.
 282 *  \param  initiatorResource:  Pointer to initiator functionality memory and
 283 *                              option requirement.
 284 *  \param  targetResource:     Pointer to target functionality memory and
 285 *                              option requirement.
 286 *  \param  tdSharedMem:        Pointer to cached memory required by the
 287 *                              target/initiator shared functionality.
 288 *
 289 *  \return: tiSuccess  - if successful
 290 *           tiError    - if failed
 291 *
 292 *****************************************************************************/
 293 osGLOBAL bit32
 294 tiCOMInit(
 295            tiRoot_t              *tiRoot,
 296            tiLoLevelResource_t   *loResource,
 297            tiInitiatorResource_t *initiatorResource,
 298            tiTargetResource_t    *targetResource,
 299            tiTdSharedMem_t       *tdSharedMem )
 300 {
 301   tdsaRoot_t         *tdsaRoot;
 302   tdsaPortContext_t  *tdsaPortContext;
 303   tdsaDeviceData_t   *tdsaDeviceData;
 304
 305 #ifdef TD_INT_COALESCE
 306   tdsaIntCoalesceContext_t *tdsaIntCoalCxt;
 307 #endif
 308
 309 #ifdef TD_DISCOVER
 310   tdsaExpander_t     *tdsaExpander;
 311 #endif
 312
 313   bit32         status = tiSuccess;
 314   void          *IniAddr = agNULL;
 315   void          *TgtAddr = agNULL;
 316   tdsaContext_t *tdsaAllShared;
 317 #if defined(TD_INT_COALESCE) || defined(TD_DISCOVER) || defined(TD_INTERNAL_DEBUG)
 318   bit32         MaxTargets;
 319 #endif
 320 #ifdef TD_INTERNAL_DEBUG  /* for debugging only */
 321   tdsaEsglAllInfo_t  *pEsglAllInfo;
 322   tdList_t           *tdlist_to_fill;
 323   tdsaEsglPageInfo_t *page_to_fill;
 324 #endif
 325   bit32          i;
 326 #ifdef FDS_DM
 327   dmSwConfig_t                   dmSwConfig;
 328   static dmMemoryRequirement_t   dmMemRequirement;
 329   bit32                          dmUsecsPerTick = 0;
 330   bit32                          dmMaxNumLocks = 0;
 331 #endif
 332  #ifdef FDS_SM
 333   smSwConfig_t                   smSwConfig;
 334   static smMemoryRequirement_t   smMemRequirement;
 335   bit32                          smUsecsPerTick = 0;
 336   bit32                          smMaxNumLocks = 0;
 337 #endif
 338
 339
 340   /* for memory analysis */
 341   TI_DBG6(("ticominit: tdsaroot\n"));
 342   TI_DBG6(("ticominit: tdsaRoot_t %d\n", (int)sizeof(tdsaRoot_t)));
 343   TI_DBG6(("ticominit: tdsaEsglAllInfo_t %d\n", (int)sizeof(tdsaEsglAllInfo_t)));
 344   TI_DBG6(("ticominit: portcontext\n"));
 345   TI_DBG6(("ticominit: tdsaPortContext_t %d\n", (int)sizeof(tdsaPortContext_t)));
 346   TI_DBG6(("ticominit: device data\n"));
 347   TI_DBG6(("ticominit: tdsaDeviceData_t  %d\n", (int)sizeof(tdsaDeviceData_t)));
 348   TI_DBG6(("ticominit: agsaSASDeviceInfo_t  %d\n", (int)sizeof(agsaSASDeviceInfo_t)));
 349   TI_DBG6(("ticominit: satDeviceData_t  %d\n", (int)sizeof(satDeviceData_t)));
 350   TI_DBG6(("ticominit: agsaSATAIdentifyData_t  %d\n", (int)sizeof(agsaSATAIdentifyData_t)));
 351
 352   TI_DBG6(("ticominit: IO request body\n"));
 353   TI_DBG6(("ticominit: tdIORequestBody_t %d\n", (int)sizeof(tdIORequestBody_t)));
 354   TI_DBG6(("ticominit: tdssIOCompleted_t %d\n", (int)sizeof(tdssIOCompleted_t)));
 355   TI_DBG6(("ticominit: agsaIORequest_t %d\n", (int)sizeof(agsaIORequest_t)));
 356
 357   TI_DBG6(("ticominit: FOR SAS\n"));
 358   TI_DBG6(("ticominit: agsaSASRequestBody_t %d\n", (int)sizeof(agsaSASRequestBody_t)));
 359   TI_DBG6(("ticominit: FOR SATA\n"));
 360   TI_DBG6(("ticominit: agsaSATAInitiatorRequest_t %d\n", (int)sizeof(agsaSATAInitiatorRequest_t)));
 361   TI_DBG6(("ticominit: scsiRspSense_t %d\n", (int)sizeof(scsiRspSense_t)));
 362   TI_DBG6(("ticominit: tiSenseData_t %d\n", (int)sizeof(tiSenseData_t)));
 363   TI_DBG6(("ticominit: satIOContext_t %d\n", (int)sizeof(satIOContext_t)));
 364   TI_DBG6(("ticominit: satInternalIo_t %d\n", (int)sizeof(satInternalIo_t)));
 365
 366
 367   /*************************************************************************
 368   * TD SHARED AREA
 369   *************************************************************************/
 370
 371   TI_DBG6(("ticominit: start\n"));
 372
 373
 374 #if defined(TD_INT_COALESCE) && defined(TD_DISCOVER)
 375
 376   /* Let's start from the tdsaRoot */
 377   tdsaRoot = tdSharedMem->tdSharedCachedMem1.virtPtr;
 378   tdsaPortContext = (tdsaPortContext_t *)((bitptr)tdSharedMem->tdSharedCachedMem1.virtPtr + sizeof(tdsaRoot_t));
 379   tdsaDeviceData = (tdsaDeviceData_t *)((bitptr)tdsaPortContext + (sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT));
 380
 381   /* the following fn fills in MaxTargets */
 382   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
 383   TI_DBG6(("tiCOMInit: MaxTargets %d\n", MaxTargets));
 384
 385   tdsaIntCoalCxt   =
 386     (tdsaIntCoalesceContext_t *)((bitptr)tdsaDeviceData
 387                                  + (sizeof(tdsaDeviceData_t) * MaxTargets));
 388
 389   tdsaExpander  =
 390     (tdsaExpander_t *)((bitptr)tdsaIntCoalCxt
 391                        + (sizeof(tdsaIntCoalesceContext_t) * TD_MAX_INT_COALESCE));
 392
 393
 394 #elif defined(TD_INT_COALESCE)
 395
 396
 397
 398   /* Let's start from the tdsaRoot */
 399   tdsaRoot = tdSharedMem->tdSharedCachedMem1.virtPtr;
 400   tdsaPortContext = (tdsaPortContext_t *)((bitptr)tdSharedMem->tdSharedCachedMem1.virtPtr + sizeof(tdsaRoot_t));
 401   tdsaDeviceData = (tdsaDeviceData_t *)((bitptr)tdsaPortContext + (sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT));
 402
 403   /* the following fn fills in MaxTargets */
 404   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
 405   TI_DBG6(("tiCOMInit: MaxTargets %d\n", MaxTargets));
 406
 407   tdsaIntCoalCxt   =
 408     (tdsaIntCoalesceContext_t *)((bitptr)tdsaDeviceData
 409                                  + (sizeof(tdsaDeviceData_t) * MaxTargets));
 410
 411
 412 #elif defined(TD_DISCOVER)
 413
 414
 415   /* Let's start from the tdsaRoot */
 416   tdsaRoot = tdSharedMem->tdSharedCachedMem1.virtPtr;
 417   tdsaPortContext = (tdsaPortContext_t *)((bitptr)tdSharedMem->tdSharedCachedMem1.virtPtr + sizeof(tdsaRoot_t));
 418   tdsaDeviceData = (tdsaDeviceData_t *)((bitptr)tdsaPortContext + (sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT));
 419
 420   /* the following fn fills in MaxTargets */
 421   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
 422   TI_DBG6(("tiCOMInit: MaxTargets %d\n", MaxTargets));
 423
 424   tdsaExpander  =
 425     (tdsaExpander_t *)((bitptr)tdsaDeviceData
 426                       + (sizeof(tdsaDeviceData_t) * MaxTargets));
 427
 428
 429
 430 #else
 431
 432   /* Let's start from the tdsaRoot */
 433   tdsaRoot = tdSharedMem->tdSharedCachedMem1.virtPtr;
 434   tdsaPortContext = (tdsaPortContext_t *)((bitptr)tdSharedMem->tdSharedCachedMem1.virtPtr + sizeof(tdsaRoot_t));
 435   tdsaDeviceData = (tdsaDeviceData_t *)((bitptr)tdsaPortContext + (sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT));
 436
 437 #endif
 438
 439   TI_DBG6(("tiCOMInit: ******* tdsaRoot %p tdsaPortContext %p tdsaDeviceData %p\n", tdsaRoot, tdsaPortContext, tdsaDeviceData));
 440
 441
 442   tiRoot->tdData    = tdsaRoot;
 443   tdsaAllShared = &(tdsaRoot->tdsaAllShared);
 444
 445
 446 #ifdef INITIATOR_DRIVER
 447   /**< Initialize initiator; itdssIni_t itself */
 448   if(initiatorResource)
 449   {
 450     IniAddr = initiatorResource->initiatorMem.tdCachedMem[0].virtPtr;
 451     tdsaRoot->itdsaIni = IniAddr;
 452     tdsaRoot->itdsaIni->tdsaAllShared = tdsaAllShared;
 453     tdsaAllShared->itdsaIni = tdsaRoot->itdsaIni;
 454   }
 455 #endif
 456
 457 #ifdef TARGET_DRIVER
 458   /**< Initialize target; ttdssTgt_t itself */
 459   if(targetResource)
 460   {
 461     TgtAddr = targetResource->targetMem.tdMem[0].virtPtr;
 462     tdsaRoot->ttdsaTgt = TgtAddr;
 463     tdsaRoot->ttdsaTgt->tdsaAllShared = tdsaAllShared;
 464     tdsaAllShared->ttdsaTgt = tdsaRoot->ttdsaTgt;
 465   }
 466 #endif /* target driver */
 467
 468   TI_DBG5(("tiCOMInit: IniAddr %p TgtAddr %p\n", IniAddr, TgtAddr));
 469
 470   TI_DBG3(("tiCOMInit: tdsaRoot %p tdsaAllShared %p \n",tdsaRoot, tdsaAllShared));
 471
 472   /**<  Initialize the OS data part of the interrupt context agRoot */
 473   tdsaAllShared->agRootOsDataForInt.tiRoot     = tiRoot;
 474   tdsaAllShared->agRootOsDataForInt.tdsaAllShared   = (void *) tdsaAllShared;
 475   tdsaAllShared->agRootOsDataForInt.itdsaIni      = (void *) IniAddr;
 476   tdsaAllShared->agRootOsDataForInt.ttdsaTgt      = (void *) TgtAddr;
 477   /* for sata */
 478   tdsaAllShared->agRootOsDataForInt.tdstHost = agNULL;
 479   tdsaAllShared->agRootOsDataForInt.tdstDevice = agNULL;
 480
 481   /* tiInterruptContext is an enum value */
 482   tdsaAllShared->agRootOsDataForInt.IntContext = tiInterruptContext;
 483   /* queueId or lockid in TD layer; LL maxlock + 1 since TD uses only one lock */
 484
 485   /* agsaRoot_t */
 486   tdsaAllShared->agRootInt.osData              =
 487     (void *) &(tdsaAllShared->agRootOsDataForInt);
 488   tdsaAllShared->agRootInt.sdkData              = agNULL;
 489
 490   /**< Initialize the OS data part of the non-interrupt context agRoot */
 491   tdsaAllShared->agRootOsDataForNonInt.tiRoot     = tiRoot;
 492   tdsaAllShared->agRootOsDataForNonInt.tdsaAllShared   = (void *) tdsaAllShared;
 493   tdsaAllShared->agRootOsDataForNonInt.itdsaIni      = (void *) IniAddr;
 494   tdsaAllShared->agRootOsDataForNonInt.ttdsaTgt      = (void *) TgtAddr;
 495   /* for sata */
 496   tdsaAllShared->agRootOsDataForNonInt.tdstHost = agNULL;
 497   tdsaAllShared->agRootOsDataForNonInt.tdstDevice = agNULL;
 498
 499   tdsaAllShared->agRootOsDataForNonInt.IntContext = tiNonInterruptContext;
 500   /* queueId or lockid in TD layer; LL maxlock + 1 since TD uses only one lock */
 501
 502   /* agsaRoot_t */
 503   tdsaAllShared->agRootNonInt.osData              =
 504     (void *) &(tdsaAllShared->agRootOsDataForNonInt);
 505   tdsaAllShared->agRootNonInt.sdkData              = agNULL;
 506
 507   tdsaAllShared->loResource = *loResource;
 508
 509   tdsaAllShared->PortContextMem = tdsaPortContext;
 510   tdsaAllShared->DeviceMem = tdsaDeviceData;
 511
 512   tdsaAllShared->IBQnumber = 0;
 513   tdsaAllShared->OBQnumber = 0;
 514
 515 #ifdef TD_INT_COALESCE
 516   tdsaAllShared->IntCoalesce = tdsaIntCoalCxt;
 517 #endif
 518
 519 #ifdef TD_DISCOVER
 520   tdsaAllShared->ExpanderHead = tdsaExpander;
 521 #endif
 522
 523   tdsaAllShared->MaxNumLocks = loResource->loLevelOption.numOfQueuesPerPort;
 524
 525   tdsaAllShared->MaxNumOSLocks = loResource->loLevelOption.maxNumOSLocks;
 526
 527 #if defined(FDS_DM) && defined(FDS_SM)
 528   dmGetRequirements(agNULL,
 529                     &dmSwConfig,
 530                     &dmMemRequirement,
 531                     &dmUsecsPerTick,
 532                     &dmMaxNumLocks
 533                     );
 534
 535   tdsaAllShared->MaxNumDMLocks = dmMaxNumLocks;
 536   TI_DBG2(("tiCOMInit: DM MaxNumDMLocks 0x%x\n", tdsaAllShared->MaxNumDMLocks));
 537
 538   smGetRequirements(agNULL,
 539                     &smSwConfig,
 540                     &smMemRequirement,
 541                     &smUsecsPerTick,
 542                     &smMaxNumLocks
 543                     );
 544
 545   tdsaAllShared->MaxNumSMLocks = smMaxNumLocks;
 546   TI_DBG2(("tiCOMInit: SM MaxNumSMLocks 0x%x\n", tdsaAllShared->MaxNumSMLocks));
 547
 548   tdsaAllShared->MaxNumLLLocks = tdsaAllShared->MaxNumLocks - TD_MAX_LOCKS - tdsaAllShared->MaxNumDMLocks - tdsaAllShared->MaxNumSMLocks;
 549   TI_DBG2(("tiCOMInit: LL MaxNumLLLocks 0x%x\n", tdsaAllShared->MaxNumLLLocks));
 550
 551 #elif defined(FDS_DM)
 552   dmGetRequirements(agNULL,
 553                     &dmSwConfig,
 554                     &dmMemRequirement,
 555                     &dmUsecsPerTick,
 556                     &dmMaxNumLocks
 557                     );
 558
 559   tdsaAllShared->MaxNumDMLocks = dmMaxNumLocks;
 560   TI_DBG2(("tiCOMInit: DM MaxNumDMLocks 0x%x\n", tdsaAllShared->MaxNumDMLocks));
 561
 562   tdsaAllShared->MaxNumLLLocks = tdsaAllShared->MaxNumLocks - TD_MAX_LOCKS - tdsaAllShared->MaxNumDMLocks;
 563   TI_DBG2(("tiCOMInit: LL MaxNumLLLocks 0x%x\n", tdsaAllShared->MaxNumLLLocks));
 564 #elif defined(FDS_SM)
 565   smGetRequirements(agNULL,
 566                     &smSwConfig,
 567                     &smMemRequirement,
 568                     &smUsecsPerTick,
 569                     &smMaxNumLocks
 570                     );
 571
 572   tdsaAllShared->MaxNumSMLocks = smMaxNumLocks;
 573   TI_DBG2(("tiCOMInit: SM MaxNumSMLocks 0x%x\n", tdsaAllShared->MaxNumSMLocks));
 574
 575   tdsaAllShared->MaxNumLLLocks = tdsaAllShared->MaxNumLocks - TD_MAX_LOCKS - tdsaAllShared->MaxNumSMLocks;
 576   TI_DBG2(("tiCOMInit: LL MaxNumLLLocks 0x%x\n", tdsaAllShared->MaxNumLLLocks));
 577 #else
 578   tdsaAllShared->MaxNumLLLocks = tdsaAllShared->MaxNumLocks - TD_MAX_LOCKS;
 579   TI_DBG2(("tiCOMInit: LL MaxNumLLLocks 0x%x\n", tdsaAllShared->MaxNumLLLocks));
 580 #endif
 581
 582 #ifdef TBD
 583   tdsaAllShared->MaxNumLLLocks = loResource->loLevelOption.numOfQueuesPerPort - TD_MAX_LOCKS;
 584 #endif
 585
 586   tdsaAllShared->resetCount = 0;
 587
 588   /* used for saHwEventAck() and ossaDeregisterDeviceHandleCB() */
 589 //  tdsaAllShared->EventValid = agFALSE;
 590   for(i=0; i<TD_MAX_NUM_PHYS; i++)
 591   {
 592     tdsaAllShared->eventSource[i].EventValid =  agFALSE;
 593     tdsaAllShared->eventSource[i].Source.agPortContext =  agNULL;
 594     tdsaAllShared->eventSource[i].Source.event =  0;
 595     /* phy ID */
 596     tdsaAllShared->eventSource[i].Source.param =  0xFF;
 597   }
 598
 599
 600 #ifdef TD_INTERNAL_DEBUG  /* for debugging only */
 601   pEsglAllInfo = (tdsaEsglAllInfo_t *)&(tdsaAllShared->EsglAllInfo);
 602 #endif
 603
 604   /* initialize CardIDString */
 605   osti_strcpy(tdsaAllShared->CardIDString,"");
 606
 607
 608 #ifdef FDS_DM
 609   tdsaAllShared->dmRoot.tdData = tdsaRoot;
 610 #endif
 611
 612 #ifdef FDS_SM
 613   tdsaAllShared->smRoot.tdData = tdsaRoot;
 614 #endif
 615
 616   /* get card ID */
 617   if (tdsaGetCardIDString(tiRoot) == tiError)
 618   {
 619     TI_DBG1(("tdsaGetCardIDString() failed\n"));
 620     return tiError;
 621   }
 622
 623   /**< initializes jumptable */
 624   tdsaJumpTableInit(tiRoot);
 625
 626   /**< initializes tdsaPortStartInfo_s including flags */
 627   tdssInitSASPortStartInfo(tiRoot);
 628
 629   /* resets all the relevant flags */
 630   tdsaResetComMemFlags(tiRoot);
 631
 632   /**< initializes timers */
 633   tdsaInitTimers(tiRoot);
 634
 635   TI_DBG6(("ticominit: ******* before tdsaRoot %p tdsaPortContext %p tdsaDeviceData %p\n", tdsaRoot, tdsaPortContext, tdsaDeviceData));
 636
 637
 638   /**< initializes tdsaPortContext_t */
 639   tdsaPortContextInit(tiRoot);
 640
 641   /**< initializes devicelist in tdsaPortContext_t */
 642   tdsaDeviceDataInit(tiRoot);
 643
 644 #ifdef TD_INT_COALESCE
 645   tdsaIntCoalCxtInit(tiRoot);
 646 #endif
 647
 648 #ifdef TD_DISCOVER
 649   tdsaExpanderInit(tiRoot);
 650 #endif
 651
 652   tdsaQueueConfigInit(tiRoot);
 653
 654 #ifdef TD_INTERNAL_DEBUG /* for debugging only */
 655   TI_DBG6(("ticominit: temp 1\n"));
 656   TDLIST_DEQUEUE_FROM_HEAD(&tdlist_to_fill, &pEsglAllInfo->freelist);
 657   /* get the pointer to the page from list pointer */
 658   page_to_fill = TDLIST_OBJECT_BASE(tdsaEsglPageInfo_t, tdlist, tdlist_to_fill);
 659   TI_DBG6(("ticominit: pageinfo ID %d\n", page_to_fill->id));
 660   /* this does not work */
 661   TDLIST_ENQUEUE_AT_HEAD(tdlist_to_fill, &pEsglAllInfo->freelist);
 662
 663   TI_DBG6(("ticominit: devide\n"));
 664   TDLIST_DEQUEUE_FROM_HEAD(&tdlist_to_fill, &pEsglAllInfo->freelist);
 665   /* get the pointer to the page from list pointer */
 666   page_to_fill = TDLIST_OBJECT_BASE(tdsaEsglPageInfo_t, tdlist, tdlist_to_fill);
 667   TDINIT_PRINT("ticominit: second pageinfo ID %d\n", page_to_fill->id);
 668
 669   TDLIST_ENQUEUE_AT_HEAD(tdlist_to_fill, &pEsglAllInfo->freelist);
 670
 671 #endif
 672
 673
 674 #ifdef INITIATOR_DRIVER
 675   if(initiatorResource != agNULL)
 676   {
 677     tdsaAllShared->currentOperation |= TD_OPERATION_INITIATOR;
 678     TI_DBG5(("tiCOMInit: calling itdssInit\n"));
 679     status = itdssInit(tiRoot, initiatorResource, tdSharedMem);
 680
 681     if(status != tiSuccess)
 682     {
 683       TI_DBG1(("tiCOMInit: itdInit FAILED\n"));
 684       return status;
 685     }
 686   }
 687 #endif
 688
 689 #ifdef TARGET_DRIVER
 690   if(targetResource != agNULL)
 691   {
 692     tdsaAllShared->currentOperation |= TD_OPERATION_TARGET;
 693     TI_DBG5 (("tiCOMInit: calling ttdssInit\n"));
 694     status = ttdssInit(tiRoot, targetResource, tdSharedMem);
 695
 696     if(status != tiSuccess)
 697     {
 698       TI_DBG1(("tiCOMInit: ttdInit FAILED\n"));
 699       return status;
 700     }
 701   }
 702 #endif
 703
 704   return status;
 705 }
 706
 707 /*****************************************************************************
 708 *! \brief tdsaLoLevelGetResource
 709 *
 710 *  Purpose:  This function is called to determine the Transport
 711 *            Dependent Layer internal resource requirement used by the
 712 *            lower layer TSDK.
 713 *
 714 *  \param  tiRoot:             Pointer to driver/port instance.
 715 *  \param  loResource:         Pointer to low level TSDK resource requirement.
 716 *
 717 *  \return: None
 718 *
 719 *  \note -  currenlty mem[0] - mem[18] are being used
 720 *
 721 *****************************************************************************/
 722 /*
 723   this calls ostiGetTransportParam which parses the configuration file to get
 724   parameters.
 725 */
 726 osGLOBAL void
 727 tdsaLoLevelGetResource(
 728                        tiRoot_t              * tiRoot,
 729                        tiLoLevelResource_t   * loResource)
 730 {
 731   agsaRoot_t          agRoot;
 732   bit32               usecsPerTick = 0;
 733   agsaSwConfig_t      SwConfig;
 734   static agsaQueueConfig_t   QueueConfig;
 735   static agsaMemoryRequirement_t memRequirement;
 736   bit32  maxQueueSets = 0;
 737   bit32  maxNumOSLocks = 0;
 738   bit32  i;
 739
 740   char    *buffer;
 741   bit32   buffLen;
 742   bit32   lenRecv = 0;
 743   char    *pLastUsedChar = agNULL;
 744   char    globalStr[]     = "Global";
 745   char    iniParmsStr[]   = "InitiatorParms";
 746   char    SwParmsStr[]   = "SWParms";
 747   char    OBQueueProps[] = "OBQueueProps";
 748   char    IBQueueProps[] = "IBQueueProps";
 749
 750   static char   IBQueueSize[30];
 751   static char   OBQueueSize[30];
 752   static char   IBQueueEleSize[30];
 753   static char   OBQueueEleSize[30];
 754
 755   static char    OBQueueInterruptCount[30];
 756   static char    OBQueueInterruptDelay[30];
 757   static char    OBQueueInterruptEnable[30];
 758   static char    IBQueuePriority[30];
 759
 760
 761   static char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
 762   static bit32   InboundQueueSize[AGSA_MAX_OUTBOUND_Q];
 763   static bit32   OutboundQueueSize[AGSA_MAX_OUTBOUND_Q];
 764   static bit32   InboundQueueEleSize[AGSA_MAX_OUTBOUND_Q];
 765   static bit32   OutboundQueueEleSize[AGSA_MAX_OUTBOUND_Q];
 766   static bit32   InboundQueuePriority[AGSA_MAX_INBOUND_Q];
 767   static bit32   OutboundQueueInterruptDelay[AGSA_MAX_OUTBOUND_Q];
 768   static bit32   OutboundQueueInterruptCount[AGSA_MAX_OUTBOUND_Q];
 769   static bit32   OutboundQueueInterruptEnable[AGSA_MAX_OUTBOUND_Q];
 770   static bit32 cardID = 0;
 771   char    CardNum[10];
 772
 773 #ifdef FDS_DM
 774   dmRoot_t                     dmRoot;
 775   dmSwConfig_t                 dmSwConfig;
 776   static dmMemoryRequirement_t dmMemRequirement;
 777   bit32                        dmUsecsPerTick = 0;
 778   bit32                        dmMaxNumLocks = 0;
 779 #endif
 780
 781 #ifdef FDS_SM
 782   smRoot_t                     smRoot;
 783   smSwConfig_t                 smSwConfig;
 784   static smMemoryRequirement_t smMemRequirement;
 785   bit32                        smUsecsPerTick = 0;
 786   bit32                        smMaxNumLocks = 0;
 787 #endif
 788
 789   TI_DBG1(("tdsaLoLevelGetResource: start \n"));
 790   TI_DBG6(("tdsaLoLevelGetResource: loResource %p\n", loResource));
 791
 792   osti_memset(&agRoot, 0, sizeof(agsaRoot_t));
 793   osti_memset(&QueueConfig, 0, sizeof(QueueConfig));
 794   osti_memset(&memRequirement, 0, sizeof(memRequirement));
 795   osti_memset(InboundQueueSize, 0, sizeof(InboundQueueSize));
 796   osti_memset(OutboundQueueSize, 0, sizeof(OutboundQueueSize));
 797   osti_memset(InboundQueueEleSize, 0, sizeof(InboundQueueEleSize));
 798   osti_memset(OutboundQueueEleSize, 0, sizeof(OutboundQueueEleSize));
 799
 800   memRequirement.count = 0;
 801
 802   /* default values which are overwritten later */
 803   /* The followings are default values */
 804   SwConfig.maxActiveIOs = DEFAULT_MAX_ACTIVE_IOS;
 805   SwConfig.numDevHandles = DEFAULT_MAX_DEV;
 806   SwConfig.smpReqTimeout = DEFAULT_SMP_TIMEOUT; /* DEFAULT_VALUE; */
 807   SwConfig.numberOfEventRegClients = DEFAULT_NUM_REG_CLIENTS;
 808   SwConfig.sizefEventLog1 = HOST_EVENT_LOG_SIZE; /* in KBytes */
 809   SwConfig.sizefEventLog2 = HOST_EVENT_LOG_SIZE; /* in KBytes */
 810   SwConfig.eventLog1Option = DEFAULT_EVENT_LOG_OPTION;
 811   SwConfig.eventLog2Option = DEFAULT_EVENT_LOG_OPTION;
 812   SwConfig.fatalErrorInterruptEnable = 1;
 813   SwConfig.fatalErrorInterruptVector = 0; /* Was 1 */
 814   SwConfig.hostDirectAccessSupport = 0;
 815   SwConfig.hostDirectAccessMode = 0;
 816   SwConfig.FWConfig = 0;
 817   SwConfig.enableDIF = agFALSE;
 818   SwConfig.enableEncryption = agFALSE;
 819
 820 #ifdef SA_CONFIG_MDFD_REGISTRY
 821   SwConfig.disableMDF = agFALSE;
 822 #endif /*SA_CONFIG_MDFD_REGISTRY*/
 823
 824 #if defined(SALLSDK_DEBUG)
 825   SwConfig.sallDebugLevel = 1; /* DEFAULT_VALUE; */
 826 #endif
 827
 828
 829 #ifdef SA_ENABLE_PCI_TRIGGER
 830   SwConfig.PCI_trigger = 0; /* DEFAULT_VALUE; */
 831  #endif /* SA_ENABLE_PCI_TRIGGER */
 832
 833 #ifdef FDS_DM
 834   /* defaults */
 835   dmMemRequirement.count = 0;
 836   dmSwConfig.numDevHandles = DEFAULT_MAX_DEV;
 837 #ifdef DM_DEBUG
 838   dmSwConfig.DMDebugLevel = 1;
 839 #endif
 840 #endif
 841
 842 #ifdef FDS_SM
 843   /* defaults */
 844   smMemRequirement.count = 0;
 845   smSwConfig.maxActiveIOs = DEFAULT_MAX_ACTIVE_IOS;
 846   smSwConfig.numDevHandles = DEFAULT_MAX_DEV;
 847 #ifdef SM_DEBUG
 848   smSwConfig.SMDebugLevel = 1;
 849 #endif
 850 #endif
 851
 852   buffer = tmpBuffer;
 853   buffLen = sizeof(tmpBuffer);
 854
 855   /* param3 points to QueueConfig; tdsaAllShared does not exit at this point yet */
 856   SwConfig.param3 = (void *)&QueueConfig;
 857
 858   osti_memset(buffer, 0, buffLen);
 859   lenRecv = 0;
 860
 861   if ((ostiGetTransportParam(
 862                              tiRoot,
 863                              globalStr,
 864                              iniParmsStr,
 865                              agNULL,
 866                              agNULL,
 867                              agNULL,
 868                              agNULL,
 869                              "MaxTargets",
 870                              buffer,
 871                              buffLen,
 872                              &lenRecv
 873                              ) == tiSuccess) && (lenRecv != 0))
 874   {
 875     if (osti_strncmp(buffer, "0x", 2) == 0)
 876     {
 877       SwConfig.numDevHandles = osti_strtoul (buffer, &pLastUsedChar, 0);
 878     }
 879     else
 880     {
 881       SwConfig.numDevHandles = osti_strtoul (buffer, &pLastUsedChar, 10);
 882     }
 883    TI_DBG2(("tdsaLoLevelGetResource: MaxTargets %d\n",  SwConfig.numDevHandles));
 884   }
 885
 886
 887   /*
 888    * read the NumInboundQueue parameter
 889    */
 890   osti_memset(buffer, 0, buffLen);
 891   lenRecv = 0;
 892
 893   QueueConfig.numInboundQueues = DEFAULT_NUM_INBOUND_QUEUE;  /* default 1 Inbound queue */
 894
 895   if ((ostiGetTransportParam(
 896                              tiRoot,
 897                              globalStr,   /* key */
 898                              SwParmsStr,  /* subkey1 */
 899                              agNULL,      /* subkey2 */
 900                              agNULL,
 901                              agNULL,
 902                              agNULL,      /* subkey5 */
 903                              "NumInboundQueues", /* valueName */
 904                              buffer,
 905                              buffLen,
 906                              &lenRecv
 907                              ) == tiSuccess) && (lenRecv != 0))
 908   {
 909     if (osti_strncmp(buffer, "0x", 2) == 0)
 910     {
 911       QueueConfig.numInboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 912     }
 913     else
 914     {
 915       QueueConfig.numInboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 916     }
 917
 918     if (QueueConfig.numInboundQueues > AGSA_MAX_INBOUND_Q)
 919     {
 920       QueueConfig.numInboundQueues = AGSA_MAX_INBOUND_Q;
 921     }
 922   }
 923
 924   /*
 925    * read the NumOutboundQueue parameter
 926    */
 927   osti_memset(buffer, 0, buffLen);
 928   lenRecv = 0;
 929
 930   QueueConfig.numOutboundQueues = DEFAULT_NUM_OUTBOUND_QUEUE;  /* default 1 Outbound queue */
 931
 932   if ((ostiGetTransportParam(
 933                              tiRoot,
 934                              globalStr,   /* key */
 935                              SwParmsStr,  /* subkey1 */
 936                              agNULL,      /* subkey2 */
 937                              agNULL,
 938                              agNULL,
 939                              agNULL,      /* subkey5 */
 940                              "NumOutboundQueues", /* valueName */
 941                              buffer,
 942                              buffLen,
 943                              &lenRecv
 944                              ) == tiSuccess) && (lenRecv != 0))
 945   {
 946     if (osti_strncmp(buffer, "0x", 2) == 0)
 947     {
 948       QueueConfig.numOutboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 949     }
 950     else
 951     {
 952       QueueConfig.numOutboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 953     }
 954
 955     if (QueueConfig.numOutboundQueues > AGSA_MAX_OUTBOUND_Q)
 956     {
 957       QueueConfig.numOutboundQueues = AGSA_MAX_OUTBOUND_Q;
 958     }
 959   }
 960
 961   /*
 962    * read the MaxActiveIO parameter
 963    */
 964   osti_memset(buffer, 0, buffLen);
 965   lenRecv = 0;
 966
 967
 968   if ((ostiGetTransportParam(
 969                              tiRoot,
 970                              globalStr,   /* key */
 971                              SwParmsStr,  /* subkey1 */
 972                              agNULL,      /* subkey2 */
 973                              agNULL,
 974                              agNULL,
 975                              agNULL,      /* subkey5 */
 976                              "MaxActiveIO", /* valueName */
 977                              buffer,
 978                              buffLen,
 979                              &lenRecv
 980                              ) == tiSuccess) && (lenRecv != 0))
 981   {
 982     if (osti_strncmp(buffer, "0x", 2) == 0)
 983     {
 984       SwConfig.maxActiveIOs = osti_strtoul (buffer, &pLastUsedChar, 0);
 985     }
 986     else
 987     {
 988       SwConfig.maxActiveIOs = osti_strtoul (buffer, &pLastUsedChar, 10);
 989     }
 990   }
 991
 992
 993
 994   /*
 995    * read the SMPTO parameter (SMP Timeout)
 996    */
 997   osti_memset(buffer, 0, buffLen);
 998   lenRecv = 0;
 999
1000   if ((ostiGetTransportParam(
1001                              tiRoot,
1002                              globalStr,   /* key */
1003                              SwParmsStr,  /* subkey1 */
1004                              agNULL,      /* subkey2 */
1005                              agNULL,
1006                              agNULL,
1007                              agNULL,      /* subkey5 */
1008                              "SMPTO", /* valueName */
1009                              buffer,
1010                              buffLen,
1011                              &lenRecv
1012                              ) == tiSuccess) && (lenRecv != 0))
1013   {
1014     if (osti_strncmp(buffer, "0x", 2) == 0)
1015     {
1016       SwConfig.smpReqTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
1017     }
1018     else
1019     {
1020       SwConfig.smpReqTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
1021     }
1022   }
1023
1024   /*
1025    * read the NumRegClients parameter
1026    */
1027   osti_memset(buffer, 0, buffLen);
1028   lenRecv = 0;
1029
1030   if ((ostiGetTransportParam(
1031                              tiRoot,
1032                              globalStr,   /* key */
1033                              SwParmsStr,  /* subkey1 */
1034                              agNULL,      /* subkey2 */
1035                              agNULL,
1036                              agNULL,
1037                              agNULL,      /* subkey5 */
1038                              "NumRegClients", /* valueName */
1039                              buffer,
1040                              buffLen,
1041                              &lenRecv
1042                              ) == tiSuccess) && (lenRecv != 0))
1043   {
1044     if (osti_strncmp(buffer, "0x", 2) == 0)
1045     {
1046       SwConfig.numberOfEventRegClients = osti_strtoul (buffer, &pLastUsedChar, 0);
1047     }
1048     else
1049     {
1050       SwConfig.numberOfEventRegClients = osti_strtoul (buffer, &pLastUsedChar, 10);
1051     }
1052   }
1053
1054 #if defined(SALLSDK_DEBUG)
1055   osti_memset(buffer, 0, buffLen);
1056   lenRecv = 0;
1057
1058   if ((ostiGetTransportParam(
1059                              tiRoot,
1060                              globalStr,   /* key */
1061                              SwParmsStr,  /* subkey1 */
1062                              agNULL,      /* subkey2 */
1063                              agNULL,
1064                              agNULL,
1065                              agNULL,      /* subkey5 */
1066                              "LLDebugLevel", /* valueName */
1067                              buffer,
1068                              buffLen,
1069                              &lenRecv
1070                              ) == tiSuccess) && (lenRecv != 0))
1071   {
1072     if (osti_strncmp(buffer, "0x", 2) == 0)
1073     {
1074       SwConfig.sallDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
1075     }
1076     else
1077     {
1078       SwConfig.sallDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
1079     }
1080   }
1081 #endif
1082
1083
1084 #if defined(DM_DEBUG)
1085   osti_memset(buffer, 0, buffLen);
1086   lenRecv = 0;
1087
1088   if ((ostiGetTransportParam(
1089                              tiRoot,
1090                              globalStr,   /* key */
1091                              SwParmsStr,  /* subkey1 */
1092                              agNULL,      /* subkey2 */
1093                              agNULL,
1094                              agNULL,
1095                              agNULL,      /* subkey5 */
1096                              "DMDebugLevel", /* valueName */
1097                              buffer,
1098                              buffLen,
1099                              &lenRecv
1100                              ) == tiSuccess) && (lenRecv != 0))
1101   {
1102     if (osti_strncmp(buffer, "0x", 2) == 0)
1103     {
1104       dmSwConfig.DMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
1105     }
1106     else
1107     {
1108       dmSwConfig.DMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
1109     }
1110   }
1111 #endif
1112
1113 #if defined(SM_DEBUG)
1114   osti_memset(buffer, 0, buffLen);
1115   lenRecv = 0;
1116
1117   if ((ostiGetTransportParam(
1118                              tiRoot,
1119                              globalStr,   /* key */
1120                              SwParmsStr,  /* subkey1 */
1121                              agNULL,      /* subkey2 */
1122                              agNULL,
1123                              agNULL,
1124                              agNULL,      /* subkey5 */
1125                              "SMDebugLevel", /* valueName */
1126                              buffer,
1127                              buffLen,
1128                              &lenRecv
1129                              ) == tiSuccess) && (lenRecv != 0))
1130   {
1131     if (osti_strncmp(buffer, "0x", 2) == 0)
1132     {
1133       smSwConfig.SMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
1134     }
1135     else
1136     {
1137       smSwConfig.SMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
1138     }
1139   }
1140 #endif
1141
1142   osti_memset(buffer, 0, buffLen);
1143   lenRecv = 0;
1144
1145   for (i=0;i<QueueConfig.numInboundQueues;i++)
1146   {
1147     osti_sprintf(IBQueueSize,"IBQueueNumElements%d", i);
1148     osti_sprintf(IBQueueEleSize,"IBQueueElementSize%d", i);
1149     osti_sprintf(IBQueuePriority,"IBQueuePriority%d", i);
1150
1151
1152
1153     /*
1154      * read the IBQueueSize
1155      */
1156     osti_memset(buffer, 0, buffLen);
1157     lenRecv = 0;
1158
1159     InboundQueueSize[i] = DEFAULT_INBOUND_QUEUE_SIZE;  /* default 256 Inbound queue size */
1160
1161     if ((ostiGetTransportParam(
1162                              tiRoot,
1163                              globalStr,   /* key */
1164                              SwParmsStr,  /* subkey1 */
1165                              IBQueueProps,      /* subkey2 */
1166                              agNULL,
1167                              agNULL,
1168                              agNULL,      /* subkey5 */
1169                              IBQueueSize, /* valueName */
1170                              buffer,
1171                              buffLen,
1172                              &lenRecv
1173                              ) == tiSuccess) && (lenRecv != 0))
1174     {
1175       if (osti_strncmp(buffer, "0x", 2) == 0)
1176       {
1177         InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1178       }
1179       else
1180       {
1181         InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1182         TI_DBG6(("tdsaLoLevelGetResource: queue number %d IB queue size %d\n", i, InboundQueueSize[i]));
1183       }
1184     }
1185
1186
1187     /*
1188      * read the IBQueueEleSize
1189      */
1190     osti_memset(buffer, 0, buffLen);
1191     lenRecv = 0;
1192
1193     InboundQueueEleSize[i] = DEFAULT_INBOUND_QUEUE_ELE_SIZE;  /* default 128 Inbound queue element */
1194
1195     if ((ostiGetTransportParam(
1196                              tiRoot,
1197                              globalStr,   /* key */
1198                              SwParmsStr,  /* subkey1 */
1199                              IBQueueProps,      /* subkey2 */
1200                              agNULL,
1201                              agNULL,
1202                              agNULL,      /* subkey5 */
1203                              IBQueueEleSize, /* valueName */
1204                              buffer,
1205                              buffLen,
1206                              &lenRecv
1207                              ) == tiSuccess) && (lenRecv != 0))
1208     {
1209       if (osti_strncmp(buffer, "0x", 2) == 0)
1210       {
1211         InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1212       }
1213       else
1214       {
1215         InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1216         TI_DBG6(("tdsaLoLevelGetResource: queue number %d IB queue ele size %d\n", i, InboundQueueEleSize[i]));
1217       }
1218     }
1219
1220     /*
1221      * read the IBQueuePriority
1222      */
1223
1224     osti_memset(buffer, 0, buffLen);
1225     lenRecv = 0;
1226
1227     InboundQueuePriority[i] = DEFAULT_INBOUND_QUEUE_PRIORITY; /* default 0 Inbound queue priority */
1228
1229     if ((ostiGetTransportParam(
1230                              tiRoot,
1231                              globalStr,   /* key */
1232                              SwParmsStr,  /* subkey1 */
1233                              IBQueueProps,/* subkey2 */
1234                              agNULL,
1235                              agNULL,
1236                              agNULL,      /* subkey5 */
1237                              IBQueuePriority, /* valueName */
1238                              buffer,
1239                              buffLen,
1240                              &lenRecv
1241                              ) == tiSuccess) && (lenRecv != 0))
1242     {
1243       if (osti_strncmp(buffer, "0x", 2) == 0)
1244       {
1245         InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1246       }
1247       else
1248       {
1249         InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1250         TI_DBG6(("tdsaLoLevelGetResource: queue number %d priority %d\n", i, InboundQueuePriority[i]));
1251       }
1252     }
1253
1254     /**********************************************/
1255     osti_memset(buffer, 0, buffLen);
1256     lenRecv = 0;
1257   }/* end of loop */
1258
1259
1260   osti_memset(buffer, 0, buffLen);
1261   lenRecv = 0;
1262
1263   for (i=0;i<QueueConfig.numOutboundQueues;i++)
1264   {
1265     osti_sprintf(OBQueueSize,"OBQueueNumElements%d", i);
1266     osti_sprintf(OBQueueEleSize,"OBQueueElementSize%d", i);
1267     osti_sprintf(OBQueueInterruptDelay,"OBQueueInterruptDelay%d", i);
1268     osti_sprintf(OBQueueInterruptCount,"OBQueueInterruptCount%d", i);
1269     osti_sprintf(OBQueueInterruptEnable,"OBQueueInterruptEnable%d", i);
1270
1271     /*
1272      * read the OBQueueSize
1273      */
1274     osti_memset(buffer, 0, buffLen);
1275     lenRecv = 0;
1276
1277     OutboundQueueSize[i] = DEFAULT_OUTBOUND_QUEUE_SIZE;  /* default 256 Outbound queue size */
1278
1279     if ((ostiGetTransportParam(
1280                              tiRoot,
1281                              globalStr,   /* key */
1282                              SwParmsStr,  /* subkey1 */
1283                              OBQueueProps,      /* subkey2 */
1284                              agNULL,
1285                              agNULL,
1286                              agNULL,      /* subkey5 */
1287                              OBQueueSize, /* valueName */
1288                              buffer,
1289                              buffLen,
1290                              &lenRecv
1291                              ) == tiSuccess) && (lenRecv != 0))
1292     {
1293       if (osti_strncmp(buffer, "0x", 2) == 0)
1294       {
1295         OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1296       }
1297       else
1298       {
1299         OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1300         TI_DBG6(("tdsaLoLevelGetResource: queue number %d OB queue size %d\n", i, OutboundQueueSize[i]));
1301       }
1302     }
1303
1304
1305     /*
1306      * read the OBQueueEleSize
1307      */
1308     osti_memset(buffer, 0, buffLen);
1309     lenRecv = 0;
1310
1311     OutboundQueueEleSize[i] = DEFAULT_OUTBOUND_QUEUE_ELE_SIZE;  /* default 128 Outbound queue element */
1312
1313     if ((ostiGetTransportParam(
1314                              tiRoot,
1315                              globalStr,   /* key */
1316                              SwParmsStr,  /* subkey1 */
1317                              OBQueueProps,      /* subkey2 */
1318                              agNULL,
1319                              agNULL,
1320                              agNULL,      /* subkey5 */
1321                              OBQueueEleSize, /* valueName */
1322                              buffer,
1323                              buffLen,
1324                              &lenRecv
1325                              ) == tiSuccess) && (lenRecv != 0))
1326     {
1327       if (osti_strncmp(buffer, "0x", 2) == 0)
1328       {
1329         OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1330       }
1331       else
1332       {
1333         OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1334         TI_DBG6(("tdsaLoLevelGetResource: queue number %d OB queue ele size %d\n", i, OutboundQueueEleSize[i]));
1335       }
1336     }
1337
1338     /*
1339      * read the OBQueueInterruptDelay
1340      */
1341     osti_memset(buffer, 0, buffLen);
1342     lenRecv = 0;
1343
1344     OutboundQueueInterruptDelay[i] = DEFAULT_OUTBOUND_QUEUE_INTERRUPT_DELAY;  /* default 1 Outbound interrupt delay */
1345
1346     if ((ostiGetTransportParam(
1347                              tiRoot,
1348                              globalStr,   /* key */
1349                              SwParmsStr,  /* subkey1 */
1350                              OBQueueProps,      /* subkey2 */
1351                              agNULL,
1352                              agNULL,
1353                              agNULL,      /* subkey5 */
1354                              OBQueueInterruptDelay, /* valueName */
1355                              buffer,
1356                              buffLen,
1357                              &lenRecv
1358                              ) == tiSuccess) && (lenRecv != 0))
1359     {
1360       if (osti_strncmp(buffer, "0x", 2) == 0)
1361       {
1362         OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1363       }
1364       else
1365       {
1366         OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1367         TI_DBG6(("tdsaLoLevelGetResource: queue number %d interrupt delay %d\n", i, OutboundQueueInterruptDelay[i]));
1368       }
1369     }
1370
1371     /*
1372      * read the OBQueueInterruptCount
1373      */
1374
1375     osti_memset(buffer, 0, buffLen);
1376     lenRecv = 0;
1377
1378     OutboundQueueInterruptCount[i] = DEFAULT_OUTBOUND_QUEUE_INTERRUPT_COUNT;  /* default 1 Outbound interrupt count */
1379
1380     if ((ostiGetTransportParam(
1381                              tiRoot,
1382                              globalStr,   /* key */
1383                              SwParmsStr,  /* subkey1 */
1384                              OBQueueProps,      /* subkey2 */
1385                              agNULL,
1386                              agNULL,
1387                              agNULL,      /* subkey5 */
1388                              OBQueueInterruptCount, /* valueName */
1389                              buffer,
1390                              buffLen,
1391                              &lenRecv
1392                              ) == tiSuccess) && (lenRecv != 0))
1393     {
1394       if (osti_strncmp(buffer, "0x", 2) == 0)
1395       {
1396         OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1397       }
1398       else
1399       {
1400         OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1401         TI_DBG6(("tdsaLoLevelGetResource: queue number %d interrupt count %d\n", i, OutboundQueueInterruptCount[i]));
1402       }
1403     }
1404
1405     /*
1406      * read the OBQueueInterruptEnable
1407      */
1408
1409     osti_memset(buffer, 0, buffLen);
1410     lenRecv = 0;
1411
1412     OutboundQueueInterruptEnable[i] = DEFAULT_OUTBOUND_INTERRUPT_ENABLE;  /* default 1 Outbound interrupt is enabled */
1413
1414     if ((ostiGetTransportParam(
1415                              tiRoot,
1416                              globalStr,   /* key */
1417                              SwParmsStr,  /* subkey1 */
1418                              OBQueueProps,      /* subkey2 */
1419                              agNULL,
1420                              agNULL,
1421                              agNULL,      /* subkey5 */
1422                              OBQueueInterruptEnable, /* valueName */
1423                              buffer,
1424                              buffLen,
1425                              &lenRecv
1426                              ) == tiSuccess) && (lenRecv != 0))
1427     {
1428       if (osti_strncmp(buffer, "0x", 2) == 0)
1429       {
1430         OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1431 #ifdef SPC_POLLINGMODE
1432         OutboundQueueInterruptEnable[i] = 0;
1433 #endif /* SPC_POLLINGMODE */
1434
1435       }
1436       else
1437       {
1438         OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1439 #ifdef SPC_POLLINGMODE
1440         OutboundQueueInterruptEnable[i] = 0;
1441 #endif /* SPC_POLLINGMODE */
1442       }
1443     TI_DBG2(("tdsaLoLevelGetResource: queue number %d interrupt enable %d\n", i, OutboundQueueInterruptEnable[i]));
1444     }
1445
1446     /**********************************************/
1447     osti_memset(buffer, 0, buffLen);
1448     lenRecv = 0;
1449
1450   }/* end of loop */
1451
1452
1453
1454   /************************************************************
1455    * READ CARD Specific
1456   */
1457   osti_memset(buffer, 0, buffLen);
1458   lenRecv = 0;
1459
1460   for (i=0;i<QueueConfig.numInboundQueues;i++)
1461   {
1462     osti_sprintf(CardNum,"CardNum%d", cardID);
1463     osti_sprintf(IBQueueSize,"IBQueueNumElements%d", i);
1464     osti_sprintf(IBQueueEleSize,"IBQueueElementSize%d", i);
1465     osti_sprintf(IBQueuePriority,"IBQueuePriority%d", i);
1466
1467     /*
1468      * read the IBQueueSize
1469      */
1470     osti_memset(buffer, 0, buffLen);
1471     lenRecv = 0;
1472
1473     if ((ostiGetTransportParam(
1474                              tiRoot,
1475                              CardNum,   /* key */
1476                              SwParmsStr,  /* subkey1 */
1477                              IBQueueProps,      /* subkey2 */
1478                              agNULL,
1479                              agNULL,
1480                              agNULL,      /* subkey5 */
1481                              IBQueueSize, /* valueName */
1482                              buffer,
1483                              buffLen,
1484                              &lenRecv
1485                              ) == tiSuccess) && (lenRecv != 0))
1486     {
1487       if (osti_strncmp(buffer, "0x", 2) == 0)
1488       {
1489         InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1490       }
1491       else
1492       {
1493         InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1494         TI_DBG6(("tdsaLoLevelGetResource: queue number %d IB queue size %d\n", i, InboundQueueSize[i]));
1495       }
1496     }
1497
1498
1499     /*
1500      * read the IBQueueEleSize
1501      */
1502     osti_memset(buffer, 0, buffLen);
1503     lenRecv = 0;
1504
1505     if ((ostiGetTransportParam(
1506                              tiRoot,
1507                              CardNum,   /* key */
1508                              SwParmsStr,  /* subkey1 */
1509                              IBQueueProps,      /* subkey2 */
1510                              agNULL,
1511                              agNULL,
1512                              agNULL,      /* subkey5 */
1513                              IBQueueEleSize, /* valueName */
1514                              buffer,
1515                              buffLen,
1516                              &lenRecv
1517                              ) == tiSuccess) && (lenRecv != 0))
1518     {
1519       if (osti_strncmp(buffer, "0x", 2) == 0)
1520       {
1521         InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1522       }
1523       else
1524       {
1525         InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1526         TI_DBG6(("tdsaLoLevelGetResource: queue number %d IB queue size %d\n", i, InboundQueueEleSize[i]));
1527       }
1528     }
1529
1530     /*
1531      * read the IBQueuePriority
1532      */
1533
1534     osti_memset(buffer, 0, buffLen);
1535     lenRecv = 0;
1536     if ((ostiGetTransportParam(
1537                              tiRoot,
1538                              CardNum,   /* key */
1539                              SwParmsStr,  /* subkey1 */
1540                              IBQueueProps,/* subkey2 */
1541                              agNULL,
1542                              agNULL,
1543                              agNULL,      /* subkey5 */
1544                              IBQueuePriority, /* valueName */
1545                              buffer,
1546                              buffLen,
1547                              &lenRecv
1548                              ) == tiSuccess) && (lenRecv != 0))
1549     {
1550       if (osti_strncmp(buffer, "0x", 2) == 0)
1551       {
1552         InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1553       }
1554       else
1555       {
1556         InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1557         TI_DBG6(("tdsaLoLevelGetResource: card number %d queue number %d priority %d\n", cardID, i, InboundQueuePriority[i]));
1558       }
1559     }
1560
1561     /**********************************************/
1562     osti_memset(buffer, 0, buffLen);
1563     lenRecv = 0;
1564   }/* end of loop */
1565
1566
1567
1568   osti_memset(buffer, 0, buffLen);
1569   lenRecv = 0;
1570
1571   for (i=0;i<QueueConfig.numOutboundQueues;i++)
1572   {
1573     osti_sprintf(CardNum,"CardNum%d", cardID);
1574     osti_sprintf(OBQueueSize,"OBQueueNumElements%d", i);
1575     osti_sprintf(OBQueueEleSize,"OBQueueElementSize%d", i);
1576     osti_sprintf(OBQueueInterruptDelay,"OBQueueInterruptDelay%d", i);
1577     osti_sprintf(OBQueueInterruptCount,"OBQueueInterruptCount%d", i);
1578     osti_sprintf(OBQueueInterruptEnable,"OBQueueInterruptEnable%d", i);
1579
1580     /*
1581      * read the OBQueueSize
1582      */
1583     osti_memset(buffer, 0, buffLen);
1584     lenRecv = 0;
1585
1586     if ((ostiGetTransportParam(
1587                              tiRoot,
1588                              CardNum,   /* key */
1589                              SwParmsStr,  /* subkey1 */
1590                              OBQueueProps,      /* subkey2 */
1591                              agNULL,
1592                              agNULL,
1593                              agNULL,      /* subkey5 */
1594                              OBQueueSize, /* valueName */
1595                              buffer,
1596                              buffLen,
1597                              &lenRecv
1598                              ) == tiSuccess) && (lenRecv != 0))
1599     {
1600       if (osti_strncmp(buffer, "0x", 2) == 0)
1601       {
1602         OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1603       }
1604       else
1605       {
1606         OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1607         TI_DBG6(("tdsaLoLevelGetResource: queue number %d OB queue size %d\n", i, OutboundQueueSize[i]));
1608       }
1609     }
1610
1611
1612     /*
1613      * read the OBQueueEleSize
1614      */
1615     osti_memset(buffer, 0, buffLen);
1616     lenRecv = 0;
1617
1618     if ((ostiGetTransportParam(
1619                              tiRoot,
1620                              CardNum,   /* key */
1621                              SwParmsStr,  /* subkey1 */
1622                              OBQueueProps,      /* subkey2 */
1623                              agNULL,
1624                              agNULL,
1625                              agNULL,      /* subkey5 */
1626                              OBQueueEleSize, /* valueName */
1627                              buffer,
1628                              buffLen,
1629                              &lenRecv
1630                              ) == tiSuccess) && (lenRecv != 0))
1631     {
1632       if (osti_strncmp(buffer, "0x", 2) == 0)
1633       {
1634         OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1635       }
1636       else
1637       {
1638         OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1639         TI_DBG6(("tdsaLoLevelGetResource: queue number %d OB queue ele size %d\n", i, OutboundQueueEleSize[i]));
1640       }
1641     }
1642
1643     /*
1644      * read the OBQueueInterruptDelay
1645      */
1646     osti_memset(buffer, 0, buffLen);
1647     lenRecv = 0;
1648
1649     if ((ostiGetTransportParam(
1650                              tiRoot,
1651                              CardNum,   /* key */
1652                              SwParmsStr,  /* subkey1 */
1653                              OBQueueProps,      /* subkey2 */
1654                              agNULL,
1655                              agNULL,
1656                              agNULL,      /* subkey5 */
1657                              OBQueueInterruptDelay, /* valueName */
1658                              buffer,
1659                              buffLen,
1660                              &lenRecv
1661                              ) == tiSuccess) && (lenRecv != 0))
1662     {
1663       if (osti_strncmp(buffer, "0x", 2) == 0)
1664       {
1665         OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1666       }
1667       else
1668       {
1669         OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1670         TI_DBG6(("tdsaLoLevelGetResource: card number %d queue number %d interrupt delay %d\n", cardID, i, OutboundQueueInterruptDelay[i]));
1671       }
1672     }
1673
1674     /*
1675      * read the OBQueueInterruptCount
1676      */
1677
1678     osti_memset(buffer, 0, buffLen);
1679     lenRecv = 0;
1680     if ((ostiGetTransportParam(
1681                              tiRoot,
1682                              CardNum,   /* key */
1683                              SwParmsStr,  /* subkey1 */
1684                              OBQueueProps,      /* subkey2 */
1685                              agNULL,
1686                              agNULL,
1687                              agNULL,      /* subkey5 */
1688                              OBQueueInterruptCount, /* valueName */
1689                              buffer,
1690                              buffLen,
1691                              &lenRecv
1692                              ) == tiSuccess) && (lenRecv != 0))
1693     {
1694       if (osti_strncmp(buffer, "0x", 2) == 0)
1695       {
1696         OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1697       }
1698       else
1699       {
1700         OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1701         TI_DBG6(("tdsaLoLevelGetResource: card number %d queue number %d interrupt count %d\n", cardID, i, OutboundQueueInterruptCount[i]));
1702       }
1703     }
1704
1705     /*
1706      * read the OBQueueInterruptEnable
1707      */
1708
1709     osti_memset(buffer, 0, buffLen);
1710     lenRecv = 0;
1711     if ((ostiGetTransportParam(
1712                              tiRoot,
1713                              CardNum,   /* key */
1714                              SwParmsStr,  /* subkey1 */
1715                              OBQueueProps,      /* subkey2 */
1716                              agNULL,
1717                              agNULL,
1718                              agNULL,      /* subkey5 */
1719                              OBQueueInterruptEnable, /* valueName */
1720                              buffer,
1721                              buffLen,
1722                              &lenRecv
1723                              ) == tiSuccess) && (lenRecv != 0))
1724     {
1725       if (osti_strncmp(buffer, "0x", 2) == 0)
1726       {
1727         OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1728 #ifdef SPC_POLLINGMODE
1729         OutboundQueueInterruptEnable[i] = 0;
1730 #endif /* SPC_POLLINGMODE */
1731
1732       }
1733       else
1734       {
1735         OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1736 #ifdef SPC_POLLINGMODE
1737         OutboundQueueInterruptEnable[i] = 0;
1738 #endif /* SPC_POLLINGMODE */
1739       }
1740       TI_DBG2(("tdsaLoLevelGetResource: card number %d queue number %d interrupt count %d\n", cardID, i, OutboundQueueInterruptEnable[i]));
1741     }
1742
1743
1744     /**********************************************/
1745     osti_memset(buffer, 0, buffLen);
1746     lenRecv = 0;
1747
1748   }/* end of loop */
1749
1750
1751   TI_DBG6(("tdsaLoLevelGetResource: \n"));
1752   tdsaPrintSwConfig(&SwConfig);
1753
1754   /* fills in queue related parameters */
1755   for (i=0;i<QueueConfig.numInboundQueues;i++)
1756   {
1757     QueueConfig.inboundQueues[i].elementCount = InboundQueueSize[i];
1758     QueueConfig.inboundQueues[i].elementSize = InboundQueueEleSize[i];
1759     QueueConfig.inboundQueues[i].priority = InboundQueuePriority[i];
1760   }
1761   for (i=0;i<QueueConfig.numOutboundQueues;i++)
1762   {
1763     QueueConfig.outboundQueues[i].elementCount = OutboundQueueSize[i];
1764     QueueConfig.outboundQueues[i].elementSize = OutboundQueueEleSize[i];
1765     QueueConfig.outboundQueues[i].interruptDelay = OutboundQueueInterruptDelay[i];
1766     QueueConfig.outboundQueues[i].interruptCount = OutboundQueueInterruptCount[i];
1767     QueueConfig.outboundQueues[i].interruptEnable = OutboundQueueInterruptEnable[i];
1768   }
1769
1770
1771   /* process event log related parameters */
1772   osti_memset(buffer, 0, buffLen);
1773   lenRecv = 0;
1774
1775
1776   if ((ostiGetTransportParam(
1777                              tiRoot,
1778                              globalStr,   /* key */
1779                              SwParmsStr,  /* subkey1 */
1780                              agNULL,      /* subkey2 */
1781                              agNULL,
1782                              agNULL,
1783                              agNULL,      /* subkey5 */
1784                              "EventLogSize1", /* valueName */
1785                              buffer,
1786                              buffLen,
1787                              &lenRecv
1788                              ) == tiSuccess) && (lenRecv != 0))
1789   {
1790     if (osti_strncmp(buffer, "0x", 2) == 0)
1791     {
1792       SwConfig.sizefEventLog1 = osti_strtoul (buffer, &pLastUsedChar, 0);
1793     }
1794     else
1795     {
1796       SwConfig.sizefEventLog1 = osti_strtoul (buffer, &pLastUsedChar, 10);
1797     }
1798   }
1799
1800   osti_memset(buffer, 0, buffLen);
1801   lenRecv = 0;
1802
1803
1804   if ((ostiGetTransportParam(
1805                              tiRoot,
1806                              globalStr,   /* key */
1807                              SwParmsStr,  /* subkey1 */
1808                              agNULL,      /* subkey2 */
1809                              agNULL,
1810                              agNULL,
1811                              agNULL,      /* subkey5 */
1812                              "EventLogOption1", /* valueName */
1813                              buffer,
1814                              buffLen,
1815                              &lenRecv
1816                              ) == tiSuccess) && (lenRecv != 0))
1817   {
1818     if (osti_strncmp(buffer, "0x", 2) == 0)
1819     {
1820       SwConfig.eventLog1Option = osti_strtoul (buffer, &pLastUsedChar, 0);
1821     }
1822     else
1823     {
1824       SwConfig.eventLog1Option = osti_strtoul (buffer, &pLastUsedChar, 10);
1825     }
1826   }
1827
1828   osti_memset(buffer, 0, buffLen);
1829   lenRecv = 0;
1830
1831
1832   if ((ostiGetTransportParam(
1833                              tiRoot,
1834                              globalStr,   /* key */
1835                              SwParmsStr,  /* subkey1 */
1836                              agNULL,      /* subkey2 */
1837                              agNULL,
1838                              agNULL,
1839                              agNULL,      /* subkey5 */
1840                              "EventLogSize2", /* valueName */ /* size in K Dwords  */
1841                              buffer,
1842                              buffLen,
1843                              &lenRecv
1844                              ) == tiSuccess) && (lenRecv != 0))
1845   {
1846     if (osti_strncmp(buffer, "0x", 2) == 0)
1847     {
1848       SwConfig.sizefEventLog2 = osti_strtoul (buffer, &pLastUsedChar, 0);
1849     }
1850     else
1851     {
1852       SwConfig.sizefEventLog2 = osti_strtoul (buffer, &pLastUsedChar, 10);
1853     }
1854   }
1855
1856   osti_memset(buffer, 0, buffLen);
1857   lenRecv = 0;
1858
1859
1860   if ((ostiGetTransportParam(
1861                              tiRoot,
1862                              globalStr,   /* key */
1863                              SwParmsStr,  /* subkey1 */
1864                              agNULL,      /* subkey2 */
1865                              agNULL,
1866                              agNULL,
1867                              agNULL,      /* subkey5 */
1868                              "EventLogOption2", /* valueName */
1869                              buffer,
1870                              buffLen,
1871                              &lenRecv
1872                              ) == tiSuccess) && (lenRecv != 0))
1873   {
1874     if (osti_strncmp(buffer, "0x", 2) == 0)
1875     {
1876       SwConfig.eventLog2Option = osti_strtoul (buffer, &pLastUsedChar, 0);
1877     }
1878     else
1879     {
1880       SwConfig.eventLog2Option = osti_strtoul (buffer, &pLastUsedChar, 10);
1881     }
1882   }
1883   /* end of event log related parameters */
1884
1885   /*
1886     HDA parameters
1887   */
1888   osti_memset(buffer, 0, buffLen);
1889   lenRecv = 0;
1890
1891
1892   if ((ostiGetTransportParam(
1893                              tiRoot,
1894                              globalStr,   /* key */
1895                              SwParmsStr,  /* subkey1 */
1896                              agNULL,      /* subkey2 */
1897                              agNULL,
1898                              agNULL,
1899                              agNULL,      /* subkey5 */
1900                              "HDASupport", /* valueName */
1901                              buffer,
1902                              buffLen,
1903                              &lenRecv
1904                              ) == tiSuccess) && (lenRecv != 0))
1905   {
1906     if (osti_strncmp(buffer, "0x", 2) == 0)
1907     {
1908       SwConfig.hostDirectAccessSupport = osti_strtoul (buffer, &pLastUsedChar, 0);
1909     }
1910     else
1911     {
1912       SwConfig.hostDirectAccessSupport = osti_strtoul (buffer, &pLastUsedChar, 10);
1913     }
1914   }
1915   /***********************************************************************/
1916   osti_memset(buffer, 0, buffLen);
1917   lenRecv = 0;
1918
1919
1920   if ((ostiGetTransportParam(
1921                              tiRoot,
1922                              globalStr,   /* key */
1923                              SwParmsStr,  /* subkey1 */
1924                              agNULL,      /* subkey2 */
1925                              agNULL,
1926                              agNULL,
1927                              agNULL,      /* subkey5 */
1928                              "HDAMode", /* valueName */
1929                              buffer,
1930                              buffLen,
1931                              &lenRecv
1932                              ) == tiSuccess) && (lenRecv != 0))
1933   {
1934     if (osti_strncmp(buffer, "0x", 2) == 0)
1935     {
1936       SwConfig.hostDirectAccessMode = osti_strtoul (buffer, &pLastUsedChar, 0);
1937     }
1938     else
1939     {
1940       SwConfig.hostDirectAccessMode = osti_strtoul (buffer, &pLastUsedChar, 10);
1941     }
1942   }
1943   /***********************************************************************/
1944   /* the end of HDA parameters */
1945
1946
1947   /* FW configuration */
1948   osti_memset(buffer, 0, buffLen);
1949   lenRecv = 0;
1950
1951
1952   if ((ostiGetTransportParam(
1953                              tiRoot,
1954                              globalStr,   /* key */
1955                              SwParmsStr,  /* subkey1 */
1956                              agNULL,      /* subkey2 */
1957                              agNULL,
1958                              agNULL,
1959                              agNULL,      /* subkey5 */
1960                              "FWConfig", /* valueName */
1961                              buffer,
1962                              buffLen,
1963                              &lenRecv
1964                              ) == tiSuccess) && (lenRecv != 0))
1965   {
1966     if (osti_strncmp(buffer, "0x", 2) == 0)
1967     {
1968       SwConfig.FWConfig = osti_strtoul (buffer, &pLastUsedChar, 0);
1969     }
1970     else
1971     {
1972       SwConfig.FWConfig = osti_strtoul (buffer, &pLastUsedChar, 10);
1973     }
1974   }
1975   /* The end of FW configuration */
1976
1977
1978
1979 #ifdef SA_ENABLE_TRACE_FUNCTIONS
1980
1981  TI_DBG2(("tdsaLoLevelGetResource:  SA_ENABLE_TRACE_FUNCTIONS\n"));
1982
1983 /*
1984   buffer = tmpBuffer;
1985   buffLen = sizeof(tmpBuffer);
1986
1987   osti_memset(buffer, 0, buffLen);
1988   lenRecv = 0;
1989 */
1990
1991   SwConfig.TraceBufferSize = 0;
1992   if ((ostiGetTransportParam(
1993                              tiRoot,
1994                              globalStr,   /* key */
1995                              SwParmsStr,  /* subkey1 */
1996                              agNULL,      /* subkey2 */
1997                              agNULL,
1998                              agNULL,
1999                              agNULL,      /* subkey5 */
2000                              "TraceBufferSize", /* valueName */
2001                              buffer,
2002                              buffLen,
2003                              &lenRecv
2004                              ) == tiSuccess) && (lenRecv != 0))
2005   {
2006     if (osti_strncmp(buffer, "0x", 2) == 0)
2007     {
2008       SwConfig.TraceBufferSize = osti_strtoul (buffer, &pLastUsedChar, 0);
2009     }
2010     else
2011     {
2012       SwConfig.TraceBufferSize = osti_strtoul (buffer, &pLastUsedChar, 10);
2013     }
2014     TI_DBG2(("tdsaLoLevelGetResource: SwConfig.TraceBufferSize %d\n",SwConfig.TraceBufferSize));
2015   }
2016
2017 #endif /*# SA_ENABLE_TRACE_FUNCTIONS */
2018
2019   SwConfig.mpiContextTable = agNULL;
2020   SwConfig.mpiContextTablelen = 0;
2021
2022   /* default */
2023   for (i=0;i<8;i++)
2024   {
2025     QueueConfig.sasHwEventQueue[i] = 0;
2026     QueueConfig.sataNCQErrorEventQueue[i] = 0;
2027   }
2028
2029 #ifdef TARGET_DRIVER
2030   for (i=0;i<8;i++)
2031   {
2032     QueueConfig.tgtITNexusEventQueue[i] = 0;
2033     QueueConfig.tgtSSPEventQueue[i] = 0;
2034     QueueConfig.tgtSMPEventQueue[i] = 0;
2035   }
2036 #endif
2037
2038   QueueConfig.iqNormalPriorityProcessingDepth = 0;
2039   QueueConfig.iqHighPriorityProcessingDepth = 0;
2040   QueueConfig.generalEventQueue = 0;
2041
2042   /*
2043    * can agRoot be agNULL below? Yes.
2044    * saGetRequirements(agRoot, IN, OUT, OUT, OUT);
2045    */
2046   saGetRequirements(&agRoot,
2047                     &SwConfig,
2048                     &memRequirement,
2049                     &usecsPerTick,
2050                     &maxQueueSets
2051                     );
2052 #ifdef FDS_DM
2053   dmGetRequirements(&dmRoot,
2054                     &dmSwConfig,
2055                     &dmMemRequirement,
2056                     &dmUsecsPerTick,
2057                     &dmMaxNumLocks
2058                     );
2059
2060
2061 #endif
2062
2063 #ifdef FDS_SM
2064   smGetRequirements(
2065                     &smRoot,
2066                     &smSwConfig,
2067                     &smMemRequirement,
2068                     &smUsecsPerTick,
2069                     &smMaxNumLocks
2070                    );
2071
2072 #endif
2073
2074  /* initialization */
2075  maxNumOSLocks = loResource->loLevelOption.maxNumOSLocks;
2076  /*
2077    MAX_LL_LAYER_MEM_DESCRIPTORS is 24. see tidefs.h and tiLoLevelMem_t
2078    in titypes.h
2079  */
2080 #if defined (FDS_DM) && defined (FDS_SM)
2081   /* for LL */
2082   TI_DBG1(("tdsaLoLevelGetResource:MAX_LL_LAYER_MEM_DESCRIPTORS %d\n", MAX_LL_LAYER_MEM_DESCRIPTORS));
2083   for(i=0;i<MAX_LL_LAYER_MEM_DESCRIPTORS;i++)
2084   {
2085     loResource->loLevelMem.mem[i].numElements           = 0;
2086     loResource->loLevelMem.mem[i].totalLength           = 0;
2087     loResource->loLevelMem.mem[i].singleElementLength   = 0;
2088     loResource->loLevelMem.mem[i].alignment             = 0;
2089     loResource->loLevelMem.mem[i].type                  = 0;
2090     loResource->loLevelMem.mem[i].reserved              = 0;
2091     loResource->loLevelMem.mem[i].virtPtr               = agNULL;
2092     loResource->loLevelMem.mem[i].osHandle              = agNULL;
2093     loResource->loLevelMem.mem[i].physAddrUpper         = 0;
2094     loResource->loLevelMem.mem[i].physAddrLower         = 0;
2095   }
2096
2097   TI_DBG1(("tdsaLoLevelGetResource:memRequirement.count %d\n", memRequirement.count));
2098   /* using the returned value from saGetRequirements */
2099   for (i=0;i< memRequirement.count;i++)
2100   {
2101     /* hardcoded values for now */
2102     loResource->loLevelMem.mem[i].numElements = memRequirement.agMemory[i].numElements;
2103     loResource->loLevelMem.mem[i].totalLength = memRequirement.agMemory[i].totalLength;
2104     loResource->loLevelMem.mem[i].singleElementLength = memRequirement.agMemory[i].singleElementLength;
2105     loResource->loLevelMem.mem[i].alignment = memRequirement.agMemory[i].alignment;
2106     TI_DBG2(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2107     if ( AGSA_DMA_MEM == memRequirement.agMemory[i].type )
2108     {
2109       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2110       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2111
2112     }
2113     else if ( AGSA_CACHED_MEM == memRequirement.agMemory[i].type )
2114     {
2115       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2116       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2117     }
2118     else if ( AGSA_CACHED_DMA_MEM == memRequirement.agMemory[i].type )
2119     {
2120       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2121       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2122     }
2123   }
2124
2125   /* for DM */
2126   TI_DBG1(("tdsaLoLevelGetResource:dmMemRequirement.count %d\n", dmMemRequirement.count));
2127   /* using the returned value from dmGetRequirements */
2128   for (i=memRequirement.count;i< (memRequirement.count + dmMemRequirement.count);i++)
2129   {
2130     /* hardcoded values for now */
2131     loResource->loLevelMem.mem[i].numElements = dmMemRequirement.dmMemory[i-memRequirement.count].numElements;
2132     loResource->loLevelMem.mem[i].totalLength = dmMemRequirement.dmMemory[i-memRequirement.count].totalLength;
2133     loResource->loLevelMem.mem[i].singleElementLength = dmMemRequirement.dmMemory[i-memRequirement.count].singleElementLength;
2134     loResource->loLevelMem.mem[i].alignment = dmMemRequirement.dmMemory[i-memRequirement.count].alignment;
2135     TI_DBG2(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2136     if ( AGSA_DMA_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2137     {
2138       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2139       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2140
2141     }
2142     else if ( AGSA_CACHED_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2143     {
2144       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2145       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2146     }
2147     else if ( AGSA_CACHED_DMA_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2148     {
2149       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2150       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2151     }
2152   }
2153
2154   /* for SM */
2155   TI_DBG1(("tdsaLoLevelGetResource:smMemRequirement.count %d\n", smMemRequirement.count));
2156   /* using the returned value from dmGetRequirements */
2157   for (i=(memRequirement.count + dmMemRequirement.count);i< (memRequirement.count + dmMemRequirement.count + smMemRequirement.count);i++)
2158   {
2159     /* hardcoded values for now */
2160     loResource->loLevelMem.mem[i].numElements = smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].numElements;
2161     loResource->loLevelMem.mem[i].totalLength = smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].totalLength;
2162     loResource->loLevelMem.mem[i].singleElementLength = smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].singleElementLength;
2163     loResource->loLevelMem.mem[i].alignment = smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].alignment;
2164     TI_DBG2(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2165     if ( AGSA_DMA_MEM == smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].type )
2166     {
2167       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2168       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2169
2170     }
2171     else if ( AGSA_CACHED_MEM == smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].type )
2172     {
2173       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2174       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2175     }
2176     else if ( AGSA_CACHED_DMA_MEM == smMemRequirement.smMemory[i-memRequirement.count-dmMemRequirement.count].type )
2177     {
2178       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2179       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2180     }
2181   }
2182
2183   /* sets the low level options */
2184   loResource->loLevelOption.usecsPerTick       = MIN(MIN(usecsPerTick, dmUsecsPerTick), smUsecsPerTick);
2185   loResource->loLevelOption.numOfQueuesPerPort = maxQueueSets + dmMaxNumLocks + smMaxNumLocks + TD_MAX_LOCKS + maxNumOSLocks;
2186   loResource->loLevelOption.mutexLockUsage     = tiOneMutexLockPerQueue;
2187   /* no more ESGL */
2188   loResource->loLevelMem.count = memRequirement.count + dmMemRequirement.count + smMemRequirement.count;
2189   /* setting interrupt requirements */
2190   loResource->loLevelOption.maxInterruptVectors = SwConfig.max_MSIX_InterruptVectors;
2191   loResource->loLevelOption.max_MSI_InterruptVectors = SwConfig.max_MSI_InterruptVectors;
2192   loResource->loLevelOption.flag = SwConfig.legacyInt_X;
2193   TI_DBG2(("tdsaLoLevelGetResource: asking maxInterruptVectors(MSIX) %d \n", loResource->loLevelOption.maxInterruptVectors));
2194   TI_DBG2(("tdsaLoLevelGetResource: asking max_MSI_InterruptVectors %d \n", loResource->loLevelOption.max_MSI_InterruptVectors));
2195   TI_DBG2(("tdsaLoLevelGetResource: asking flag - legacyInt_X %d \n", loResource->loLevelOption.flag));
2196
2197 //  TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n",memRequirement.count, loResource->loLevelMem.mem[memRequirement.count].numElements,loResource->loLevelMem.mem[memRequirement.count].totalLength, loResource->loLevelMem.mem[memRequirement.count].singleElementLength,loResource->loLevelMem.mem[memRequirement.count].alignment ));
2198   TI_DBG6(("tdsaLoLevelGetResource: total memRequirement count %d TI_DMA_MEM\n", loResource->loLevelMem.count));
2199
2200 #elif defined(FDS_DM)
2201   TI_DBG1(("tdsaLoLevelGetResource:MAX_LL_LAYER_MEM_DESCRIPTORS %d\n", MAX_LL_LAYER_MEM_DESCRIPTORS));
2202   for(i=0;i<MAX_LL_LAYER_MEM_DESCRIPTORS;i++)
2203   {
2204     loResource->loLevelMem.mem[i].numElements           = 0;
2205     loResource->loLevelMem.mem[i].totalLength           = 0;
2206     loResource->loLevelMem.mem[i].singleElementLength   = 0;
2207     loResource->loLevelMem.mem[i].alignment             = 0;
2208     loResource->loLevelMem.mem[i].type                  = 0;
2209     loResource->loLevelMem.mem[i].reserved              = 0;
2210     loResource->loLevelMem.mem[i].virtPtr               = agNULL;
2211     loResource->loLevelMem.mem[i].osHandle              = agNULL;
2212     loResource->loLevelMem.mem[i].physAddrUpper         = 0;
2213     loResource->loLevelMem.mem[i].physAddrLower         = 0;
2214   }
2215
2216   TI_DBG1(("tdsaLoLevelGetResource:memRequirement.count %d\n", memRequirement.count));
2217   /* using the returned value from saGetRequirements */
2218   for (i=0;i< memRequirement.count;i++)
2219   {
2220     /* hardcoded values for now */
2221     loResource->loLevelMem.mem[i].numElements = memRequirement.agMemory[i].numElements;
2222     loResource->loLevelMem.mem[i].totalLength = memRequirement.agMemory[i].totalLength;
2223     loResource->loLevelMem.mem[i].singleElementLength = memRequirement.agMemory[i].singleElementLength;
2224     loResource->loLevelMem.mem[i].alignment = memRequirement.agMemory[i].alignment;
2225     TI_DBG2(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2226     if ( AGSA_DMA_MEM == memRequirement.agMemory[i].type )
2227     {
2228       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2229       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2230
2231     }
2232     else if ( AGSA_CACHED_MEM == memRequirement.agMemory[i].type )
2233     {
2234       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2235       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2236     }
2237     else if ( AGSA_CACHED_DMA_MEM == memRequirement.agMemory[i].type )
2238     {
2239       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2240       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2241     }
2242   }
2243
2244   TI_DBG1(("tdsaLoLevelGetResource:dmMemRequirement.count %d\n", dmMemRequirement.count));
2245   /* using the returned value from dmGetRequirements */
2246   for (i=memRequirement.count;i< (memRequirement.count + dmMemRequirement.count);i++)
2247   {
2248     /* hardcoded values for now */
2249     loResource->loLevelMem.mem[i].numElements = dmMemRequirement.dmMemory[i-memRequirement.count].numElements;
2250     loResource->loLevelMem.mem[i].totalLength = dmMemRequirement.dmMemory[i-memRequirement.count].totalLength;
2251     loResource->loLevelMem.mem[i].singleElementLength = dmMemRequirement.dmMemory[i-memRequirement.count].singleElementLength;
2252     loResource->loLevelMem.mem[i].alignment = dmMemRequirement.dmMemory[i-memRequirement.count].alignment;
2253     TI_DBG2(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2254     if ( AGSA_DMA_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2255     {
2256       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2257       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2258
2259     }
2260     else if ( AGSA_CACHED_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2261     {
2262       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2263       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2264     }
2265     else if ( AGSA_CACHED_DMA_MEM == dmMemRequirement.dmMemory[i-memRequirement.count].type )
2266     {
2267       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2268       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2269     }
2270   }
2271
2272
2273
2274   /* sets the low level options */
2275   loResource->loLevelOption.usecsPerTick       = MIN(usecsPerTick, dmUsecsPerTick);
2276   loResource->loLevelOption.numOfQueuesPerPort = maxQueueSets + dmMaxNumLocks + TD_MAX_LOCKS + maxNumOSLocks;
2277   loResource->loLevelOption.mutexLockUsage     = tiOneMutexLockPerQueue;
2278   /* no more ESGL */
2279   loResource->loLevelMem.count = memRequirement.count + dmMemRequirement.count;
2280   /* setting interrupt requirements */
2281   loResource->loLevelOption.maxInterruptVectors = SwConfig.max_MSIX_InterruptVectors;
2282   loResource->loLevelOption.max_MSI_InterruptVectors = SwConfig.max_MSI_InterruptVectors;
2283   loResource->loLevelOption.flag = SwConfig.legacyInt_X;
2284   TI_DBG2(("tdsaLoLevelGetResource: asking maxInterruptVectors(MSIX) %d \n", loResource->loLevelOption.maxInterruptVectors));
2285   TI_DBG2(("tdsaLoLevelGetResource: asking max_MSI_InterruptVectors %d \n", loResource->loLevelOption.max_MSI_InterruptVectors));
2286   TI_DBG2(("tdsaLoLevelGetResource: asking flag - legacyInt_X %d \n", loResource->loLevelOption.flag));
2287
2288 //  TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n",memRequirement.count, loResource->loLevelMem.mem[memRequirement.count].numElements,loResource->loLevelMem.mem[memRequirement.count].totalLength, loResource->loLevelMem.mem[memRequirement.count].singleElementLength,loResource->loLevelMem.mem[memRequirement.count].alignment ));
2289   TI_DBG6(("tdsaLoLevelGetResource: total memRequirement count %d TI_DMA_MEM\n", loResource->loLevelMem.count));
2290
2291 #elif defined(FDS_SM)
2292   TI_DBG1(("tdsaLoLevelGetResource:MAX_LL_LAYER_MEM_DESCRIPTORS %d\n", MAX_LL_LAYER_MEM_DESCRIPTORS));
2293   for(i=0;i<MAX_LL_LAYER_MEM_DESCRIPTORS;i++)
2294   {
2295     loResource->loLevelMem.mem[i].numElements           = 0;
2296     loResource->loLevelMem.mem[i].totalLength           = 0;
2297     loResource->loLevelMem.mem[i].singleElementLength   = 0;
2298     loResource->loLevelMem.mem[i].alignment             = 0;
2299     loResource->loLevelMem.mem[i].type                  = 0;
2300     loResource->loLevelMem.mem[i].reserved              = 0;
2301     loResource->loLevelMem.mem[i].virtPtr               = agNULL;
2302     loResource->loLevelMem.mem[i].osHandle              = agNULL;
2303     loResource->loLevelMem.mem[i].physAddrUpper         = 0;
2304     loResource->loLevelMem.mem[i].physAddrLower         = 0;
2305   }
2306
2307   TI_DBG1(("tdsaLoLevelGetResource:memRequirement.count %d\n", memRequirement.count));
2308   /* using the returned value from saGetRequirements */
2309   for (i=0;i< memRequirement.count;i++)
2310   {
2311     /* hardcoded values for now */
2312     loResource->loLevelMem.mem[i].numElements = memRequirement.agMemory[i].numElements;
2313     loResource->loLevelMem.mem[i].totalLength = memRequirement.agMemory[i].totalLength;
2314     loResource->loLevelMem.mem[i].singleElementLength = memRequirement.agMemory[i].singleElementLength;
2315     loResource->loLevelMem.mem[i].alignment = memRequirement.agMemory[i].alignment;
2316     TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2317     if ( AGSA_DMA_MEM == memRequirement.agMemory[i].type )
2318     {
2319       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2320       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2321
2322     }
2323     else if ( AGSA_CACHED_MEM == memRequirement.agMemory[i].type )
2324     {
2325       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2326       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2327     }
2328     else if ( AGSA_CACHED_DMA_MEM == memRequirement.agMemory[i].type )
2329     {
2330       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2331       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2332     }
2333   }
2334
2335   TI_DBG1(("tdsaLoLevelGetResource:smMemRequirement.count %d\n", smMemRequirement.count));
2336   /* using the returned value from smGetRequirements */
2337   for (i=memRequirement.count;i< (memRequirement.count + smMemRequirement.count);i++)
2338   {
2339     /* hardcoded values for now */
2340     loResource->loLevelMem.mem[i].numElements = smMemRequirement.smMemory[i-memRequirement.count].numElements;
2341     loResource->loLevelMem.mem[i].totalLength = smMemRequirement.smMemory[i-memRequirement.count].totalLength;
2342     loResource->loLevelMem.mem[i].singleElementLength = smMemRequirement.smMemory[i-memRequirement.count].singleElementLength;
2343     loResource->loLevelMem.mem[i].alignment = smMemRequirement.smMemory[i-memRequirement.count].alignment;
2344     TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2345     if ( AGSA_DMA_MEM == smMemRequirement.smMemory[i-memRequirement.count].type )
2346     {
2347       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2348       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2349
2350     }
2351     else if ( AGSA_CACHED_MEM == smMemRequirement.smMemory[i-memRequirement.count].type )
2352     {
2353       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2354       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2355     }
2356     else if ( AGSA_CACHED_DMA_MEM == smMemRequirement.smMemory[i-memRequirement.count].type )
2357     {
2358       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2359       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2360     }
2361   }
2362
2363
2364
2365   /* sets the low level options */
2366   loResource->loLevelOption.usecsPerTick       = MIN(usecsPerTick, smUsecsPerTick);
2367   loResource->loLevelOption.numOfQueuesPerPort = maxQueueSets + smMaxNumLocks + TD_MAX_LOCKS + maxNumOSLocks;
2368   loResource->loLevelOption.mutexLockUsage     = tiOneMutexLockPerQueue;
2369   /* no more ESGL */
2370   loResource->loLevelMem.count = memRequirement.count + smMemRequirement.count;
2371   /* setting interrupt requirements */
2372   loResource->loLevelOption.maxInterruptVectors = SwConfig.max_MSIX_InterruptVectors;
2373   loResource->loLevelOption.max_MSI_InterruptVectors = SwConfig.max_MSI_InterruptVectors;
2374   loResource->loLevelOption.flag = SwConfig.legacyInt_X;
2375   TI_DBG2(("tdsaLoLevelGetResource: asking maxInterruptVectors(MSIX) %d \n", loResource->loLevelOption.maxInterruptVectors));
2376   TI_DBG2(("tdsaLoLevelGetResource: asking max_MSI_InterruptVectors %d \n", loResource->loLevelOption.max_MSI_InterruptVectors));
2377   TI_DBG2(("tdsaLoLevelGetResource: asking flag - legacyInt_X %d \n", loResource->loLevelOption.flag));
2378
2379 //  TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n",memRequirement.count, loResource->loLevelMem.mem[memRequirement.count].numElements,loResource->loLevelMem.mem[memRequirement.count].totalLength, loResource->loLevelMem.mem[memRequirement.count].singleElementLength,loResource->loLevelMem.mem[memRequirement.count].alignment ));
2380   TI_DBG6(("tdsaLoLevelGetResource: total memRequirement count %d TI_DMA_MEM\n", loResource->loLevelMem.count));
2381
2382
2383 #else
2384   TI_DBG6(("tdsaLoLevelGetResource:MAX_LL_LAYER_MEM_DESCRIPTORS %d\n", MAX_LL_LAYER_MEM_DESCRIPTORS));
2385   for(i=0;i<MAX_LL_LAYER_MEM_DESCRIPTORS;i++)
2386   {
2387     loResource->loLevelMem.mem[i].numElements           = 0;
2388     loResource->loLevelMem.mem[i].totalLength           = 0;
2389     loResource->loLevelMem.mem[i].singleElementLength   = 0;
2390     loResource->loLevelMem.mem[i].alignment             = 0;
2391     loResource->loLevelMem.mem[i].type                  = 0;
2392     loResource->loLevelMem.mem[i].reserved              = 0;
2393     loResource->loLevelMem.mem[i].virtPtr               = agNULL;
2394     loResource->loLevelMem.mem[i].osHandle              = agNULL;
2395     loResource->loLevelMem.mem[i].physAddrUpper         = 0;
2396     loResource->loLevelMem.mem[i].physAddrLower         = 0;
2397   }
2398
2399   /* using the returned value from saGetRequirements */
2400   for (i=0;i< memRequirement.count;i++)
2401   {
2402     /* hardcoded values for now */
2403     loResource->loLevelMem.mem[i].numElements = memRequirement.agMemory[i].numElements;
2404     loResource->loLevelMem.mem[i].totalLength = memRequirement.agMemory[i].totalLength;
2405     loResource->loLevelMem.mem[i].singleElementLength = memRequirement.agMemory[i].singleElementLength;
2406     loResource->loLevelMem.mem[i].alignment = memRequirement.agMemory[i].alignment;
2407     TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].numElements, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].singleElementLength,loResource->loLevelMem.mem[i].alignment ));
2408     if ( AGSA_DMA_MEM == memRequirement.agMemory[i].type )
2409     {
2410       loResource->loLevelMem.mem[i].type = TI_DMA_MEM;
2411       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_DMA_MEM\n", i));
2412
2413     }
2414     else if ( AGSA_CACHED_MEM == memRequirement.agMemory[i].type )
2415     {
2416       loResource->loLevelMem.mem[i].type = TI_CACHED_MEM;
2417       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_MEM\n", i));
2418     }
2419     else if ( AGSA_CACHED_DMA_MEM == memRequirement.agMemory[i].type )
2420     {
2421       loResource->loLevelMem.mem[i].type = TI_CACHED_DMA_MEM;
2422       TI_DBG6(("tdsaLoLevelGetResource: index %d TI_CACHED_DMA_MEM\n", i));
2423     }
2424   }
2425
2426
2427
2428   /* sets the low level options */
2429   loResource->loLevelOption.usecsPerTick       = usecsPerTick;
2430   loResource->loLevelOption.numOfQueuesPerPort = maxQueueSets + TD_MAX_LOCKS + maxNumOSLocks;
2431   loResource->loLevelOption.mutexLockUsage     = tiOneMutexLockPerQueue;
2432   /* no more ESGL */
2433   loResource->loLevelMem.count = memRequirement.count;
2434   /* setting interrupt requirements */
2435   loResource->loLevelOption.maxInterruptVectors = SwConfig.max_MSIX_InterruptVectors;
2436   loResource->loLevelOption.max_MSI_InterruptVectors = SwConfig.max_MSI_InterruptVectors;
2437   loResource->loLevelOption.flag = SwConfig.legacyInt_X;
2438   TI_DBG2(("tdsaLoLevelGetResource: asking maxInterruptVectors(MSIX) %d \n", loResource->loLevelOption.maxInterruptVectors));
2439   TI_DBG2(("tdsaLoLevelGetResource: asking max_MSI_InterruptVectors %d \n", loResource->loLevelOption.max_MSI_InterruptVectors));
2440   TI_DBG2(("tdsaLoLevelGetResource: asking flag - legacyInt_X %d \n", loResource->loLevelOption.flag));
2441
2442   TI_DBG6(("tdsaLoLevelGetResource: index %d numElements %d totalLength %d singleElementLength %d alignment %d\n",memRequirement.count, loResource->loLevelMem.mem[memRequirement.count].numElements,loResource->loLevelMem.mem[memRequirement.count].totalLength, loResource->loLevelMem.mem[memRequirement.count].singleElementLength,loResource->loLevelMem.mem[memRequirement.count].alignment ));
2443   TI_DBG6(("tdsaLoLevelGetResource: memRequirement.count %d TI_DMA_MEM\n", memRequirement.count));
2444 #endif
2445
2446
2447
2448  return;
2449 }
2450
2451 /*****************************************************************************
2452 *! \brief tdsaSharedMemCalculate
2453 *
2454 *  Purpose:  This function is called to determine the Transport
2455 *            Dependent Layer internal resource requirement
2456 *            for shared memory between target and initiator
2457 *            functionality.
2458 *
2459 *  \param  tiRoot:             Pointer to driver/port instance.
2460 *  \param  tdSharedMem:        Pointer to shared memory structure
2461 *
2462 *  \return: None
2463 *
2464 *  \note - The shared memory is composed of like the followings
2465 *          sizeof(tdsaRoot_t)
2466 *          + sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT
2467 *          + sizeof(tdsaDeviceData_t) * MaxTargets
2468 *          + sizeof(tdsaEsglPageInfo_t) * NumEsglPages
2469 *
2470 *****************************************************************************/
2471 osGLOBAL void
2472 tdsaSharedMemCalculate(
2473                        tiRoot_t              * tiRoot,
2474                        tiLoLevelResource_t   * loResource,
2475                        tiTdSharedMem_t       * tdSharedMem
2476                        )
2477 {
2478   bit32 MaxTargets;
2479
2480   /* the following fn fills in MaxTargets */
2481   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
2482   TI_DBG6(("tdsaSharedMemCalculate: MaxTargets %d\n", MaxTargets));
2483
2484   /*
2485    * Cached mem for the shared TD Layer functionality
2486    */
2487   tdSharedMem->tdSharedCachedMem1.singleElementLength =
2488     sizeof(tdsaRoot_t) + (sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT) +
2489     (sizeof(tdsaDeviceData_t) * MaxTargets);
2490
2491 #ifdef TD_INT_COALESCE
2492   /* adding TD interrupt coalesce data structure to the shared TD layer */
2493   /* TD_MAX_INT_COALESCE is defined to be 512 */
2494   tdSharedMem->tdSharedCachedMem1.singleElementLength +=
2495     sizeof(tdsaIntCoalesceContext_t) * TD_MAX_INT_COALESCE;
2496 #endif
2497
2498 #ifdef TD_DISCOVER
2499   /* adding expander data strutures */
2500   tdSharedMem->tdSharedCachedMem1.singleElementLength +=
2501     sizeof(tdsaExpander_t) * MaxTargets;
2502 #endif
2503
2504   tdSharedMem->tdSharedCachedMem1.numElements = 1;
2505
2506   tdSharedMem->tdSharedCachedMem1.totalLength =
2507       tdSharedMem->tdSharedCachedMem1.singleElementLength *
2508       tdSharedMem->tdSharedCachedMem1.numElements;
2509
2510   tdSharedMem->tdSharedCachedMem1.alignment = 8;
2511
2512   tdSharedMem->tdSharedCachedMem1.type = TI_CACHED_MEM;
2513
2514   tdSharedMem->tdSharedCachedMem1.virtPtr = agNULL;
2515   tdSharedMem->tdSharedCachedMem1.osHandle = agNULL;
2516   tdSharedMem->tdSharedCachedMem1.physAddrUpper = 0;
2517   tdSharedMem->tdSharedCachedMem1.physAddrLower = 0;
2518   tdSharedMem->tdSharedCachedMem1.reserved = 0;
2519
2520   return;
2521 }
2522
2523
2524 /*****************************************************************************
2525 *! \biref tdResetComMemFlags
2526 *
2527 *  Purpose:  This function is called to reset all the flags for the port
2528 *
2529 *  \param  tiRoot:             Pointer to driver/port instance.
2530 *
2531 *  \return: None
2532 *
2533 *
2534 *****************************************************************************/
2535 osGLOBAL void
2536 tdsaResetComMemFlags(
2537                      tiRoot_t *tiRoot
2538                      )
2539 {
2540   tdsaRoot_t    *tdsaRoot = (tdsaRoot_t *)tiRoot->tdData;
2541   tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2542 #ifdef TD_DEBUG_ENABLE
2543   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2544   TI_DBG6(("tdsaResetComMemFlags: start\n"));
2545   TI_DBG6(("tdsaResetComMemFlag:: ******* tdsaRoot %p \n", tdsaRoot));
2546   TI_DBG6(("tdsaResetComMemFlag:: ******* tdsaPortContext %p \n",tdsaPortContext));
2547 #endif
2548
2549   tdsaAllShared->flags.sysIntsActive              = agFALSE;
2550   tdsaAllShared->flags.resetInProgress            = agFALSE;
2551
2552   return;
2553 }
2554
2555 /*****************************************************************************
2556 *! \biref tdssInitSASPortStartInfo
2557 *
2558 *  Purpose:  This function sets information related to staring a port
2559 *
2560 *  \param  tiRoot:             Pointer to driver/port instance.
2561 *
2562 *  \return: None
2563 *
2564 *
2565 *****************************************************************************/
2566 osGLOBAL void
2567 tdssInitSASPortStartInfo(
2568                          tiRoot_t *tiRoot
2569                          )
2570 {
2571   tdsaRoot_t        *tdsaRoot = (tdsaRoot_t *)tiRoot->tdData;
2572   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2573   int i;
2574 #ifdef TD_DEBUG_ENABLE
2575   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2576   TI_DBG6(("tdssInitSASPortStartInfo: start\n"));
2577
2578   TI_DBG6(("tdssInitSASPortStartInfo: ******* tdsaRoot %p \n", tdsaRoot));
2579   TI_DBG6(("tdssInitSASPortStartInfo: ******* tdsaPortContext %p \n",tdsaPortContext));
2580 #endif
2581
2582   for(i=0;i<TD_MAX_NUM_PHYS;i++)
2583   {
2584     tdsaAllShared->Ports[i].tiPortalContext = agNULL;
2585     tdsaAllShared->Ports[i].portContext = agNULL;
2586     tdsaAllShared->Ports[i].SASID.sasAddressHi[0] = 0;
2587     tdsaAllShared->Ports[i].SASID.sasAddressHi[1] = 0;
2588     tdsaAllShared->Ports[i].SASID.sasAddressHi[2] = 0;
2589     tdsaAllShared->Ports[i].SASID.sasAddressHi[3] = 0;
2590     tdsaAllShared->Ports[i].SASID.sasAddressLo[0] = 0;
2591     tdsaAllShared->Ports[i].SASID.sasAddressLo[1] = 0;
2592     tdsaAllShared->Ports[i].SASID.sasAddressLo[2] = 0;
2593     tdsaAllShared->Ports[i].SASID.sasAddressLo[3] = 0;
2594     tdsaAllShared->Ports[i].SASID.phyIdentifier = (bit8) i;
2595     /* continue .... */
2596
2597     tdsaAllShared->Ports[i].flags.portStarted = agFALSE;
2598     tdsaAllShared->Ports[i].flags.portInitialized = agFALSE;
2599     tdsaAllShared->Ports[i].flags.portReadyForDiscoverySent = agFALSE;
2600     tdsaAllShared->Ports[i].flags.portStoppedByOSLayer = agFALSE;
2601     tdsaAllShared->Ports[i].flags.failPortInit = agFALSE;
2602   }
2603
2604   return;
2605 }
2606
2607
2608 /*****************************************************************************
2609 *! \brief tdsaInitTimers
2610 *
2611 *  Purpose: This function is called to initialize the timers
2612 *           for initiator
2613 *
2614 *  \param   tiRoot: pointer to the driver instance
2615 *
2616 *  \return: None
2617 *
2618 *  \note:
2619 *
2620 *****************************************************************************/
2621
2622 osGLOBAL void
2623 tdsaInitTimers(
2624                tiRoot_t *tiRoot
2625                )
2626 {
2627   tdsaRoot_t               *tdsaRoot    = (tdsaRoot_t *)tiRoot->tdData;
2628   tdsaContext_t            *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2629 #ifdef TD_DEBUG_ENABLE
2630   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2631
2632   TI_DBG6(("tdsaInitTimers: start \n"));
2633   TI_DBG6(("tdsaInitTimers: ******* tdsaRoot %p \n", tdsaRoot));
2634   TI_DBG6(("tdsaInitTimers: ******* tdsaPortContext %p \n",tdsaPortContext));
2635 #endif
2636
2637   /* initialize the timerlist */
2638   TDLIST_INIT_HDR(&(tdsaAllShared->timerlist));
2639
2640   return;
2641 }
2642
2643
2644 /*****************************************************************************
2645 *! \brief tdsaJumpTableInit
2646 *
2647 *  Purpose: This function initializes SAS related callback functions
2648 *
2649 *  \param   tiRoot: pointer to the driver instance
2650 *
2651 *  \return: None
2652 *
2653 *  \note:
2654 *
2655 *****************************************************************************/
2656 osGLOBAL void
2657 tdsaJumpTableInit(
2658                   tiRoot_t *tiRoot
2659                   )
2660 {
2661
2662   tdsaRoot_t        *tdsaRoot    = (tdsaRoot_t *)tiRoot->tdData;
2663   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2664 #ifdef TD_DEBUG_ENABLE
2665   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2666
2667   TI_DBG6(("tdsaJumpTableInit: start \n"));
2668   TI_DBG6(("tdsaJumpTableInit:: ******* tdsaRoot %p \n", tdsaRoot));
2669   TI_DBG6(("tdsaJumpTableInit:: ******* tdsaPortContext %p \n",tdsaPortContext));
2670 #endif
2671
2672   /* tdtype.h */
2673   /*
2674     For combo,
2675     pSSPIOCompleted, pSMPCompleted; use callback
2676     pSSPReqReceive, pSMPReqReceived; use jumptable
2677   */
2678
2679 #ifdef INITIATOR_DRIVER
2680   tdsaAllShared->tdJumpTable.pSSPIOCompleted = agNULL; /* initiator */
2681   tdsaAllShared->tdJumpTable.pSMPCompleted =agNULL; /* initiator */
2682 #endif
2683 #ifdef TARGET_DRIVER
2684   tdsaAllShared->tdJumpTable.pSSPIOCompleted = agNULL;
2685   tdsaAllShared->tdJumpTable.pSSPReqReceived = &ttdsaSSPReqReceived;
2686   tdsaAllShared->tdJumpTable.pSMPReqReceived = &ttdsaSMPReqReceived;
2687   tdsaAllShared->tdJumpTable.pSMPCompleted =agNULL;
2688 #endif
2689   tdsaAllShared->tdJumpTable.pGetSGLChunk = agNULL;
2690   return;
2691
2692 }
2693
2694
2695 /*****************************************************************************
2696 *! \brief tdsaPortContextInit
2697 *
2698 *  Purpose: This function initializes port contexts.
2699 *
2700 *  \param   tiRoot: pointer to the driver instance
2701 *
2702 *  \return: None
2703 *
2704 *  \note:
2705 *
2706 *****************************************************************************/
2707 osGLOBAL void
2708 tdsaPortContextInit(
2709                     tiRoot_t *tiRoot
2710                     )
2711 {
2712   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
2713   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2714   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2715   int i = 0;
2716   int j = 0;
2717
2718   TI_DBG6(("tdsaPortContextInit: start\n"));
2719   TI_DBG6(("tdsaPortContextInit: ******* sizeof(tdsaPortContext) %d %x\n", (int)sizeof(tdsaPortContext_t), (unsigned int)sizeof(tdsaPortContext_t)));
2720   TI_DBG6(("tdsaPortContextInit: ******* tdsaRoot %p \n", tdsaRoot));
2721   TI_DBG6(("tdsaPortContextInit: ******* tdsaPortContext %p \n",tdsaPortContext));
2722   TI_DBG6(("tdsaPortContextInit: ******* tdsaPortContext+1 %p \n",tdsaPortContext + 1));
2723   TI_DBG6(("tdsaPortContextInit: ******* &tdsaPortContext[0] %p  &tdsaPortContext[1] %p\n", &(tdsaPortContext[0]), &(tdsaPortContext[1])));
2724
2725   TDLIST_INIT_HDR(&(tdsaAllShared->MainPortContextList));
2726   TDLIST_INIT_HDR(&(tdsaAllShared->FreePortContextList));
2727
2728   for(i=0;i<TD_MAX_PORT_CONTEXT;i++)
2729   {
2730     TDLIST_INIT_ELEMENT(&(tdsaPortContext[i].FreeLink));
2731     TDLIST_INIT_ELEMENT(&(tdsaPortContext[i].MainLink));
2732
2733 #ifdef TD_DISCOVER
2734     TDLIST_INIT_HDR(&(tdsaPortContext[i].discovery.discoveringExpanderList));
2735     TDLIST_INIT_HDR(&(tdsaPortContext[i].discovery.UpdiscoveringExpanderList));
2736     tdsaPortContext[i].discovery.type = TDSA_DISCOVERY_OPTION_FULL_START;
2737     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.discoveryTimer));
2738     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.configureRouteTimer));
2739     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.deviceRegistrationTimer));
2740     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.SMPBusyTimer));
2741     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.BCTimer));
2742     tdsaInitTimerRequest(tiRoot, &(tdsaPortContext[i].discovery.DiscoverySMPTimer));
2743     tdsaPortContext[i].discovery.retries = 0;
2744     tdsaPortContext[i].discovery.configureRouteRetries = 0;
2745     tdsaPortContext[i].discovery.deviceRetistrationRetries = 0;
2746     tdsaPortContext[i].discovery.pendingSMP = 0;
2747     tdsaPortContext[i].discovery.SeenBC = agFALSE;
2748     tdsaPortContext[i].discovery.forcedOK = agFALSE;
2749     tdsaPortContext[i].discovery.SMPRetries = 0;
2750 //    tdsaPortContext[i].discovery.doIncremental = agFALSE;
2751     tdsaPortContext[i].discovery.ResetTriggerred = agFALSE;
2752 #endif
2753
2754
2755 #ifdef INITIATOR_DRIVER
2756     tdsaPortContext[i].DiscoveryState = ITD_DSTATE_NOT_STARTED;
2757     tdsaPortContext[i].nativeSATAMode = agFALSE;
2758     tdsaPortContext[i].directAttatchedSAS = agFALSE;
2759     tdsaPortContext[i].DiscoveryRdyGiven = agFALSE;
2760     tdsaPortContext[i].SeenLinkUp = agFALSE;
2761
2762 #endif
2763     tdsaPortContext[i].id = i;
2764     tdsaPortContext[i].agPortContext = agNULL;
2765     tdsaPortContext[i].LinkRate = 0;
2766     tdsaPortContext[i].Count = 0;
2767     tdsaPortContext[i].valid = agFALSE;
2768     for (j=0;j<TD_MAX_NUM_PHYS;j++)
2769     {
2770       tdsaPortContext[i].PhyIDList[j] = agFALSE;
2771     }
2772     tdsaPortContext[i].RegisteredDevNums = 0;
2773     tdsaPortContext[i].eventPhyID = 0xFF;
2774     tdsaPortContext[i].Transient = agFALSE;
2775     tdsaPortContext[i].PortRecoverPhyID = 0xFF;
2776     tdsaPortContext[i].DiscFailNSeenBC = agFALSE;
2777 #ifdef FDS_DM
2778     tdsaPortContext[i].dmPortContext.tdData = &(tdsaPortContext[i]);
2779     tdsaPortContext[i].DMDiscoveryState = dmDiscCompleted;
2780     tdsaPortContext[i].UseDM = agFALSE;
2781     tdsaPortContext[i].UpdateMCN = agFALSE;
2782 #endif
2783     /* add more variables later */
2784     TDLIST_ENQUEUE_AT_TAIL(&(tdsaPortContext[i].FreeLink), &(tdsaAllShared->FreePortContextList));
2785   }
2786
2787 #ifdef TD_INTERNAL_DEBUG  /* for debugging only */
2788   for(i=0;i<TD_MAX_PORT_CONTEXT;i++)
2789   {
2790     TI_DBG6(("tdsaPortContextInit: index %d  &tdsaPortContext[] %p\n", i, &(tdsaPortContext[i])));
2791   }
2792   TI_DBG6(("tdsaPortContextInit: sizeof(tdsaPortContext_t) %d 0x%x\n", sizeof(tdsaPortContext_t), sizeof(tdsaPortContext_t)));
2793 #endif
2794   return;
2795 }
2796
2797 /*****************************************************************************
2798 *! \brief tdsaPortContextReInit
2799 *
2800 *  Purpose: This function re-initializes port contexts for reuse.
2801 *
2802 *  \param   tiRoot:         pointer to the driver instance
2803 *  \param   onePortContext: pointer to the portcontext
2804 *
2805 *  \return: None
2806 *
2807 *  \note:
2808 *
2809 *****************************************************************************/
2810 osGLOBAL void
2811 tdsaPortContextReInit(
2812                       tiRoot_t             *tiRoot,
2813                       tdsaPortContext_t    *onePortContext
2814                     )
2815 {
2816   int               j=0;
2817 #ifdef TD_DISCOVER
2818   tdsaDiscovery_t   *discovery;
2819 #endif
2820
2821   TI_DBG3(("tdsaPortContextReInit: start\n"));
2822
2823 #ifdef TD_DISCOVER
2824   discovery = &(onePortContext->discovery);
2825
2826     onePortContext->discovery.type = TDSA_DISCOVERY_OPTION_FULL_START;
2827     onePortContext->discovery.retries = 0;
2828     onePortContext->discovery.configureRouteRetries = 0;
2829     onePortContext->discovery.deviceRetistrationRetries = 0;
2830     onePortContext->discovery.pendingSMP = 0;
2831     onePortContext->discovery.SeenBC = agFALSE;
2832     onePortContext->discovery.forcedOK = agFALSE;
2833     onePortContext->discovery.SMPRetries = 0;
2834     onePortContext->discovery.ResetTriggerred = agFALSE;
2835     /* free expander lists */
2836     tdsaFreeAllExp(tiRoot, onePortContext);
2837     /* kill the discovery-related timers if they are running */
2838     if (discovery->discoveryTimer.timerRunning == agTRUE)
2839     {
2840       tdsaKillTimer(
2841                     tiRoot,
2842                     &discovery->discoveryTimer
2843                    );
2844     }
2845     if (discovery->configureRouteTimer.timerRunning == agTRUE)
2846     {
2847       tdsaKillTimer(
2848                     tiRoot,
2849                     &discovery->configureRouteTimer
2850                    );
2851     }
2852     if (discovery->deviceRegistrationTimer.timerRunning == agTRUE)
2853     {
2854       tdsaKillTimer(
2855                     tiRoot,
2856                     &discovery->deviceRegistrationTimer
2857                    );
2858     }
2859     if (discovery->BCTimer.timerRunning == agTRUE)
2860     {
2861       tdsaKillTimer(
2862                     tiRoot,
2863                     &discovery->BCTimer
2864                    );
2865     }
2866     if (discovery->SMPBusyTimer.timerRunning == agTRUE)
2867     {
2868       tdsaKillTimer(
2869                     tiRoot,
2870                     &discovery->SMPBusyTimer
2871                    );
2872     }
2873     if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
2874     {
2875       tdsaKillTimer(
2876                     tiRoot,
2877                     &discovery->DiscoverySMPTimer
2878                    );
2879     }
2880 #endif
2881
2882 #ifdef INITIATOR_DRIVER
2883     onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
2884     onePortContext->nativeSATAMode = agFALSE;
2885     onePortContext->directAttatchedSAS = agFALSE;
2886     onePortContext->DiscoveryRdyGiven = agFALSE;
2887     onePortContext->SeenLinkUp = agFALSE;
2888 #endif
2889     onePortContext->agPortContext->osData = agNULL;
2890     onePortContext->agPortContext = agNULL;
2891     onePortContext->tiPortalContext = agNULL;
2892     onePortContext->agRoot = agNULL;
2893     onePortContext->LinkRate = 0;
2894     onePortContext->Count = 0;
2895     onePortContext->valid = agFALSE;
2896     for (j=0;j<TD_MAX_NUM_PHYS;j++)
2897     {
2898       onePortContext->PhyIDList[j] = agFALSE;
2899     }
2900     onePortContext->RegisteredDevNums = 0;
2901     onePortContext->eventPhyID = 0xFF;
2902     onePortContext->Transient = agFALSE;
2903     onePortContext->PortRecoverPhyID = 0xFF;
2904     onePortContext->DiscFailNSeenBC = agFALSE;
2905
2906 #ifdef FDS_DM
2907     onePortContext->dmPortContext.tdData = onePortContext;
2908     onePortContext->DMDiscoveryState = dmDiscCompleted;
2909     onePortContext->UseDM = agFALSE;
2910     onePortContext->UpdateMCN = agFALSE;
2911 #endif
2912   return;
2913 }
2914
2915 /*****************************************************************************
2916 *! \brief tdsaDeviceDataInit
2917 *
2918 *  Purpose: This function initializes devices
2919 *
2920 *  \param   tiRoot: pointer to the driver instance
2921 *
2922 *  \return: None
2923 *
2924 *  \note:
2925 *
2926 *****************************************************************************/
2927 osGLOBAL void
2928 tdsaDeviceDataInit(
2929                    tiRoot_t *tiRoot
2930                    )
2931 {
2932   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
2933   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2934 #ifdef TD_DEBUG_ENABLE
2935   tdsaPortContext_t *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContextMem;
2936 #endif
2937   tdsaDeviceData_t  *tdsaDeviceData =
2938     (tdsaDeviceData_t *)tdsaAllShared->DeviceMem;
2939   int i;
2940 #ifdef  SATA_ENABLE
2941   bit32             j;
2942   satInternalIo_t   *satIntIO;
2943 #endif
2944   bit32             MaxTargets;
2945
2946   TI_DBG6(("tdsaDeviceDataInit: start\n"));
2947   TI_DBG6(("tdsaDeviceDataInit: ******* tdsaPortContext %p \n",tdsaPortContext));
2948   TI_DBG6(("tdsaDeviceDataInit: ******* tdsaDeviceData %p\n", tdsaDeviceData));
2949   TI_DBG6(("tdsaDeviceDataInit: ******* tdsaDeviceData+1 %p\n", tdsaDeviceData+1));
2950   TI_DBG6(("tdsaDeviceDataInit: ******* &tdsaDeviceData[0] %p  &tdsaDeviceData[1] %p\n", &(tdsaDeviceData[0]), &(tdsaDeviceData[1])));
2951
2952   /* the following fn fills in MaxTargets */
2953   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
2954   TI_DBG6(("tdsaDeviceDataInit: MaxTargets %d\n", MaxTargets));
2955
2956   TDLIST_INIT_HDR(&(tdsaAllShared->MainDeviceList));
2957   TDLIST_INIT_HDR(&(tdsaAllShared->FreeDeviceList));
2958
2959   for(i=0;i<(int)MaxTargets;i++)
2960   {
2961     TDLIST_INIT_ELEMENT(&(tdsaDeviceData[i].FreeLink));
2962     TDLIST_INIT_ELEMENT(&(tdsaDeviceData[i].MainLink));
2963     TDLIST_INIT_ELEMENT(&(tdsaDeviceData[i].IncDisLink));
2964     tdsaDeviceData[i].id = i;
2965     tdsaDeviceData[i].InQID = 0;
2966     tdsaDeviceData[i].OutQID = 0;
2967     tdsaDeviceData[i].DeviceType = TD_DEFAULT_DEVICE;
2968     tdsaDeviceData[i].agRoot = agNULL;
2969     tdsaDeviceData[i].agDevHandle = agNULL;
2970
2971     tdsaDeviceData[i].pJumpTable = &(tdsaAllShared->tdJumpTable);
2972     tdsaDeviceData[i].tiDeviceHandle.osData = agNULL;
2973     tdsaDeviceData[i].tiDeviceHandle.tdData = &(tdsaDeviceData[i]);
2974     tdsaDeviceData[i].tdPortContext = agNULL;
2975     tdsaDeviceData[i].tdExpander = agNULL;
2976     tdsaDeviceData[i].ExpDevice = agNULL;
2977     tdsaDeviceData[i].phyID = 0xFF;
2978     tdsaDeviceData[i].SASAddressID.sasAddressHi = 0;
2979     tdsaDeviceData[i].SASAddressID.sasAddressLo = 0;
2980     tdsaDeviceData[i].valid = agFALSE;
2981     tdsaDeviceData[i].valid2 = agFALSE;
2982     tdsaDeviceData[i].processed = agFALSE;
2983     tdsaDeviceData[i].initiator_ssp_stp_smp = 0;
2984     tdsaDeviceData[i].target_ssp_stp_smp = 0;
2985     tdsaDeviceData[i].numOfPhys = 0;
2986     tdsaDeviceData[i].registered = agFALSE;
2987     tdsaDeviceData[i].directlyAttached = agFALSE;
2988     tdsaDeviceData[i].SASSpecDeviceType = 0xFF;
2989     tdsaDeviceData[i].IOStart = 0;
2990     tdsaDeviceData[i].IOResponse = 0;
2991     tdsaDeviceData[i].agDeviceResetContext.osData = agNULL;
2992     tdsaDeviceData[i].agDeviceResetContext.sdkData = agNULL;
2993     tdsaDeviceData[i].TRflag = agFALSE;
2994     tdsaDeviceData[i].ResetCnt = 0;
2995     tdsaDeviceData[i].OSAbortAll = agFALSE;
2996
2997 #ifdef FDS_DM
2998     tdsaDeviceData[i].devMCN = 1;
2999     tdsaDeviceData[i].finalMCN = 1;
3000 #endif
3001
3002 #ifdef FDS_SM
3003     tdsaDeviceData[i].SMNumOfFCA = 0;
3004     tdsaDeviceData[i].SMNumOfID = 0;
3005 #endif
3006
3007 #ifdef  SATA_ENABLE
3008     TDLIST_INIT_HDR(&(tdsaDeviceData[i].satDevData.satIoLinkList));
3009     TDLIST_INIT_HDR(&(tdsaDeviceData[i].satDevData.satFreeIntIoLinkList));
3010     TDLIST_INIT_HDR(&(tdsaDeviceData[i].satDevData.satActiveIntIoLinkList));
3011
3012     /* default */
3013     tdsaDeviceData[i].satDevData.satDriveState = SAT_DEV_STATE_NORMAL;
3014     tdsaDeviceData[i].satDevData.satNCQMaxIO =SAT_NCQ_MAX;
3015     tdsaDeviceData[i].satDevData.satPendingIO = 0;
3016     tdsaDeviceData[i].satDevData.satPendingNCQIO = 0;
3017     tdsaDeviceData[i].satDevData.satPendingNONNCQIO = 0;
3018     tdsaDeviceData[i].satDevData.IDDeviceValid = agFALSE;
3019     tdsaDeviceData[i].satDevData.freeSATAFDMATagBitmap = 0;
3020     tdsaDeviceData[i].satDevData.NumOfFCA = 0;
3021     tdsaDeviceData[i].satDevData.NumOfIDRetries = 0;
3022     tdsaDeviceData[i].satDevData.ID_Retries = 0;
3023     tdsaDeviceData[i].satDevData.IDPending = agFALSE;
3024     tdsaInitTimerRequest(tiRoot, &(tdsaDeviceData[i].SATAIDDeviceTimer));
3025 #ifdef FDS_SM
3026     tdsaInitTimerRequest(tiRoot, &(tdsaDeviceData[i].tdIDTimer));
3027 #endif
3028     osti_memset(tdsaDeviceData[i].satDevData.satMaxLBA, 0, sizeof(tdsaDeviceData[i].satDevData.satMaxLBA));
3029
3030     tdsaDeviceData[i].satDevData.satSaDeviceData = &tdsaDeviceData[i];
3031     satIntIO = &tdsaDeviceData[i].satDevData.satIntIo[0];
3032     for (j = 0; j < SAT_MAX_INT_IO; j++)
3033     {
3034       TDLIST_INIT_ELEMENT (&satIntIO->satIntIoLink);
3035       TDLIST_ENQUEUE_AT_TAIL (&satIntIO->satIntIoLink,
3036                               &tdsaDeviceData[i].satDevData.satFreeIntIoLinkList);
3037       satIntIO->satOrgTiIORequest = agNULL;
3038       satIntIO->id = j;
3039       satIntIO = satIntIO + 1;
3040     }
3041 #endif
3042     /* some other variables */
3043     TDLIST_ENQUEUE_AT_TAIL(&(tdsaDeviceData[i].FreeLink), &(tdsaAllShared->FreeDeviceList));
3044   }
3045
3046 #ifdef TD_INTERNAL_DEBUG  /* for debugging only */
3047   for(i=0;i<MaxTargets;i++)
3048   {
3049     TI_DBG6(("tdsaDeviceDataInit: index %d  &tdsaDeviceData[] %p\n", i, &(tdsaDeviceData[i])));
3050
3051   }
3052   TI_DBG6(("tdsaDeviceDataInit: sizeof(tdsaDeviceData_t) %d 0x%x\n", sizeof(tdsaDeviceData_t), sizeof(tdsaDeviceData_t)));
3053 #endif
3054   return;
3055 }
3056
3057 /*****************************************************************************
3058 *! \brief tdsaDeviceDataReInit
3059 *
3060 *  Purpose: This function re-initializes device data for reuse.
3061 *
3062 *  \param   tiRoot:         pointer to the driver instance
3063 *  \param   onePortContext: pointer to the device data
3064 *
3065 *  \return: None
3066 *
3067 *  \note:
3068 *
3069 *****************************************************************************/
3070 osGLOBAL void
3071 tdsaDeviceDataReInit(
3072                    tiRoot_t             *tiRoot,
3073                    tdsaDeviceData_t     *oneDeviceData
3074                    )
3075 {
3076   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
3077   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3078 #ifdef  SATA_ENABLE
3079   int               j=0;
3080   satInternalIo_t   *satIntIO;
3081 #endif
3082
3083   TI_DBG3(("tdsaDeviceDataReInit: start\n"));
3084
3085     oneDeviceData->InQID = 0;
3086     oneDeviceData->OutQID = 0;
3087     oneDeviceData->DeviceType = TD_DEFAULT_DEVICE;
3088     oneDeviceData->agDevHandle = agNULL;
3089
3090     oneDeviceData->pJumpTable = &(tdsaAllShared->tdJumpTable);
3091     oneDeviceData->tiDeviceHandle.osData = agNULL;
3092     oneDeviceData->tiDeviceHandle.tdData = oneDeviceData;
3093     oneDeviceData->tdPortContext = agNULL;
3094     oneDeviceData->tdExpander = agNULL;
3095     oneDeviceData->ExpDevice = agNULL;
3096     oneDeviceData->phyID = 0xFF;
3097     oneDeviceData->SASAddressID.sasAddressHi = 0;
3098     oneDeviceData->SASAddressID.sasAddressLo = 0;
3099     oneDeviceData->valid = agFALSE;
3100     oneDeviceData->valid2 = agFALSE;
3101     oneDeviceData->processed = agFALSE;
3102     oneDeviceData->initiator_ssp_stp_smp = 0;
3103     oneDeviceData->target_ssp_stp_smp = 0;
3104     oneDeviceData->numOfPhys = 0;
3105     oneDeviceData->registered = agFALSE;
3106     oneDeviceData->directlyAttached = agFALSE;
3107     oneDeviceData->SASSpecDeviceType = 0xFF;
3108     oneDeviceData->IOStart = 0;
3109     oneDeviceData->IOResponse = 0;
3110     oneDeviceData->agDeviceResetContext.osData = agNULL;
3111     oneDeviceData->agDeviceResetContext.sdkData = agNULL;
3112     oneDeviceData->TRflag = agFALSE;
3113     oneDeviceData->ResetCnt = 0;
3114     oneDeviceData->OSAbortAll = agFALSE;
3115
3116 #ifdef FDS_DM
3117     oneDeviceData->devMCN = 1;
3118     oneDeviceData->finalMCN = 1;
3119 #endif
3120
3121 #ifdef FDS_SM
3122     oneDeviceData->SMNumOfFCA = 0;
3123     oneDeviceData->SMNumOfID = 0;
3124     if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
3125     {
3126       tdsaKillTimer(
3127                     tiRoot,
3128                     &oneDeviceData->tdIDTimer
3129                     );
3130     }
3131 #endif
3132
3133 #ifdef  SATA_ENABLE
3134     /* default */
3135     oneDeviceData->satDevData.satDriveState = SAT_DEV_STATE_NORMAL;
3136     oneDeviceData->satDevData.satNCQMaxIO =SAT_NCQ_MAX;
3137     oneDeviceData->satDevData.satPendingIO = 0;
3138     oneDeviceData->satDevData.satPendingNCQIO = 0;
3139     oneDeviceData->satDevData.satPendingNONNCQIO = 0;
3140     oneDeviceData->satDevData.IDDeviceValid = agFALSE;
3141     oneDeviceData->satDevData.freeSATAFDMATagBitmap = 0;
3142     oneDeviceData->satDevData.NumOfFCA = 0;
3143     oneDeviceData->satDevData.NumOfIDRetries = 0;
3144     oneDeviceData->satDevData.ID_Retries = 0;
3145     oneDeviceData->satDevData.IDPending = agFALSE;
3146
3147     osti_memset(oneDeviceData->satDevData.satMaxLBA, 0, sizeof(oneDeviceData->satDevData.satMaxLBA));
3148     osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
3149
3150     oneDeviceData->satDevData.satSaDeviceData = oneDeviceData;
3151
3152     satIntIO = (satInternalIo_t *)&(oneDeviceData->satDevData.satIntIo[0]);
3153     for (j = 0; j < SAT_MAX_INT_IO; j++)
3154     {
3155       TI_DBG3(("tdsaDeviceDataReInit: in loop of internal io free, id %d\n", satIntIO->id));
3156       satFreeIntIoResource(tiRoot, &(oneDeviceData->satDevData), satIntIO);
3157       satIntIO = satIntIO + 1;
3158     }
3159 #endif
3160   return;
3161 }
3162
3163 #ifdef TD_INT_COALESCE
3164 /*****************************************************************************
3165 *! \brief tdsaIntCoalCxtInit(
3166 *
3167 *  Purpose: This function initializes interrupt coalesce contexts.
3168 *
3169 *  \param   tiRoot: pointer to the driver instance
3170 *
3171 *  \return: None
3172 *
3173 *  \note:
3174 *
3175 *****************************************************************************/
3176 osGLOBAL void
3177 tdsaIntCoalCxtInit(
3178                     tiRoot_t *tiRoot
3179                     )
3180 {
3181   tdsaRoot_t               *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
3182   tdsaContext_t            *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3183   tdsaPortContext_t        *tdsaPortContext = (tdsaPortContext_t *)tdsaAllShared->PortContext;
3184   tdsaDeviceData_t         *tdsaDeviceData  = (tdsaDeviceData_t *)tdsaAllShared->DeviceDataHead;
3185   tdsaIntCoalesceContext_t *tdsaIntCoalCxt  = (tdsaIntCoalesceContext_t *)tdsaAllShared->IntCoalesce;
3186   int i = 0;
3187   int j = 0;
3188   bit32             MaxTargets;
3189
3190   TI_DBG2(("tdsaIntCoalCxtInit: start\n"));
3191   TI_DBG6(("tdsaIntCoalCxtInit: ******* sizeof(tdsaPortContext) %d 0x%x\n", sizeof(tdsaPortContext_t), sizeof(tdsaPortContext_t)));
3192   TI_DBG6(("tdsaIntCoalCxtInit: ******* sizeof(tdsaIntCoalCxt) %d 0x%x\n", sizeof(tdsaDeviceData_t), sizeof(tdsaDeviceData_t)));
3193   TI_DBG6(("tdsaIntCoalCxtInit: ******* sizeof(tdsaIntCoalCxt) %d 0x%x\n", sizeof(tdsaIntCoalesceContext_t), sizeof(tdsaIntCoalesceContext_t)));
3194   TI_DBG6(("tdsaIntCoalCxtInit: ******* tdsaRoot %p \n", tdsaRoot));
3195   TI_DBG6(("tdsaIntCoalCxtInit: ******* tdsaPortContext %p \n",tdsaPortContext));
3196   TI_DBG6(("tdsaDeviceDataInit: ******* tdsaDeviceData %p\n", tdsaDeviceData));
3197   TI_DBG6(("tdsaIntCoalCxtInit: ******* tdsaIntCoalCxt+1 %p \n", tdsaIntCoalCxt + 1));
3198   TI_DBG6(("tdsaIntCoalCxtInit: ******* &tdsaIntCoalCxt[0] %p  &tdsaIntCoalCxt[1] %p\n", &(tdsaIntCoalCxt[0]), &(tdsaIntCoalCxt[1])));
3199
3200   /* for debug */
3201   TI_DBG6(("tdsaIntCoalCxtInit: TD_MAX_PORT_CONTEXT %d\n", TD_MAX_PORT_CONTEXT));
3202   /* the following fn fills in MaxTargets */
3203   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
3204   TI_DBG6(("tdsaIntCoalCxtInit: MaxTargets %d\n", MaxTargets));
3205
3206   TI_DBG6(("tdsaIntCoalCxtInit: portcontext in sum 0x%x\n", sizeof(tdsaPortContext_t) * TD_MAX_PORT_CONTEXT));
3207   TI_DBG6(("tdsaIntCoalCxtInit: devicedata in sum 0x%x\n", sizeof(tdsaDeviceData_t) * MaxTargets));
3208
3209   /*
3210      tdsaIntCoalCx[0] is just head, not an element
3211   */
3212   TDLIST_INIT_HDR(&(tdsaIntCoalCxt[0].MainLink));
3213   TDLIST_INIT_HDR(&(tdsaIntCoalCxt[0].FreeLink));
3214
3215   tdsaIntCoalCxt[0].tdsaAllShared = tdsaAllShared;
3216   tdsaIntCoalCxt[0].tiIntCoalesceCxt = agNULL;
3217   tdsaIntCoalCxt[0].id = 0;
3218
3219
3220   for(i=1;i<TD_MAX_INT_COALESCE;i++)
3221   {
3222     TDLIST_INIT_ELEMENT(&(tdsaIntCoalCxt[i].FreeLink));
3223     TDLIST_INIT_ELEMENT(&(tdsaIntCoalCxt[i].MainLink));
3224
3225     tdsaIntCoalCxt[i].tdsaAllShared = tdsaAllShared;
3226     tdsaIntCoalCxt[i].tiIntCoalesceCxt = agNULL;
3227     tdsaIntCoalCxt[i].id = i;
3228
3229     /* enqueue */
3230     TDLIST_ENQUEUE_AT_TAIL(&(tdsaIntCoalCxt[i].FreeLink), &(tdsaIntCoalCxt[0].FreeLink));
3231   }
3232   return;
3233 }
3234 #endif /* TD_INT_COALESCE */
3235
3236
3237 osGLOBAL void
3238 tdsaExpanderInit(
3239                  tiRoot_t *tiRoot
3240                  )
3241 {
3242   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
3243   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3244
3245   tdsaExpander_t    *tdsaExpander =
3246     (tdsaExpander_t *)tdsaAllShared->ExpanderHead;
3247   bit32             MaxTargets;
3248
3249
3250   int i;
3251
3252   TI_DBG6(("tdsaExpanderInit: start\n"));
3253   tdssGetMaxTargetsParams(tiRoot, &MaxTargets);
3254   TI_DBG6(("tdsaExpanderInit: MaxTargets %d\n", MaxTargets));
3255
3256   //  TDLIST_INIT_HDR(&(tdsaAllShared->discoveringExpanderList));
3257   TDLIST_INIT_HDR(&(tdsaAllShared->freeExpanderList));
3258
3259   for(i=0;i<(int)MaxTargets;i++)
3260   {
3261     TDLIST_INIT_ELEMENT(&(tdsaExpander[i].linkNode));
3262     TDLIST_INIT_ELEMENT(&(tdsaExpander[i].upNode));
3263     /* initialize expander fields */
3264     tdsaExpander[i].tdDevice = agNULL;
3265     tdsaExpander[i].tdUpStreamExpander = agNULL;
3266     tdsaExpander[i].tdDeviceToProcess = agNULL;
3267     tdsaExpander[i].tdCurrentDownStreamExpander = agNULL;
3268     tdsaExpander[i].hasUpStreamDevice = agFALSE;
3269     tdsaExpander[i].numOfUpStreamPhys = 0;
3270     tdsaExpander[i].currentUpStreamPhyIndex = 0;
3271     tdsaExpander[i].numOfDownStreamPhys = 0;
3272     tdsaExpander[i].currentDownStreamPhyIndex = 0;
3273     tdsaExpander[i].discoveringPhyId = 0;
3274     tdsaExpander[i].underDiscovering = agFALSE;
3275     tdsaExpander[i].id = i;
3276     tdsaExpander[i].tdReturnginExpander = agNULL;
3277     tdsaExpander[i].discoverSMPAllowed = agTRUE;
3278     osti_memset( &(tdsaExpander[i].currentIndex), 0, sizeof(tdsaExpander[i].currentIndex));
3279     osti_memset( &(tdsaExpander[i].upStreamPhys), 0, sizeof(tdsaExpander[i].upStreamPhys));
3280     osti_memset( &(tdsaExpander[i].downStreamPhys), 0, sizeof(tdsaExpander[i].downStreamPhys));
3281     osti_memset( &(tdsaExpander[i].routingAttribute), 0, sizeof(tdsaExpander[i].routingAttribute));
3282     tdsaExpander[i].configSASAddrTableIndex = 0;
3283     osti_memset( &(tdsaExpander[i].configSASAddressHiTable), 0, sizeof(tdsaExpander[i].configSASAddressHiTable));
3284     osti_memset( &(tdsaExpander[i].configSASAddressLoTable), 0, sizeof(tdsaExpander[i].configSASAddressLoTable));
3285
3286
3287     TDLIST_ENQUEUE_AT_TAIL(&(tdsaExpander[i].linkNode), &(tdsaAllShared->freeExpanderList));
3288   }
3289   return;
3290 }
3291
3292 osGLOBAL void
3293 tdsaQueueConfigInit(
3294              tiRoot_t *tiRoot
3295              )
3296 {
3297   tdsaRoot_t     *tdsaRoot    = (tdsaRoot_t *)tiRoot->tdData;
3298   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3299
3300   /* for memory index requirement */
3301   agsaQueueConfig_t   *QueueConfig;
3302   bit32                i;
3303
3304   TI_DBG2(("tdsaQueueConfigInit: start\n"));
3305   tdsaGetSwConfigParams(tiRoot);
3306   QueueConfig = &tdsaAllShared->QueueConfig;
3307
3308   for(i=0;i<QueueConfig->numInboundQueues;i++)
3309   {
3310     QueueConfig->inboundQueues[i].elementCount = tdsaAllShared->InboundQueueSize[i];
3311     QueueConfig->inboundQueues[i].elementSize = tdsaAllShared->InboundQueueEleSize[i];
3312     QueueConfig->inboundQueues[i].priority = tdsaAllShared->InboundQueuePriority[i];
3313     QueueConfig->inboundQueues[i].reserved = 0;
3314   }
3315   for(i=0;i<QueueConfig->numOutboundQueues;i++)
3316   {
3317     QueueConfig->outboundQueues[i].elementCount = tdsaAllShared->OutboundQueueSize[i];
3318     QueueConfig->outboundQueues[i].elementSize = tdsaAllShared->OutboundQueueEleSize[i];
3319     QueueConfig->outboundQueues[i].interruptDelay = tdsaAllShared->OutboundQueueInterruptDelay[i]; /* default 0; no interrupt delay */
3320     QueueConfig->outboundQueues[i].interruptCount = tdsaAllShared->OutboundQueueInterruptCount[i]; /* default 1*/
3321     QueueConfig->outboundQueues[i].interruptEnable = tdsaAllShared->OutboundQueueInterruptEnable[i]; /* default 1*/
3322     QueueConfig->outboundQueues[i].interruptVectorIndex = 0;
3323   }
3324   /*  default  */
3325   for (i=0;i<8;i++)
3326   {
3327     QueueConfig->sasHwEventQueue[i] = 0;
3328     QueueConfig->sataNCQErrorEventQueue[i] = 0;
3329   }
3330
3331 #ifdef TARGET_DRIVER
3332   for (i=0;i<8;i++)
3333   {
3334     QueueConfig->tgtITNexusEventQueue[i] = 0;
3335     QueueConfig->tgtSSPEventQueue[i] = 0;
3336     QueueConfig->tgtSMPEventQueue[i] = 0;
3337   }
3338 #endif
3339   QueueConfig->iqNormalPriorityProcessingDepth = 0;
3340   QueueConfig->iqHighPriorityProcessingDepth = 0;
3341   QueueConfig->generalEventQueue = 0;
3342
3343   return;
3344 }
3345
3346 /*****************************************************************************
3347 *! \brief  tdssGetMaxTargetsParams
3348 *
3349 *  Purpose: This function is called to get default parameters from the
3350 *           OS Specific area. This function is called in the context of
3351 *           tiCOMGetResource() and tiCOMInit().
3352 *
3353 *
3354 *  \param  tiRoot:   Pointer to initiator driver/port instance.
3355 *  \param  option:   Pointer to bit32 where the max target number is saved
3356 *
3357 *  \return: None
3358 *
3359 *  \note -
3360 *
3361 *****************************************************************************/
3362 osGLOBAL void
3363 tdssGetMaxTargetsParams(
3364                       tiRoot_t                *tiRoot,
3365                       bit32                   *pMaxTargets
3366                       )
3367 {
3368   char    *key = agNULL;
3369   char    *subkey1 = agNULL;
3370   char    *subkey2 = agNULL;
3371   char    *buffer;
3372   bit32   buffLen;
3373   bit32   lenRecv = 0;
3374   char    *pLastUsedChar = agNULL;
3375   char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
3376   char    globalStr[]     = "Global";
3377   char    iniParmsStr[]   = "InitiatorParms";
3378   bit32   MaxTargets;
3379
3380   TI_DBG6(("tdssGetMaxTargetsParams: start\n"));
3381
3382   *pMaxTargets = DEFAULT_MAX_DEV;
3383
3384   /* to remove compiler warnings */
3385   pLastUsedChar   = pLastUsedChar;
3386   lenRecv         = lenRecv;
3387   subkey2         = subkey2;
3388   subkey1         = subkey1;
3389   key             = key;
3390   buffer          = &tmpBuffer[0];
3391   buffLen         = sizeof (tmpBuffer);
3392
3393   osti_memset(buffer, 0, buffLen);
3394
3395   /* defaults are overwritten in the following */
3396   /* Get MaxTargets */
3397   if ((ostiGetTransportParam(
3398                              tiRoot,
3399                              globalStr,
3400                              iniParmsStr,
3401                              agNULL,
3402                              agNULL,
3403                              agNULL,
3404                              agNULL,
3405                              "MaxTargets",
3406                              buffer,
3407                              buffLen,
3408                              &lenRecv
3409                              ) == tiSuccess) && (lenRecv != 0))
3410   {
3411     if (osti_strncmp(buffer, "0x", 2) == 0)
3412     {
3413       MaxTargets = osti_strtoul (buffer, &pLastUsedChar, 0);
3414     }
3415     else
3416     {
3417       MaxTargets = osti_strtoul (buffer, &pLastUsedChar, 10);
3418     }
3419     *pMaxTargets = MaxTargets;
3420     TI_DBG2(("tdssGetMaxTargetsParams: MaxTargets %d\n", MaxTargets ));
3421   }
3422
3423   osti_memset(buffer, 0, buffLen);
3424   lenRecv = 0;
3425
3426   return;
3427 }
3428
3429 /* temporary to distinguish SAS and SATA mode  */
3430 osGLOBAL void
3431 tdssGetSATAOnlyModeParams(
3432                       tiRoot_t                *tiRoot,
3433                       bit32                   *pSATAOnlyMode
3434                       )
3435 {
3436   char    *key = agNULL;
3437   char    *subkey1 = agNULL;
3438   char    *subkey2 = agNULL;
3439   char    *buffer;
3440   bit32   buffLen;
3441   bit32   lenRecv = 0;
3442   char    *pLastUsedChar = agNULL;
3443   char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
3444   char    globalStr[]     = "Global";
3445   char    iniParmsStr[]   = "InitiatorParms";
3446   bit32   SATAOnlyMode;
3447
3448   TI_DBG6(("tdssGetSATAOnlyModeParams: start\n"));
3449
3450   *pSATAOnlyMode = agFALSE; /* default SAS and SATA */
3451
3452   /* to remove compiler warnings */
3453   pLastUsedChar   = pLastUsedChar;
3454   lenRecv         = lenRecv;
3455   subkey2         = subkey2;
3456   subkey1         = subkey1;
3457   key             = key;
3458   buffer          = &tmpBuffer[0];
3459   buffLen         = sizeof (tmpBuffer);
3460
3461   osti_memset(buffer, 0, buffLen);
3462
3463   /* defaults are overwritten in the following */
3464   /* Get SATAOnlyMode */
3465   if ((ostiGetTransportParam(
3466                              tiRoot,
3467                              globalStr,
3468                              iniParmsStr,
3469                              agNULL,
3470                              agNULL,
3471                              agNULL,
3472                              agNULL,
3473                              "SATAOnlyMode",
3474                              buffer,
3475                              buffLen,
3476                              &lenRecv
3477                              ) == tiSuccess) && (lenRecv != 0))
3478   {
3479     if (osti_strncmp(buffer, "0x", 2) == 0)
3480     {
3481       SATAOnlyMode = osti_strtoul (buffer, &pLastUsedChar, 0);
3482     }
3483     else
3484     {
3485       SATAOnlyMode = osti_strtoul (buffer, &pLastUsedChar, 10);
3486     }
3487     *pSATAOnlyMode = SATAOnlyMode;
3488   }
3489
3490   osti_memset(buffer, 0, buffLen);
3491   lenRecv = 0;
3492
3493   return;
3494 }
3495
3496