sys/dev/pms/RefTisa/tisa/sassata/common/tdport.c

   1 /*******************************************************************************
   2 *Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
   3 *
   4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
   5 *that the following conditions are met:
   6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
   7 *following disclaimer.
   8 *2. Redistributions in binary form must reproduce the above copyright notice,
   9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
  10 *with the distribution.
  11 *
  12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
  13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  20
  21 ********************************************************************************/
  22 /*******************************************************************************/
  23 /** \file
  24  *
  25  * tdport.c
  26  * This file contains port realted functions such as tiCOMPortStart()
  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/spc/sadefs.h>
  40 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
  41
  42 #include <dev/pms/RefTisa/tisa/api/titypes.h>
  43 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
  44 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
  45 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
  46
  47 #ifdef FDS_SM
  48 #include <dev/pms/RefTisa/sat/api/sm.h>
  49 #include <dev/pms/RefTisa/sat/api/smapi.h>
  50 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
  51 #endif
  52
  53 #ifdef FDS_DM
  54 #include <dev/pms/RefTisa/discovery/api/dm.h>
  55 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
  56 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
  57 #endif
  58
  59 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
  60 #include <dev/pms/freebsd/driver/common/osstring.h>
  61 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
  62
  63 #ifdef INITIATOR_DRIVER
  64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
  65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
  66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
  67 #endif
  68
  69 #ifdef TARGET_DRIVER
  70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
  71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
  72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
  73 #endif
  74
  75 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
  76 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
  77
  78 #ifndef TURN_OFF_HDA
  79 #include <dev/pms/RefTisa/sallsdk/hda/64k/aap1img.h> /* SPC HDA */
  80 #include <dev/pms/RefTisa/sallsdk/hda/64k/ilaimg.h>
  81 #include <dev/pms/RefTisa/sallsdk/hda/64k/iopimg.h>
  82 #include <dev/pms/RefTisa/sallsdk/hda/64k/istrimg.h>
  83
  84 #include <dev/pms/RefTisa/sallsdk/hda/64k/aap18008.h>   /* SPCv HDA */
  85 #include <dev/pms/RefTisa/sallsdk/hda/64k/iop8008.h>
  86
  87 #include <dev/pms/RefTisa/sallsdk/hda/64k/ila8008.h> /* Ila common to SPCv SPCvp versions */
  88
  89 #include <dev/pms/RefTisa/sallsdk/hda/64k/raae8070.h>   /* SPCv 12g HDA */
  90 #include <dev/pms/RefTisa/sallsdk/hda/64k/iop8070.h>
  91 #include <dev/pms/RefTisa/sallsdk/hda/64k/ila8070.h> /* Ila 12g  SPCv SPCvp versions */
  92
  93 #endif /* TURN_OFF_HDA */
  94
  95
  96 bit32 gSSC_Disable = 0;
  97 bit32 volatile sgpioResponseSet = 0;
  98
  99 #ifdef ECHO_TESTING
 100 /* temporary to test saEchoCommand() */
 101 bit8 gEcho;
 102 #endif
 103 bit32 tiCOMConfigureSgpio(
 104                         tiRoot_t    *tiRoot,
 105                         bit8        enableSgpio
 106                         );
 107
 108
 109 /*****************************************************************************
 110 *! \brief tdsaGetSwConfigParams
 111 *
 112 *  Purpose:  This function reads software configuration parameters from the
 113 *            configuration file
 114 *
 115 *  \param  tiRoot:            Pointer to driver/port instance.
 116 *
 117 *  \return: None
 118 *
 119 *  \note -
 120 *
 121 *****************************************************************************/
 122 osGLOBAL void
 123 tdsaGetSwConfigParams(
 124                       tiRoot_t *tiRoot
 125                       )
 126 {
 127   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
 128   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
 129   agsaSwConfig_t *SwConfig;
 130   agsaQueueConfig_t   *QueueConfig;
 131   char           *buffer;
 132   bit32          buffLen;
 133   bit32          lenRecv = 0;
 134   char           *pLastUsedChar = agNULL;
 135   char           tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
 136   char           globalStr[]     = "Global";
 137   char           iniParmsStr[]   = "InitiatorParms";
 138   char           SwParmsStr[]   = "SWParms";
 139   char           OBQueueProps[] = "OBQueueProps";
 140   char           IBQueueProps[] = "IBQueueProps";
 141   char           IBQueueSize[40];
 142   char           OBQueueSize[40];
 143   char           IBQueueEleSize[40];
 144   char           OBQueueEleSize[40];
 145   char           OBQueueInterruptCount[40];
 146   char           OBQueueInterruptDelay[40];
 147   char           OBQueueInterruptEnable[40];
 148   char           IBQueuePriority[40];
 149   char           *cardNum = tdsaAllShared->CardIDString;
 150   bit32          i;
 151   bit32          enableDIF;
 152   bit32          enableEncryption;
 153 #ifdef SA_CONFIG_MDFD_REGISTRY
 154   bit32          disableMDF;
 155 #endif
 156
 157 #ifdef FDS_DM
 158   dmSwConfig_t   *dmSwConfig;
 159 #endif
 160 #ifdef FDS_SM
 161   smSwConfig_t   *smSwConfig;
 162 #endif
 163
 164   TI_DBG6(("tdsaGetSwConfigParams: start\n"));
 165   TI_DBG6(("tdsaGetSwConfigParams: tdsaRoot %p tdsaAllShared %p \n",tdsaRoot, tdsaAllShared));
 166
 167   buffer = tmpBuffer;
 168   buffLen = sizeof(tmpBuffer);
 169
 170   osti_memset(buffer, 0, buffLen);
 171
 172   /* the followings are the default values */
 173   SwConfig = (agsaSwConfig_t *)&(tdsaAllShared->SwConfig);
 174   QueueConfig = (agsaQueueConfig_t *)&(tdsaAllShared->QueueConfig);
 175
 176 #ifdef FDS_DM
 177   dmSwConfig = (dmSwConfig_t *)&(tdsaAllShared->dmSwConfig);
 178 #endif
 179 #ifdef FDS_SM
 180   smSwConfig = (smSwConfig_t *)&(tdsaAllShared->smSwConfig);
 181 #endif
 182
 183   /*
 184     just default values
 185     and are overwritten later by the configuration file contents
 186   */
 187   SwConfig->numDevHandles = DEFAULT_MAX_DEV;
 188
 189   SwConfig->maxActiveIOs = DEFAULT_MAX_ACTIVE_IOS;
 190   SwConfig->smpReqTimeout = DEFAULT_SMP_TIMEOUT; /* DEFAULT_VALUE; */
 191   SwConfig->numberOfEventRegClients = DEFAULT_NUM_REG_CLIENTS;
 192   SwConfig->sizefEventLog1 = HOST_EVENT_LOG_SIZE;
 193   SwConfig->sizefEventLog2 = HOST_EVENT_LOG_SIZE;
 194   SwConfig->eventLog1Option = DEFAULT_EVENT_LOG_OPTION;
 195   SwConfig->eventLog2Option = DEFAULT_EVENT_LOG_OPTION;
 196   SwConfig->fatalErrorInterruptEnable = 1;
 197   SwConfig->fatalErrorInterruptVector = 0; /* Was 1 */
 198   SwConfig->hostDirectAccessSupport = 0;
 199   SwConfig->hostDirectAccessMode = 0;
 200   SwConfig->FWConfig = 0;
 201   SwConfig->enableDIF = agFALSE;
 202   SwConfig->enableEncryption = agFALSE;
 203
 204 #ifdef SA_CONFIG_MDFD_REGISTRY
 205   SwConfig->disableMDF = agFALSE;
 206 #endif
 207
 208   SwConfig->param1 = tdsaAllShared->tdDeviceIdVendId;
 209   SwConfig->param2 = tdsaAllShared->tdSubVendorId;
 210
 211
 212 #if defined(SALLSDK_DEBUG)
 213   SwConfig->sallDebugLevel = 1; /* DEFAULT_VALUE; */
 214 #endif
 215 #if defined(DM_DEBUG)
 216   dmSwConfig->DMDebugLevel = 1; /* DEFAULT_VALUE; */
 217 #endif
 218 #if defined(SM_DEBUG)
 219   smSwConfig->SMDebugLevel = 1; /* DEFAULT_VALUE; */
 220 #endif
 221
 222   tdsaAllShared->portTMO = PORT_RECOVERY_TIMEOUT;   /* default 5 sec */
 223   tdsaAllShared->stp_idle_time = STP_IDLE_TIME;     /* default 5 us */
 224   tdsaAllShared->itNexusTimeout = IT_NEXUS_TIMEOUT; /* default 2000 ms */
 225
 226   osti_memset(buffer, 0, buffLen);
 227   lenRecv = 0;
 228
 229   if ((ostiGetTransportParam(
 230                              tiRoot,
 231                              globalStr,
 232                              iniParmsStr,
 233                              agNULL,
 234                              agNULL,
 235                              agNULL,
 236                              agNULL,
 237                              "MaxTargets",
 238                              buffer,
 239                              buffLen,
 240                              &lenRecv
 241                              ) == tiSuccess) && (lenRecv != 0))
 242   {
 243     if (osti_strncmp(buffer, "0x", 2) == 0)
 244     {
 245       SwConfig->numDevHandles = osti_strtoul (buffer, &pLastUsedChar, 0);
 246     }
 247     else
 248     {
 249       SwConfig->numDevHandles = osti_strtoul (buffer, &pLastUsedChar, 10);
 250     }
 251     TI_DBG2(("tdsaGetSwConfigParams: MaxTargets  %d\n",SwConfig->numDevHandles  ));
 252   }
 253
 254   /*
 255    * read the NumInboundQueue parameter
 256    */
 257   osti_memset(buffer, 0, buffLen);
 258   lenRecv = 0;
 259
 260   QueueConfig->numInboundQueues = DEFAULT_NUM_INBOUND_QUEUE;  /* default 1 Inbound queue */
 261
 262   if ((ostiGetTransportParam(
 263                              tiRoot,
 264                              globalStr,   /* key */
 265                              SwParmsStr,  /* subkey1 */
 266                              agNULL,      /* subkey2 */
 267                              agNULL,
 268                              agNULL,
 269                              agNULL,      /* subkey5 */
 270                              "NumInboundQueues", /* valueName */
 271                              buffer,
 272                              buffLen,
 273                              &lenRecv
 274                              ) == tiSuccess) && (lenRecv != 0))
 275   {
 276     if (osti_strncmp(buffer, "0x", 2) == 0)
 277     {
 278       QueueConfig->numInboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 279     }
 280     else
 281     {
 282       QueueConfig->numInboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 283     }
 284
 285     if (QueueConfig->numInboundQueues > AGSA_MAX_INBOUND_Q)
 286     {
 287       QueueConfig->numInboundQueues = AGSA_MAX_INBOUND_Q;
 288     }
 289   }
 290
 291   /*
 292    * read the NumOutboundQueue parameter
 293    */
 294   osti_memset(buffer, 0, buffLen);
 295   lenRecv = 0;
 296
 297   QueueConfig->numOutboundQueues = DEFAULT_NUM_OUTBOUND_QUEUE;  /* default 1 Outbound queue */
 298
 299   if ((ostiGetTransportParam(
 300                              tiRoot,
 301                              globalStr,   /* key */
 302                              SwParmsStr,  /* subkey1 */
 303                              agNULL,      /* subkey2 */
 304                              agNULL,
 305                              agNULL,
 306                              agNULL,      /* subkey5 */
 307                              "NumOutboundQueues", /* valueName */
 308                              buffer,
 309                              buffLen,
 310                              &lenRecv
 311                              ) == tiSuccess) && (lenRecv != 0))
 312   {
 313     if (osti_strncmp(buffer, "0x", 2) == 0)
 314     {
 315       QueueConfig->numOutboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 316     }
 317     else
 318     {
 319       QueueConfig->numOutboundQueues = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 320     }
 321
 322     if (QueueConfig->numOutboundQueues > AGSA_MAX_OUTBOUND_Q)
 323     {
 324       QueueConfig->numOutboundQueues = AGSA_MAX_OUTBOUND_Q;
 325     }
 326   }
 327
 328   /*
 329    * read the outbound queue option
 330    */
 331
 332   osti_memset(buffer, 0, buffLen);
 333   lenRecv = 0;
 334
 335   tdsaAllShared->QueueOption = DEFAULT_QUEUE_OPTION;  /* default 0 Outbound queue element */
 336
 337   if ((ostiGetTransportParam(
 338                              tiRoot,
 339                              globalStr,   /* key */
 340                              SwParmsStr,  /* subkey1 */
 341                              agNULL,      /* subkey2 */
 342                              agNULL,
 343                              agNULL,
 344                              agNULL,      /* subkey5 */
 345                              "QueueOption", /* valueName */
 346                              buffer,
 347                              buffLen,
 348                              &lenRecv
 349                              ) == tiSuccess) && (lenRecv != 0))
 350   {
 351     if (osti_strncmp(buffer, "0x", 2) == 0)
 352     {
 353       tdsaAllShared->QueueOption = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 354     }
 355     else
 356     {
 357       tdsaAllShared->QueueOption = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 358     }
 359   }
 360
 361   /*
 362    * read the MaxActiveIO parameter
 363    */
 364
 365   osti_memset(buffer, 0, buffLen);
 366   lenRecv = 0;
 367
 368   if ((ostiGetTransportParam(
 369                              tiRoot,
 370                              globalStr,   /* key */
 371                              SwParmsStr,  /* subkey1 */
 372                              agNULL,      /* subkey2 */
 373                              agNULL,
 374                              agNULL,
 375                              agNULL,      /* subkey5 */
 376                              "MaxActiveIO", /* valueName */
 377                              buffer,
 378                              buffLen,
 379                              &lenRecv
 380                              ) == tiSuccess) && (lenRecv != 0))
 381   {
 382     if (osti_strncmp(buffer, "0x", 2) == 0)
 383     {
 384       SwConfig->maxActiveIOs = osti_strtoul (buffer, &pLastUsedChar, 0);
 385       TI_DBG6(("tdsaGetSwConfigParams: maxactiveio 1 !!!\n"));
 386     }
 387     else
 388     {
 389       SwConfig->maxActiveIOs = osti_strtoul (buffer, &pLastUsedChar, 10);
 390       TI_DBG6(("tdsaGetSwConfigParams: maxactiveio 2 !!!\n"));
 391     }
 392     TI_DBG6(("tdsaGetSwConfigParams: maxactiveio 3 !!!\n"));
 393   }
 394
 395
 396
 397   /*
 398    * read the SMPTO parameter (SMP Timeout)
 399    */
 400   osti_memset(buffer, 0, buffLen);
 401   lenRecv = 0;
 402
 403   if ((ostiGetTransportParam(
 404                              tiRoot,
 405                              globalStr,   /* key */
 406                              SwParmsStr,  /* subkey1 */
 407                              agNULL,      /* subkey2 */
 408                              agNULL,
 409                              agNULL,
 410                              agNULL,      /* subkey5 */
 411                              "SMPTO", /* valueName */
 412                              buffer,
 413                              buffLen,
 414                              &lenRecv
 415                              ) == tiSuccess) && (lenRecv != 0))
 416   {
 417     if (osti_strncmp(buffer, "0x", 2) == 0)
 418     {
 419       SwConfig->smpReqTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
 420     }
 421     else
 422     {
 423       SwConfig->smpReqTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
 424     }
 425   }
 426
 427
 428   /*
 429    * read the NumRegClients parameter (SMP Timeout)
 430    */
 431   osti_memset(buffer, 0, buffLen);
 432   lenRecv = 0;
 433
 434   if ((ostiGetTransportParam(
 435                              tiRoot,
 436                              globalStr,   /* key */
 437                              SwParmsStr,  /* subkey1 */
 438                              agNULL,      /* subkey2 */
 439                              agNULL,
 440                              agNULL,
 441                              agNULL,      /* subkey5 */
 442                              "NumRegClients", /* valueName */
 443                              buffer,
 444                              buffLen,
 445                              &lenRecv
 446                              ) == tiSuccess) && (lenRecv != 0))
 447   {
 448     if (osti_strncmp(buffer, "0x", 2) == 0)
 449     {
 450       SwConfig->numberOfEventRegClients = osti_strtoul (buffer, &pLastUsedChar, 0);
 451     }
 452     else
 453     {
 454       SwConfig->numberOfEventRegClients = osti_strtoul (buffer, &pLastUsedChar, 10);
 455     }
 456   }
 457
 458 #if defined(SALLSDK_DEBUG)
 459   osti_memset(buffer, 0, buffLen);
 460   lenRecv = 0;
 461
 462   if ((ostiGetTransportParam(
 463                              tiRoot,
 464                              globalStr,   /* key */
 465                              SwParmsStr,  /* subkey1 */
 466                              agNULL,      /* subkey2 */
 467                              agNULL,
 468                              agNULL,
 469                              agNULL,      /* subkey5 */
 470                              "LLDebugLevel", /* valueName */
 471                              buffer,
 472                              buffLen,
 473                              &lenRecv
 474                              ) == tiSuccess) && (lenRecv != 0))
 475   {
 476     if (osti_strncmp(buffer, "0x", 2) == 0)
 477     {
 478       SwConfig->sallDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
 479     }
 480     else
 481     {
 482       SwConfig->sallDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
 483     }
 484   }
 485 #endif
 486
 487 #if defined(DM_DEBUG)
 488   osti_memset(buffer, 0, buffLen);
 489   lenRecv = 0;
 490
 491   if ((ostiGetTransportParam(
 492                              tiRoot,
 493                              globalStr,   /* key */
 494                              SwParmsStr,  /* subkey1 */
 495                              agNULL,      /* subkey2 */
 496                              agNULL,
 497                              agNULL,
 498                              agNULL,      /* subkey5 */
 499                              "DMDebugLevel", /* valueName */
 500                              buffer,
 501                              buffLen,
 502                              &lenRecv
 503                              ) == tiSuccess) && (lenRecv != 0))
 504   {
 505     if (osti_strncmp(buffer, "0x", 2) == 0)
 506     {
 507       dmSwConfig->DMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
 508     }
 509     else
 510     {
 511       dmSwConfig->DMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
 512     }
 513   }
 514 #endif
 515
 516 #if defined(SM_DEBUG)
 517   osti_memset(buffer, 0, buffLen);
 518   lenRecv = 0;
 519
 520   if ((ostiGetTransportParam(
 521                              tiRoot,
 522                              globalStr,   /* key */
 523                              SwParmsStr,  /* subkey1 */
 524                              agNULL,      /* subkey2 */
 525                              agNULL,
 526                              agNULL,
 527                              agNULL,      /* subkey5 */
 528                              "SMDebugLevel", /* valueName */
 529                              buffer,
 530                              buffLen,
 531                              &lenRecv
 532                              ) == tiSuccess) && (lenRecv != 0))
 533   {
 534     if (osti_strncmp(buffer, "0x", 2) == 0)
 535     {
 536       smSwConfig->SMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 0);
 537     }
 538     else
 539     {
 540       smSwConfig->SMDebugLevel = osti_strtoul (buffer, &pLastUsedChar, 10);
 541     }
 542   }
 543 #endif
 544
 545   osti_memset(buffer, 0, buffLen);
 546   lenRecv = 0;
 547
 548   for (i=0;i<QueueConfig->numInboundQueues;i++)
 549   {
 550     osti_sprintf(IBQueueSize,"IBQueueNumElements%d", i);
 551     osti_sprintf(IBQueueEleSize,"IBQueueElementSize%d", i);
 552     osti_sprintf(IBQueuePriority,"IBQueuePriority%d", i);
 553
 554     /*
 555      * read the IBQueueSize
 556      */
 557
 558     osti_memset(buffer, 0, buffLen);
 559     lenRecv = 0;
 560
 561     tdsaAllShared->InboundQueueSize[i] = DEFAULT_INBOUND_QUEUE_SIZE;  /* default 256 Inbound queue size */
 562
 563     if ((ostiGetTransportParam(
 564                              tiRoot,
 565                              globalStr,   /* key */
 566                              SwParmsStr,  /* subkey1 */
 567                              IBQueueProps,/* subkey2 */
 568                              agNULL,
 569                              agNULL,
 570                              agNULL,      /* subkey5 */
 571                              IBQueueSize, /* valueName */
 572                              buffer,
 573                              buffLen,
 574                              &lenRecv
 575                              ) == tiSuccess) && (lenRecv != 0))
 576     {
 577       if (osti_strncmp(buffer, "0x", 2) == 0)
 578       {
 579         tdsaAllShared->InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 580       }
 581       else
 582       {
 583         tdsaAllShared->InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 584         TI_DBG6(("tdsaGetSwConfigParams: queue number %d IB queue size %d\n", i, tdsaAllShared->InboundQueueSize[i]));
 585       }
 586     }
 587
 588
 589     /*
 590      * read the IBQueueEleSize
 591      */
 592
 593     osti_memset(buffer, 0, buffLen);
 594     lenRecv = 0;
 595
 596     tdsaAllShared->InboundQueueEleSize[i] = DEFAULT_INBOUND_QUEUE_ELE_SIZE;  /* default 128 Inbound queue element */
 597
 598     if ((ostiGetTransportParam(
 599                              tiRoot,
 600                              globalStr,   /* key */
 601                              SwParmsStr,  /* subkey1 */
 602                              IBQueueProps,/* subkey2 */
 603                              agNULL,
 604                              agNULL,
 605                              agNULL,      /* subkey5 */
 606                              IBQueueEleSize, /* valueName */
 607                              buffer,
 608                              buffLen,
 609                              &lenRecv
 610                              ) == tiSuccess) && (lenRecv != 0))
 611     {
 612       if (osti_strncmp(buffer, "0x", 2) == 0)
 613       {
 614         tdsaAllShared->InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 615       }
 616       else
 617       {
 618         tdsaAllShared->InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 619         TI_DBG6(("tdsaGetSwConfigParams: queue number %d IB queue ele size %d\n", i, tdsaAllShared->InboundQueueEleSize[i]));
 620       }
 621     }
 622
 623     /*
 624      * read the IBQueuePriority
 625      */
 626
 627     osti_memset(buffer, 0, buffLen);
 628     lenRecv = 0;
 629
 630     tdsaAllShared->InboundQueuePriority[i] = DEFAULT_INBOUND_QUEUE_PRIORITY; /* default 0 Inbound queue priority */
 631
 632     if ((ostiGetTransportParam(
 633                              tiRoot,
 634                              globalStr,   /* key */
 635                              SwParmsStr,  /* subkey1 */
 636                              IBQueueProps,/* subkey2 */
 637                              agNULL,
 638                              agNULL,
 639                              agNULL,      /* subkey5 */
 640                              IBQueuePriority, /* valueName */
 641                              buffer,
 642                              buffLen,
 643                              &lenRecv
 644                              ) == tiSuccess) && (lenRecv != 0))
 645     {
 646       if (osti_strncmp(buffer, "0x", 2) == 0)
 647       {
 648         tdsaAllShared->InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 649       }
 650       else
 651       {
 652         tdsaAllShared->InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 653         TI_DBG6(("tdsaGetSwConfigParams: queue number %d priority %d\n", i, tdsaAllShared->InboundQueuePriority[i]));
 654       }
 655     }
 656
 657     /**********************************************/
 658     osti_memset(buffer, 0, buffLen);
 659     lenRecv = 0;
 660   }/* end of loop */
 661
 662
 663
 664   osti_memset(buffer, 0, buffLen);
 665   lenRecv = 0;
 666
 667   for (i=0;i<QueueConfig->numOutboundQueues;i++)
 668   {
 669     osti_sprintf(OBQueueSize,"OBQueueNumElements%d", i);
 670     osti_sprintf(OBQueueEleSize,"OBQueueElementSize%d", i);
 671     osti_sprintf(OBQueueInterruptDelay,"OBQueueInterruptDelay%d", i);
 672     osti_sprintf(OBQueueInterruptCount,"OBQueueInterruptCount%d", i);
 673     osti_sprintf(OBQueueInterruptEnable,"OBQueueInterruptEnable%d", i);
 674
 675     /*
 676      * read the OBQueueSize
 677      */
 678     osti_memset(buffer, 0, buffLen);
 679     lenRecv = 0;
 680
 681
 682     tdsaAllShared->OutboundQueueSize[i] = DEFAULT_OUTBOUND_QUEUE_SIZE;  /* default 256 Outbound queue size */
 683
 684     if ((ostiGetTransportParam(
 685                              tiRoot,
 686                              globalStr,   /* key */
 687                              SwParmsStr,  /* subkey1 */
 688                              OBQueueProps,      /* subkey2 */
 689                              agNULL,
 690                              agNULL,
 691                              agNULL,      /* subkey5 */
 692                              OBQueueSize, /* valueName */
 693                              buffer,
 694                              buffLen,
 695                              &lenRecv
 696                              ) == tiSuccess) && (lenRecv != 0))
 697     {
 698       if (osti_strncmp(buffer, "0x", 2) == 0)
 699       {
 700         tdsaAllShared->OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 701       }
 702       else
 703       {
 704         tdsaAllShared->OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 705         TI_DBG6(("tdsaGetSwConfigParams: queue number %d OB queue size %d\n", i, tdsaAllShared->OutboundQueueSize[i]));
 706
 707       }
 708     }
 709
 710
 711     /*
 712      * read the OBQueueEleSize
 713      */
 714     osti_memset(buffer, 0, buffLen);
 715     lenRecv = 0;
 716
 717
 718     tdsaAllShared->OutboundQueueEleSize[i] = DEFAULT_OUTBOUND_QUEUE_ELE_SIZE;  /* default 128 Outbound queue element */
 719
 720     if ((ostiGetTransportParam(
 721                              tiRoot,
 722                              globalStr,   /* key */
 723                              SwParmsStr,  /* subkey1 */
 724                              OBQueueProps,      /* subkey2 */
 725                              agNULL,
 726                              agNULL,
 727                              agNULL,      /* subkey5 */
 728                              OBQueueEleSize, /* valueName */
 729                              buffer,
 730                              buffLen,
 731                              &lenRecv
 732                              ) == tiSuccess) && (lenRecv != 0))
 733     {
 734       if (osti_strncmp(buffer, "0x", 2) == 0)
 735       {
 736         tdsaAllShared->OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 737       }
 738       else
 739       {
 740         tdsaAllShared->OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 741         TI_DBG6(("tdsaGetSwConfigParams: queue number %d OB queue ele size %d\n", i, tdsaAllShared->OutboundQueueEleSize[i]));
 742
 743       }
 744     }
 745
 746
 747     /*
 748      * read the OBQueueInterruptDelay
 749      */
 750     osti_memset(buffer, 0, buffLen);
 751     lenRecv = 0;
 752
 753
 754     tdsaAllShared->OutboundQueueInterruptDelay[i] = DEFAULT_OUTBOUND_QUEUE_INTERRUPT_DELAY;  /* default 1 Outbound interrupt delay */
 755
 756     if ((ostiGetTransportParam(
 757                              tiRoot,
 758                              globalStr,   /* key */
 759                              SwParmsStr,  /* subkey1 */
 760                              OBQueueProps,      /* subkey2 */
 761                              agNULL,
 762                              agNULL,
 763                              agNULL,      /* subkey5 */
 764                              OBQueueInterruptDelay, /* valueName */
 765                              buffer,
 766                              buffLen,
 767                              &lenRecv
 768                              ) == tiSuccess) && (lenRecv != 0))
 769     {
 770       if (osti_strncmp(buffer, "0x", 2) == 0)
 771       {
 772         tdsaAllShared->OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 773       }
 774       else
 775       {
 776         tdsaAllShared->OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 777         TI_DBG6(("tdsaGetSwConfigParams: queue number %d interrupt delay %d\n", i, tdsaAllShared->OutboundQueueInterruptDelay[i]));
 778
 779       }
 780     }
 781
 782     /*
 783      * read the OBQueueInterruptCount
 784      */
 785
 786     osti_memset(buffer, 0, buffLen);
 787     lenRecv = 0;
 788
 789     tdsaAllShared->OutboundQueueInterruptCount[i] = DEFAULT_OUTBOUND_QUEUE_INTERRUPT_COUNT;  /* default 1 Outbound interrupt count */
 790
 791     if ((ostiGetTransportParam(
 792                              tiRoot,
 793                              globalStr,   /* key */
 794                              SwParmsStr,  /* subkey1 */
 795                              OBQueueProps,      /* subkey2 */
 796                              agNULL,
 797                              agNULL,
 798                              agNULL,      /* subkey5 */
 799                              OBQueueInterruptCount, /* valueName */
 800                              buffer,
 801                              buffLen,
 802                              &lenRecv
 803                              ) == tiSuccess) && (lenRecv != 0))
 804     {
 805       if (osti_strncmp(buffer, "0x", 2) == 0)
 806       {
 807         tdsaAllShared->OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 808       }
 809       else
 810       {
 811         tdsaAllShared->OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 812         TI_DBG6(("tdsaGetSwConfigParams: queue number %d interrupt count %d\n", i, tdsaAllShared->OutboundQueueInterruptCount[i]));
 813       }
 814     }
 815
 816
 817     /*
 818      * read the OBQueueInterruptEnable
 819      */
 820
 821     osti_memset(buffer, 0, buffLen);
 822     lenRecv = 0;
 823
 824     tdsaAllShared->OutboundQueueInterruptEnable[i] = DEFAULT_OUTBOUND_INTERRUPT_ENABLE;  /* default 1 Outbound interrupt is enabled */
 825
 826     if ((ostiGetTransportParam(
 827                              tiRoot,
 828                              globalStr,   /* key */
 829                              SwParmsStr,  /* subkey1 */
 830                              OBQueueProps,      /* subkey2 */
 831                              agNULL,
 832                              agNULL,
 833                              agNULL,      /* subkey5 */
 834                              OBQueueInterruptEnable, /* valueName */
 835                              buffer,
 836                              buffLen,
 837                              &lenRecv
 838                              ) == tiSuccess) && (lenRecv != 0))
 839     {
 840       if (osti_strncmp(buffer, "0x", 2) == 0)
 841       {
 842         tdsaAllShared->OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 843       }
 844       else
 845       {
 846         tdsaAllShared->OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 847         TI_DBG6(("tdsaGetSwConfigParams: queue number %d interrupt enable %d\n", i, tdsaAllShared->OutboundQueueInterruptEnable[i]));
 848       }
 849     }
 850
 851     /**********************************************/
 852     osti_memset(buffer, 0, buffLen);
 853     lenRecv = 0;
 854
 855   }/* end of loop */
 856
 857
 858
 859   /********************READ CARD SPECIFIC *******************************************************/
 860
 861   osti_memset(buffer, 0, buffLen);
 862   lenRecv = 0;
 863
 864   for (i=0;i<QueueConfig->numInboundQueues;i++)
 865   {
 866     osti_sprintf(IBQueueSize,"IBQueueNumElements%d", i);
 867     osti_sprintf(IBQueueEleSize,"IBQueueElementSize%d", i);
 868     osti_sprintf(IBQueuePriority,"IBQueuePriority%d", i);
 869
 870     /*
 871      * read the IBQueueSize
 872      */
 873
 874     osti_memset(buffer, 0, buffLen);
 875     lenRecv = 0;
 876
 877     if ((ostiGetTransportParam(
 878                              tiRoot,
 879                              cardNum,   /* key */
 880                              SwParmsStr,  /* subkey1 */
 881                              IBQueueProps,/* subkey2 */
 882                              agNULL,
 883                              agNULL,
 884                              agNULL,      /* subkey5 */
 885                              IBQueueSize, /* valueName */
 886                              buffer,
 887                              buffLen,
 888                              &lenRecv
 889                              ) == tiSuccess) && (lenRecv != 0))
 890     {
 891       if (osti_strncmp(buffer, "0x", 2) == 0)
 892       {
 893         tdsaAllShared->InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 894       }
 895       else
 896       {
 897         tdsaAllShared->InboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 898         TI_DBG6(("tdsaGetSwConfigParams: queue number %d IB queue size %d\n", i, tdsaAllShared->InboundQueueSize[i]));
 899       }
 900     }
 901
 902     /*
 903      * read the IBQueueEleSize
 904      */
 905
 906     osti_memset(buffer, 0, buffLen);
 907     lenRecv = 0;
 908
 909     if ((ostiGetTransportParam(
 910                              tiRoot,
 911                              cardNum,   /* key */
 912                              SwParmsStr,  /* subkey1 */
 913                              IBQueueProps,/* subkey2 */
 914                              agNULL,
 915                              agNULL,
 916                              agNULL,      /* subkey5 */
 917                              IBQueueEleSize, /* valueName */
 918                              buffer,
 919                              buffLen,
 920                              &lenRecv
 921                              ) == tiSuccess) && (lenRecv != 0))
 922     {
 923       if (osti_strncmp(buffer, "0x", 2) == 0)
 924       {
 925         tdsaAllShared->InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 926       }
 927       else
 928       {
 929         tdsaAllShared->InboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 930         TI_DBG6(("tdsaGetSwConfigParams: queue number %d IB queue ele size %d\n", i, tdsaAllShared->InboundQueueEleSize[i]));
 931       }
 932     }
 933
 934     /*
 935      * read the IBQueuePriority
 936      */
 937
 938     osti_memset(buffer, 0, buffLen);
 939     lenRecv = 0;
 940
 941     if ((ostiGetTransportParam(
 942                              tiRoot,
 943                              cardNum,   /* key */
 944                              SwParmsStr,  /* subkey1 */
 945                              IBQueueProps,/* subkey2 */
 946                              agNULL,
 947                              agNULL,
 948                              agNULL,      /* subkey5 */
 949                              IBQueuePriority, /* valueName */
 950                              buffer,
 951                              buffLen,
 952                              &lenRecv
 953                              ) == tiSuccess) && (lenRecv != 0))
 954     {
 955       if (osti_strncmp(buffer, "0x", 2) == 0)
 956       {
 957         tdsaAllShared->InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
 958       }
 959       else
 960       {
 961         tdsaAllShared->InboundQueuePriority[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
 962         TI_DBG6(("tdsaGetSwConfigParams: card number %s queue number %d priority %d\n", cardNum, i, tdsaAllShared->InboundQueuePriority[i]));
 963       }
 964     }
 965
 966     /**********************************************/
 967     osti_memset(buffer, 0, buffLen);
 968     lenRecv = 0;
 969   }/* end of loop */
 970
 971
 972
 973   osti_memset(buffer, 0, buffLen);
 974   lenRecv = 0;
 975
 976   for (i=0;i<QueueConfig->numOutboundQueues;i++)
 977   {
 978     osti_sprintf(OBQueueSize,"OBQueueNumElements%d", i);
 979     osti_sprintf(OBQueueEleSize,"OBQueueElementSize%d", i);
 980     osti_sprintf(OBQueueInterruptDelay,"OBQueueInterruptDelay%d", i);
 981     osti_sprintf(OBQueueInterruptCount,"OBQueueInterruptCount%d", i);
 982     osti_sprintf(OBQueueInterruptEnable,"OBQueueInterruptEnable%d", i);
 983
 984     /*
 985      * read the OBQueueSize
 986      */
 987     osti_memset(buffer, 0, buffLen);
 988     lenRecv = 0;
 989
 990     if ((ostiGetTransportParam(
 991                              tiRoot,
 992                              cardNum,   /* key */
 993                              SwParmsStr,  /* subkey1 */
 994                              OBQueueProps,      /* subkey2 */
 995                              agNULL,
 996                              agNULL,
 997                              agNULL,      /* subkey5 */
 998                              OBQueueSize, /* valueName */
 999                              buffer,
1000                              buffLen,
1001                              &lenRecv
1002                              ) == tiSuccess) && (lenRecv != 0))
1003     {
1004       if (osti_strncmp(buffer, "0x", 2) == 0)
1005       {
1006         tdsaAllShared->OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1007       }
1008       else
1009       {
1010         tdsaAllShared->OutboundQueueSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1011         TI_DBG6(("tdsaGetSwConfigParams: queue number %d OB queue size %d\n", i, tdsaAllShared->OutboundQueueSize[i]));
1012
1013       }
1014     }
1015
1016     /*
1017      * read the OBQueueEleSize
1018      */
1019     osti_memset(buffer, 0, buffLen);
1020     lenRecv = 0;
1021
1022
1023     if ((ostiGetTransportParam(
1024                              tiRoot,
1025                              cardNum,   /* key */
1026                              SwParmsStr,  /* subkey1 */
1027                              OBQueueProps,      /* subkey2 */
1028                              agNULL,
1029                              agNULL,
1030                              agNULL,      /* subkey5 */
1031                              OBQueueEleSize, /* valueName */
1032                              buffer,
1033                              buffLen,
1034                              &lenRecv
1035                              ) == tiSuccess) && (lenRecv != 0))
1036     {
1037       if (osti_strncmp(buffer, "0x", 2) == 0)
1038       {
1039         tdsaAllShared->OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1040       }
1041       else
1042       {
1043         tdsaAllShared->OutboundQueueEleSize[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1044         TI_DBG6(("tdsaGetSwConfigParams: queue number %d OB queue ele size %d\n", i, tdsaAllShared->OutboundQueueEleSize[i]));
1045
1046       }
1047     }
1048
1049     /*
1050      * read the OBQueueInterruptDelay
1051      */
1052     osti_memset(buffer, 0, buffLen);
1053     lenRecv = 0;
1054
1055
1056     if ((ostiGetTransportParam(
1057                              tiRoot,
1058                              cardNum,   /* key */
1059                              SwParmsStr,  /* subkey1 */
1060                              OBQueueProps,      /* subkey2 */
1061                              agNULL,
1062                              agNULL,
1063                              agNULL,      /* subkey5 */
1064                              OBQueueInterruptDelay, /* valueName */
1065                              buffer,
1066                              buffLen,
1067                              &lenRecv
1068                              ) == tiSuccess) && (lenRecv != 0))
1069     {
1070       if (osti_strncmp(buffer, "0x", 2) == 0)
1071       {
1072         tdsaAllShared->OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1073       }
1074       else
1075       {
1076         tdsaAllShared->OutboundQueueInterruptDelay[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1077         TI_DBG6(("tdsaGetSwConfigParams: card number %s queue number %d interrupt delay %d\n", cardNum, i, tdsaAllShared->OutboundQueueInterruptDelay[i]));
1078
1079       }
1080     }
1081
1082     /*
1083      * read the OBQueueInterruptCount
1084      */
1085
1086     osti_memset(buffer, 0, buffLen);
1087     lenRecv = 0;
1088
1089     if ((ostiGetTransportParam(
1090                              tiRoot,
1091                              cardNum,   /* key */
1092                              SwParmsStr,  /* subkey1 */
1093                              OBQueueProps,      /* subkey2 */
1094                              agNULL,
1095                              agNULL,
1096                              agNULL,      /* subkey5 */
1097                              OBQueueInterruptCount, /* valueName */
1098                              buffer,
1099                              buffLen,
1100                              &lenRecv
1101                              ) == tiSuccess) && (lenRecv != 0))
1102     {
1103       if (osti_strncmp(buffer, "0x", 2) == 0)
1104       {
1105         tdsaAllShared->OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1106       }
1107       else
1108       {
1109         tdsaAllShared->OutboundQueueInterruptCount[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1110         TI_DBG6(("tdsaGetSwConfigParams: card number %s queue number %d interrupt count %d\n", cardNum, i, tdsaAllShared->OutboundQueueInterruptCount[i]));
1111       }
1112     }
1113
1114
1115     /*
1116      * read the OBQueueInterruptEnable
1117      */
1118
1119     osti_memset(buffer, 0, buffLen);
1120     lenRecv = 0;
1121
1122     if ((ostiGetTransportParam(
1123                              tiRoot,
1124                              cardNum,   /* key */
1125                              SwParmsStr,  /* subkey1 */
1126                              OBQueueProps,      /* subkey2 */
1127                              agNULL,
1128                              agNULL,
1129                              agNULL,      /* subkey5 */
1130                              OBQueueInterruptEnable, /* valueName */
1131                              buffer,
1132                              buffLen,
1133                              &lenRecv
1134                              ) == tiSuccess) && (lenRecv != 0))
1135     {
1136       if (osti_strncmp(buffer, "0x", 2) == 0)
1137       {
1138         tdsaAllShared->OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 0);
1139       }
1140       else
1141       {
1142         tdsaAllShared->OutboundQueueInterruptEnable[i] = (bit16) osti_strtoul (buffer, &pLastUsedChar, 10);
1143         TI_DBG6(("tdsaGetSwConfigParams: card number %s queue number %d interrupt enable %d\n", cardNum, i, tdsaAllShared->OutboundQueueInterruptEnable[i]));
1144       }
1145     }
1146
1147
1148     /**********************************************/
1149     osti_memset(buffer, 0, buffLen);
1150     lenRecv = 0;
1151
1152   }/* end of loop */
1153
1154   /* process event log related parameters */
1155   osti_memset(buffer, 0, buffLen);
1156   lenRecv = 0;
1157
1158   if ((ostiGetTransportParam(
1159                              tiRoot,
1160                              globalStr,   /* key */
1161                              SwParmsStr,  /* subkey1 */
1162                              agNULL,      /* subkey2 */
1163                              agNULL,
1164                              agNULL,
1165                              agNULL,      /* subkey5 */
1166                              "EventLogSize1", /* valueName */
1167                              buffer,
1168                              buffLen,
1169                              &lenRecv
1170                              ) == tiSuccess) && (lenRecv != 0))
1171   {
1172     if (osti_strncmp(buffer, "0x", 2) == 0)
1173     {
1174       SwConfig->sizefEventLog1 = osti_strtoul (buffer, &pLastUsedChar, 0);
1175     }
1176     else
1177     {
1178       SwConfig->sizefEventLog1 = osti_strtoul (buffer, &pLastUsedChar, 10);
1179     }
1180   }
1181
1182   osti_memset(buffer, 0, buffLen);
1183   lenRecv = 0;
1184
1185   if ((ostiGetTransportParam(
1186                              tiRoot,
1187                              globalStr,   /* key */
1188                              SwParmsStr,  /* subkey1 */
1189                              agNULL,      /* subkey2 */
1190                              agNULL,
1191                              agNULL,
1192                              agNULL,      /* subkey5 */
1193                              "EventLogOption1", /* valueName */
1194                              buffer,
1195                              buffLen,
1196                              &lenRecv
1197                              ) == tiSuccess) && (lenRecv != 0))
1198   {
1199     if (osti_strncmp(buffer, "0x", 2) == 0)
1200     {
1201       SwConfig->eventLog1Option = osti_strtoul (buffer, &pLastUsedChar, 0);
1202     }
1203     else
1204     {
1205       SwConfig->eventLog1Option = osti_strtoul (buffer, &pLastUsedChar, 10);
1206     }
1207   }
1208
1209   osti_memset(buffer, 0, buffLen);
1210   lenRecv = 0;
1211
1212   if ((ostiGetTransportParam(
1213                              tiRoot,
1214                              globalStr,   /* key */
1215                              SwParmsStr,  /* subkey1 */
1216                              agNULL,      /* subkey2 */
1217                              agNULL,
1218                              agNULL,
1219                              agNULL,      /* subkey5 */
1220                              "EventLogSize2", /* valueName *//* IOP size in K dWords   */
1221                              buffer,
1222                              buffLen,
1223                              &lenRecv
1224                              ) == tiSuccess) && (lenRecv != 0))
1225   {
1226     if (osti_strncmp(buffer, "0x", 2) == 0)
1227     {
1228       SwConfig->sizefEventLog2 = osti_strtoul (buffer, &pLastUsedChar, 0);
1229     }
1230     else
1231     {
1232       SwConfig->sizefEventLog2 = osti_strtoul (buffer, &pLastUsedChar, 10);
1233     }
1234   }
1235
1236   osti_memset(buffer, 0, buffLen);
1237   lenRecv = 0;
1238
1239   if ((ostiGetTransportParam(
1240                              tiRoot,
1241                              globalStr,   /* key */
1242                              SwParmsStr,  /* subkey1 */
1243                              agNULL,      /* subkey2 */
1244                              agNULL,
1245                              agNULL,
1246                              agNULL,      /* subkey5 */
1247                              "EventLogOption2", /* valueName */
1248                              buffer,
1249                              buffLen,
1250                              &lenRecv
1251                              ) == tiSuccess) && (lenRecv != 0))
1252   {
1253     if (osti_strncmp(buffer, "0x", 2) == 0)
1254     {
1255       SwConfig->eventLog2Option = osti_strtoul (buffer, &pLastUsedChar, 0);
1256     }
1257     else
1258     {
1259       SwConfig->eventLog2Option = osti_strtoul (buffer, &pLastUsedChar, 10);
1260     }
1261   }
1262   /* end of event log related parameters */
1263
1264   /*
1265     HDA parameters
1266   */
1267   osti_memset(buffer, 0, buffLen);
1268   lenRecv = 0;
1269
1270   if ((ostiGetTransportParam(
1271                              tiRoot,
1272                              globalStr,   /* key */
1273                              SwParmsStr,  /* subkey1 */
1274                              agNULL,      /* subkey2 */
1275                              agNULL,
1276                              agNULL,
1277                              agNULL,      /* subkey5 */
1278                              "HDASupport", /* valueName */
1279                              buffer,
1280                              buffLen,
1281                              &lenRecv
1282                              ) == tiSuccess) && (lenRecv != 0))
1283   {
1284     if (osti_strncmp(buffer, "0x", 2) == 0)
1285     {
1286       SwConfig->hostDirectAccessSupport = osti_strtoul (buffer, &pLastUsedChar, 0);
1287     }
1288     else
1289     {
1290       SwConfig->hostDirectAccessSupport = osti_strtoul (buffer, &pLastUsedChar, 10);
1291     }
1292   }
1293
1294   osti_memset(buffer, 0, buffLen);
1295   lenRecv = 0;
1296
1297   if ((ostiGetTransportParam(
1298                              tiRoot,
1299                              globalStr,   /* key */
1300                              SwParmsStr,  /* subkey1 */
1301                              agNULL,      /* subkey2 */
1302                              agNULL,
1303                              agNULL,
1304                              agNULL,      /* subkey5 */
1305                              "HDAMode", /* valueName */
1306                              buffer,
1307                              buffLen,
1308                              &lenRecv
1309                              ) == tiSuccess) && (lenRecv != 0))
1310   {
1311     if (osti_strncmp(buffer, "0x", 2) == 0)
1312     {
1313       SwConfig->hostDirectAccessMode = osti_strtoul (buffer, &pLastUsedChar, 0);
1314     }
1315     else
1316     {
1317       SwConfig->hostDirectAccessMode = osti_strtoul (buffer, &pLastUsedChar, 10);
1318     }
1319   }
1320   /* the end of HDA parameters */
1321
1322   /* FW configuration */
1323   osti_memset(buffer, 0, buffLen);
1324   lenRecv = 0;
1325
1326   if ((ostiGetTransportParam(
1327                              tiRoot,
1328                              globalStr,   /* key */
1329                              SwParmsStr,  /* subkey1 */
1330                              agNULL,      /* subkey2 */
1331                              agNULL,
1332                              agNULL,
1333                              agNULL,      /* subkey5 */
1334                              "FWConfig", /* valueName */
1335                              buffer,
1336                              buffLen,
1337                              &lenRecv
1338                              ) == tiSuccess) && (lenRecv != 0))
1339   {
1340     if (osti_strncmp(buffer, "0x", 2) == 0)
1341     {
1342       SwConfig->FWConfig = osti_strtoul (buffer, &pLastUsedChar, 0);
1343     }
1344     else
1345     {
1346       SwConfig->FWConfig = osti_strtoul (buffer, &pLastUsedChar, 10);
1347     }
1348   }
1349   /* The end of FW configuration */
1350
1351   /* IQ Normal priority and High priority */
1352   osti_memset(buffer, 0, buffLen);
1353   lenRecv = 0;
1354
1355   if ((ostiGetTransportParam(
1356                              tiRoot,
1357                              globalStr,   /* key */
1358                              SwParmsStr,  /* subkey1 */
1359                              IBQueueProps,/* subkey2 */
1360                              agNULL,
1361                              agNULL,
1362                              agNULL,      /* subkey5 */
1363                              "IQNQDepth", /* valueName */
1364                              buffer,
1365                              buffLen,
1366                              &lenRecv
1367                              ) == tiSuccess) && (lenRecv != 0))
1368     {
1369       if (osti_strncmp(buffer, "0x", 2) == 0)
1370       {
1371         QueueConfig->iqNormalPriorityProcessingDepth = (bit8) osti_strtoul (buffer, &pLastUsedChar, 0);
1372       }
1373       else
1374       {
1375         QueueConfig->iqNormalPriorityProcessingDepth = (bit8) osti_strtoul (buffer, &pLastUsedChar, 10);
1376       }
1377     }
1378
1379   osti_memset(buffer, 0, buffLen);
1380   lenRecv = 0;
1381
1382   if ((ostiGetTransportParam(
1383                              tiRoot,
1384                              globalStr,   /* key */
1385                              SwParmsStr,  /* subkey1 */
1386                              IBQueueProps,/* subkey2 */
1387                              agNULL,
1388                              agNULL,
1389                              agNULL,      /* subkey5 */
1390                              "IQHQDepth", /* valueName */
1391                              buffer,
1392                              buffLen,
1393                              &lenRecv
1394                              ) == tiSuccess) && (lenRecv != 0))
1395     {
1396       if (osti_strncmp(buffer, "0x", 2) == 0)
1397       {
1398         QueueConfig->iqHighPriorityProcessingDepth = (bit8) osti_strtoul (buffer, &pLastUsedChar, 0);
1399       }
1400       else
1401       {
1402         QueueConfig->iqHighPriorityProcessingDepth = (bit8) osti_strtoul (buffer, &pLastUsedChar, 10);
1403       }
1404     }
1405   /* End IQ Normal priority and High priority */
1406
1407   /* Start port timeout value */
1408   osti_memset(buffer, 0, buffLen);
1409   lenRecv = 0;
1410
1411   if ((ostiGetTransportParam(
1412                              tiRoot,
1413                              globalStr,   /* key */
1414                              SwParmsStr,  /* subkey1 */
1415                              agNULL,/* subkey2 */
1416                              agNULL,
1417                              agNULL,
1418                              agNULL,      /* subkey5 */
1419                              "PortTMO", /* valueName */
1420                              buffer,
1421                              buffLen,
1422                              &lenRecv
1423                              ) == tiSuccess) && (lenRecv != 0))
1424     {
1425       if (osti_strncmp(buffer, "0x", 2) == 0)
1426       {
1427         tdsaAllShared->portTMO = osti_strtoul (buffer, &pLastUsedChar, 0);
1428       }
1429       else
1430       {
1431         tdsaAllShared->portTMO = osti_strtoul (buffer, &pLastUsedChar, 10);
1432       }
1433     }
1434   /* End port timeout value */
1435
1436 #ifdef SA_ENABLE_TRACE_FUNCTIONS
1437   osti_memset(buffer, 0, buffLen);
1438   lenRecv = 0;
1439   if ((ostiGetTransportParam(
1440                              tiRoot,
1441                              globalStr,   /* key */
1442                              SwParmsStr,  /* subkey1 */
1443                              agNULL,      /* subkey2 */
1444                              agNULL,
1445                              agNULL,
1446                              agNULL,      /* subkey5 */
1447                              "TraceDestination", /* valueName */
1448                              buffer,
1449                              buffLen,
1450                              &lenRecv
1451                              ) == tiSuccess) && (lenRecv != 0))
1452   {
1453     if (osti_strncmp(buffer, "0x", 2) == 0)
1454     {
1455       SwConfig->TraceDestination = osti_strtoul (buffer, &pLastUsedChar, 0);
1456     }
1457     else
1458     {
1459       SwConfig->TraceDestination = osti_strtoul (buffer, &pLastUsedChar, 10);
1460     }
1461     TI_DBG2(("tdsaGetSwConfigParams: SwConfig->TraceDestination %d\n",SwConfig->TraceDestination));
1462   }
1463
1464   osti_memset(buffer, 0, buffLen);
1465   lenRecv = 0;
1466   if ((ostiGetTransportParam(
1467                              tiRoot,
1468                              globalStr,   /* key */
1469                              SwParmsStr,  /* subkey1 */
1470                              agNULL,      /* subkey2 */
1471                              agNULL,
1472                              agNULL,
1473                              agNULL,      /* subkey5 */
1474                              "TraceMask", /* valueName */
1475                              buffer,
1476                              buffLen,
1477                              &lenRecv
1478                              ) == tiSuccess) && (lenRecv != 0))
1479   {
1480     if (osti_strncmp(buffer, "0x", 2) == 0)
1481     {
1482       SwConfig->TraceMask = osti_strtoul (buffer, &pLastUsedChar, 0);
1483     }
1484     else
1485     {
1486       SwConfig->TraceMask = osti_strtoul (buffer, &pLastUsedChar, 10);
1487     }
1488     TI_DBG2(("tdsaGetSwConfigParams: SwConfig->TraceMask %d %X\n",SwConfig->TraceMask,SwConfig->TraceMask));
1489   }
1490 #endif /*# SA_ENABLE_TRACE_FUNCTIONS */
1491
1492 #ifdef AGTIAPI_CTL
1493   /*
1494    * read the SAS Connection Time Limit parameter
1495    */
1496   osti_memset(buffer, 0, buffLen);
1497   lenRecv = 0;
1498   tdsaAllShared->SASConnectTimeLimit = 0;
1499
1500   if ((ostiGetTransportParam(
1501                              tiRoot,
1502                              globalStr,   /* key */
1503                              SwParmsStr,  /* subkey1 */
1504                              agNULL,      /* subkey2 */
1505                              agNULL,
1506                              agNULL,
1507                              agNULL,      /* subkey5 */
1508                              "SASCTL",    /* valueName */
1509                              buffer,
1510                              buffLen,
1511                              &lenRecv
1512                              ) == tiSuccess) && (lenRecv != 0))
1513   {
1514     if (osti_strncmp(buffer, "0x", 2) == 0)
1515       tdsaAllShared->SASConnectTimeLimit = osti_strtoul (buffer, &pLastUsedChar, 0);
1516     else
1517       tdsaAllShared->SASConnectTimeLimit = osti_strtoul (buffer, &pLastUsedChar, 10);
1518   }
1519 #endif
1520
1521   /* Start FCA value */
1522   osti_memset(buffer, 0, buffLen);
1523   lenRecv = 0;
1524
1525   tdsaAllShared->FCA = 1; /* No FCA by default */
1526
1527   if ((ostiGetTransportParam(
1528                              tiRoot,
1529                              globalStr,   /* key */
1530                              "InitiatorParms",  /* subkey1 */
1531                              agNULL,/* subkey2 */
1532                              agNULL,
1533                              agNULL,
1534                              agNULL,      /* subkey5 */
1535                              "FCA", /* valueName */
1536                              buffer,
1537                              buffLen,
1538                              &lenRecv
1539                              ) == tiSuccess) && (lenRecv != 0))
1540     {
1541       if (osti_strncmp(buffer, "0x", 2) == 0)
1542       {
1543         tdsaAllShared->FCA = osti_strtoul (buffer, &pLastUsedChar, 0);
1544       }
1545       else
1546       {
1547         tdsaAllShared->FCA = osti_strtoul (buffer, &pLastUsedChar, 10);
1548       }
1549     }
1550   /* End FCA value */
1551
1552   /* Start ResetInDiscovery value */
1553   osti_memset(buffer, 0, buffLen);
1554   lenRecv = 0;
1555
1556   tdsaAllShared->ResetInDiscovery = 0; /* No ResetInDiscovery by default */
1557
1558   if ((ostiGetTransportParam(
1559                              tiRoot,
1560                              globalStr,   /* key */
1561                              "InitiatorParms",  /* subkey1 */
1562                              agNULL,/* subkey2 */
1563                              agNULL,
1564                              agNULL,
1565                              agNULL,      /* subkey5 */
1566                              "ResetInDiscovery", /* valueName */
1567                              buffer,
1568                              buffLen,
1569                              &lenRecv
1570                              ) == tiSuccess) && (lenRecv != 0))
1571     {
1572       if (osti_strncmp(buffer, "0x", 2) == 0)
1573       {
1574         tdsaAllShared->ResetInDiscovery = osti_strtoul (buffer, &pLastUsedChar, 0);
1575       }
1576       else
1577       {
1578         tdsaAllShared->ResetInDiscovery = osti_strtoul (buffer, &pLastUsedChar, 10);
1579       }
1580     }
1581   /* End ResetInDiscovery value */
1582
1583   /* Start MCN value */
1584   osti_memset(buffer, 0, buffLen);
1585   lenRecv = 0;
1586
1587   tdsaAllShared->MCN = 1; /* default MCN */
1588
1589   if ((ostiGetTransportParam(
1590                              tiRoot,
1591                              globalStr,   /* key */
1592                              SwParmsStr,  /* subkey1 */
1593                              agNULL,/* subkey2 */
1594                              agNULL,
1595                              agNULL,
1596                              agNULL,      /* subkey5 */
1597                              "MCN", /* valueName */
1598                              buffer,
1599                              buffLen,
1600                              &lenRecv
1601                              ) == tiSuccess) && (lenRecv != 0))
1602   {
1603     if (osti_strncmp(buffer, "0x", 2) == 0)
1604     {
1605       tdsaAllShared->MCN = osti_strtoul (buffer, &pLastUsedChar, 0);
1606     }
1607     else
1608     {
1609       tdsaAllShared->MCN = osti_strtoul (buffer, &pLastUsedChar, 10);
1610     }
1611     TI_DBG6(("tdsaGetSwConfigParams: MCN %d\n", tdsaAllShared->MCN));
1612   }
1613   /* End MCN value */
1614
1615   /* Start sflag value */
1616   osti_memset(buffer, 0, buffLen);
1617   lenRecv = 0;
1618
1619   tdsaAllShared->sflag = 0; /* default sflag */
1620
1621   if ((ostiGetTransportParam(
1622                              tiRoot,
1623                              globalStr,   /* key */
1624                              SwParmsStr,  /* subkey1 */
1625                              agNULL,      /* subkey2 */
1626                              agNULL,
1627                              agNULL,
1628                              agNULL,      /* subkey5 */
1629                              "Sflag",     /* valueName */
1630                              buffer,
1631                              buffLen,
1632                              &lenRecv
1633                              ) == tiSuccess) && (lenRecv != 0))
1634   {
1635     if (osti_strncmp(buffer, "0x", 2) == 0)
1636     {
1637       tdsaAllShared->sflag = osti_strtoul (buffer, &pLastUsedChar, 0);
1638     }
1639     else
1640     {
1641       tdsaAllShared->sflag = osti_strtoul (buffer, &pLastUsedChar, 10);
1642     }
1643     TI_DBG1(("tdsaGetSwConfigParams: sflag %d\n", tdsaAllShared->sflag));
1644   }
1645   /* End sflag value */
1646
1647   /* Start enable DIF */
1648   osti_memset(buffer, 0, buffLen);
1649   lenRecv = 0;
1650
1651   if ((ostiGetTransportParam(
1652                              tiRoot,
1653                              globalStr,   /* key */
1654                              SwParmsStr,  /* subkey1 */
1655                              agNULL,/* subkey2 */
1656                              agNULL,
1657                              agNULL,
1658                              agNULL,      /* subkey5 */
1659                              "enableDIF", /* valueName */
1660                              buffer,
1661                              buffLen,
1662                              &lenRecv
1663                              ) == tiSuccess) && (lenRecv != 0))
1664   {
1665     if (osti_strncmp(buffer, "0x", 2) == 0)
1666     {
1667       enableDIF = osti_strtoul (buffer, &pLastUsedChar, 0);
1668     }
1669     else
1670     {
1671       enableDIF = osti_strtoul (buffer, &pLastUsedChar, 10);
1672     }
1673     TI_DBG6(("tdsaGetSwConfigParams: enableDIF %d\n", enableDIF));
1674     if (enableDIF)
1675     {
1676       SwConfig->enableDIF = agTRUE;
1677     }
1678     else
1679     {
1680       SwConfig->enableDIF = agFALSE;
1681     }
1682     TI_DBG6(("tdsaGetSwConfigParams: SwConfig->enableDIF %d\n", SwConfig->enableDIF));
1683   }
1684   /* End enable DIF */
1685
1686
1687   /* Start enable Encryption */
1688   osti_memset(buffer, 0, buffLen);
1689   lenRecv = 0;
1690
1691   if ((ostiGetTransportParam(
1692                              tiRoot,
1693                              globalStr,   /* key */
1694                              SwParmsStr,  /* subkey1 */
1695                              agNULL,/* subkey2 */
1696                              agNULL,
1697                              agNULL,
1698                              agNULL,      /* subkey5 */
1699                              "enableEncryption", /* valueName */
1700                              buffer,
1701                              buffLen,
1702                              &lenRecv
1703                              ) == tiSuccess) && (lenRecv != 0))
1704   {
1705     if (osti_strncmp(buffer, "0x", 2) == 0)
1706     {
1707       enableEncryption = osti_strtoul (buffer, &pLastUsedChar, 0);
1708     }
1709     else
1710     {
1711       enableEncryption = osti_strtoul (buffer, &pLastUsedChar, 10);
1712     }
1713     TI_DBG6(("tdsaGetSwConfigParams: enableEncryption %d\n", enableEncryption));
1714     if (enableEncryption)
1715     {
1716       SwConfig->enableEncryption = agTRUE;
1717     }
1718     else
1719     {
1720       SwConfig->enableEncryption = agFALSE;
1721     }
1722     TI_DBG6(("tdsaGetSwConfigParams: SwConfig->enableEncryption %d\n", SwConfig->enableEncryption));
1723   }
1724   /* End enable Encryption */
1725
1726   /* Start allow connection rate change */
1727   osti_memset(buffer, 0, buffLen);
1728   lenRecv = 0;
1729   tdsaAllShared->RateAdjust = 0; /* No rate adjust by default */
1730   if ((ostiGetTransportParam(
1731                              tiRoot,
1732                              globalStr,   /* key */
1733                              SwParmsStr,  /* subkey1 */
1734                              agNULL,/* subkey2 */
1735                              agNULL,
1736                              agNULL,
1737                              agNULL,      /* subkey5 */
1738                              "RateAdjust", /* valueName */
1739                              buffer,
1740                              buffLen,
1741                              &lenRecv
1742                              ) == tiSuccess) && (lenRecv != 0))
1743   {
1744     if (osti_strncmp(buffer, "0x", 2) == 0)
1745     {
1746       tdsaAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 0);
1747     }
1748     else
1749     {
1750       tdsaAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 10);
1751     }
1752     TI_DBG6(("tdsaGetSwConfigParams: tdsaAllShared->RateAdjust %d\n", tdsaAllShared->RateAdjust));
1753   }
1754   /* End allow connection rate change */
1755
1756
1757 #ifdef SA_CONFIG_MDFD_REGISTRY
1758   /* Start disable MDF */
1759   osti_memset(buffer, 0, buffLen);
1760   lenRecv = 0;
1761
1762   if ((ostiGetTransportParam(
1763                              tiRoot,
1764                              globalStr,   /* key */
1765                              SwParmsStr,  /* subkey1 */
1766                              agNULL,/* subkey2 */
1767                              agNULL,
1768                              agNULL,
1769                              agNULL,      /* subkey5 */
1770                              "disableMDF", /* valueName */
1771                              buffer,
1772                              buffLen,
1773                              &lenRecv
1774                              ) == tiSuccess) && (lenRecv != 0))
1775   {
1776     if (osti_strncmp(buffer, "0x", 2) == 0)
1777     {
1778       disableMDF = osti_strtoul (buffer, &pLastUsedChar, 0);
1779     }
1780     else
1781     {
1782       disableMDF = osti_strtoul (buffer, &pLastUsedChar, 10);
1783     }
1784     TI_DBG6(("tdsaGetSwConfigParams: disableMDF %d\n", disableMDF));
1785     if (disableMDF)
1786     {
1787       SwConfig->disableMDF = agTRUE;
1788     }
1789     else
1790     {
1791       SwConfig->disableMDF = agFALSE;
1792     }
1793     TI_DBG6(("tdsaGetSwConfigParams: SwConfig->disableMDF %d\n", SwConfig->disableMDF));
1794   }
1795   /* End disable MDF */
1796 #endif /*SA_CONFIG_MDFD_REGISTRY*/
1797
1798   /* Start IT_NEXUS_TIMEOUT */
1799   osti_memset(buffer, 0, buffLen);
1800   lenRecv = 0;
1801
1802   if ((ostiGetTransportParam(
1803                              tiRoot,
1804                              globalStr,   /* key */
1805                              SwParmsStr,  /* subkey1 */
1806                              agNULL,/* subkey2 */
1807                              agNULL,
1808                              agNULL,
1809                              agNULL,      /* subkey5 */
1810                              "IT_NEXUS_TIMEOUT", /* valueName */
1811                              buffer,
1812                              buffLen,
1813                              &lenRecv
1814                              ) == tiSuccess) && (lenRecv != 0))
1815   {
1816     if (osti_strncmp(buffer, "0x", 2) == 0)
1817     {
1818       tdsaAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
1819     }
1820     else
1821     {
1822       tdsaAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
1823     }
1824     TI_DBG1(("tdsaGetSwConfigParams: tdsaAllShared->itNexusTimeout %d\n", tdsaAllShared->itNexusTimeout));
1825   }
1826   /* End IT_NEXUS_TIMEOUT */
1827
1828   /* Start stp idle time */
1829   osti_memset(buffer, 0, buffLen);
1830   lenRecv = 0;
1831
1832   if ((ostiGetTransportParam(
1833                              tiRoot,
1834                              globalStr,   /* key */
1835                              SwParmsStr,  /* subkey1 */
1836                              agNULL,/* subkey2 */
1837                              agNULL,
1838                              agNULL,
1839                              agNULL,      /* subkey5 */
1840                              "STPIdleTime", /* valueName */
1841                              buffer,
1842                              buffLen,
1843                              &lenRecv
1844                              ) == tiSuccess) && (lenRecv != 0))
1845   {
1846     if (osti_strncmp(buffer, "0x", 2) == 0)
1847     {
1848       tdsaAllShared->stp_idle_time = osti_strtoul (buffer, &pLastUsedChar, 0);
1849     }
1850     else
1851     {
1852       tdsaAllShared->stp_idle_time = osti_strtoul (buffer, &pLastUsedChar, 10);
1853     }
1854     TI_DBG2(("tdsaGetSwConfigParams: STPIdleTime %d\n", tdsaAllShared->stp_idle_time));
1855   }
1856   /* End stp idle time */
1857
1858   /* Start STP_MCT_TMO */
1859   osti_memset(buffer, 0, buffLen);
1860   lenRecv = 0;
1861
1862   tdsaAllShared->STP_MCT_TMO = 32;
1863   if ((ostiGetTransportParam(
1864                              tiRoot,
1865                              globalStr,   /* key */
1866                              SwParmsStr,  /* subkey1 */
1867                              agNULL,/* subkey2 */
1868                              agNULL,
1869                              agNULL,
1870                              agNULL,      /* subkey5 */
1871                              "SAS_STP_MCT_TMO", /* valueName */
1872                              buffer,
1873                              buffLen,
1874                              &lenRecv
1875                              ) == tiSuccess) && (lenRecv != 0))
1876   {
1877     if (osti_strncmp(buffer, "0x", 2) == 0)
1878     {
1879       tdsaAllShared->STP_MCT_TMO = osti_strtoul (buffer, &pLastUsedChar, 0);
1880     }
1881     else
1882     {
1883       tdsaAllShared->STP_MCT_TMO = osti_strtoul (buffer, &pLastUsedChar, 10);
1884     }
1885     TI_DBG2(("tdsaGetSwConfigParams: STP_MCT_TMO %d\n", tdsaAllShared->STP_MCT_TMO));
1886   }
1887   /* End  STP_MCT_TMO */
1888
1889   /* Start SSP_MCT_TMO */
1890   osti_memset(buffer, 0, buffLen);
1891   lenRecv = 0;
1892   tdsaAllShared->SSP_MCT_TMO = 32;
1893   if ((ostiGetTransportParam(
1894                              tiRoot,
1895                              globalStr,   /* key */
1896                              SwParmsStr,  /* subkey1 */
1897                              agNULL,/* subkey2 */
1898                              agNULL,
1899                              agNULL,
1900                              agNULL,      /* subkey5 */
1901                              "SAS_SSP_MCT_TMO", /* valueName */
1902                              buffer,
1903                              buffLen,
1904                              &lenRecv
1905                              ) == tiSuccess) && (lenRecv != 0))
1906   {
1907     if (osti_strncmp(buffer, "0x", 2) == 0)
1908     {
1909       tdsaAllShared->SSP_MCT_TMO = osti_strtoul (buffer, &pLastUsedChar, 0);
1910     }
1911     else
1912     {
1913       tdsaAllShared->SSP_MCT_TMO = osti_strtoul (buffer, &pLastUsedChar, 10);
1914     }
1915     TI_DBG2(("tdsaGetSwConfigParams: SSP_MCT_TMO %d\n", tdsaAllShared->SSP_MCT_TMO));
1916   }
1917   /* End  SSP_MCT_TMO */
1918
1919
1920   /* Start MAX_OPEN_TIME */
1921   osti_memset(buffer, 0, buffLen);
1922   lenRecv = 0;
1923   tdsaAllShared->MAX_OPEN_TIME = 5;
1924   if ((ostiGetTransportParam(
1925                              tiRoot,
1926                              globalStr,   /* key */
1927                              SwParmsStr,  /* subkey1 */
1928                              agNULL,/* subkey2 */
1929                              agNULL,
1930                              agNULL,
1931                              agNULL,      /* subkey5 */
1932                              "SAS_MAX_OPEN_TIME", /* valueName */
1933                              buffer,
1934                              buffLen,
1935                              &lenRecv
1936                              ) == tiSuccess) && (lenRecv != 0))
1937   {
1938     if (osti_strncmp(buffer, "0x", 2) == 0)
1939     {
1940       tdsaAllShared->MAX_OPEN_TIME = osti_strtoul (buffer, &pLastUsedChar, 0);
1941     }
1942     else
1943     {
1944       tdsaAllShared->MAX_OPEN_TIME = osti_strtoul (buffer, &pLastUsedChar, 10);
1945     }
1946     TI_DBG2(("tdsaGetSwConfigParams: MAX_OPEN_TIME %d\n", tdsaAllShared->MAX_OPEN_TIME));
1947   }
1948   /* End  MAX_OPEN_TIME */
1949
1950
1951   /* Start SMP_MAX_CONN_TIMER */
1952   osti_memset(buffer, 0, buffLen);
1953   lenRecv = 0;
1954   tdsaAllShared->SMP_MAX_CONN_TIMER = 0xFF;
1955   if ((ostiGetTransportParam(
1956                              tiRoot,
1957                              globalStr,   /* key */
1958                              SwParmsStr,  /* subkey1 */
1959                              agNULL,/* subkey2 */
1960                              agNULL,
1961                              agNULL,
1962                              agNULL,      /* subkey5 */
1963                              "SAS_SMP_MAX_CONN_TIMER", /* valueName */
1964                              buffer,
1965                              buffLen,
1966                              &lenRecv
1967                              ) == tiSuccess) && (lenRecv != 0))
1968   {
1969     if (osti_strncmp(buffer, "0x", 2) == 0)
1970     {
1971       tdsaAllShared->SMP_MAX_CONN_TIMER = osti_strtoul (buffer, &pLastUsedChar, 0);
1972     }
1973     else
1974     {
1975       tdsaAllShared->SMP_MAX_CONN_TIMER = osti_strtoul (buffer, &pLastUsedChar, 10);
1976     }
1977     TI_DBG2(("tdsaGetSwConfigParams: SMP_MAX_CONN_TIMER %d\n", tdsaAllShared->SMP_MAX_CONN_TIMER));
1978   }
1979   /* End  SMP_MAX_CONN_TIMER */
1980
1981   /* Start STP_FRM_TMO */
1982   osti_memset(buffer, 0, buffLen);
1983   lenRecv = 0;
1984   tdsaAllShared->STP_FRM_TMO = 0;
1985   if ((ostiGetTransportParam(
1986                              tiRoot,
1987                              globalStr,   /* key */
1988                              SwParmsStr,  /* subkey1 */
1989                              agNULL,/* subkey2 */
1990                              agNULL,
1991                              agNULL,
1992                              agNULL,      /* subkey5 */
1993                              "SAS_STP_FRM_TMO", /* valueName */
1994                              buffer,
1995                              buffLen,
1996                              &lenRecv
1997                              ) == tiSuccess) && (lenRecv != 0))
1998   {
1999     if (osti_strncmp(buffer, "0x", 2) == 0)
2000     {
2001       tdsaAllShared->STP_FRM_TMO = osti_strtoul (buffer, &pLastUsedChar, 0);
2002     }
2003     else
2004     {
2005       tdsaAllShared->STP_FRM_TMO = osti_strtoul (buffer, &pLastUsedChar, 10);
2006     }
2007     TI_DBG2(("tdsaGetSwConfigParams: STP_FRM_TMO %d\n", tdsaAllShared->STP_FRM_TMO));
2008   }
2009   /* End  STP_FRM_TMO */
2010
2011   /* Start MFD_OPNRJT_RTRY_INTVL */
2012   osti_memset(buffer, 0, buffLen);
2013   lenRecv = 0;
2014   tdsaAllShared->MFD = 1; /* disabled  by default */
2015   if ((ostiGetTransportParam(
2016                              tiRoot,
2017                              globalStr,   /* key */
2018                              SwParmsStr,  /* subkey1 */
2019                              agNULL,/* subkey2 */
2020                              agNULL,
2021                              agNULL,
2022                              agNULL,      /* subkey5 */
2023                              "SAS_MFD", /* valueName */
2024                              buffer,
2025                              buffLen,
2026                              &lenRecv
2027                              ) == tiSuccess) && (lenRecv != 0))
2028   {
2029     if (osti_strncmp(buffer, "0x", 2) == 0)
2030     {
2031       tdsaAllShared->MFD = osti_strtoul (buffer, &pLastUsedChar, 0);
2032     }
2033     else
2034     {
2035       tdsaAllShared->MFD = osti_strtoul (buffer, &pLastUsedChar, 10);
2036     }
2037     TI_DBG2(("tdsaGetSwConfigParams: MFD %d\n", tdsaAllShared->MFD));
2038   }
2039   /* End  MFD_OPNRJT_RTRY_INTVL */
2040
2041   /* Start MFD_OPNRJT_RTRY_INTVL */
2042   osti_memset(buffer, 0, buffLen);
2043   lenRecv = 0;
2044   tdsaAllShared->OPNRJT_RTRY_INTVL = 2;
2045   if ((ostiGetTransportParam(
2046                              tiRoot,
2047                              globalStr,   /* key */
2048                              SwParmsStr,  /* subkey1 */
2049                              agNULL,/* subkey2 */
2050                              agNULL,
2051                              agNULL,
2052                              agNULL,      /* subkey5 */
2053                              "SAS_OPNRJT_RTRY_INTVL", /* valueName */
2054                              buffer,
2055                              buffLen,
2056                              &lenRecv
2057                              ) == tiSuccess) && (lenRecv != 0))
2058   {
2059     if (osti_strncmp(buffer, "0x", 2) == 0)
2060     {
2061       tdsaAllShared->OPNRJT_RTRY_INTVL = osti_strtoul (buffer, &pLastUsedChar, 0);
2062     }
2063     else
2064     {
2065       tdsaAllShared->OPNRJT_RTRY_INTVL = osti_strtoul (buffer, &pLastUsedChar, 10);
2066     }
2067     TI_DBG2(("tdsaGetSwConfigParams: OPNRJT_RTRY_INTVL %d\n", tdsaAllShared->OPNRJT_RTRY_INTVL));
2068   }
2069   /* End  MFD_OPNRJT_RTRY_INTVL */
2070
2071   /* Start DOPNRJT_RTRY_TMO */
2072   osti_memset(buffer, 0, buffLen);
2073   lenRecv = 0;
2074   tdsaAllShared->DOPNRJT_RTRY_TMO = 128;
2075   if ((ostiGetTransportParam(
2076                              tiRoot,
2077                              globalStr,   /* key */
2078                              SwParmsStr,  /* subkey1 */
2079                              agNULL,/* subkey2 */
2080                              agNULL,
2081                              agNULL,
2082                              agNULL,      /* subkey5 */
2083                              "SAS_DOPNRJT_RTRY_TMO", /* valueName */
2084                              buffer,
2085                              buffLen,
2086                              &lenRecv
2087                              ) == tiSuccess) && (lenRecv != 0))
2088   {
2089     if (osti_strncmp(buffer, "0x", 2) == 0)
2090     {
2091       tdsaAllShared->DOPNRJT_RTRY_TMO = osti_strtoul (buffer, &pLastUsedChar, 0);
2092     }
2093     else
2094     {
2095       tdsaAllShared->DOPNRJT_RTRY_TMO = osti_strtoul (buffer, &pLastUsedChar, 10);
2096     }
2097     TI_DBG2(("tdsaGetSwConfigParams: DOPNRJT_RTRY_TMO %d\n", tdsaAllShared->DOPNRJT_RTRY_TMO));
2098   }
2099   /* End  DOPNRJT_RTRY_TMO */
2100
2101   /* Start COPNRJT_RTRY_TMO */
2102   osti_memset(buffer, 0, buffLen);
2103   lenRecv = 0;
2104 //  tdsaAllShared->COPNRJT_RTRY_TMO = 32;
2105   tdsaAllShared->COPNRJT_RTRY_TMO = 128;
2106   if ((ostiGetTransportParam(
2107                              tiRoot,
2108                              globalStr,   /* key */
2109                              SwParmsStr,  /* subkey1 */
2110                              agNULL,/* subkey2 */
2111                              agNULL,
2112                              agNULL,
2113                              agNULL,      /* subkey5 */
2114                              "SAS_COPNRJT_RTRY_TMO", /* valueName */
2115                              buffer,
2116                              buffLen,
2117                              &lenRecv
2118                              ) == tiSuccess) && (lenRecv != 0))
2119   {
2120     if (osti_strncmp(buffer, "0x", 2) == 0)
2121     {
2122       tdsaAllShared->COPNRJT_RTRY_TMO = osti_strtoul (buffer, &pLastUsedChar, 0);
2123     }
2124     else
2125     {
2126       tdsaAllShared->COPNRJT_RTRY_TMO = osti_strtoul (buffer, &pLastUsedChar, 10);
2127     }
2128     TI_DBG2(("tdsaGetSwConfigParams: COPNRJT_RTRY_TMO %d\n", tdsaAllShared->COPNRJT_RTRY_TMO));
2129   }
2130   /* End  COPNRJT_RTRY_TMO */
2131
2132   /* Start DOPNRJT_RTRY_THR */
2133   osti_memset(buffer, 0, buffLen);
2134   lenRecv = 0;
2135 //  tdsaAllShared->DOPNRJT_RTRY_THR = 16; /* FW default */
2136   /*
2137     Making ORR bigger than IT NEXUS LOSS which is 2000000us = 2 second.
2138     Assuming a bigger value 3 second, 3000000/128 = 23437.5 where 128 is tdsaAllShared->DOPNRJT_RTRY_TMO
2139   */
2140   tdsaAllShared->DOPNRJT_RTRY_THR = 23438;
2141   if ((ostiGetTransportParam(
2142                              tiRoot,
2143                              globalStr,   /* key */
2144                              SwParmsStr,  /* subkey1 */
2145                              agNULL,/* subkey2 */
2146                              agNULL,
2147                              agNULL,
2148                              agNULL,      /* subkey5 */
2149                              "SAS_DOPNRJT_RTRY_THR", /* valueName */
2150                              buffer,
2151                              buffLen,
2152                              &lenRecv
2153                              ) == tiSuccess) && (lenRecv != 0))
2154   {
2155     if (osti_strncmp(buffer, "0x", 2) == 0)
2156     {
2157       tdsaAllShared->DOPNRJT_RTRY_THR = osti_strtoul (buffer, &pLastUsedChar, 0);
2158     }
2159     else
2160     {
2161       tdsaAllShared->DOPNRJT_RTRY_THR = osti_strtoul (buffer, &pLastUsedChar, 10);
2162     }
2163     TI_DBG2(("tdsaGetSwConfigParams: DOPNRJT_RTRY_THR %d\n", tdsaAllShared->DOPNRJT_RTRY_THR));
2164   }
2165   /* End  DOPNRJT_RTRY_THR */
2166
2167   /* Start COPNRJT_RTRY_THR */
2168   osti_memset(buffer, 0, buffLen);
2169   lenRecv = 0;
2170 //  tdsaAllShared->COPNRJT_RTRY_THR = 1024; /* FW default */
2171   /*
2172     Making ORR bigger than IT NEXUS LOSS which is 2000000us = 2 second.
2173     Assuming a bigger value 3 second, 3000000/128 =  23437.5 where 128 is tdsaAllShared->COPNRJT_RTRY_TMO
2174   */
2175   tdsaAllShared->COPNRJT_RTRY_THR = 23438;
2176   if ((ostiGetTransportParam(
2177                              tiRoot,
2178                              globalStr,   /* key */
2179                              SwParmsStr,  /* subkey1 */
2180                              agNULL,/* subkey2 */
2181                              agNULL,
2182                              agNULL,
2183                              agNULL,      /* subkey5 */
2184                              "SAS_COPNRJT_RTRY_THR", /* valueName */
2185                              buffer,
2186                              buffLen,
2187                              &lenRecv
2188                              ) == tiSuccess) && (lenRecv != 0))
2189   {
2190     if (osti_strncmp(buffer, "0x", 2) == 0)
2191     {
2192       tdsaAllShared->COPNRJT_RTRY_THR = osti_strtoul (buffer, &pLastUsedChar, 0);
2193     }
2194     else
2195     {
2196       tdsaAllShared->COPNRJT_RTRY_THR = osti_strtoul (buffer, &pLastUsedChar, 10);
2197     }
2198     TI_DBG2(("tdsaGetSwConfigParams: COPNRJT_RTRY_THR %d\n", tdsaAllShared->COPNRJT_RTRY_THR));
2199   }
2200   /* End  COPNRJT_RTRY_THR */
2201
2202   /* Start MAX_AIP */
2203   osti_memset(buffer, 0, buffLen);
2204   lenRecv = 0;
2205   tdsaAllShared->MAX_AIP = 0x200000;
2206   if ((ostiGetTransportParam(
2207                              tiRoot,
2208                              globalStr,   /* key */
2209                              SwParmsStr,  /* subkey1 */
2210                              agNULL,/* subkey2 */
2211                              agNULL,
2212                              agNULL,
2213                              agNULL,      /* subkey5 */
2214                              "SAS_MAX_AIP", /* valueName */
2215                              buffer,
2216                              buffLen,
2217                              &lenRecv
2218                              ) == tiSuccess) && (lenRecv != 0))
2219   {
2220     if (osti_strncmp(buffer, "0x", 2) == 0)
2221     {
2222       tdsaAllShared->MAX_AIP = osti_strtoul (buffer, &pLastUsedChar, 0);
2223     }
2224     else
2225     {
2226       tdsaAllShared->MAX_AIP = osti_strtoul (buffer, &pLastUsedChar, 10);
2227     }
2228     TI_DBG2(("tdsaGetSwConfigParams: MAX_AIP %d\n", tdsaAllShared->MAX_AIP));
2229   }
2230   /* End  MAX_AIP */
2231
2232   /***********************************************************************/
2233   osti_memset(buffer, 0, buffLen);
2234   lenRecv = 0;
2235
2236
2237     /*
2238     typedef struct agsaMPIContext_s
2239     {
2240       bit32   MPITableType;
2241       bit32   offset;
2242       bit32   value;
2243     } agsaMPIContext_t;
2244     */
2245
2246   {
2247     bit32 MpiContextvalue  = 0;
2248     SwConfig->mpiContextTable = agNULL;
2249     SwConfig->mpiContextTablelen = 0;
2250
2251     if ((ostiGetTransportParam(
2252                                tiRoot,
2253                                globalStr,   /* key */
2254                                SwParmsStr,  /* subkey1 */
2255                                agNULL,      /* subkey2 */
2256                                agNULL,
2257                                agNULL,
2258                                agNULL,      /* subkey5 */
2259                                "MpiContext", /* valueName */
2260                                buffer,
2261                                buffLen,
2262                                &lenRecv
2263                                ) == tiSuccess) && (lenRecv != 0))
2264     {
2265
2266       if (osti_strncmp(buffer, "0x", 2) == 0)
2267       {
2268         MpiContextvalue = osti_strtoul (buffer, &pLastUsedChar, 0);
2269       }
2270       else
2271       {
2272         MpiContextvalue =  osti_strtoul (buffer, &pLastUsedChar, 10);
2273       }
2274
2275
2276       if (MpiContextvalue  == 0)
2277       {
2278         SwConfig->mpiContextTable = agNULL;
2279         SwConfig->mpiContextTablelen = 0;
2280       }
2281       else
2282       {
2283         tdsaRoot_t    *tdsaRoot = (tdsaRoot_t *)tiRoot->tdData;
2284         if(agNULL != tdsaRoot)
2285         {
2286           tdsaRoot->tdsaAllShared.MpiOverride.MPITableType = 0xFF;
2287           tdsaRoot->tdsaAllShared.MpiOverride.offset = 0;
2288           tdsaRoot->tdsaAllShared.MpiOverride.value = 0;
2289
2290           SwConfig->mpiContextTable = &(tdsaRoot->tdsaAllShared.MpiOverride);
2291           SwConfig->mpiContextTablelen = sizeof(agsaMPIContext_t);
2292         }
2293
2294         TI_DBG1(("tdsaGetSwConfigParams: MpiContext %p Len %d\n", SwConfig->mpiContextTable, SwConfig->mpiContextTablelen));
2295
2296       }
2297     }
2298
2299     if(SwConfig->mpiContextTable != agNULL )
2300     {
2301       tdsaRoot_t    *tdsaRoot = (tdsaRoot_t *)tiRoot->tdData;
2302       if(agNULL != tdsaRoot)
2303       {
2304         if ((ostiGetTransportParam(
2305                                    tiRoot,
2306                                    globalStr,   /* key */
2307                                    SwParmsStr,  /* subkey1 */
2308                                    agNULL,      /* subkey2 */
2309                                    agNULL,
2310                                    agNULL,
2311                                    agNULL,      /* subkey5 */
2312                                    "MpiTableType", /* valueName */
2313                                    buffer,
2314                                    buffLen,
2315                                    &lenRecv
2316                                    ) == tiSuccess) && (lenRecv != 0))
2317         {
2318           if (osti_strncmp(buffer, "0x", 2) == 0)
2319           {
2320             tdsaRoot->tdsaAllShared.MpiOverride.MPITableType = osti_strtoul (buffer, &pLastUsedChar, 0);
2321           }
2322           else
2323           {
2324             tdsaRoot->tdsaAllShared.MpiOverride.MPITableType =  osti_strtoul (buffer, &pLastUsedChar, 10);
2325           }
2326         TI_DBG1(("tdsaGetSwConfigParams: MpiOverride.MPITableType  0x%X\n",tdsaRoot->tdsaAllShared.MpiOverride.MPITableType ));
2327         }
2328
2329         if ((ostiGetTransportParam(
2330                                    tiRoot,
2331                                    globalStr,   /* key */
2332                                    SwParmsStr,  /* subkey1 */
2333                                    agNULL,      /* subkey2 */
2334                                    agNULL,
2335                                    agNULL,
2336                                    agNULL,      /* subkey5 */
2337                                    "MpiTableOffset", /* valueName */
2338                                    buffer,
2339                                    buffLen,
2340                                    &lenRecv
2341                                    ) == tiSuccess) && (lenRecv != 0))
2342         {
2343           if (osti_strncmp(buffer, "0x", 2) == 0)
2344           {
2345             tdsaRoot->tdsaAllShared.MpiOverride.offset = osti_strtoul (buffer, &pLastUsedChar, 0);
2346           }
2347           else
2348           {
2349             tdsaRoot->tdsaAllShared.MpiOverride.offset =  osti_strtoul (buffer, &pLastUsedChar, 10);
2350           }
2351
2352         TI_DBG1(("tdsaGetSwConfigParams: MpiOverride.offset 0x%X\n",tdsaRoot->tdsaAllShared.MpiOverride.offset ));
2353         }
2354
2355         if ((ostiGetTransportParam(
2356                                    tiRoot,
2357                                    globalStr,   /* key */
2358                                    SwParmsStr,  /* subkey1 */
2359                                    agNULL,      /* subkey2 */
2360                                    agNULL,
2361                                    agNULL,
2362                                    agNULL,      /* subkey5 */
2363                                    "MpiTableValue", /* valueName */
2364                                    buffer,
2365                                    buffLen,
2366                                    &lenRecv
2367                                    ) == tiSuccess) && (lenRecv != 0))
2368         {
2369           if (osti_strncmp(buffer, "0x", 2) == 0)
2370           {
2371             tdsaRoot->tdsaAllShared.MpiOverride.value = osti_strtoul (buffer, &pLastUsedChar, 0);
2372           }
2373           else
2374           {
2375             tdsaRoot->tdsaAllShared.MpiOverride.value =  osti_strtoul (buffer, &pLastUsedChar, 10);
2376           }
2377           TI_DBG1(("tdsaGetSwConfigParams: MpiOverride.value 0x%X\n",tdsaRoot->tdsaAllShared.MpiOverride.value ));
2378         }
2379       }
2380     }
2381   }
2382   /***********************************************************************/
2383
2384 #ifdef SA_ENABLE_PCI_TRIGGER
2385
2386   osti_memset(buffer, 0, buffLen);
2387   lenRecv = 0;
2388
2389   if ((ostiGetTransportParam(
2390                              tiRoot,
2391                              globalStr,   /* key */
2392                              SwParmsStr,  /* subkey1 */
2393                              agNULL,      /* subkey2 */
2394                              agNULL,
2395                              agNULL,
2396                              agNULL,      /* subkey5 */
2397                              "PciTrigger", /* valueName */
2398                              buffer,
2399                              buffLen,
2400                              &lenRecv
2401                              ) == tiSuccess) && (lenRecv != 0))
2402   {
2403
2404     if (osti_strncmp(buffer, "0x", 2) == 0)
2405     {
2406       SwConfig->PCI_trigger = osti_strtoul (buffer, &pLastUsedChar, 0);
2407     }
2408     else
2409     {
2410       SwConfig->PCI_trigger = osti_strtoul (buffer, &pLastUsedChar, 10);
2411     }
2412     TI_DBG1(("tdsaGetSwConfigParams: PciTrigger %d\n",SwConfig->PCI_trigger));
2413   }
2414 #endif /* SA_ENABLE_PCI_TRIGGER */
2415
2416
2417   TI_DBG6(("tdsaGetSwConfigParams: $$$$$$$$$$$$$$$$$ merge $$$$$$$$$$$$$\n"));
2418 #if defined(SALLSDK_DEBUG)
2419   TI_DBG2(("tdsaGetSwConfigParams: SwConfig->sallDebugLevel %d\n", SwConfig->sallDebugLevel));
2420 #endif
2421
2422 #ifdef SA_ENABLE_PCI_TRIGGER
2423   TI_DBG1(("tdsaGetSwConfigParams: SwConfig->PCI_trigger  0x%x   0x%x\n",SwConfig->PCI_trigger, tdsaRoot->itdsaIni->tdsaAllShared->SwConfig.PCI_trigger));
2424 #endif /* SA_ENABLE_PCI_TRIGGER */
2425
2426
2427 #ifdef AGTIAPI_CTL
2428   TI_DBG6(("tdsaLoLevelGetResource: SASConnectTimeLimit 0x%x\n",
2429            tdsaAllShared->SASConnectTimeLimit));
2430 #endif
2431
2432   return;
2433 }
2434
2435 /*****************************************************************************
2436 *! \brief  tdsaParseLinkRateMode
2437 *
2438 *  Purpose:  This function parses link rate and mode.
2439 *
2440 *  \param   LinkRate: Link rate specified by user.
2441 *  \param   Mode: Link rate specified by user.
2442 *
2443 *  \return:
2444 *           Value combined with Linkrate and Mode
2445 *
2446 *   \note:
2447 *
2448 *****************************************************************************/
2449 osGLOBAL void
2450 tdsaParseLinkRateMode(
2451                       tiRoot_t *tiRoot,
2452                       bit32 index,
2453                       bit32 LinkRateRead,
2454                       bit32 ModeRead,
2455                       bit32 OpticalModeRead,
2456                       bit32 LinkRate,
2457                       bit32 Mode,
2458                       bit32 OpticalMode
2459                       )
2460 {
2461   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
2462   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
2463
2464   TI_DBG3(("tdsaParseLinkRateMode: index 0x%X\n",index));
2465   TI_DBG3(("tdsaParseLinkRateMode: LinkRateRead 0x%X    LinkRate 0x%X\n",LinkRateRead,LinkRate));
2466   TI_DBG3(("tdsaParseLinkRateMode: ModeRead 0x%X        Mode 0x%X\n",ModeRead,Mode));
2467   TI_DBG3(("tdsaParseLinkRateMode: OpticalModeRead 0x%X OpticalMode 0x%X\n",OpticalModeRead,OpticalMode));
2468
2469
2470   if (LinkRateRead == agTRUE)
2471   {
2472     /* link rate */
2473     if (LinkRate & 0x1)
2474     {
2475       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x1;
2476     }
2477     if (LinkRate & 0x2)
2478     {
2479       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x2;
2480     }
2481     if (LinkRate & 0x4)
2482     {
2483       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x4;
2484     }
2485     if (LinkRate & 0x8)
2486     {
2487       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x8;
2488     }
2489     if (LinkRate == 0 || LinkRate > 0xF )
2490     {
2491       /* not allowed, set the rate to default 1.5 G */
2492       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = 0;
2493       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x1;
2494       TI_DBG1(("tdsaParseLinkRateMode:  LinkRate == 0 || LinkRate >= 0x%x\n",tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2495     }
2496     TI_DBG2(("tdsaParseLinkRateMode:A index 0x%x LinkRate 0x%x Mode 0x%x\n",index,LinkRate,Mode));
2497
2498   }
2499
2500   if ( ModeRead == agTRUE)
2501   {
2502     /* mode */
2503     if (Mode & 0x1)
2504     {
2505       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x10;
2506     }
2507     if (Mode & 0x2)
2508     {
2509       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x20;
2510     }
2511     if (Mode == 0 || Mode >= 4 )
2512     {
2513       /* not allowed, set the mode to default SAS/SATA */
2514       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties & 0xf;
2515       tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | 0x30;
2516     }
2517     TI_DBG2(("tdsaParseLinkRateMode:1 index 0x%x Mode 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2518   }
2519
2520   if ( OpticalModeRead == agTRUE)
2521   {
2522     /* setting bit20 */
2523     agsaRoot_t     *agRoot = &tdsaAllShared->agRootInt;
2524
2525     if (OpticalMode == 0)
2526     {
2527       TI_DBG1(("tdsaParseLinkRateMode: OpticalMode 0  phy %d phyProperties 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2528     }
2529     else if(OpticalMode == 1)
2530     {
2531       if(tIsSPCV12or6G(agRoot))
2532       {
2533         TI_DBG1(("tdsaParseLinkRateMode: OpticalMode 1  phy %d phyProperties 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2534         tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | (1 << 22);
2535       }
2536       else
2537       {
2538         tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | (1 << 22);
2539         tdsaAllShared->Ports[index].agPhyConfig.phyProperties &= 0xFFFFFFF0;
2540         tdsaAllShared->Ports[index].agPhyConfig.phyProperties |= 0x4;
2541       }
2542     }
2543     else if(OpticalMode == 2 )
2544     {
2545       if(tIsSPCV12or6G(agRoot))
2546       {
2547         TI_DBG1(("tdsaParseLinkRateMode: OpticalMode 2  phy %d phyProperties 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2548         tdsaAllShared->Ports[index].agPhyConfig.phyProperties = tdsaAllShared->Ports[index].agPhyConfig.phyProperties | (1 << 20);
2549       }
2550       else
2551       {
2552         TD_ASSERT(0, "SPC optical mode 2");
2553       }
2554
2555       TI_DBG1(("tdsaParseLinkRateMode: OpticalMode %d phy %d phyProperties 0x%x\n",OpticalMode,index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2556     }
2557     else
2558     {
2559        TI_DBG1(("tdsaParseLinkRateMode: OpticalMode unknown %d  phy %d phyProperties 0x%x\n",OpticalMode,index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2560     }
2561   }
2562   else
2563   {
2564     TI_DBG1(("tdsaParseLinkRateMode: OpticalMode off phy %d phyProperties 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2565   }
2566
2567   TI_DBG1(("tdsaParseLinkRateMode: phy %d phyProperties 0x%x\n",index,tdsaAllShared->Ports[index].agPhyConfig.phyProperties));
2568
2569
2570   return;
2571 }
2572
2573
2574 /*****************************************************************************
2575 *! \brief tdsaGetHwConfigParams
2576 *
2577 *  Purpose:  This function reads hardware configuration parameters from the
2578 *            configuration file
2579 *
2580 *  \param  tiRoot:            Pointer to driver/port instance.
2581 *
2582 *  \return: None
2583 *
2584 *  \note -
2585 *
2586 *****************************************************************************/
2587 osGLOBAL void
2588 tdsaGetHwConfigParams(
2589                       tiRoot_t *tiRoot
2590                       )
2591 {
2592   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
2593   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
2594   agsaHwConfig_t *HwConfig;
2595   char           *buffer;
2596   bit32          buffLen;
2597   bit32          lenRecv = 0;
2598   char           *pLastUsedChar = agNULL;
2599   char           tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
2600   char           globalStr[]     = "Global";
2601   char           HwParmsStr[]   = "HWParms";
2602   char           phyReg[10];
2603   int            i,j;
2604   agsaPhyAnalogSetupTable_t *phyRegTable;
2605
2606   TI_DBG6(("tdsaGetHwConfigParams: start\n"));
2607   TI_DBG6(("tdsaGetHwConfigParams: tdsaRoot %p tdsaAllShared %p \n",tdsaRoot, tdsaAllShared));
2608
2609   buffer = tmpBuffer;
2610   buffLen = sizeof(tmpBuffer);
2611
2612   osti_memset(buffer, 0, buffLen);
2613
2614   HwConfig = (agsaHwConfig_t *)&(tdsaAllShared->HwConfig);
2615   phyRegTable = (agsaPhyAnalogSetupTable_t *)&(HwConfig->phyAnalogConfig);
2616
2617   osti_memset(HwConfig, 0, sizeof(agsaHwConfig_t));
2618
2619   /*
2620     just default values
2621     and are overwritten later by the configuration file contents
2622     turning off hw control interrupt coalescing
2623   */
2624   tdsaAllShared->FWMaxPorts = DEFAULT_FW_MAX_PORTS; /* 8, applicable only to SPC not to SPCv */
2625   HwConfig->phyCount = TD_MAX_NUM_PHYS;
2626   HwConfig->hwInterruptCoalescingTimer = 1;
2627   HwConfig->hwInterruptCoalescingControl = 0;
2628   tdsaAllShared->phyCalibration = 0;
2629   HwConfig->hwOption = 0; /* default: PI/CI addresses are 32-bit */
2630
2631   osti_memset(buffer, 0, buffLen);
2632   lenRecv = 0;
2633
2634   if ((ostiGetTransportParam(
2635                              tiRoot,
2636                              globalStr,   /* key */
2637                              HwParmsStr,  /* subkey1 */
2638                              agNULL,      /* subkey2 */
2639                              agNULL,
2640                              agNULL,
2641                              agNULL,      /* subkey5 */
2642                              "HwIntCoalTimer", /* valueName */
2643                              buffer,
2644                              buffLen,
2645                              &lenRecv
2646                              ) == tiSuccess) && (lenRecv != 0))
2647   {
2648     if (osti_strncmp(buffer, "0x", 2) == 0)
2649     {
2650       HwConfig->hwInterruptCoalescingTimer = osti_strtoul (buffer, &pLastUsedChar, 0);
2651     }
2652     else
2653     {
2654       HwConfig->hwInterruptCoalescingTimer = osti_strtoul (buffer, &pLastUsedChar, 10);
2655     }
2656   }
2657
2658   osti_memset(buffer, 0, buffLen);
2659   lenRecv = 0;
2660
2661   if ((ostiGetTransportParam(
2662                              tiRoot,
2663                              globalStr,   /* key */
2664                              HwParmsStr,  /* subkey1 */
2665                              agNULL,      /* subkey2 */
2666                              agNULL,
2667                              agNULL,
2668                              agNULL,      /* subkey5 */
2669                              "HwIntCoalControl", /* valueName */
2670                              buffer,
2671                              buffLen,
2672                              &lenRecv
2673                              ) == tiSuccess) && (lenRecv != 0))
2674   {
2675     if (osti_strncmp(buffer, "0x", 2) == 0)
2676     {
2677       HwConfig->hwInterruptCoalescingControl = osti_strtoul (buffer, &pLastUsedChar, 0);
2678     }
2679     else
2680     {
2681       HwConfig->hwInterruptCoalescingControl = osti_strtoul (buffer, &pLastUsedChar, 10);
2682     }
2683   }
2684
2685   /* For hwInterruptCoalescingTimer, 0 disables interrrupt, not allowed */
2686   if (HwConfig->hwInterruptCoalescingControl == 1 && HwConfig->hwInterruptCoalescingTimer == 0)
2687   {
2688     HwConfig->hwInterruptCoalescingTimer = 1;
2689   }
2690
2691   osti_memset(buffer, 0, buffLen);
2692   lenRecv = 0;
2693
2694   /* interrupt reassetion field*/
2695   if ((ostiGetTransportParam(
2696                              tiRoot,
2697                              globalStr,   /* key */
2698                              HwParmsStr,  /* subkey1 */
2699                              agNULL,      /* subkey2 */
2700                              agNULL,
2701                              agNULL,
2702                              agNULL,      /* subkey5 */
2703                              "IntReassertionOpt", /* valueName */
2704                              buffer,
2705                              buffLen,
2706                              &lenRecv
2707                              ) == tiSuccess) && (lenRecv != 0))
2708   {
2709     if (osti_strncmp(buffer, "0x", 2) == 0)
2710     {
2711       HwConfig->intReassertionOption = osti_strtoul (buffer, &pLastUsedChar, 0);
2712     }
2713     else
2714     {
2715       HwConfig->intReassertionOption = osti_strtoul (buffer, &pLastUsedChar, 10);
2716     }
2717   }
2718
2719   osti_memset(buffer, 0, buffLen);
2720   lenRecv = 0;
2721
2722   /* interrupt reassetion field*/
2723   if ((ostiGetTransportParam(
2724                              tiRoot,
2725                              globalStr,   /* key */
2726                              HwParmsStr,  /* subkey1 */
2727                              agNULL,      /* subkey2 */
2728                              agNULL,
2729                              agNULL,
2730                              agNULL,      /* subkey5 */
2731                              "HwOption", /* valueName */
2732                              buffer,
2733                              buffLen,
2734                              &lenRecv
2735                              ) == tiSuccess) && (lenRecv != 0))
2736   {
2737     if (osti_strncmp(buffer, "0x", 2) == 0)
2738     {
2739       HwConfig->hwOption = osti_strtoul (buffer, &pLastUsedChar, 0);
2740     }
2741     else
2742     {
2743       HwConfig->hwOption = osti_strtoul (buffer, &pLastUsedChar, 10);
2744     }
2745   }
2746
2747   osti_memset(buffer, 0, buffLen);
2748   lenRecv = 0;
2749
2750   /* interrupt reassetion field*/
2751   if ((ostiGetTransportParam(
2752                              tiRoot,
2753                              globalStr,   /* key */
2754                              HwParmsStr,  /* subkey1 */
2755                              agNULL,      /* subkey2 */
2756                              agNULL,
2757                              agNULL,
2758                              agNULL,      /* subkey5 */
2759                              "MaxFWPorts", /* valueName */
2760                              buffer,
2761                              buffLen,
2762                              &lenRecv
2763                              ) == tiSuccess) && (lenRecv != 0))
2764   {
2765     if (osti_strncmp(buffer, "0x", 2) == 0)
2766     {
2767       tdsaAllShared->FWMaxPorts = osti_strtoul (buffer, &pLastUsedChar, 0);
2768     }
2769     else
2770     {
2771       tdsaAllShared->FWMaxPorts = osti_strtoul (buffer, &pLastUsedChar, 10);
2772     }
2773   }
2774
2775   osti_memset(buffer, 0, buffLen);
2776   lenRecv = 0;
2777
2778   if ((ostiGetTransportParam(
2779                              tiRoot,
2780                              globalStr,   /* key */
2781                              HwParmsStr,  /* subkey1 */
2782                              agNULL,      /* subkey2 */
2783                              agNULL,
2784                              agNULL,
2785                              agNULL,      /* subkey5 */
2786                              "phyCalibration", /* valueName */
2787                              buffer,
2788                              buffLen,
2789                              &lenRecv
2790                              ) == tiSuccess) && (lenRecv != 0))
2791   {
2792     if (osti_strncmp(buffer, "0x", 2) == 0)
2793     {
2794       tdsaAllShared->phyCalibration = osti_strtoul (buffer, &pLastUsedChar, 0);
2795     }
2796     else
2797     {
2798       tdsaAllShared->phyCalibration = osti_strtoul (buffer, &pLastUsedChar, 10);
2799     }
2800   }
2801
2802   osti_memset(buffer, 0, buffLen);
2803   lenRecv = 0;
2804
2805
2806   /* phy calibration */
2807   for (i=0;i<MAX_INDEX;i++)
2808   {
2809     for(j=0;j<10;j++)
2810     {
2811       osti_sprintf(phyReg,"spaReg%d%d",i,j);
2812       TI_DBG6(("tdsaGetHwConfigParams: phyReg %s\n", phyReg));
2813
2814       if (j == 0)
2815       {
2816         if ((ostiGetTransportParam(
2817                                tiRoot,
2818                                globalStr,   /* key */
2819                                HwParmsStr,  /* subkey1 */
2820                                agNULL,      /* subkey2 */
2821                                agNULL,
2822                                agNULL,
2823                                agNULL,      /* subkey5 */
2824                                phyReg, /* valueName */
2825                                buffer,
2826                                buffLen,
2827                                &lenRecv
2828                                ) == tiSuccess) && (lenRecv != 0))
2829       {
2830         if (osti_strncmp(buffer, "0x", 2) == 0)
2831         {
2832           phyRegTable->phyAnalogSetupRegisters[i].spaRegister0 = osti_strtoul (buffer, &pLastUsedChar, 0);
2833         }
2834         else
2835         {
2836           phyRegTable->phyAnalogSetupRegisters[i].spaRegister0 = osti_strtoul (buffer, &pLastUsedChar, 10);
2837         }
2838       }
2839
2840       osti_memset(buffer, 0, buffLen);
2841       lenRecv = 0;
2842       }
2843       else if (j == 1)
2844       {
2845         if ((ostiGetTransportParam(
2846                                tiRoot,
2847                                globalStr,   /* key */
2848                                HwParmsStr,  /* subkey1 */
2849                                agNULL,      /* subkey2 */
2850                                agNULL,
2851                                agNULL,
2852                                agNULL,      /* subkey5 */
2853                                phyReg, /* valueName */
2854                                buffer,
2855                                buffLen,
2856                                &lenRecv
2857                                ) == tiSuccess) && (lenRecv != 0))
2858       {
2859         if (osti_strncmp(buffer, "0x", 2) == 0)
2860         {
2861           phyRegTable->phyAnalogSetupRegisters[i].spaRegister1 = osti_strtoul (buffer, &pLastUsedChar, 0);
2862         }
2863         else
2864         {
2865           phyRegTable->phyAnalogSetupRegisters[i].spaRegister1 = osti_strtoul (buffer, &pLastUsedChar, 10);
2866         }
2867       }
2868
2869       osti_memset(buffer, 0, buffLen);
2870       lenRecv = 0;
2871       }
2872       else if (j == 2)
2873       {
2874         if ((ostiGetTransportParam(
2875                                tiRoot,
2876                                globalStr,   /* key */
2877                                HwParmsStr,  /* subkey1 */
2878                                agNULL,      /* subkey2 */
2879                                agNULL,
2880                                agNULL,
2881                                agNULL,      /* subkey5 */
2882                                phyReg, /* valueName */
2883                                buffer,
2884                                buffLen,
2885                                &lenRecv
2886                                ) == tiSuccess) && (lenRecv != 0))
2887       {
2888         if (osti_strncmp(buffer, "0x", 2) == 0)
2889         {
2890           phyRegTable->phyAnalogSetupRegisters[i].spaRegister2 = osti_strtoul (buffer, &pLastUsedChar, 0);
2891         }
2892         else
2893         {
2894           phyRegTable->phyAnalogSetupRegisters[i].spaRegister2 = osti_strtoul (buffer, &pLastUsedChar, 10);
2895         }
2896       }
2897
2898       osti_memset(buffer, 0, buffLen);
2899       lenRecv = 0;
2900       }
2901       else if (j == 3)
2902       {
2903         if ((ostiGetTransportParam(
2904                                tiRoot,
2905                                globalStr,   /* key */
2906                                HwParmsStr,  /* subkey1 */
2907                                agNULL,      /* subkey2 */
2908                                agNULL,
2909                                agNULL,
2910                                agNULL,      /* subkey5 */
2911                                phyReg, /* valueName */
2912                                buffer,
2913                                buffLen,
2914                                &lenRecv
2915                                ) == tiSuccess) && (lenRecv != 0))
2916       {
2917         if (osti_strncmp(buffer, "0x", 2) == 0)
2918         {
2919           phyRegTable->phyAnalogSetupRegisters[i].spaRegister3 = osti_strtoul (buffer, &pLastUsedChar, 0);
2920         }
2921         else
2922         {
2923           phyRegTable->phyAnalogSetupRegisters[i].spaRegister3 = osti_strtoul (buffer, &pLastUsedChar, 10);
2924         }
2925       }
2926
2927       osti_memset(buffer, 0, buffLen);
2928       lenRecv = 0;
2929       }
2930       else if (j == 4)
2931       {
2932         if ((ostiGetTransportParam(
2933                                tiRoot,
2934                                globalStr,   /* key */
2935                                HwParmsStr,  /* subkey1 */
2936                                agNULL,      /* subkey2 */
2937                                agNULL,
2938                                agNULL,
2939                                agNULL,      /* subkey5 */
2940                                phyReg, /* valueName */
2941                                buffer,
2942                                buffLen,
2943                                &lenRecv
2944                                ) == tiSuccess) && (lenRecv != 0))
2945       {
2946         if (osti_strncmp(buffer, "0x", 2) == 0)
2947         {
2948           phyRegTable->phyAnalogSetupRegisters[i].spaRegister4 = osti_strtoul (buffer, &pLastUsedChar, 0);
2949         }
2950         else
2951         {
2952           phyRegTable->phyAnalogSetupRegisters[i].spaRegister4 = osti_strtoul (buffer, &pLastUsedChar, 10);
2953         }
2954       }
2955
2956       osti_memset(buffer, 0, buffLen);
2957       lenRecv = 0;
2958       }
2959       else if (j == 5)
2960       {
2961         if ((ostiGetTransportParam(
2962                                tiRoot,
2963                                globalStr,   /* key */
2964                                HwParmsStr,  /* subkey1 */
2965                                agNULL,      /* subkey2 */
2966                                agNULL,
2967                                agNULL,
2968                                agNULL,      /* subkey5 */
2969                                phyReg, /* valueName */
2970                                buffer,
2971                                buffLen,
2972                                &lenRecv
2973                                ) == tiSuccess) && (lenRecv != 0))
2974       {
2975         if (osti_strncmp(buffer, "0x", 2) == 0)
2976         {
2977           phyRegTable->phyAnalogSetupRegisters[i].spaRegister5 = osti_strtoul (buffer, &pLastUsedChar, 0);
2978         }
2979         else
2980         {
2981           phyRegTable->phyAnalogSetupRegisters[i].spaRegister5 = osti_strtoul (buffer, &pLastUsedChar, 10);
2982         }
2983       }
2984
2985       osti_memset(buffer, 0, buffLen);
2986       lenRecv = 0;
2987       }
2988       else if (j == 6)
2989       {
2990         if ((ostiGetTransportParam(
2991                                tiRoot,
2992                                globalStr,   /* key */
2993                                HwParmsStr,  /* subkey1 */
2994                                agNULL,      /* subkey2 */
2995                                agNULL,
2996                                agNULL,
2997                                agNULL,      /* subkey5 */
2998                                phyReg, /* valueName */
2999                                buffer,
3000                                buffLen,
3001                                &lenRecv
3002                                ) == tiSuccess) && (lenRecv != 0))
3003       {
3004         if (osti_strncmp(buffer, "0x", 2) == 0)
3005         {
3006           phyRegTable->phyAnalogSetupRegisters[i].spaRegister6 = osti_strtoul (buffer, &pLastUsedChar, 0);
3007         }
3008         else
3009         {
3010           phyRegTable->phyAnalogSetupRegisters[i].spaRegister6 = osti_strtoul (buffer, &pLastUsedChar, 10);
3011         }
3012       }
3013
3014       osti_memset(buffer, 0, buffLen);
3015       lenRecv = 0;
3016       }
3017       else if (j == 7)
3018       {
3019         if ((ostiGetTransportParam(
3020                                tiRoot,
3021                                globalStr,   /* key */
3022                                HwParmsStr,  /* subkey1 */
3023                                agNULL,      /* subkey2 */
3024                                agNULL,
3025                                agNULL,
3026                                agNULL,      /* subkey5 */
3027                                phyReg, /* valueName */
3028                                buffer,
3029                                buffLen,
3030                                &lenRecv
3031                                ) == tiSuccess) && (lenRecv != 0))
3032       {
3033         if (osti_strncmp(buffer, "0x", 2) == 0)
3034         {
3035           phyRegTable->phyAnalogSetupRegisters[i].spaRegister7 = osti_strtoul (buffer, &pLastUsedChar, 0);
3036         }
3037         else
3038         {
3039           phyRegTable->phyAnalogSetupRegisters[i].spaRegister7 = osti_strtoul (buffer, &pLastUsedChar, 10);
3040         }
3041       }
3042
3043       osti_memset(buffer, 0, buffLen);
3044       lenRecv = 0;
3045       }
3046       else if (j == 8)
3047       {
3048         if ((ostiGetTransportParam(
3049                                tiRoot,
3050                                globalStr,   /* key */
3051                                HwParmsStr,  /* subkey1 */
3052                                agNULL,      /* subkey2 */
3053                                agNULL,
3054                                agNULL,
3055                                agNULL,      /* subkey5 */
3056                                phyReg, /* valueName */
3057                                buffer,
3058                                buffLen,
3059                                &lenRecv
3060                                ) == tiSuccess) && (lenRecv != 0))
3061       {
3062         if (osti_strncmp(buffer, "0x", 2) == 0)
3063         {
3064           phyRegTable->phyAnalogSetupRegisters[i].spaRegister8 = osti_strtoul (buffer, &pLastUsedChar, 0);
3065         }
3066         else
3067         {
3068           phyRegTable->phyAnalogSetupRegisters[i].spaRegister8 = osti_strtoul (buffer, &pLastUsedChar, 10);
3069         }
3070       }
3071
3072       osti_memset(buffer, 0, buffLen);
3073       lenRecv = 0;
3074       }
3075       else if (j == 9)
3076       {
3077         if ((ostiGetTransportParam(
3078                                tiRoot,
3079                                globalStr,   /* key */
3080                                HwParmsStr,  /* subkey1 */
3081                                agNULL,      /* subkey2 */
3082                                agNULL,
3083                                agNULL,
3084                                agNULL,      /* subkey5 */
3085                                phyReg, /* valueName */
3086                                buffer,
3087                                buffLen,
3088                                &lenRecv
3089                                ) == tiSuccess) && (lenRecv != 0))
3090       {
3091         if (osti_strncmp(buffer, "0x", 2) == 0)
3092         {
3093           phyRegTable->phyAnalogSetupRegisters[i].spaRegister9 = osti_strtoul (buffer, &pLastUsedChar, 0);
3094         }
3095         else
3096         {
3097           phyRegTable->phyAnalogSetupRegisters[i].spaRegister9 = osti_strtoul (buffer, &pLastUsedChar, 10);
3098         }
3099       }
3100
3101       osti_memset(buffer, 0, buffLen);
3102       lenRecv = 0;
3103       }
3104
3105     } /* inner loop */
3106   } /* outer loop */
3107   return;
3108 }
3109 /*****************************************************************************
3110 *! \brief tdsaGetCardPhyParams
3111 *
3112 *  Purpose:  This function reads phy-related configuration parameters from the
3113 *            configuration file
3114 *
3115 *  \param  tiRoot:            Pointer to driver/port instance.
3116 *
3117 *  \return: None
3118 *
3119 *  \note - just a place holder for now
3120 *
3121 *****************************************************************************/
3122 osGLOBAL void
3123 tdsaGetCardPhyParams(
3124                  tiRoot_t *tiRoot
3125                  )
3126 {
3127   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
3128   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
3129   agsaRoot_t     *agRoot = &tdsaAllShared->agRootInt;
3130   char           *buffer;
3131   bit32          buffLen;
3132   bit32          lenRecv = 0;
3133   char           *pLastUsedChar = agNULL;
3134   char           tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
3135   char           *globalStr = tdsaAllShared->CardIDString;
3136   char           phyParmsStr[12];
3137   int            i;
3138   bit32          LinkRate = 15, Mode = 3, OpticalMode = 0; //VG
3139   bit32          LinkRateRead = agTRUE, ModeRead = agFALSE, OpticalModeRead = agFALSE;
3140   bit32          flag = agFALSE; /* true only for PM8008 or PM8009 (SPCv and SPCve) controller */
3141
3142   TI_DBG6(("tdsaGetCardPhyParams: start \n"));
3143   TI_DBG6(("tdsaGetCardPhyParams: tdsaRoot %p tdsaAllShared %p \n", tdsaRoot,tdsaAllShared));
3144
3145   if (tiIS_8PHY(agRoot))
3146   {
3147     TI_DBG6(("tdsaGetCardPhyParams: SPCv or SPCve \n"));
3148     flag = agTRUE;
3149   }
3150   TI_DBG6(("tdsaGetCardPhyParams: flag %d\n", flag));
3151
3152 #ifdef REMOVED
3153 #ifdef FPGA_CARD
3154   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3155   {
3156     /* setting default phy properties */
3157     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3158     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05060708);
3159     /* 1.5G only, SAS/SATA, no spin-up control */
3160     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x31; /* 49 */
3161   }
3162 #else
3163 #ifdef INITIATOR_DRIVER
3164   /* ASIC */
3165   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3166   {
3167     /* setting default phy properties */
3168     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3169     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05060708);
3170     /* 1.5G/3G , SAS/SATA, no spin-up control */
3171     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x37; /* 55 */
3172     TI_DBG6(("tdsaGetCardPhyParams: phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3173   }
3174 #endif
3175
3176 #ifdef TARGET_DRIVER
3177   /* ASIC */
3178   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3179   {
3180     /* setting default phy properties */
3181     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3182     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05050500+i);
3183     /* 1.5G/3G , SAS/SATA, no spin-up control */
3184     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x37; /* 55 */
3185     TI_DBG6(("tdsaGetCardPhyParams: phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3186   }
3187 #endif
3188
3189 #endif
3190 #endif /* REMOVED */
3191
3192
3193   buffer = tmpBuffer;
3194   buffLen = sizeof(tmpBuffer);
3195
3196   osti_memset(buffer, 0, buffLen);
3197   lenRecv = 0;
3198
3199   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3200   {
3201     if (flag == agFALSE)
3202     {
3203       osti_sprintf(phyParmsStr,"PhyParms%d", i);
3204     }
3205     else
3206     {
3207       if (i >= 4)
3208       {
3209         osti_sprintf(phyParmsStr,"PhyParms%d", i+4);
3210       }
3211       else
3212       {
3213         osti_sprintf(phyParmsStr,"PhyParms%d", i);
3214       }
3215     }
3216
3217     TI_DBG6(("tdsaGetCardPhyParams: i %d PhyParms %s\n", i, phyParmsStr));
3218
3219     TI_DBG2(("tdsaGetCardPhyParams: phy %d phyProperties %d\n", i, tdsaAllShared->Ports[i].agPhyConfig.phyProperties));
3220
3221
3222     if ((ostiGetTransportParam (
3223                                 tiRoot,
3224                                 globalStr,
3225                                 phyParmsStr,
3226                                 agNULL,
3227                                 agNULL,
3228                                 agNULL,
3229                                 agNULL,
3230                                 "AddrHi",
3231                                 buffer,
3232                                 buffLen,
3233                                 &lenRecv
3234                                 ) == tiSuccess) && (lenRecv != 0))
3235     {
3236       if (osti_strncmp(buffer, "0x", 2) == 0)
3237       {
3238         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, osti_strtoul(buffer, &pLastUsedChar, 0));
3239         TI_DBG6(("tdsaGetCardPhyParams: phy %d hi 0x%x \n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID))));
3240       }
3241       else
3242       {
3243         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, osti_strtoul(buffer, &pLastUsedChar, 10));
3244         TI_DBG6(("tdsaGetCardPhyParams: phy %d hi %d \n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID))));
3245       }
3246     }
3247
3248
3249     osti_memset(buffer, 0, buffLen);
3250     lenRecv = 0;
3251
3252     if ((ostiGetTransportParam (
3253                                 tiRoot,
3254                                 globalStr,
3255                                 phyParmsStr,
3256                                 agNULL,
3257                                 agNULL,
3258                                 agNULL,
3259                                 agNULL,
3260                                 "AddrLow",
3261                                 buffer,
3262                                 buffLen,
3263                                 &lenRecv
3264                                 ) == tiSuccess) && (lenRecv != 0))
3265     {
3266       if (osti_strncmp(buffer, "0x", 2) == 0)
3267       {
3268         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, osti_strtoul(buffer, &pLastUsedChar, 0));
3269         TI_DBG6(("tdsaGetCardPhyParams: phy %d lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3270       }
3271       else
3272       {
3273         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, osti_strtoul(buffer, &pLastUsedChar, 10));
3274         TI_DBG6(("tdsaGetCardPhyParams: phy %d lo %d\n", i, SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3275       }
3276     }
3277     TI_DBG6(("tdsaGetCardPhyParams: loop phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3278
3279     /* phy properties */
3280     osti_memset(buffer, 0, buffLen);
3281     lenRecv = 0;
3282 /*
3283     if ((ostiGetTransportParam (
3284                                 tiRoot,
3285                                 globalStr,
3286                                 phyParmsStr,
3287                                 agNULL,
3288                                 agNULL,
3289                                 agNULL,
3290                                 agNULL,
3291                                 "LinkRate",
3292                                 buffer,
3293                                 buffLen,
3294                                 &lenRecv
3295                                 ) == tiSuccess) && (lenRecv != 0))
3296     {
3297       LinkRateRead = agTRUE;
3298       if (osti_strncmp(buffer, "0x", 2) == 0)
3299       {
3300         LinkRate = osti_strtoul(buffer, &pLastUsedChar, 0);
3301         TI_DBG6(("tdsaGetCardPhyParams: phy %d linkrate 0x%x \n", i, LinkRate));
3302       }
3303       else
3304       {
3305         LinkRate = osti_strtoul(buffer, &pLastUsedChar, 10);
3306         TI_DBG6(("tdsaGetCardPhyParams: phy %d linkrate %d \n", i, LinkRate));
3307       }
3308     }
3309
3310     TI_DBG2(("tdsaGetCardPhyParams: phy %d linkrate %d \n", i, LinkRate));
3311 */
3312
3313     osti_memset(buffer, 0, buffLen);
3314     lenRecv = 0;
3315
3316     if ((ostiGetTransportParam (
3317                                 tiRoot,
3318                                 globalStr,
3319                                 phyParmsStr,
3320                                 agNULL,
3321                                 agNULL,
3322                                 agNULL,
3323                                 agNULL,
3324                                 "Mode",
3325                                 buffer,
3326                                 buffLen,
3327                                 &lenRecv
3328                                 ) == tiSuccess) && (lenRecv != 0))
3329     {
3330       ModeRead = agTRUE;
3331       if (osti_strncmp(buffer, "0x", 2) == 0)
3332       {
3333         Mode = osti_strtoul(buffer, &pLastUsedChar, 0);
3334         TI_DBG6(("tdsaGetCardPhyParams: phy %d Mode 0x%x \n", i, Mode));
3335       }
3336       else
3337       {
3338         Mode = osti_strtoul(buffer, &pLastUsedChar, 10);
3339         TI_DBG6(("tdsaGetCardPhyParams: phy %d Mode %d \n", i, Mode));
3340       }
3341     }
3342
3343     osti_memset(buffer, 0, buffLen);
3344     lenRecv = 0;
3345
3346     if ((ostiGetTransportParam (
3347                                 tiRoot,
3348                                 globalStr,
3349                                 phyParmsStr,
3350                                 agNULL,
3351                                 agNULL,
3352                                 agNULL,
3353                                 agNULL,
3354                                 "OpticalMode",
3355                                 buffer,
3356                                 buffLen,
3357                                 &lenRecv
3358                                 ) == tiSuccess) && (lenRecv != 0))
3359     {
3360       OpticalModeRead = agTRUE;
3361       if (osti_strncmp(buffer, "0x", 2) == 0)
3362       {
3363         OpticalMode = osti_strtoul(buffer, &pLastUsedChar, 0);
3364         TI_DBG6(("tdsaGetCardPhyParams: phy %d OpticalMode 0x%x \n", i, OpticalMode));
3365       }
3366       else
3367       {
3368         OpticalMode = osti_strtoul(buffer, &pLastUsedChar, 10);
3369         TI_DBG6(("tdsaGetCardPhyParams: phy %d OpticalMode %d \n", i, OpticalMode));
3370       }
3371     }
3372
3373     tdsaParseLinkRateMode(tiRoot, i, LinkRateRead, ModeRead, OpticalModeRead, LinkRate, Mode, OpticalMode);
3374
3375     TI_DBG2(("tdsaGetCardPhyParams: phy %d phyProperties %d\n", i, tdsaAllShared->Ports[i].agPhyConfig.phyProperties));
3376
3377
3378     /**********************************************/
3379     osti_memset(buffer, 0, buffLen);
3380     lenRecv = 0;
3381     LinkRateRead = agTRUE;//VG
3382     ModeRead = agFALSE;
3383     OpticalModeRead = agFALSE;
3384
3385   } /* end for */
3386   return;
3387 }
3388
3389
3390
3391
3392
3393 /*****************************************************************************
3394 *! \brief tdsaGetGlobalPhyParams
3395 *
3396 *  Purpose:  This function reads phy-related configuration parameters from the
3397 *            configuration file
3398 *
3399 *  \param  tiRoot:            Pointer to driver/port instance.
3400 *
3401 *  \return: None
3402 *
3403 *  \note - just a place holder for now
3404 *
3405 *****************************************************************************/
3406 osGLOBAL void
3407 tdsaGetGlobalPhyParams(
3408                  tiRoot_t *tiRoot
3409                  )
3410 {
3411   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
3412   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
3413   agsaRoot_t     *agRoot = &tdsaAllShared->agRootInt;
3414   char           *buffer;
3415   bit32          buffLen;
3416   bit32          lenRecv = 0;
3417   char           *pLastUsedChar = agNULL;
3418   char           tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
3419   char           globalStr[]     = "Global";
3420   char           phyParmsStr[12];
3421   int            i;
3422   bit32          LinkRate = 15/*7*/, Mode = 3, OpticalMode = 0;
3423   bit32          LinkRateRead = agFALSE, ModeRead = agFALSE, OpticalModeRead = agFALSE;
3424   bit32          flag = agFALSE; /* true only for PM8008 or PM8009 (SPCv and SPCve) controller */
3425
3426   TI_DBG6(("tdsaGetGlobalPhyParams: start \n"));
3427   TI_DBG6(("tdsaGetGlobalPhyParams: tdsaRoot %p tdsaAllShared %p \n", tdsaRoot,tdsaAllShared));
3428
3429   if (tiIS_8PHY(agRoot) )
3430   {
3431     TI_DBG6(("tdsaGetGlobalPhyParams: SPCv or SPCve \n"));
3432     flag = agTRUE;
3433   }
3434
3435   TI_DBG6(("tdsaGetGlobalPhyParams: flag %d\n", flag));
3436
3437 #ifdef FPGA_CARD
3438   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3439   {
3440     /* setting default phy properties */
3441     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3442     OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05060708);
3443     /* 1.5G only, SAS/SATA, no spin-up control */
3444     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x31; /* 49 */
3445   }
3446 #else
3447   /* ASIC */
3448 #ifdef INITIATOR_DRIVER
3449   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3450   {
3451     /* setting default phy properties */
3452     if (flag == agFALSE) /* SPC or SPCv+ */
3453     {
3454       if (0 <= i && i <= 7)
3455       {
3456         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3457         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05060708);
3458       }
3459       else
3460       {
3461         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01010101);
3462         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x02020202);
3463       }
3464     }
3465     else /* SPCv or SPCve */
3466     {
3467       if (0 <= i && i <= 3)
3468       {
3469         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3470         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05060708);
3471       }
3472       else if (4 <= i && i <= 7)
3473       {
3474         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3475         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x02020202);
3476       }
3477       else /* don't care */
3478       {
3479         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01010101);
3480         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x0f0f0f0f);
3481       }
3482
3483     }
3484     /* 1.5G/3G , SAS/SATA, no spin-up control */
3485     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x31; /* 55 */
3486     TI_DBG6(("tdsaGetGlobalPhyParams: phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3487
3488   }
3489 #endif
3490 #ifdef TARGET_DRIVER
3491    for (i=0;i<TD_MAX_NUM_PHYS;i++)
3492   {
3493     /* setting default phy properties */
3494     /* SPC; narrow ports; 8 ports
3495        SPCv, SPCve wide port; 8 ports
3496        SPCv+ wide port; 16 ports
3497     */
3498     if (tiIS_SPC(agRoot))
3499     {
3500        if (0 <= i && i <= 7)
3501       {
3502         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3503         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05050500+i);
3504       }
3505       else
3506       {
3507         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3508         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x06060600+i);
3509       }
3510     }
3511     else if (tiIS_16PHY(agRoot))
3512     {
3513        if (0 <= i && i <= 7)
3514       {
3515         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3516         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05050500+i);
3517       }
3518       else
3519       {
3520         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3521         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x06060600+i);
3522       }
3523     }
3524     else
3525     {
3526       if (0 <= i && i <= 3)
3527       {
3528         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3529         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x05050500+i);
3530       }
3531       else if (4 <= i && i <= 7)
3532       {
3533         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3534         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x06060600+i);
3535       }
3536       else /* don't care */
3537       {
3538         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, 0x01020304);
3539         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, 0x0f0f0f0f+i);
3540       }
3541     }
3542     /* 1.5G/3G , SAS/SATA, no spin-up control */
3543     tdsaAllShared->Ports[i].agPhyConfig.phyProperties = 0x31; /* 49 The default is 1.5G and will be changed based on the registry value */
3544     TI_DBG6(("tdsaGetGlobalPhyParams: phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3545
3546   }
3547 #endif
3548 #endif
3549
3550
3551   buffer = tmpBuffer;
3552   buffLen = sizeof(tmpBuffer);
3553
3554   osti_memset(buffer, 0, buffLen);
3555   lenRecv = 0;
3556
3557   /* needs to read Phy's id frame */
3558   for (i=0;i<TD_MAX_NUM_PHYS;i++)
3559   {
3560     if (flag == agFALSE)
3561     {
3562       osti_sprintf(phyParmsStr,"PhyParms%d", i);
3563     }
3564     else
3565     {
3566       if (i >= 4)
3567       {
3568         osti_sprintf(phyParmsStr,"PhyParms%d", i+4);
3569       }
3570       else
3571       {
3572         osti_sprintf(phyParmsStr,"PhyParms%d", i);
3573       }
3574     }
3575
3576     TI_DBG6(("tdsaGetGlobalPhyParams: i %d PhyParms %s\n", i, phyParmsStr));
3577
3578
3579     if ((ostiGetTransportParam (
3580                                 tiRoot,
3581                                 globalStr,
3582                                 phyParmsStr,
3583                                 agNULL,
3584                                 agNULL,
3585                                 agNULL,
3586                                 agNULL,
3587                                 "AddrHi",
3588                                 buffer,
3589                                 buffLen,
3590                                 &lenRecv
3591                                 ) == tiSuccess) && (lenRecv != 0))
3592     {
3593       if (osti_strncmp(buffer, "0x", 2) == 0)
3594       {
3595         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, osti_strtoul(buffer, &pLastUsedChar, 0));
3596         TI_DBG6(("tdsaGetGlobalPhyParams: phy %d hi 0x%x \n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID))));
3597       }
3598       else
3599       {
3600         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressHi, 0, osti_strtoul(buffer, &pLastUsedChar, 10));
3601         TI_DBG6(("tdsaGetGlobalPhyParams: phy %d hi %d \n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID))));
3602
3603       }
3604     }
3605
3606
3607     osti_memset(buffer, 0, buffLen);
3608     lenRecv = 0;
3609
3610     if ((ostiGetTransportParam (
3611                                 tiRoot,
3612                                 globalStr,
3613                                 phyParmsStr,
3614                                 agNULL,
3615                                 agNULL,
3616                                 agNULL,
3617                                 agNULL,
3618                                 "AddrLow",
3619                                 buffer,
3620                                 buffLen,
3621                                 &lenRecv
3622                                 ) == tiSuccess) && (lenRecv != 0))
3623     {
3624       if (osti_strncmp(buffer, "0x", 2) == 0)
3625       {
3626         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, osti_strtoul(buffer, &pLastUsedChar, 0));
3627         TI_DBG6(("tdsaGetGlobalPhyParams: phy %d lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3628       }
3629       else
3630       {
3631         OSSA_WRITE_BE_32(agRoot, tdsaAllShared->Ports[i].SASID.sasAddressLo, 0, osti_strtoul(buffer, &pLastUsedChar, 10));
3632         TI_DBG6(("tdsaGetGlobalPhyParams: phy %d lo %d\n", i, SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3633
3634       }
3635     }
3636     TI_DBG6(("tdsaGetGlobalPhyParams: loop phy %d hi 0x%x lo 0x%x\n", i, SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[i].SASID)), SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[i].SASID))));
3637
3638     /* phy properties */
3639     osti_memset(buffer, 0, buffLen);
3640     lenRecv = 0;
3641 /*
3642     if ((ostiGetTransportParam (
3643                                 tiRoot,
3644                                 globalStr,
3645                                 phyParmsStr,
3646                                 agNULL,
3647                                 agNULL,
3648                                 agNULL,
3649                                 agNULL,
3650                                 "LinkRate",
3651                                 buffer,
3652                                 buffLen,
3653                                 &lenRecv
3654                                 ) == tiSuccess) && (lenRecv != 0))
3655     {
3656       LinkRateRead = agTRUE;
3657       if (osti_strncmp(buffer, "0x", 2) == 0)
3658       {
3659         LinkRate = osti_strtoul(buffer, &pLastUsedChar, 0);
3660         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d linkrate 0x%x \n", i, LinkRate));
3661       }
3662       else
3663       {
3664         LinkRate = osti_strtoul(buffer, &pLastUsedChar, 10);
3665         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d linkrate %d \n", i, LinkRate));
3666       }
3667     }
3668 */
3669
3670     osti_memset(buffer, 0, buffLen);
3671     lenRecv = 0;
3672
3673     if ((ostiGetTransportParam (
3674                                 tiRoot,
3675                                 globalStr,
3676                                 phyParmsStr,
3677                                 agNULL,
3678                                 agNULL,
3679                                 agNULL,
3680                                 agNULL,
3681                                 "Mode",
3682                                 buffer,
3683                                 buffLen,
3684                                 &lenRecv
3685                                 ) == tiSuccess) && (lenRecv != 0))
3686     {
3687       ModeRead = agTRUE;
3688       if (osti_strncmp(buffer, "0x", 2) == 0)
3689       {
3690         Mode = osti_strtoul(buffer, &pLastUsedChar, 0);
3691         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d Mode 0x%x \n", i, Mode));
3692       }
3693       else
3694       {
3695         Mode = osti_strtoul(buffer, &pLastUsedChar, 10);
3696         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d Mode %d \n", i, Mode));
3697       }
3698     }
3699
3700     osti_memset(buffer, 0, buffLen);
3701     lenRecv = 0;
3702
3703     if ((ostiGetTransportParam (
3704                                 tiRoot,
3705                                 globalStr,
3706                                 phyParmsStr,
3707                                 agNULL,
3708                                 agNULL,
3709                                 agNULL,
3710                                 agNULL,
3711                                 "OpticalMode",
3712                                 buffer,
3713                                 buffLen,
3714                                 &lenRecv
3715                                 ) == tiSuccess) && (lenRecv != 0))
3716     {
3717       OpticalModeRead = agTRUE;
3718       if (osti_strncmp(buffer, "0x", 2) == 0)
3719       {
3720         OpticalMode = osti_strtoul(buffer, &pLastUsedChar, 0);
3721         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d OpticalMode 0x%x \n", i, OpticalMode));
3722       }
3723       else
3724       {
3725         OpticalMode = osti_strtoul(buffer, &pLastUsedChar, 10);
3726         TI_DBG2(("tdsaGetGlobalPhyParams: phy %d OpticalMode %d \n", i, OpticalMode));
3727       }
3728     }
3729
3730     TI_DBG2(("tdsaGetGlobalPhyParams:A phy %d phyProperties %d\n", i, tdsaAllShared->Ports[i].agPhyConfig.phyProperties));
3731     tdsaParseLinkRateMode(tiRoot, i, LinkRateRead, ModeRead, OpticalModeRead, LinkRate, Mode, OpticalMode);
3732
3733     TI_DBG2(("tdsaGetGlobalPhyParams:B phy %d phyProperties %d\n", i, tdsaAllShared->Ports[i].agPhyConfig.phyProperties));
3734
3735
3736
3737     /**********************************************/
3738     osti_memset(buffer, 0, buffLen);
3739     lenRecv = 0;
3740     /* restore default */
3741     LinkRate = 15;
3742     Mode = 3;
3743     OpticalMode = 0;
3744     LinkRateRead = agTRUE;//VG
3745     ModeRead = agFALSE;
3746     OpticalModeRead = agFALSE;
3747
3748
3749   } /* end for */
3750
3751   return;
3752 }
3753
3754 /*****************************************************************************
3755 *! \brief  tdsaGetPortParams
3756 *
3757 *  Purpose:  This function reads port-related configuration parameters from the
3758 *            configuration file
3759 *
3760 *  \param  tiRoot:            Pointer to driver/port instance.
3761 *
3762 *  \return:     None
3763 *
3764 *  \note - just a place holder for now
3765 *
3766 *****************************************************************************/
3767 osGLOBAL void
3768 tdsaGetPortParams(
3769                   tiRoot_t *tiRoot
3770                   )
3771 {
3772   tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
3773   tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
3774
3775
3776   char    *buffer;
3777   bit32   buffLen;
3778   bit32   lenRecv = 0;
3779   char    *pLastUsedChar = agNULL;
3780   char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
3781   char    globalStr[]     = "Global";
3782   char    portParmsStr[] = "PortParms";
3783
3784   TI_DBG6(("tdsaGetPortParams: start \n"));
3785   TI_DBG6(("tdsaGetPortParams: tdsaRoot %p tdsaAllShared %p \n", tdsaRoot,tdsaAllShared));
3786
3787   buffer = tmpBuffer;
3788   buffLen = sizeof(tmpBuffer);
3789   osti_memset(buffer, 0, buffLen);
3790
3791   if ((ostiGetTransportParam (
3792                               tiRoot,
3793                               globalStr,
3794                               portParmsStr,
3795                               agNULL,
3796                               agNULL,
3797                               agNULL,
3798                               agNULL,
3799                               "InterruptDelay",
3800                               buffer,
3801                               buffLen,
3802                               &lenRecv
3803                               ) == tiSuccess) && (lenRecv != 0))
3804   {
3805     if (osti_strncmp(buffer, "0x", 2) == 0)
3806     {
3807       tdsaAllShared->currentInterruptDelay = osti_strtoul (buffer, &pLastUsedChar, 0);
3808     }
3809     else
3810     {
3811       tdsaAllShared->currentInterruptDelay = osti_strtoul (buffer, &pLastUsedChar, 10);
3812     }
3813     TI_DBG6(("tdsaGetPortParams: in \n"));
3814   }
3815   osti_memset(buffer, 0, buffLen);
3816   lenRecv = 0;
3817
3818   TI_DBG6(("tdsaGetPortParams: out \n"));
3819
3820   /* and more .... */
3821
3822
3823   return;
3824 }
3825
3826 #ifdef FW_EVT_LOG_TST
3827 void saLogDump(agsaRoot_t *agRoot,
3828                U32    *eventLogSize,
3829                U32   **eventLogAddress);
3830
3831 void tiLogDump(tiRoot_t *tiRoot, U32 *size, U32 **addr)
3832 {
3833   tdsaRoot_t    *tdsaRoot;
3834   tdsaContext_t *tdsaAllShared;
3835
3836   tdsaRoot = (tdsaRoot_t*)tiRoot->tdData;
3837   tdsaAllShared = (tdsaContext_t*)&(tdsaRoot->tdsaAllShared);
3838   saLogDump(&tdsaAllShared->agRootNonInt, size, addr);
3839 }
3840 #endif
3841
3842
3843
3844 /*****************************************************************************
3845 *! \brief  tiCOMPortInit
3846 *
3847 *  Purpose: This function is called to initialize the port hardware.
3848 *           This call could only be called until after the successful
3849 *           completion tiCOMInit().
3850 *
3851 *  \param   tiRoot:         Pointer to root data structure.
3852 *  \param   sysIntsActive:  system interrupt flag
3853 *
3854 *  \return:
3855 *           tiSuccess:      Successful.
3856 *           Others:             Fail.
3857 *
3858 *  \note -
3859 *
3860 *****************************************************************************/
3861 osGLOBAL bit32
3862 tiCOMPortInit(
3863               tiRoot_t      *tiRoot,
3864               bit32         sysIntsActive
3865               )
3866 {
3867   tdsaRoot_t          *tdsaRoot;
3868   tdsaContext_t       *tdsaAllShared;
3869   agsaRoot_t          *agRoot;
3870   tiLoLevelResource_t *loResource;
3871   bit32                status = tiError;
3872   bit32                i;
3873
3874   agsaQueueConfig_t   *QueueConfig;
3875
3876 #ifdef CONTROLLER_STATUS_TESTING
3877   static agsaControllerStatus_t  agcontrollerStatus;
3878 #endif /* CONTROLLER_STATUS_TESTING */
3879
3880 #ifdef CONTROLLER_INFO_TESTING
3881   static agsaControllerInfo_t  agcontrollerInfo;
3882 #endif /* CONTROLLER_INFO_TESTING */
3883
3884 #ifdef CONTROLLER_ENCRYPT_TESTING
3885   static  agsaEncryptInfo_t       agsaEncryptInfo;
3886 #endif /* CONTROLLER_INFO_TESTING */
3887
3888   static agsaMemoryRequirement_t agMemoryRequirement;
3889 #ifdef ECHO_TESTING
3890   /* temp */
3891   static   bit8                     payload[56];
3892 #endif
3893
3894 #if defined(FDS_DM) || defined(FDS_SM)
3895   static agsaMemoryRequirement_t memRequirement;
3896   bit32                          maxQueueSets = 0;
3897   bit32                          LLMemCount = 0;
3898   bit32                          usecsPerTick = 0;
3899   static agsaSwConfig_t          tmpLLSwConfig;
3900 #endif
3901
3902 #ifdef FDS_DM
3903    static  dmRoot_t                       *dmRoot = agNULL;
3904 #ifdef FDS_SM
3905    static dmSwConfig_t                   dmSwConfig;
3906 #endif
3907   static dmMemoryRequirement_t   dmMemRequirement;
3908   bit32                          DMMemCount = 0;
3909 #endif
3910
3911 #if defined(FDS_DM) && defined(FDS_SM)
3912   bit32                          dmUsecsPerTick = 0;
3913   bit32                          dmMaxNumLocks = 0;
3914 #endif
3915
3916 #ifdef FDS_SM
3917   smRoot_t                       *smRoot = agNULL;
3918 //  smSwConfig_t                   smSwConfig;
3919   static smMemoryRequirement_t   smMemRequirement;
3920   bit32                          SMMemCount = 0;
3921 #endif
3922
3923 #ifndef TURN_OFF_HDA
3924   static agsaFwImg_t                    HDAImg;
3925 #endif /*  TURN_OFF_HDA */
3926
3927   TI_DBG3(("tiCOMPortInit: start\n"));
3928   TI_DBG6(("tiCOMPortInit: sizeof agsaMemoryRequirement_t %d\n", (int)sizeof(agsaMemoryRequirement_t)));
3929
3930   tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
3931   tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
3932
3933   osti_memset(&agMemoryRequirement, 0, sizeof(agsaMemoryRequirement_t));
3934   /*
3935    * don't do anything if reset is in progress
3936    */
3937   if (tdsaAllShared->flags.resetInProgress == agTRUE)
3938   {
3939     TI_DBG1(("tiCOMPortInit: resetinProgress error\n"));
3940     return tiError;
3941   }
3942
3943   loResource = &(tdsaAllShared->loResource);
3944
3945   agRoot = &(tdsaAllShared->agRootNonInt);
3946   tdsaAllShared->flags.sysIntsActive    = sysIntsActive;
3947
3948   /*
3949      gets port-related parameters; not in use for now
3950      tdsaGetPortParams(tiRoot);
3951    */
3952
3953   /* call these before agroot is created  for testing */
3954
3955
3956 #ifdef CONTROLLER_STATUS_TESTING
3957   TI_DBG1(("tiCOMPortInit: saGetControllerStatus returns 0x%X\n",saGetControllerStatus(agRoot,&agcontrollerStatus ) ));
3958 #endif /* CONTROLLER_INFO_TESTING */
3959
3960 #ifdef CONTROLLER_INFO_TESTING
3961   TI_DBG1(("tiCOMPortInit: saGetControllerInfo returns 0x%X\n",saGetControllerInfo(agRoot,&agcontrollerInfo ) ));
3962 #endif /* CONTROLLER_INFO_TESTING */
3963
3964 #ifdef CONTROLLER_ENCRYPT_TESTING
3965   TI_DBG1(("tiCOMPortInit: saEncryptGetMode returns 0x%X\n",saEncryptGetMode(agRoot,agNULL, &agsaEncryptInfo ) ));
3966 #endif /* CONTROLLER_INFO_TESTING */
3967
3968
3969   tdsaGetSwConfigParams(tiRoot);
3970   tdsaPrintSwConfig(&(tdsaAllShared->SwConfig));
3971
3972   /* setting interrupt requirements */
3973   tdsaAllShared->SwConfig.max_MSIX_InterruptVectors = loResource->loLevelOption.maxInterruptVectors;
3974   tdsaAllShared->SwConfig.max_MSI_InterruptVectors = loResource->loLevelOption.max_MSI_InterruptVectors;
3975   tdsaAllShared->SwConfig.legacyInt_X = loResource->loLevelOption.flag;
3976   TI_DBG2(("tiCOMPortInit: got max_MSIX_InterruptVectors %d \n", tdsaAllShared->SwConfig.max_MSIX_InterruptVectors));
3977   TI_DBG2(("tiCOMPortInit: got max_MSI_InterruptVectors %d \n", tdsaAllShared->SwConfig.max_MSI_InterruptVectors));
3978   TI_DBG2(("tiCOMPortInit: got flag - legacyInt_X %d \n", tdsaAllShared->SwConfig.legacyInt_X));
3979
3980   /* error checking for interrupt types */
3981   if (
3982       ((tdsaAllShared->SwConfig.max_MSIX_InterruptVectors == 0) &&
3983        (tdsaAllShared->SwConfig.max_MSI_InterruptVectors == 0)  &&
3984        (tdsaAllShared->SwConfig.legacyInt_X == 0))
3985       ||
3986       ((tdsaAllShared->SwConfig.max_MSIX_InterruptVectors != 0) &&
3987        (tdsaAllShared->SwConfig.max_MSI_InterruptVectors == 0)  &&
3988        (tdsaAllShared->SwConfig.legacyInt_X == 0))
3989       ||
3990       ((tdsaAllShared->SwConfig.max_MSIX_InterruptVectors == 0) &&
3991        (tdsaAllShared->SwConfig.max_MSI_InterruptVectors != 0)  &&
3992        (tdsaAllShared->SwConfig.legacyInt_X == 0))
3993       ||
3994       ((tdsaAllShared->SwConfig.max_MSIX_InterruptVectors == 0) &&
3995        (tdsaAllShared->SwConfig.max_MSI_InterruptVectors == 0)  &&
3996        (tdsaAllShared->SwConfig.legacyInt_X != 0))
3997      )
3998   {
3999     /* do nothing */
4000   }
4001   else
4002   {
4003     TI_DBG1(("tiCOMPortInit: incorrect interrupt\n"));
4004     return tiError;
4005   }
4006
4007   QueueConfig = &tdsaAllShared->QueueConfig;
4008
4009   for(i=0;i<QueueConfig->numInboundQueues;i++)
4010   {
4011     QueueConfig->inboundQueues[i].elementCount = tdsaAllShared->InboundQueueSize[i];
4012     QueueConfig->inboundQueues[i].elementSize = tdsaAllShared->InboundQueueEleSize[i];
4013     QueueConfig->inboundQueues[i].priority = tdsaAllShared->InboundQueuePriority[i];
4014     QueueConfig->inboundQueues[i].reserved = 0;
4015     TI_DBG6(("tiCOMPortInit: InboundQueuePriroity %d \n", tdsaAllShared->InboundQueuePriority[i]));
4016   }
4017   for(i=0;i<QueueConfig->numOutboundQueues;i++)
4018   {
4019     QueueConfig->outboundQueues[i].elementCount = tdsaAllShared->OutboundQueueSize[i];
4020     QueueConfig->outboundQueues[i].elementSize = tdsaAllShared->OutboundQueueEleSize[i];
4021     QueueConfig->outboundQueues[i].interruptDelay = tdsaAllShared->OutboundQueueInterruptDelay[i]; /* default 0; no interrupt delay */
4022     QueueConfig->outboundQueues[i].interruptCount = tdsaAllShared->OutboundQueueInterruptCount[i]; /* default 1 */
4023     QueueConfig->outboundQueues[i].interruptEnable = tdsaAllShared->OutboundQueueInterruptEnable[i]; /* default 1 */
4024     QueueConfig->outboundQueues[i].interruptVectorIndex = 0;
4025     if (tdsaAllShared->SwConfig.max_MSIX_InterruptVectors != 0)
4026     {
4027       QueueConfig->outboundQueues[i].interruptVectorIndex = i % tdsaAllShared->SwConfig.max_MSIX_InterruptVectors;
4028     }
4029     else if (tdsaAllShared->SwConfig.max_MSI_InterruptVectors != 0)
4030     {
4031       QueueConfig->outboundQueues[i].interruptVectorIndex = i % tdsaAllShared->SwConfig.max_MSI_InterruptVectors;
4032     }
4033     else
4034     {
4035       QueueConfig->outboundQueues[i].interruptVectorIndex = 0;
4036     }
4037     TI_DBG6(("tiCOMPortInit: OutboundQueueInterruptDelay %d OutboundQueueInterruptCount %d OutboundQueueInterruptEnable %d\n", tdsaAllShared->OutboundQueueInterruptDelay[i], tdsaAllShared->OutboundQueueInterruptCount[i], tdsaAllShared->OutboundQueueInterruptEnable[i]));
4038
4039   }
4040   /* queue option */
4041   QueueConfig->queueOption = tdsaAllShared->QueueOption;
4042
4043   tdsaAllShared->SwConfig.param3 = (void *)QueueConfig;
4044   tdsaAllShared->SwConfig.stallUsec = 10;
4045
4046   /* finds a first high priority queue for SMP */
4047   tdsaAllShared->SMPQNum = 0; /* default */
4048   for(i=0;i<QueueConfig->numInboundQueues;i++)
4049   {
4050     if (QueueConfig->inboundQueues[i].priority != DEFAULT_INBOUND_QUEUE_PRIORITY) /* 0 */
4051     {
4052       tdsaAllShared->SMPQNum = i;
4053       break;
4054     }
4055   }
4056
4057   tdsaGetHwConfigParams(tiRoot);
4058
4059   tdsaPrintHwConfig(&(tdsaAllShared->HwConfig));
4060
4061 #ifdef TARGET_DRIVER
4062   /* target, not yet */
4063   if (tdsaAllShared->currentOperation & TD_OPERATION_TARGET)
4064   {
4065     ttdssGetTargetParams(tiRoot);
4066   }
4067 #endif
4068
4069 #if defined(FDS_DM) && defined(FDS_SM)
4070   /*
4071     needs to call saGetRequirements() to find out agMemoryRequirement.count requested by LL
4072   */
4073   osti_memcpy(&tmpLLSwConfig, &(tdsaAllShared->SwConfig), sizeof(agsaSwConfig_t));
4074
4075   saGetRequirements(agRoot,
4076                     &tmpLLSwConfig,
4077                     &memRequirement,
4078                     &usecsPerTick,
4079                     &maxQueueSets
4080                     );
4081   TI_DBG1(("tiCOMPortInit: usecsPerTick %d\n", usecsPerTick));
4082
4083   TI_DBG1(("tiCOMPortInit: LL memRequirement.count %d\n", memRequirement.count));
4084   TI_DBG1(("tiCOMPortInit: loResource->loLevelMem.count %d\n", loResource->loLevelMem.count));
4085   LLMemCount = memRequirement.count;
4086
4087   /*
4088     needs to call dmGetRequirements() to find out dmMemoryRequirement.count requested by DM
4089   */
4090
4091   dmGetRequirements(dmRoot,
4092                     &dmSwConfig,
4093                     &dmMemRequirement,
4094                     &dmUsecsPerTick,
4095                     &dmMaxNumLocks
4096                     );
4097
4098   TI_DBG1(("tiCOMPortInit: DM dmmemRequirement.count %d\n", dmMemRequirement.count));
4099   TI_DBG1(("tiCOMPortInit: loResource->loLevelMem.count %d\n", loResource->loLevelMem.count));
4100
4101   DMMemCount = dmMemRequirement.count;
4102   SMMemCount = loResource->loLevelMem.count - LLMemCount - DMMemCount;
4103   agMemoryRequirement.count =  LLMemCount;
4104
4105   TI_DBG1(("tiCOMPortInit: SMMemCount %d\n", SMMemCount));
4106
4107
4108 #elif defined(FDS_DM)
4109   /*
4110     needs to call saGetRequirements() to find out agMemoryRequirement.count requested by LL
4111   */
4112   osti_memcpy(&tmpLLSwConfig, &(tdsaAllShared->SwConfig), sizeof(agsaSwConfig_t));
4113
4114   saGetRequirements(agRoot,
4115                     &tmpLLSwConfig,
4116                     &memRequirement,
4117                     &usecsPerTick,
4118                     &maxQueueSets
4119                     );
4120
4121   TI_DBG1(("tiCOMPortInit: memRequirement.count %d\n", memRequirement.count));
4122   TI_DBG1(("tiCOMPortInit: loResource->loLevelMem.count %d\n", loResource->loLevelMem.count));
4123
4124   LLMemCount = memRequirement.count;
4125   DMMemCount = loResource->loLevelMem.count - LLMemCount;
4126
4127   agMemoryRequirement.count =  LLMemCount;
4128
4129 #elif defined(FDS_SM)
4130   osti_memcpy(&tmpLLSwConfig, &(tdsaAllShared->SwConfig), sizeof(agsaSwConfig_t));
4131
4132   saGetRequirements(agRoot,
4133                     &tmpLLSwConfig,
4134                     &memRequirement,
4135                     &usecsPerTick,
4136                     &maxQueueSets
4137                     );
4138
4139   TI_DBG1(("tiCOMPortInit: memRequirement.count %d\n", memRequirement.count));
4140   TI_DBG1(("tiCOMPortInit: loResource->loLevelMem.count %d\n", loResource->loLevelMem.count));
4141
4142   LLMemCount = memRequirement.count;
4143   SMMemCount = loResource->loLevelMem.count - LLMemCount;
4144
4145   agMemoryRequirement.count =  LLMemCount;
4146
4147 #else
4148
4149   agMemoryRequirement.count = loResource->loLevelMem.count;
4150
4151 #endif
4152
4153 #if defined(FDS_DM) && defined(FDS_SM)
4154   /* for debugging */
4155   for(i=0;i<(int)(LLMemCount + DMMemCount + SMMemCount);i++)
4156   {
4157     TI_DBG2(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].physAddrUpper, loResource->loLevelMem.mem[i].physAddrLower, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].alignment));
4158     TI_DBG2(("tiCOMPortInit: index %d virtPtr %p\n",i, loResource->loLevelMem.mem[i].virtPtr));
4159   }
4160 #endif
4161
4162   /* initialize */
4163   TI_DBG6(("tiCOMPortInit: AGSA_NUM_MEM_CHUNKS %d\n", AGSA_NUM_MEM_CHUNKS));
4164   for(i=0;i<AGSA_NUM_MEM_CHUNKS;i++)
4165   {
4166     agMemoryRequirement.agMemory[i].virtPtr = agNULL;
4167     agMemoryRequirement.agMemory[i].osHandle = agNULL;
4168     agMemoryRequirement.agMemory[i].phyAddrUpper = 0;
4169     agMemoryRequirement.agMemory[i].phyAddrLower = 0;
4170     agMemoryRequirement.agMemory[i].totalLength = 0;
4171     agMemoryRequirement.agMemory[i].numElements = 0;
4172     agMemoryRequirement.agMemory[i].singleElementLength = 0;
4173     agMemoryRequirement.agMemory[i].alignment = 0;
4174     agMemoryRequirement.agMemory[i].type = 0;
4175     agMemoryRequirement.agMemory[i].reserved = 0;
4176   }
4177
4178   for(i=0;i<(int)agMemoryRequirement.count;i++)
4179   {
4180     TI_DBG2(("tiCOMPortInit: LL copying loResource.loLevelMem to agsaMemoryRequirement_t index %d\n", i));
4181     agMemoryRequirement.agMemory[i].virtPtr = loResource->loLevelMem.mem[i].virtPtr;
4182     agMemoryRequirement.agMemory[i].osHandle = loResource->loLevelMem.mem[i].osHandle;
4183     agMemoryRequirement.agMemory[i].phyAddrUpper = loResource->loLevelMem.mem[i].physAddrUpper;
4184     agMemoryRequirement.agMemory[i].phyAddrLower = loResource->loLevelMem.mem[i].physAddrLower;
4185     agMemoryRequirement.agMemory[i].totalLength = loResource->loLevelMem.mem[i].totalLength;
4186     agMemoryRequirement.agMemory[i].numElements = loResource->loLevelMem.mem[i].numElements;
4187     agMemoryRequirement.agMemory[i].singleElementLength = loResource->loLevelMem.mem[i].singleElementLength;
4188     agMemoryRequirement.agMemory[i].alignment = loResource->loLevelMem.mem[i].alignment;
4189     if (loResource->loLevelMem.mem[i].type == TI_DMA_MEM)
4190     {
4191       agMemoryRequirement.agMemory[i].type = AGSA_DMA_MEM;
4192     }
4193     else if (loResource->loLevelMem.mem[i].type == TI_CACHED_MEM)
4194     {
4195       agMemoryRequirement.agMemory[i].type = AGSA_CACHED_MEM;
4196
4197     }
4198     else if (loResource->loLevelMem.mem[i].type == TI_CACHED_DMA_MEM)
4199     {
4200       agMemoryRequirement.agMemory[i].type = AGSA_CACHED_DMA_MEM;
4201     }
4202
4203     agMemoryRequirement.agMemory[i].reserved = loResource->loLevelMem.mem[i].reserved;
4204     TI_DBG2(("tiCOMPortInit: index %d virtPtr %p osHandle %p\n",i, loResource->loLevelMem.mem[i].virtPtr, loResource->loLevelMem.mem[i].osHandle));
4205     TI_DBG2(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d numElements %d\n", i,
4206     loResource->loLevelMem.mem[i].physAddrUpper,
4207     loResource->loLevelMem.mem[i].physAddrLower,
4208     loResource->loLevelMem.mem[i].totalLength,
4209     loResource->loLevelMem.mem[i].numElements));
4210     TI_DBG2(("tiCOMPortInit: index %d singleElementLength 0x%x alignment 0x%x type %d reserved %d\n", i,
4211     loResource->loLevelMem.mem[i].singleElementLength,
4212     loResource->loLevelMem.mem[i].alignment,
4213     loResource->loLevelMem.mem[i].type,
4214     loResource->loLevelMem.mem[i].reserved));
4215
4216   }
4217   osti_memset(&(tdsaAllShared->tdFWControlEx), 0, sizeof(tdFWControlEx_t));
4218
4219   /*
4220    * Note: Be sure to call this only once since sallsdk does initialization only once
4221    * saInitialize(IN, IN, IN, IN, IN);
4222    */
4223
4224   TI_DBG1(("tiCOMPortInit: tdsaAllShared->tdDeviceIdVendId %x\n",tdsaAllShared->tdDeviceIdVendId));
4225   TI_DBG1(("tiCOMPortInit: tdsaAllShared->tdSubVendorId= SUB_VEN_ID %x\n",tdsaAllShared->tdSubVendorId));
4226
4227   TI_DBG1(("tiCOMPortInit: swConfig->param1 hwDEVICE_ID_VENDID %x\n", tdsaAllShared->SwConfig.param1 ));
4228   TI_DBG1(("tiCOMPortInit: swConfig->param2 hwSVID             %x\n", tdsaAllShared->SwConfig.param2));
4229
4230   /*
4231     1. Read hostDirectAccessSupport
4232     2. If set, read HDA images based on chip ID
4233  */
4234
4235   t_MacroCheck(agRoot);
4236
4237 #ifndef TURN_OFF_HDA
4238   if (tdsaAllShared->SwConfig.hostDirectAccessSupport != 0)
4239   {
4240     osti_memset(&HDAImg, 0, sizeof(HDAImg));
4241     if (tiIS_SPC(agRoot))
4242     {
4243       TI_DBG1(("tiCOMPortInit: SPC HDA\n"));
4244       HDAImg.aap1Img = (bit8*)(&aap1array);
4245       HDAImg.aap1Len = sizeof( aap1array);
4246       HDAImg.iopImg  = (bit8*)(&ioparray);
4247       HDAImg.iopLen  = sizeof(  ioparray);
4248       HDAImg.istrImg = (bit8*)(&istrarray);
4249       HDAImg.istrLen = sizeof( istrarray);
4250
4251       HDAImg.ilaImg  = (bit8*)(&ilaarray);
4252       HDAImg.ilaLen  = sizeof(ilaarray);
4253     }
4254     else if (tiIS_SPC6V(agRoot))
4255     {
4256       TI_DBG1(("tiCOMPortInit: SPCv HDA\n"));
4257       HDAImg.aap1Img = (bit8*)(&spcv_aap1array);
4258       HDAImg.aap1Len =  sizeof( spcv_aap1array);
4259       HDAImg.iopImg  = (bit8*)(&spcv_ioparray);
4260       HDAImg.iopLen  = sizeof(  spcv_ioparray);
4261
4262       HDAImg.ilaImg  = (bit8*)(&spcv_ilaarray);
4263       HDAImg.ilaLen  = sizeof(spcv_ilaarray);
4264     }
4265     else if (tIsSPCV12G(agRoot))
4266     {
4267       TI_DBG1(("tiCOMPortInit: SPCv12G HDA\n"));
4268       HDAImg.aap1Img = (bit8*)(&spcv12g_raaearray);
4269       HDAImg.aap1Len =  sizeof( spcv12g_raaearray);
4270       HDAImg.iopImg  = (bit8*)(&spcv12g_ioparray);
4271       HDAImg.iopLen  = sizeof(  spcv12g_ioparray);
4272
4273       HDAImg.ilaImg  = (bit8*)(&spcv12g_ilaarray);
4274       HDAImg.ilaLen  = sizeof(spcv12g_ilaarray);
4275     }
4276     else
4277     {
4278       TI_DBG1(("tiCOMPortInit: HDA Mode Unknown chip type 0x%08x\n",ossaHwRegReadConfig32(agRoot,0 )));
4279       return tiError;
4280     }
4281     TI_DBG1(("tiCOMPortInit: HDA aap1Len 0x%08x iopLen 0x%08x ilaLen 0x%08x\n",HDAImg.aap1Len,HDAImg.iopLen,HDAImg.ilaLen ));
4282     tdsaAllShared->SwConfig.param4 = &(HDAImg);
4283   }
4284   else
4285   {
4286     TI_DBG1(("tiCOMPortInit: HDA off\n"));
4287     tdsaAllShared->SwConfig.param4 = agNULL;
4288   }
4289 #endif /*  TURN_OFF_HDA */
4290
4291   if (tiIS_SPC(agRoot))
4292   {
4293     /* FW config is only for SPC */
4294     tdsaAllShared->SwConfig.FWConfig = 0;
4295     /* default port recovery timer 0x32 = 50 = 5000ms and port reset timer 3 (300 ms)*/
4296     tdsaAllShared->SwConfig.PortRecoveryResetTimer = 0x30032;
4297     TI_DBG1(("tiCOMPortInit:only for SPC FWConfig set\n"));
4298   }
4299
4300   tdsaAllShared->SwConfig.fatalErrorInterruptVector = loResource->loLevelOption.maxInterruptVectors > 31 ? 31 : loResource->loLevelOption.maxInterruptVectors -1;
4301
4302   TI_DBG1(("tiCOMPortInit: SwConfig->FWConfig 0x%x\n", tdsaAllShared->SwConfig.FWConfig));
4303   TI_DBG1(("tiCOMPortInit: SwConfig->fatalErrorInterruptVector 0x%x\n", tdsaAllShared->SwConfig.fatalErrorInterruptVector));
4304   TI_DBG1(("tiCOMPortInit: loResource->loLevelOption.usecsPerTick %d\n", loResource->loLevelOption.usecsPerTick));
4305
4306   status = saInitialize(agRoot,
4307                         &agMemoryRequirement,
4308                         &(tdsaAllShared->HwConfig),
4309                         /* &temp_HwConfig, */
4310                         &(tdsaAllShared->SwConfig),
4311                         loResource->loLevelOption.usecsPerTick);
4312
4313   TI_DBG6(("tiCOMPortInit: loResource->loLevelOption.usecsPerTick %d 0x%x\n", loResource->loLevelOption.usecsPerTick, loResource->loLevelOption.usecsPerTick));
4314
4315   /*TI_DBG6(("tiCOMPortInit: tdsaAllShared->SwConfig.enableDIF %d\n", tdsaAllShared->SwConfig.enableDIF)); */
4316   /*TI_DBG6(("tiCOMPortInit: tdsaAllShared->SwConfig.enableEncryption %d\n", tdsaAllShared->SwConfig.enableEncryption)); */
4317
4318   if(status == AGSA_RC_FAILURE )
4319   {
4320     TI_DBG1(("tiCOMPortInit: saInitialize AGSA_RC_FAILURE, status 0x%x\n", status));
4321     return tiError;
4322   }
4323
4324   if( status == AGSA_RC_VERSION_INCOMPATIBLE)
4325   {
4326     TI_DBG1(("tiCOMPortInit: saInitialize AGSA_RC_VERSION_INCOMPATIBLE, status 0x%x\n", status));
4327     return tiError;
4328   }
4329
4330   /* let's make sdkData same for Int and Non-int agRoots */
4331   tdsaAllShared->agRootInt.sdkData = tdsaAllShared->agRootNonInt.sdkData;
4332
4333
4334   /* mark the port as initialized */
4335   for(i=0;i<TD_MAX_NUM_PHYS;i++)
4336   {
4337     tdsaAllShared->Ports[i].flags.portInitialized = agTRUE;
4338   }
4339
4340 #ifdef INITIATOR_DRIVER                 //ini. only in stsdkll spec (TP)
4341   /* register device registration callback function */
4342   TI_DBG6(("tiCOMPortInit: calling saRegisterEventCallback for device registration\n"));
4343   status = saRegisterEventCallback(agRoot, OSSA_EVENT_SOURCE_DEVICE_HANDLE_ADDED, (void *)ossaDeviceRegistrationCB);
4344   if (status == AGSA_RC_FAILURE)
4345   {
4346     TI_DBG6(("tiCOMPortInit: saRegisterEventCallback Device Register failed\n"));
4347   }
4348   else
4349   {
4350     TI_DBG6(("tiCOMPortInit: saRegisterEventCallback Device Register succeeded\n"));
4351   }
4352 #endif
4353
4354   /* register device deregistration callback function */
4355   TI_DBG6(("tiCOMPortInit: calling saRegisterEventCallback for device de-registration\n"));
4356   status = saRegisterEventCallback(agRoot, OSSA_EVENT_SOURCE_DEVICE_HANDLE_REMOVED, (void *)ossaDeregisterDeviceHandleCB);
4357   if (status == AGSA_RC_FAILURE)
4358   {
4359     TI_DBG6(("tiCOMPortInit: saRegisterEventCallback Device Deregister failed\n"));
4360   }
4361   else
4362   {
4363     TI_DBG6(("tiCOMPortInit: saRegisterEventCallback Device Deregister succeeded\n"));
4364   }
4365
4366 #ifdef ECHO_TESTING
4367   /* temporary to test saEchoCommand() */
4368   /*
4369     send echo
4370   */
4371   payload[0] = gEcho;
4372   payload[55] = gEcho;
4373   TI_DBG2(("tiCOMPortInit: calling saEchoCommand gEcho %d\n", gEcho));
4374   saEchoCommand(agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), (void *)&payload);
4375   gEcho++;
4376 #endif
4377
4378 #ifdef CONTROLLER_STATUS_TESTING
4379   TI_DBG1(("tiCOMPortInit: saGetControllerStatus returns 0x%X\n",saGetControllerStatus(agRoot,&agcontrollerStatus ) ));
4380 #endif /* CONTROLLER_INFO_TESTING */
4381
4382 #ifdef CONTROLLER_INFO_TESTING
4383   TI_DBG1(("tiCOMPortInit: saGetControllerInfo returns 0x%X\n",saGetControllerInfo(agRoot,&agcontrollerInfo ) ));
4384 #endif /* CONTROLLER_INFO_TESTING */
4385
4386 #ifdef CONTROLLER_ENCRYPT_TESTING
4387   TI_DBG1(("tiCOMPortInit: saEncryptGetMode returns 0x%X\n",saEncryptGetMode(agRoot,agNULL,&agsaEncryptInfo ) ));
4388 #endif /* CONTROLLER_INFO_TESTING */
4389
4390
4391 #ifdef VPD_TESTING
4392   /* temporary to test saSetVPDCommand() and saGetVPDCommand */
4393   tdsaVPDSet(tiRoot);
4394 #endif /* VPD_TESTING */
4395
4396 #if defined(FDS_DM) && defined(FDS_SM)
4397   /* initialize DM then SM */
4398   /* DM */
4399   dmRoot = &(tdsaAllShared->dmRoot);
4400   osti_memset(&dmMemRequirement, 0, sizeof(dmMemoryRequirement_t));
4401
4402   dmMemRequirement.count = DMMemCount;
4403
4404   for(i=LLMemCount;i<(int)(LLMemCount + DMMemCount);i++)
4405   {
4406     TI_DBG2(("tiCOMPortInit: DM copying loResource.loLevelMem to agsaMemoryRequirement_t index %d\n", i));
4407     dmMemRequirement.dmMemory[i-LLMemCount].virtPtr = loResource->loLevelMem.mem[i].virtPtr;
4408     dmMemRequirement.dmMemory[i-LLMemCount].osHandle = loResource->loLevelMem.mem[i].osHandle;
4409     dmMemRequirement.dmMemory[i-LLMemCount].physAddrUpper = loResource->loLevelMem.mem[i].physAddrUpper;
4410     dmMemRequirement.dmMemory[i-LLMemCount].physAddrLower = loResource->loLevelMem.mem[i].physAddrLower;
4411     dmMemRequirement.dmMemory[i-LLMemCount].totalLength = loResource->loLevelMem.mem[i].totalLength;
4412     dmMemRequirement.dmMemory[i-LLMemCount].numElements = loResource->loLevelMem.mem[i].numElements;
4413     dmMemRequirement.dmMemory[i-LLMemCount].singleElementLength = loResource->loLevelMem.mem[i].singleElementLength;
4414     dmMemRequirement.dmMemory[i-LLMemCount].alignment = loResource->loLevelMem.mem[i].alignment;
4415     dmMemRequirement.dmMemory[i-LLMemCount].type = loResource->loLevelMem.mem[i].type;
4416     dmMemRequirement.dmMemory[i-LLMemCount].reserved = loResource->loLevelMem.mem[i].reserved;
4417     TI_DBG2(("tiCOMPortInit: index %d virtPtr %p osHandle %p\n",i, loResource->loLevelMem.mem[i].virtPtr, loResource->loLevelMem.mem[i].osHandle));
4418     TI_DBG2(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d numElements %d\n", i,
4419     loResource->loLevelMem.mem[i].physAddrUpper,
4420     loResource->loLevelMem.mem[i].physAddrLower,
4421     loResource->loLevelMem.mem[i].totalLength,
4422     loResource->loLevelMem.mem[i].numElements));
4423     TI_DBG2(("tiCOMPortInit: index %d singleElementLength 0x%x alignment 0x%x type %d reserved %d\n", i,
4424     loResource->loLevelMem.mem[i].singleElementLength,
4425     loResource->loLevelMem.mem[i].alignment,
4426     loResource->loLevelMem.mem[i].type,
4427     loResource->loLevelMem.mem[i].reserved));
4428
4429   }
4430
4431   status = dmInitialize(dmRoot,
4432                         agRoot,
4433                         &dmMemRequirement,
4434                         &(tdsaAllShared->dmSwConfig), //&dmSwConfig, /* start here */
4435                         loResource->loLevelOption.usecsPerTick);
4436
4437   if(status == DM_RC_FAILURE || status == DM_RC_VERSION_INCOMPATIBLE)
4438   {
4439     TI_DBG1(("tiCOMPortInit: dmInitialize FAILED, status 0x%x\n", status));
4440     return tiError;
4441   }
4442
4443   /* SM */
4444   smRoot = &(tdsaAllShared->smRoot);
4445   osti_memset(&smMemRequirement, 0, sizeof(smMemoryRequirement_t));
4446
4447   smMemRequirement.count = SMMemCount;
4448
4449   for(i=(LLMemCount + DMMemCount);i<(int)(LLMemCount + DMMemCount + SMMemCount);i++)
4450   {
4451     TI_DBG1(("tiCOMPortInit: SM copying loResource.loLevelMem to agsaMemoryRequirement_t index %d\n", i));
4452     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].virtPtr = loResource->loLevelMem.mem[i].virtPtr;
4453     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].osHandle = loResource->loLevelMem.mem[i].osHandle;
4454     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].physAddrUpper = loResource->loLevelMem.mem[i].physAddrUpper;
4455     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].physAddrLower = loResource->loLevelMem.mem[i].physAddrLower;
4456     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].totalLength = loResource->loLevelMem.mem[i].totalLength;
4457     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].numElements = loResource->loLevelMem.mem[i].numElements;
4458     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].singleElementLength = loResource->loLevelMem.mem[i].singleElementLength;
4459     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].alignment = loResource->loLevelMem.mem[i].alignment;
4460     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].type = loResource->loLevelMem.mem[i].type;
4461     smMemRequirement.smMemory[i-LLMemCount-DMMemCount].reserved = loResource->loLevelMem.mem[i].reserved;
4462     TI_DBG2(("tiCOMPortInit: index %d virtPtr %p osHandle %p\n",i, loResource->loLevelMem.mem[i].virtPtr, loResource->loLevelMem.mem[i].osHandle));
4463     TI_DBG2(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d numElements %d\n", i,
4464     loResource->loLevelMem.mem[i].physAddrUpper,
4465     loResource->loLevelMem.mem[i].physAddrLower,
4466     loResource->loLevelMem.mem[i].totalLength,
4467     loResource->loLevelMem.mem[i].numElements));
4468     TI_DBG2(("tiCOMPortInit: index %d singleElementLength 0x%x alignment 0x%x type %d reserved %d\n", i,
4469     loResource->loLevelMem.mem[i].singleElementLength,
4470     loResource->loLevelMem.mem[i].alignment,
4471     loResource->loLevelMem.mem[i].type,
4472     loResource->loLevelMem.mem[i].reserved));
4473
4474   }
4475
4476   status = smInitialize(smRoot,
4477                         agRoot,
4478                         &smMemRequirement,
4479                         &(tdsaAllShared->smSwConfig), //&smSwConfig, /* start here */
4480                         loResource->loLevelOption.usecsPerTick);
4481
4482   if(status == SM_RC_FAILURE || status == SM_RC_VERSION_INCOMPATIBLE)
4483   {
4484     TI_DBG1(("tiCOMPortInit: smInitialize FAILED, status 0x%x\n", status));
4485     return tiError;
4486   }
4487
4488 #elif defined(FDS_DM)
4489   dmRoot = &(tdsaAllShared->dmRoot);
4490   osti_memset(&dmMemRequirement, 0, sizeof(dmMemoryRequirement_t));
4491
4492   dmMemRequirement.count = DMMemCount;
4493
4494   for(i=LLMemCount;i<(int)(LLMemCount + DMMemCount);i++)
4495   {
4496     TI_DBG6(("tiCOMPortInit: copying loResource.loLevelMem to agsaMemoryRequirement_t index %d\n", i));
4497     dmMemRequirement.dmMemory[i-LLMemCount].virtPtr = loResource->loLevelMem.mem[i].virtPtr;
4498     dmMemRequirement.dmMemory[i-LLMemCount].osHandle = loResource->loLevelMem.mem[i].osHandle;
4499     dmMemRequirement.dmMemory[i-LLMemCount].physAddrUpper = loResource->loLevelMem.mem[i].physAddrUpper;
4500     dmMemRequirement.dmMemory[i-LLMemCount].physAddrLower = loResource->loLevelMem.mem[i].physAddrLower;
4501     dmMemRequirement.dmMemory[i-LLMemCount].totalLength = loResource->loLevelMem.mem[i].totalLength;
4502     dmMemRequirement.dmMemory[i-LLMemCount].numElements = loResource->loLevelMem.mem[i].numElements;
4503     dmMemRequirement.dmMemory[i-LLMemCount].singleElementLength = loResource->loLevelMem.mem[i].singleElementLength;
4504     dmMemRequirement.dmMemory[i-LLMemCount].alignment = loResource->loLevelMem.mem[i].alignment;
4505     dmMemRequirement.dmMemory[i-LLMemCount].type = loResource->loLevelMem.mem[i].type;
4506     dmMemRequirement.dmMemory[i-LLMemCount].reserved = loResource->loLevelMem.mem[i].reserved;
4507     TI_DBG6(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].physAddrUpper, loResource->loLevelMem.mem[i].physAddrLower, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].alignment));
4508     TI_DBG6(("tiCOMPortInit: index %d virtPtr %p\n",i, loResource->loLevelMem.mem[i].virtPtr));
4509
4510   }
4511
4512   status = dmInitialize(dmRoot,
4513                         agRoot,
4514                         &dmMemRequirement,
4515                         &(tdsaAllShared->dmSwConfig), //&dmSwConfig, /* start here */
4516                         loResource->loLevelOption.usecsPerTick);
4517
4518   if(status == DM_RC_FAILURE || status == DM_RC_VERSION_INCOMPATIBLE)
4519   {
4520     TI_DBG1(("tiCOMPortInit: dmInitialize FAILED, status 0x%x\n", status));
4521     return tiError;
4522   }
4523
4524 #elif defined(FDS_SM)
4525   smRoot = &(tdsaAllShared->smRoot);
4526   osti_memset(&smMemRequirement, 0, sizeof(smMemoryRequirement_t));
4527
4528   smMemRequirement.count = SMMemCount;
4529
4530   for(i=LLMemCount;i<(int)(LLMemCount + SMMemCount);i++)
4531   {
4532     TI_DBG6(("tiCOMPortInit: copying loResource.loLevelMem to agsaMemoryRequirement_t index %d\n", i));
4533     smMemRequirement.smMemory[i-LLMemCount].virtPtr = loResource->loLevelMem.mem[i].virtPtr;
4534     smMemRequirement.smMemory[i-LLMemCount].osHandle = loResource->loLevelMem.mem[i].osHandle;
4535     smMemRequirement.smMemory[i-LLMemCount].physAddrUpper = loResource->loLevelMem.mem[i].physAddrUpper;
4536     smMemRequirement.smMemory[i-LLMemCount].physAddrLower = loResource->loLevelMem.mem[i].physAddrLower;
4537     smMemRequirement.smMemory[i-LLMemCount].totalLength = loResource->loLevelMem.mem[i].totalLength;
4538     smMemRequirement.smMemory[i-LLMemCount].numElements = loResource->loLevelMem.mem[i].numElements;
4539     smMemRequirement.smMemory[i-LLMemCount].singleElementLength = loResource->loLevelMem.mem[i].singleElementLength;
4540     smMemRequirement.smMemory[i-LLMemCount].alignment = loResource->loLevelMem.mem[i].alignment;
4541     smMemRequirement.smMemory[i-LLMemCount].type = loResource->loLevelMem.mem[i].type;
4542     smMemRequirement.smMemory[i-LLMemCount].reserved = loResource->loLevelMem.mem[i].reserved;
4543     TI_DBG6(("tiCOMPortInit: index %d phyAddrUpper 0x%x phyAddrLower 0x%x totalLength %d alignment %d\n", i, loResource->loLevelMem.mem[i].physAddrUpper, loResource->loLevelMem.mem[i].physAddrLower, loResource->loLevelMem.mem[i].totalLength, loResource->loLevelMem.mem[i].alignment));
4544     TI_DBG6(("tiCOMPortInit: index %d virtPtr %p\n",i, loResource->loLevelMem.mem[i].virtPtr));
4545
4546   }
4547
4548   status = smInitialize(smRoot,
4549                         agRoot,
4550                         &smMemRequirement,
4551                         &(tdsaAllShared->smSwConfig), //&smSwConfig, /* start here */
4552                         loResource->loLevelOption.usecsPerTick);
4553
4554   if(status == SM_RC_FAILURE || status == SM_RC_VERSION_INCOMPATIBLE)
4555   {
4556     TI_DBG1(("tiCOMPortInit: smInitialize FAILED, status 0x%x\n", status));
4557     return tiError;
4558   }
4559 #else
4560   /* nothing */
4561 #endif /* FDS_DM && FDS_SM */
4562
4563   /* call these again after agroot is created  for testing */
4564 #ifdef CONTROLLER_STATUS_TESTING
4565   TI_DBG1(("tiCOMPortInit:again saGetControllerStatus returns 0x%X\n",saGetControllerStatus(agRoot,&agcontrollerStatus ) ));
4566 #endif /* CONTROLLER_INFO_TESTING */
4567
4568 #ifdef CONTROLLER_INFO_TESTING
4569   TI_DBG1(("tiCOMPortInit:again saGetControllerInfo returns 0x%X\n",saGetControllerInfo(agRoot,&agcontrollerInfo ) ));
4570 #endif /* CONTROLLER_INFO_TESTING */
4571
4572 #ifdef CONTROLLER_ENCRYPT_TESTING
4573   TI_DBG1(("tiCOMPortInit:again saEncryptGetMode returns 0x%X\n",saEncryptGetMode(agRoot,agNULL,&agsaEncryptInfo ) ));
4574 #endif /* CONTROLLER_INFO_TESTING */
4575
4576 /* Enable SGPIO */
4577   if (tiSuccess == tiCOMConfigureSgpio(tiRoot, agTRUE))
4578   {
4579     TI_DBG2(("tiCOMPortInit: Successfully sent request to enable SGPIO\n"));
4580   }
4581   else
4582   {
4583     TI_DBG1(("tiCOMPortInit: Failed to enable SGPIO\n"));
4584   }
4585
4586   return tiSuccess;
4587 }
4588
4589 /*****************************************************************************
4590 *! \brief SendSgpioRequest
4591 *
4592 *  Purpose: This function is used to send SGPIO request during initialization
4593 *
4594 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4595 *                   instance.
4596 *  \param   regType: Register Type
4597 *  \param   regIndex: Register Index
4598 *  \param   regCount: Register Count
4599 *  \param   writeData: Part of the request
4600 *
4601 *  \return:
4602 *           tiSuccess on success
4603 *           Other status on failure
4604 *
4605 *****************************************************************************/
4606 static bit32 SendSgpioRequest(
4607                             tiRoot_t    *tiRoot,
4608                             bit8        regType,
4609                             bit8        regIndex,
4610                             bit8        regCount,
4611                             bit32       *writeData
4612                             )
4613 {
4614     static bit32            buffer[128] = {0};
4615     bit32                   status = tiError;
4616     bit32                   retVal = IOCTL_CALL_FAIL;
4617     tiIOCTLPayload_t        *agIOCTLPayload = (tiIOCTLPayload_t *) buffer;
4618     agsaSGpioReqResponse_t  *pSGpioReq = (agsaSGpioReqResponse_t *) &agIOCTLPayload->FunctionSpecificArea[0];
4619     agsaSGpioReqResponse_t  *pSgpioResponse = (agsaSGpioReqResponse_t *) &agIOCTLPayload->FunctionSpecificArea[0];
4620
4621     do{
4622
4623     /* Frame the Ioctl payload */
4624     agIOCTLPayload->MajorFunction = IOCTL_MJ_SGPIO;
4625     agIOCTLPayload->Length = sizeof(agsaSGpioReqResponse_t);
4626
4627     /* Frame the SGPIO request */
4628     pSGpioReq->smpFrameType = SMP_REQUEST;
4629     pSGpioReq->function = AGSA_WRITE_SGPIO_REGISTER;
4630     pSGpioReq->registerType = regType;
4631     pSGpioReq->registerIndex = regIndex;
4632     pSGpioReq->registerCount = regCount;
4633     memcpy(pSGpioReq->readWriteData, writeData, regCount * 4);
4634
4635     /* Send the SGPIO request */
4636     sgpioResponseSet = 0;
4637     retVal = tdsaSGpioIoctlSetup(tiRoot, agNULL, agIOCTLPayload, agNULL, agNULL);
4638     if (retVal != IOCTL_CALL_PENDING)
4639     {
4640         break;
4641     }
4642     /* Waiting for SGPIO Response */
4643     while(!sgpioResponseSet)
4644     {
4645         tiCOMDelayedInterruptHandler(tiRoot, 0, 1, tiNonInterruptContext);
4646     }
4647     sgpioResponseSet = 0;
4648     /* Check the ioctl result */
4649     if(agIOCTLPayload->Status != IOCTL_ERR_STATUS_OK)
4650     {
4651         break;
4652     }
4653     /* Check the sgpio function result */
4654     if(pSgpioResponse->functionResult != 0x00)
4655     {
4656         break;
4657     }
4658
4659     status = tiSuccess;
4660
4661   }while(0);
4662
4663     return status;
4664 }
4665
4666 /*****************************************************************************
4667 *! \brief tiCOMConfigureSgpio
4668 *
4669 *  Purpose: This function is used to configure SGPIO during initialization
4670 *
4671 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
4672 *                   instance.
4673 *  \param   enableSgpio: Enable / Disable SGPIO
4674 *
4675 *  \return:
4676 *           tiSuccess on success
4677 *           Other status on failure
4678 *
4679 *****************************************************************************/
4680 bit32 tiCOMConfigureSgpio(
4681                         tiRoot_t    *tiRoot,
4682                         bit8        enableSgpio
4683                         )
4684 {
4685     bit32           status = tiError;
4686     bit32           i;
4687     bit8            regCount;
4688     bit32           writeData[OSSA_SGPIO_MAX_READ_DATA_COUNT] = {0};
4689     agsaSGpioCfg0_t *pCfg0 = (agsaSGpioCfg0_t *) &writeData[0];
4690     agsaSGpioCfg1_t *pCfg1 = (agsaSGpioCfg1_t *) &writeData[1];
4691     tdsaRoot_t      *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
4692     tdsaContext_t   *tdsaAllShared = (tdsaContext_t *) &tdsaRoot->tdsaAllShared;
4693     bit32           phyCount = tdsaAllShared->phyCount;
4694
4695     if (enableSgpio)
4696     {
4697         /* Configure both CFG[0] and CFG[1] */
4698         regCount = 2;
4699
4700         /* Enable SGPIO */
4701         pCfg0->gpioEnable = 1;
4702
4703         /* The following are the default values for CFG[1] suggested by SFF-8485 spec */
4704         /* Maximum Activity ON: 2 */
4705         /* Forced Activity OFF: 1 */
4706         pCfg1->maxActOn = 2;
4707         pCfg1->forceActOff = 1;
4708     }
4709     else
4710     {
4711         /* Configure CFG[0] only */
4712         regCount = 1;
4713
4714         /* Disable SGPIO */
4715         pCfg0->gpioEnable = 0;
4716     }
4717
4718     status = SendSgpioRequest(tiRoot, AGSA_SGPIO_CONFIG_REG, 0, regCount, writeData);
4719     if((tiSuccess == status) && (enableSgpio))
4720     {
4721          /* Write default values to transmit registers */
4722          /* RegisterCount = Number of phys present in HBA / 4 */
4723          regCount = phyCount / 4;
4724          for(i = 0; i < regCount; i++)
4725          {
4726            /* Following are the default values specified in SFF-8485 spec */
4727            /* Activity: 5 */
4728            /* Locate: 0 */
4729            /* Error: 0 */
4730            writeData[i] = 0xA0A0A0A0;
4731         }
4732         status = SendSgpioRequest(tiRoot, AGSA_SGPIO_DRIVE_BY_DRIVE_TRANSMIT_REG, 0, regCount, writeData);
4733    }
4734
4735    return status;
4736 }
4737
4738
4739 /*****************************************************************************
4740 *! \brief  tiCOMPortStart
4741 *
4742 *  Purpose: This function is called to bring the port hardware online. This
4743 *           call could only be called until after the successful completion
4744 *           tiCOMPortInit().
4745 *
4746 *  \param  tiRoot:          Pointer to root data structure.
4747 *  \param  portID:          A ID for this portal to be used by the TD Layer
4748 *                           to get the portal configuration information.
4749 *  \param  portalContext:   Pointer to the context for this portal.
4750 *  \param  option:          An option for starting a port
4751 *
4752 *  \return:
4753 *          tiSuccess:      Successful.
4754 *          Others:             Fail.
4755 *
4756 *  \note -
4757 *   If sas or sata initiator, this will be called 8 (the number of phys) times.
4758 *   If both sas and sata initiator, this will be called 16 times
4759 *
4760 *****************************************************************************/
4761 /* portID is used as PhyID
4762    Should return always tiSuccess. PortStarted is returned in ossaHwCB()
4763 */
4764 osGLOBAL bit32
4765 tiCOMPortStart(
4766                tiRoot_t          * tiRoot,
4767                bit32               portID,
4768                tiPortalContext_t * portalContext,
4769                bit32               option
4770                )
4771 {
4772   tdsaRoot_t    *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
4773   tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
4774   agsaRoot_t *agRoot = &tdsaAllShared->agRootInt;
4775   agsaSASProtocolTimerConfigurationPage_t SASConfigPage;
4776   bit32 status = AGSA_RC_FAILURE;
4777   static bit32 IsSendSASConfigPage = agFALSE;
4778
4779
4780   TI_DBG3(("tiCOMPortStart: start portID %d\n", portID));
4781
4782   /*
4783    * return error if reset is in progress
4784    */
4785   if (tdsaAllShared->flags.resetInProgress == agTRUE)
4786   {
4787     TI_DBG1(("tiCOMPortStart: reset error\n"));
4788     return tiError;
4789   }
4790
4791   /*
4792    *
4793    * port is not initialized, return error
4794    */
4795   if (tdsaAllShared->Ports[portID].flags.portInitialized == agFALSE)
4796   {
4797     TI_DBG1(("tiCOMPortStart: not intialized error\n"));
4798     return tiError;
4799   }
4800
4801   /* portal has been started. */
4802   if (portalContext->tdData != NULL)
4803   {
4804     if (tdsaAllShared->Ports[portID].flags.portStarted == agTRUE)
4805     {
4806       TI_DBG3 (("tiCOMPortStart : Cannot start port again: Port has already been started\n"));
4807       ostiPortEvent (
4808                      tiRoot,
4809                      tiPortStarted,
4810                      tiSuccess,
4811                      (void *) tdsaAllShared->Ports[portID].tiPortalContext
4812                      );
4813       return tiSuccess;
4814     }
4815   }
4816
4817   portalContext->tdData =  &(tdsaAllShared->Ports[portID]);
4818   TI_DBG4 (("tiCOMPortStart : saving portalconext portID %d tdsaAllShared %p\n", portID, tdsaAllShared));
4819   /* saving tiportalContext_t */
4820   tdsaAllShared->Ports[portID].tiPortalContext = portalContext;
4821   TI_DBG4(("tiCOMPortStart : portID/phyID %d tiPortalContext %p\n", portID, tdsaAllShared->Ports[portID].tiPortalContext));
4822
4823   /*
4824     where is "tdsaAllShared->Ports[0].portContext" set?
4825     in ossaHWCB
4826   */
4827   if (tdsaAllShared->Ports[portID].flags.portStarted == agTRUE)
4828   {
4829     TI_DBG1(("tiCOMPortStart: port already has been started \n"));
4830     return tiSuccess;
4831   }
4832
4833
4834   /*
4835     hardcode sasID frame. It should be read by ostigettransportparams later from configuration file
4836   */
4837 #ifdef INITIATOR_DRIVER
4838
4839   tdsaAllShared->Ports[portID].SASID.target_ssp_stp_smp = 0;
4840   tdsaAllShared->Ports[portID].SASID.initiator_ssp_stp_smp
4841       = SA_IDFRM_SSP_BIT | SA_IDFRM_STP_BIT | SA_IDFRM_SMP_BIT;
4842   tdsaAllShared->Ports[portID].SASID.deviceType_addressFrameType = AGSA_DEV_TYPE_END_DEVICE;
4843
4844   tdsaAllShared->Ports[portID].SASID.phyIdentifier = (bit8)portID;
4845
4846 #endif
4847
4848 #ifdef TARGET_DRIVER
4849
4850   tdsaAllShared->Ports[portID].SASID.target_ssp_stp_smp = SA_IDFRM_SSP_BIT;
4851   tdsaAllShared->Ports[portID].SASID.initiator_ssp_stp_smp = 0;
4852   tdsaAllShared->Ports[portID].SASID.deviceType_addressFrameType = AGSA_DEV_TYPE_END_DEVICE;
4853   tdsaAllShared->Ports[portID].SASID.phyIdentifier = (bit8)portID;
4854
4855 #endif
4856
4857 #if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER)
4858
4859   /* for combo testing */
4860   tdsaAllShared->Ports[portID].SASID.target_ssp_stp_smp = SA_IDFRM_SSP_BIT;
4861   tdsaAllShared->Ports[portID].SASID.initiator_ssp_stp_smp
4862       = SA_IDFRM_SSP_BIT | SA_IDFRM_STP_BIT | SA_IDFRM_SMP_BIT;
4863   tdsaAllShared->Ports[portID].SASID.deviceType_addressFrameType = AGSA_DEV_TYPE_END_DEVICE;
4864
4865   tdsaAllShared->Ports[portID].SASID.phyIdentifier = (bit8)portID;
4866
4867 #endif
4868
4869
4870   TI_DBG6(("tiCOMPortStart: before pid %d\n", portID));
4871   tdssPrintSASIdentify(&(tdsaAllShared->Ports[portID].SASID));
4872
4873   TI_DBG6(("tiCOMPortStart: sysIntsActive %s\n",
4874            (tdsaAllShared->flags.sysIntsActive == agTRUE) ? "agTRUE" : "agFALSE"));
4875
4876   /* Read global configuration first then card-specific configuration */
4877
4878   /* the following must be processed only once */
4879   if ( tdsaAllShared->first_process == agFALSE)
4880   {
4881     tdsaGetGlobalPhyParams(tiRoot);
4882     tdsaGetCardPhyParams(tiRoot);
4883     tdsaAllShared->first_process = agTRUE;
4884   }
4885
4886   TI_DBG6(("tiCOMPortStart: after pid %d\n", portID));
4887   tdssPrintSASIdentify(&(tdsaAllShared->Ports[portID].SASID));
4888
4889   /*
4890      Phy Calibration
4891   */
4892   if (tdsaAllShared->phyCalibration)
4893   {
4894     /* Change default phy calibration */
4895     tdsaAllShared->Ports[portID].agPhyConfig.phyProperties =
4896       (tdsaAllShared->Ports[portID].agPhyConfig.phyProperties) | 0x80;
4897     /* Setting index of phy calibration table index
4898        portID is used as phy calibration table index
4899     */
4900     tdsaAllShared->Ports[portID].agPhyConfig.phyProperties =
4901       (tdsaAllShared->Ports[portID].agPhyConfig.phyProperties) | (portID << 8);
4902   }
4903   TI_DBG2(("tiCOMPortStart: tdsaAllShared->Ports[0x%x].agPhyConfig.phyProperties 0x%x\n",
4904     portID, tdsaAllShared->Ports[portID].agPhyConfig.phyProperties));
4905
4906
4907   if(gSSC_Disable)
4908   {
4909     tdsaAllShared->Ports[portID].agPhyConfig.phyProperties = tdsaAllShared->Ports[portID].agPhyConfig.phyProperties | 0x40000;
4910     TI_DBG1(("tiCOMPortStart:gSSC_Disable tdsaAllShared->Ports[portID].agPhyConfig.phyProperties 0x%x\n", tdsaAllShared->Ports[portID].agPhyConfig.phyProperties));
4911
4912   }
4913
4914   if(tIsSPCV12or6G(agRoot) && !IsSendSASConfigPage) /* Not SPC */
4915   {
4916     /* call saSetControllerConfig() to set STP_IDLE_TIME; All others are the defaults */
4917     osti_memset(&SASConfigPage, 0, sizeof(agsaSASProtocolTimerConfigurationPage_t));
4918     SASConfigPage.pageCode        =  AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE;
4919     SASConfigPage.MST_MSI         =  3 << 15; /* enables both MCT for SSP target and initiator */
4920     SASConfigPage.STP_SSP_MCT_TMO =  (tdsaAllShared->STP_MCT_TMO << 16) | tdsaAllShared->SSP_MCT_TMO; /* default of 3200 us for STP and SSP maximum connection time */
4921     SASConfigPage.STP_FRM_TMO     = (tdsaAllShared->MAX_OPEN_TIME << 24) | (tdsaAllShared->SMP_MAX_CONN_TIMER << 16) | tdsaAllShared->STP_FRM_TMO; /* MAX_OPEN_TIME, SMP_MAX_CONN_TIMER, STP frame timeout */
4922     SASConfigPage.STP_IDLE_TMO    =  tdsaAllShared->stp_idle_time;
4923     if (SASConfigPage.STP_IDLE_TMO > 0x3FFFFFF)
4924     {
4925       SASConfigPage.STP_IDLE_TMO = 0x3FFFFFF;
4926     }
4927     SASConfigPage.OPNRJT_RTRY_INTVL =         (tdsaAllShared->MFD << 16)              | tdsaAllShared->OPNRJT_RTRY_INTVL; /* Multi Data Fetach enabled and 2 us for Open Reject Retry interval */
4928     SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO =  (tdsaAllShared->DOPNRJT_RTRY_TMO << 16) | tdsaAllShared->COPNRJT_RTRY_TMO; /* 128 us for ORR Timeout for DATA phase and 32 us for ORR Timeout for command phase */
4929     SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR =  (tdsaAllShared->DOPNRJT_RTRY_THR << 16) | tdsaAllShared->COPNRJT_RTRY_THR; /* 16 for ORR backoff threshold for DATA phase and 1024 for ORR backoff threshold for command phase */
4930     SASConfigPage.MAX_AIP =  tdsaAllShared->MAX_AIP; /* MAX AIP. Default is  0x200000 */
4931
4932     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.pageCode                 0x%08x\n",SASConfigPage.pageCode));
4933     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.MST_MSI                  0x%08x\n",SASConfigPage.MST_MSI));
4934     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.STP_SSP_MCT_TMO          0x%08x\n",SASConfigPage.STP_SSP_MCT_TMO));
4935     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.STP_FRM_TMO              0x%08x\n",SASConfigPage.STP_FRM_TMO));
4936     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.STP_IDLE_TMO             0x%08x\n",SASConfigPage.STP_IDLE_TMO));
4937     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.OPNRJT_RTRY_INTVL        0x%08x\n",SASConfigPage.OPNRJT_RTRY_INTVL));
4938     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO 0x%08x\n",SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO));
4939     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR 0x%08x\n",SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR));
4940     TI_DBG1(("tiCOMPortStart: saSetControllerConfig SASConfigPage.MAX_AIP                  0x%08x\n",SASConfigPage.MAX_AIP));
4941
4942     status = saSetControllerConfig(agRoot,
4943                                     0,
4944                                     AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE,
4945                                     sizeof(agsaSASProtocolTimerConfigurationPage_t),
4946                                     &SASConfigPage,
4947                                     agNULL);
4948     if (status != AGSA_RC_SUCCESS)
4949     {
4950       TI_DBG1(("tiCOMPortStart: calling saSetControllerConfig() failed\n"));
4951     }
4952     else
4953     {
4954       TI_DBG2(("tiCOMPortStart: calling saSetControllerConfig() is OK\n"));
4955     }
4956     IsSendSASConfigPage = agTRUE;
4957   }
4958   else
4959   {
4960     TI_DBG1(("tiCOMPortStart: saSetControllerConfig not called tIsSPCV12or6G %d IsSendSASConfigPage %d\n",tIsSPCV12or6G(agRoot),IsSendSASConfigPage));
4961   }
4962
4963   /* maps portID to phyID */
4964   status = saPhyStart(agRoot,
4965                       agNULL,
4966                       0,
4967                       portID,
4968                       &(tdsaAllShared->Ports[portID].agPhyConfig),
4969                       &(tdsaAllShared->Ports[portID].SASID)
4970                       );
4971
4972   TI_DBG6(("tiCOMPortStart: saPhyStart status %d\n", status));
4973
4974   if (status == AGSA_RC_SUCCESS)
4975   {
4976     TI_DBG3(("tiCOMPortStart : calling portstarted\n"));
4977     ostiPortEvent(
4978                   tiRoot,
4979                   tiPortStarted,
4980                   tiSuccess,
4981                   (void *) tdsaAllShared->Ports[portID].tiPortalContext
4982                   );
4983     return tiSuccess;
4984   }
4985   else
4986   {
4987     TI_DBG3(("tiCOMPortStart : cant' start port\n"));
4988     return tiError;
4989   }
4990
4991 }
4992
4993 /*****************************************************************************
4994 *! \brief  tiCOMPortStop
4995 *
4996 *  Purpose: This function is called to bring the port hardware down.
4997 *
4998 *  \param  tiRoot:          Pointer to root data structure.
4999 *  \param  portalContext:   Pointer to the context for this portal.
5000 *
5001 *  \return:
5002 *          tiSuccess:      Successful.
5003 *          Others:             Fail.
5004 *
5005 *  \note -
5006 *
5007 *****************************************************************************/
5008 osGLOBAL bit32
5009 tiCOMPortStop (
5010   tiRoot_t          *tiRoot,
5011   tiPortalContext_t *portalContext
5012   )
5013 {
5014   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
5015   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5016   tdList_t          *PortContextList;
5017   tdsaPortContext_t *onePortContext = agNULL;
5018   agsaRoot_t        *agRoot = agNULL;
5019   bit32             i;
5020   bit32             found = agFALSE;
5021
5022 #ifdef CONTROLLER_STATUS_TESTING
5023   agsaControllerStatus_t  agcontrollerStatus;
5024 #endif /* CONTROLLER_STATUS_TESTING */
5025
5026
5027   TI_DBG3(("tiCOMPortStop: start\n"));
5028   /*
5029     find the portcontext
5030     find phys belonging to that portcotext
5031     call saPhyStop for all those phys
5032     call saPhyStop()
5033     remove the portcontext from the portcontext list
5034   */
5035
5036   agRoot = &(tdsaAllShared->agRootNonInt);
5037
5038 #ifdef CONTROLLER_STATUS_TESTING
5039   TI_DBG1(("tiCOMPortStop: saGetControllerStatus returns 0x%X\n",saGetControllerStatus(agRoot,&agcontrollerStatus ) ));
5040 #endif /* CONTROLLER_INFO_TESTING */
5041
5042   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
5043   {
5044     TI_DBG1(("tiCOMPortStop: empty tdsaPortContext\n"));
5045     return tiError;
5046   }
5047
5048   /* find a right portcontext */
5049   PortContextList = tdsaAllShared->MainPortContextList.flink;
5050   while (PortContextList != &(tdsaAllShared->MainPortContextList))
5051   {
5052     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
5053     if (onePortContext == agNULL)
5054     {
5055       TI_DBG1(("tiCOMPortStop: onePortContext is NULL!!!\n"));
5056       return tiError;
5057     }
5058     if (onePortContext->tiPortalContext == portalContext)
5059     {
5060       TI_DBG6(("tiCOMPortStop: found; oneportContext ID %d\n", onePortContext->id));
5061       found = agTRUE;
5062       break;
5063     }
5064     PortContextList = PortContextList->flink;
5065   }
5066
5067   if (found == agFALSE)
5068   {
5069     TI_DBG1(("tiCOMPortStop: No corressponding tdsaPortContext\n"));
5070     return tiError;
5071   }
5072
5073 #ifdef INITIATOR_DRIVER
5074   /* reset the fields of portcontext */
5075   onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
5076   onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
5077 #endif /* INITIATOR_DRIVER */
5078
5079   onePortContext->Count = 0;
5080   onePortContext->agContext.osData = onePortContext;
5081   for(i=0;i<TD_MAX_NUM_PHYS;i++)
5082   {
5083     if (onePortContext->PhyIDList[i] == agTRUE)
5084     {
5085       tdsaAllShared->Ports[i].portContext = agNULL;
5086 #ifdef CCFLAGS_PHYCONTROL_COUNTS
5087       if( tiIS_SPC(agRoot) )
5088       {
5089
5090         saLocalPhyControl(agRoot,&onePortContext->agContext,0 , i, AGSA_PHY_GET_ERROR_COUNTS, agNULL);
5091         saLocalPhyControl(agRoot,&onePortContext->agContext,0 , i, AGSA_PHY_CLEAR_ERROR_COUNTS, agNULL);
5092         saLocalPhyControl(agRoot,&onePortContext->agContext,0 , i, AGSA_PHY_GET_BW_COUNTS, agNULL);
5093       }
5094       else
5095       {
5096         TI_DBG1(("\ntiCOMPortStop: CCFLAGS_PHYCONTROL_COUNTS PHY %d\n",i));
5097         saGetPhyProfile( agRoot,&onePortContext->agContext,0, AGSA_SAS_PHY_ERR_COUNTERS_PAGE, i);
5098         saGetPhyProfile( agRoot,&onePortContext->agContext,0, AGSA_SAS_PHY_BW_COUNTERS_PAGE,i);
5099         saGetPhyProfile( agRoot,&onePortContext->agContext,0, AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE,i);
5100         saGetPhyProfile( agRoot,&onePortContext->agContext,0, AGSA_SAS_PHY_GENERAL_STATUS_PAGE,i);
5101         saGetPhyProfile( agRoot,&onePortContext->agContext,0, AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE,i);
5102
5103         TI_DBG1(("tiCOMPortStop: CCFLAGS_PHYCONTROL_COUNTS PHY %d\n",i));
5104
5105       }
5106
5107 #endif /* CCFLAGS_PHYCONTROL_COUNTS */
5108       saPhyStop(agRoot, &onePortContext->agContext, 0, i);
5109     }
5110   }
5111
5112   return tiSuccess;
5113 }
5114
5115
5116 /*****************************************************************************
5117 *! \brief tiCOMGetPortInfo
5118 *
5119 *  Purpose:  This function is called to return information about the specific
5120 *            port instant
5121 *
5122 *
5123 *  \param   tiRoot:        Pointer to driver/port instance.
5124 *  \param   portalContext  Pointer to the context for this portal.
5125 *  \param   tiPortInfo:    Pointer to port information structure.
5126 *
5127 *  \Return: tiSuccess
5128 *
5129 *****************************************************************************/
5130 /*
5131   can't find tdsaportcontext in this function
5132   since discovery has not been called by OS layer yet
5133   Therefore, hardcoded value are being returned for now
5134 */
5135 osGLOBAL bit32 tiCOMGetPortInfo(
5136                                 tiRoot_t            *tiRoot,
5137                                 tiPortalContext_t   *portalContext,
5138                                 tiPortInfo_t        *tiPortInfo
5139                                 )
5140
5141 {
5142   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
5143   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5144   tdList_t          *PortContextList;
5145   tdsaPortContext_t *onePortContext = agNULL;
5146   bit32             found = agFALSE;
5147   static bit8       localname[68], remotename[68];
5148
5149   TI_DBG6(("tiCOMGetPortInfo: start\n"));
5150
5151
5152   tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
5153   if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
5154   {
5155     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
5156     TI_DBG1(("tiCOMGetPortInfo: No tdsaPortContext\n"));
5157     return tiError;
5158   }
5159   else
5160   {
5161     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
5162   }
5163
5164   /* find a corresponding portcontext */
5165   PortContextList = tdsaAllShared->MainPortContextList.flink;
5166   while (PortContextList != &(tdsaAllShared->MainPortContextList))
5167   {
5168     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
5169     TI_DBG3(("tiCOMGetPortInfo: oneportContext pid %d\n", onePortContext->id));
5170     if (onePortContext->tiPortalContext == portalContext && onePortContext->valid == agTRUE)
5171     {
5172       TI_DBG3(("tiCOMGetPortInfo: found; oneportContext pid %d\n", onePortContext->id));
5173       found = agTRUE;
5174       break;
5175     }
5176     PortContextList = PortContextList->flink;
5177   }
5178
5179   if (found == agFALSE)
5180   {
5181     TI_DBG1(("tiCOMGetPortInfo: First, No corresponding tdsaPortContext\n"));
5182     return tiError;
5183   }
5184
5185   if (onePortContext == agNULL)
5186   {
5187     TI_DBG1(("tiCOMGetPortInfo: Second, No corressponding tdsaPortContext\n"));
5188     return tiError;
5189   }
5190
5191   osti_memset(localname, 0, sizeof(localname));
5192   osti_memset(remotename, 0, sizeof(remotename));
5193
5194   /*
5195     Parse the type of port then fill in the information
5196   */
5197   if ( onePortContext->sasRemoteAddressHi == 0xFFFFFFFF && onePortContext->sasRemoteAddressLo == 0xFFFFFFFF)
5198   {
5199     /* directly attached SATA port */
5200     osti_memcpy(localname, &(onePortContext->sasLocalAddressHi), 4);
5201     osti_memcpy(&(localname[4]), &(onePortContext->sasLocalAddressLo), 4);
5202     tiPortInfo->localNameLen = 8;
5203     /* information is from SATA ID device data. remoteName is serial number, firmware version, model number */
5204     osti_memcpy(remotename, onePortContext->remoteName, 68);
5205     tiPortInfo->remoteNameLen = 68;
5206   }
5207   else
5208   {
5209     /* copy hi address and low address */
5210     osti_memcpy(localname, &(onePortContext->sasLocalAddressHi), 4);
5211     osti_memcpy(&(localname[4]), &(onePortContext->sasLocalAddressLo), 4);
5212     tiPortInfo->localNameLen = 8;
5213     osti_memcpy(remotename, &(onePortContext->sasRemoteAddressHi), 4);
5214     osti_memcpy(&(remotename[4]), &(onePortContext->sasRemoteAddressLo), 4);
5215     tiPortInfo->remoteNameLen = 8;
5216   }
5217
5218   tiPortInfo->localName = (char *)&localname;
5219   tiPortInfo->remoteName = (char *)&remotename;
5220
5221
5222   return tiSuccess;
5223
5224 }
5225
5226 /*****************************************************************************
5227 *
5228 * tiCOMSetControllerConfig
5229 *
5230 *  Purpose:  This function is called to set the controller's advanced configuration.
5231 *            The status is reported via ostiPortEvent().
5232 *
5233 *  Parameters:
5234 *
5235 *    tiRoot:        Pointer to driver/port instance.
5236 *
5237 *  Return:
5238 *     tiSuccess:  The setting controller configuration was started.
5239 *     tiError:    The setting controller configuration was not started.
5240 *
5241 *****************************************************************************/
5242 osGLOBAL bit32  tiCOMSetControllerConfig (
5243          tiRoot_t    *tiRoot,
5244          bit32       modePage,
5245          bit32       length,
5246          void        *buffer,
5247          void        *context)
5248 {
5249    agsaRoot_t      *agRoot;
5250    bit32           returnCode = AGSA_RC_BUSY;
5251    bit32           tiStatus = tiSuccess;
5252    tdsaRoot_t      *tdsaRoot ;
5253    tdsaContext_t   *tdsaAllShared ;
5254
5255    TD_ASSERT(tiRoot, "tiRoot");
5256    tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5257    TD_ASSERT(tdsaRoot, "tdsaRoot");
5258
5259    tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5260    TD_ASSERT(tdsaAllShared, "tdsaAllShared");
5261    agRoot = &(tdsaAllShared->agRootNonInt);
5262    TD_ASSERT(agRoot, "agRoot");
5263
5264    agRoot = &(tdsaAllShared->agRootNonInt);
5265
5266    TI_DBG1(("tiCOMSetControllerConfig:\n" ));
5267
5268    /*do some sanity checking */
5269    if ( ((modePage == TI_INTERRUPT_CONFIGURATION_PAGE)   && (length != sizeof(tiInterruptConfigPage_t )))   ||
5270         ((modePage == TI_ENCRYPTION_GENERAL_CONFIG_PAGE) && (length != sizeof(tiEncryptGeneralPage_t  )))    ||
5271         ((modePage == TI_ENCRYPTION_DEK_CONFIG_PAGE)     && (length != sizeof(tiEncryptDekConfigPage_t)))    ||
5272         ((modePage == TI_ENCRYPTION_CONTROL_PARM_PAGE)  && (length != sizeof(tiEncryptControlParamPage_t ))) ||
5273         ((modePage == TI_ENCRYPTION_HMAC_CONFIG_PAGE)  && (length != sizeof(tiEncryptHMACConfigPage_t )))    ||
5274         ((modePage == TI_SAS_PROTOCOL_TIMER_CONFIG_PAGE) && (length != sizeof(tiSASProtocolTimerConfigurationPage_t )))  )
5275    {
5276        tiStatus = tiError;
5277    }
5278    else
5279    {
5280        returnCode = saSetControllerConfig(agRoot, 0, modePage, length, buffer, context);
5281
5282        if (returnCode == AGSA_RC_SUCCESS)
5283        {
5284            tiStatus = tiSuccess;
5285        }
5286        else if (returnCode == AGSA_RC_BUSY)
5287        {
5288            tiStatus = tiBusy;
5289        }
5290        else
5291        {
5292            tiStatus = tiError;
5293        }
5294    }
5295    return(tiStatus);
5296 }
5297
5298 /*****************************************************************************
5299 *
5300 * tiCOMGetControllerConfig
5301 *
5302 *  Purpose:  This function is called to get the controller's advanced configuration.
5303 *            The status is reported via ostiPortEvent().
5304 *
5305 *  Parameters:
5306 *
5307 *    tiRoot:        Pointer to driver/port instance.
5308 *    flag:          Interrupt  Vector Mask
5309 *                   This parameter is valid only when modePage is set to TI_INTERRUPT_CONFIGURATION_PAGE.
5310 *                   When the modePage field is set to TI_INTERRUPT_CONFIGURATION_PAGE,
5311 *                   this field contains a bitmap of interrupt vectors for which interrupt coalescing parameters are retrieved.
5312 *  Return:
5313 *     tiSuccess:  The controller configuration retrival was started.
5314 *     tiError:    The controller configuration retrival was not started.
5315 *
5316 *****************************************************************************/
5317 osGLOBAL bit32  tiCOMGetControllerConfig (
5318          tiRoot_t    *tiRoot,
5319          bit32       modePage,
5320          bit32       flag,
5321          void        *context)
5322
5323 {
5324   agsaRoot_t      *agRoot;
5325   bit32           returnCode = AGSA_RC_BUSY;
5326   bit32           tiStatus = tiSuccess;
5327   tdsaRoot_t      *tdsaRoot ;
5328   tdsaContext_t   *tdsaAllShared ;
5329
5330   TD_ASSERT(tiRoot, "tiRoot");
5331   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5332   TD_ASSERT(tdsaRoot, "tdsaRoot");
5333
5334   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5335   TD_ASSERT(tdsaAllShared, "tdsaAllShared");
5336   agRoot = &(tdsaAllShared->agRootNonInt);
5337   TD_ASSERT(agRoot, "agRoot");
5338
5339   agRoot = &(tdsaAllShared->agRootNonInt);
5340
5341   TI_DBG1(("tiCOMGetControllerConfig: modePage 0x%x context %p\n",modePage,context ));
5342
5343   returnCode = saGetControllerConfig(agRoot, 0, modePage, flag, 0, context);
5344
5345   if (returnCode == AGSA_RC_SUCCESS)
5346   {
5347     tiStatus = tiSuccess;
5348     TI_DBG1(("tiCOMGetControllerConfig:modePage 0x%x tiSuccess\n",modePage ));
5349   }
5350   else if (returnCode == AGSA_RC_BUSY)
5351   {
5352     tiStatus = tiBusy;
5353     TI_DBG1(("tiCOMGetControllerConfig:modePage 0x%x tiBusy\n",modePage ));
5354   }
5355   else
5356   {
5357     tiStatus = tiError;
5358     TI_DBG1(("tiCOMGetControllerConfig:modePage 0x%x tiError\n",modePage ));
5359   }
5360
5361    return(tiStatus);
5362 }
5363
5364 /*****************************************************************************
5365 *
5366 * tiCOMEncryptGetInfo
5367 *
5368 *  Purpose:  This function is called to return information about the encryption
5369 *            engine for the specified port.
5370 *
5371 *  Parameters:
5372 *
5373 *    tiRoot:        Pointer to driver/port instance.
5374 *
5375 *  Return:
5376 *   tiSuccess       The request is being processed
5377 *   tiNotSupported  Encryption is not supported
5378 *
5379 *****************************************************************************/
5380 osGLOBAL bit32 tiCOMEncryptGetInfo(tiRoot_t *tiRoot)
5381 {
5382   tiEncryptInfo_t tiEncryptInfo;
5383   agsaEncryptInfo_t agsaEncryptInfo;
5384   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
5385   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5386   agsaRoot_t      *agRoot;
5387   tiEncryptPort_t tiEncryptPort;
5388   bit32           returnCode;
5389   bit32           tiStatus;
5390
5391   agRoot = &(tdsaAllShared->agRootNonInt);
5392
5393   returnCode = saEncryptGetMode(agRoot,agNULL, &agsaEncryptInfo);
5394   TI_DBG1(("tiCOMEncryptGetInfo: returnCode 0x%x\n", returnCode));
5395
5396   if (returnCode == AGSA_RC_SUCCESS)
5397   {
5398       tiStatus = tiSuccess;
5399
5400       /*
5401        * The data encoded in the agsaEncryptInfo must be converted
5402        * to match the fields of the tiEncryptInfo structure.
5403        *
5404        * No sector information is currently available.
5405        */
5406       osti_memset(&tiEncryptInfo, 0x0, sizeof(tiEncryptInfo_t));
5407
5408       /* cipher mode */
5409       if (agsaEncryptInfo.encryptionCipherMode == agsaEncryptCipherModeXTS)
5410       {
5411          tiEncryptInfo.securityCipherMode = TI_ENCRYPT_ATTRIB_CIPHER_XTS;
5412       }
5413       /* security mode */
5414       if (agsaEncryptInfo.encryptionSecurityMode == agsaEncryptSMF)
5415       {
5416          tiEncryptInfo.securityCipherMode |= TI_ENCRYPT_SEC_MODE_FACT_INIT;
5417       }
5418       else if (agsaEncryptInfo.encryptionSecurityMode == agsaEncryptSMA)
5419       {
5420          tiEncryptInfo.securityCipherMode |= TI_ENCRYPT_SEC_MODE_A;
5421       }
5422       else if (agsaEncryptInfo.encryptionSecurityMode == agsaEncryptSMB)
5423       {
5424          tiEncryptInfo.securityCipherMode |= TI_ENCRYPT_SEC_MODE_B;
5425       }
5426
5427       tiEncryptInfo.status = agsaEncryptInfo.status;
5428
5429       tiEncryptPort.pData = &tiEncryptInfo;
5430
5431       /* The low level returns synchronously, so fake a port event now.*/
5432       tiEncryptPort.encryptEvent = tiEncryptGetInfo;
5433       tiEncryptPort.subEvent = 0;
5434
5435       ostiPortEvent(tiRoot,tiEncryptOperation,tiStatus,&tiEncryptPort);
5436   }
5437   else
5438   {
5439     if (returnCode == AGSA_RC_NOT_SUPPORTED)
5440     {
5441       tiStatus = tiNotSupported;
5442       TI_DBG1(("tiCOMEncryptGetInfo: tiNotSupported\n"));
5443     }
5444     else
5445     {
5446       TI_DBG1(("tiCOMEncryptGetInfo: tiError returnCode 0x%x\n",returnCode));
5447       tiStatus = tiError;
5448     }
5449
5450     tiEncryptPort.pData = NULL;
5451   }
5452
5453   return(tiStatus);
5454 }
5455
5456 /*****************************************************************************
5457 *
5458 * tiCOMEncryptSetMode
5459 *
5460 *  Purpose:  This function is called to set the encryption security and cipher modes
5461 *            for the encryption engine.
5462 *
5463 *  Parameters:
5464 *
5465 *    tiRoot:        Pointer to driver/port instance.
5466 *
5467 *  Return:
5468 *   tiSuccess       The request is being processed
5469 *   tiError         The encryption engine is not in factory init mode or multiple
5470 *                   security modes were specified.
5471 *
5472 *****************************************************************************/
5473
5474 osGLOBAL bit32 tiCOMEncryptSetMode(tiRoot_t            *tiRoot,
5475                                    bit32               securityCipherMode)
5476 {
5477   bit32                         returnCode;
5478   bit32                         tiStatus;
5479   agsaEncryptInfo_t mode;
5480   agsaEncryptInfo_t *pmode = &mode;
5481
5482   tdsaRoot_t        *tdsaRoot ;
5483   tdsaContext_t     *tdsaAllShared;
5484   agsaRoot_t        *agRoot;
5485
5486   TD_ASSERT(tiRoot, "tiRoot");
5487   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5488   TD_ASSERT(tdsaRoot, "tdsaRoot");
5489
5490   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5491   TD_ASSERT(tdsaAllShared, "tdsaAllShared");
5492   agRoot = &(tdsaAllShared->agRootNonInt);
5493   TD_ASSERT(agRoot, "agRoot");
5494
5495   pmode->encryptionSecurityMode = 0;
5496   pmode->encryptionCipherMode = 0;
5497   pmode->status = 0;
5498
5499   TI_DBG1(("tiCOMEncryptSetMode:\n"));
5500
5501
5502   if(( securityCipherMode & TI_ENCRYPT_SEC_MODE_A ) == TI_ENCRYPT_SEC_MODE_A)
5503   {
5504     pmode->encryptionSecurityMode = agsaEncryptSMA;
5505   }
5506
5507   if(( securityCipherMode & TI_ENCRYPT_SEC_MODE_B ) == TI_ENCRYPT_SEC_MODE_B)
5508   {
5509     pmode->encryptionSecurityMode = agsaEncryptSMB;
5510   }
5511
5512   if( (securityCipherMode & TI_ENCRYPT_ATTRIB_CIPHER_XTS)  == TI_ENCRYPT_ATTRIB_CIPHER_XTS)
5513   {
5514     pmode->encryptionCipherMode |= agsaEncryptCipherModeXTS;
5515   }
5516
5517   /* ECB is not supported in SPCv */
5518   if(( securityCipherMode & TI_ENCRYPT_ATTRIB_CIPHER_ECB)  == TI_ENCRYPT_ATTRIB_CIPHER_ECB)
5519   {
5520     return tiError;
5521   }
5522
5523   returnCode = saEncryptSetMode(agRoot,agNULL, 0, pmode );
5524
5525   if (returnCode == AGSA_RC_SUCCESS)
5526   {
5527     tiStatus = tiSuccess;
5528   }
5529   else if (returnCode == AGSA_RC_BUSY)
5530   {
5531     TI_DBG1(("tiCOMEncryptSetMode:tiBusy\n"));
5532     tiStatus = tiBusy;
5533   }
5534   else
5535   {
5536     TI_DBG1(("tiCOMEncryptSetMode:tiError\n"));
5537     tiStatus = tiError;
5538   }
5539
5540   return(tiStatus);
5541 }
5542
5543 /*****************************************************************************
5544 *
5545 * tiCOMEncryptDekAdd
5546 *
5547 *  Purpose:  This function is called to add a DEK to the controller cache.
5548 *
5549 *  Parameters:
5550 *
5551 *    tiRoot:          Pointer to driver/port instance.
5552 *    kekIndext:         Index of the KEK table
5553 *    dekTableSelect:  Number of the DEK table receiving a new entry
5554 *    dekAddrHi:       Upper 32-bits of the DEK table physical address
5555 *    dekAddrLo:       Lower 32-bits of the DEK table physical address
5556 *    dekIndex:        Number of the first entry in the DEK table that will inserted in the cache
5557 *    dekNumberOfEntries: Number of entries to be inserted in the cache
5558 *    dekBlobFormat:     Specifies the DEK blob format
5559 *    dekTableKeyEntrySize: Encoded value for DEK Entry Size in the DEK Table
5560 *
5561 *  Return:
5562 *   tiSuccess       The request is being processed
5563 *   tiError         An invalid parameter was specified
5564 *
5565 *****************************************************************************/
5566 osGLOBAL bit32 tiCOMEncryptDekAdd(tiRoot_t            *tiRoot,
5567                                   bit32               kekIndex,
5568                                   bit32               dekTableSelect,
5569                                   bit32               dekAddrHi,
5570                                   bit32               dekAddrLo,
5571                                   bit32               dekIndex,
5572                                   bit32               dekNumberOfEntries,
5573                                   bit32               dekBlobFormat,
5574                                   bit32               dekTableKeyEntrySize
5575
5576                                   )
5577 {
5578     agsaRoot_t        *agRoot;
5579     bit32           returnCode;
5580     bit32           tiStatus;
5581     tdsaRoot_t        *tdsaRoot ;
5582     tdsaContext_t     *tdsaAllShared ;
5583
5584     TD_ASSERT(tiRoot, "tiRoot");
5585     tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5586     TD_ASSERT(tdsaRoot, "tdsaRoot");
5587
5588     tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5589     TD_ASSERT(tdsaAllShared, "tdsaAllShared");
5590     agRoot = &(tdsaAllShared->agRootNonInt);
5591     TD_ASSERT(agRoot, "agRoot");
5592
5593
5594     agRoot = &(tdsaAllShared->agRootNonInt);
5595
5596
5597     TI_DBG1(("tiCOMEncryptDekAdd:\n" ));
5598
5599     returnCode = saEncryptDekCacheUpdate(agRoot,
5600                                     agNULL,
5601                                     0,
5602                                     kekIndex,
5603                                     dekTableSelect,
5604                                     dekAddrHi,
5605                                     dekAddrLo,
5606                                     dekIndex,
5607                                     dekNumberOfEntries,
5608                                     dekBlobFormat,
5609                                     dekTableKeyEntrySize
5610                                     );
5611
5612     if (returnCode == AGSA_RC_SUCCESS)
5613     {
5614         tiStatus = tiSuccess;
5615     }
5616     else if (returnCode == AGSA_RC_BUSY)
5617     {
5618         tiStatus = tiBusy;
5619     }
5620     else
5621     {
5622         tiStatus = tiError;
5623     }
5624
5625     return(tiStatus);
5626 }
5627
5628 /*****************************************************************************
5629 *
5630 * tiCOMEncryptDekInvalidate
5631 *
5632 *  Purpose:  This function is called to remove a DEK entry from the hardware cache.
5633 *
5634 *  Parameters:
5635 *
5636 *    tiRoot:        Pointer to driver/port instance.
5637 *    dekTable       DEK table that will be affected
5638 *    dekIndex:      DEK table entry that will be affected. The value 0xfffffff clears the cache.
5639 *
5640 *  Return:
5641 *   tiSuccess       The request is being processed
5642 *   tiError         An invalid parameter was specified
5643 *   tiBusy          An operation is already in progress
5644 *
5645 *****************************************************************************/
5646
5647 osGLOBAL bit32 tiCOMEncryptDekInvalidate(tiRoot_t            *tiRoot,
5648                                          bit32               dekTable,
5649                                          bit32               dekIndex)
5650 {
5651
5652     tdsaRoot_t        *tdsaRoot;
5653     tdsaContext_t     *tdsaAllShared;
5654
5655     agsaRoot_t        *agRoot;
5656     tiEncryptPort_t tiEncryptPort;
5657     tiEncryptDek_t  tiEncryptDek;
5658     bit32           returnCode;
5659     bit32           tiStatus;
5660
5661     TD_ASSERT(tiRoot, "tiRoot");
5662     tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5663     TD_ASSERT(tdsaRoot, "tdsaRoot");
5664
5665     tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5666     TD_ASSERT(tdsaAllShared, "tdsaAllShared");
5667     agRoot = &(tdsaAllShared->agRootNonInt);
5668     TD_ASSERT(agRoot, "agRoot");
5669
5670     TI_DBG1(("tiCOMEncryptDekInvalidate:dekTable 0x%x dekIndex 0x%x\n", dekTable, dekIndex));
5671
5672     returnCode = saEncryptDekCacheInvalidate(agRoot, agNULL, 0, dekTable, dekIndex);
5673
5674     if (returnCode == AGSA_RC_SUCCESS)
5675     {
5676         tiStatus = tiSuccess;
5677     }
5678     else
5679     {
5680         if (returnCode == AGSA_RC_NOT_SUPPORTED)
5681         {
5682             tiStatus = tiNotSupported;
5683         }
5684         else if (returnCode == AGSA_RC_BUSY)
5685         {
5686             tiStatus = tiBusy;
5687         }
5688         else
5689         {
5690             tiStatus = tiError;
5691         }
5692
5693         tiEncryptDek.dekTable = dekTable;
5694         tiEncryptDek.dekIndex = dekIndex;
5695
5696         tiEncryptPort.encryptEvent = tiEncryptDekInvalidate;
5697         tiEncryptPort.subEvent = 0;
5698         tiEncryptPort.pData = (void *) &tiEncryptDek;
5699
5700         ostiPortEvent(tiRoot,tiEncryptOperation,tiStatus,&tiEncryptPort);
5701     }
5702
5703     return(tiStatus);
5704 }
5705
5706 /*****************************************************************************
5707 *
5708 * tiCOMEncryptKekAdd
5709 *
5710 *  Purpose:  This function is called to add a KEK in the register specified by
5711 *            the index parameter.
5712 *
5713 *  Parameters:
5714 *
5715 *    tiRoot:           Pointer to driver/port instance.
5716 *    kekIndex:         KEK table entry that will be affected
5717 *    wrapperKekIndex   KEK table entry that encrypt the KEK blob
5718 *    encryptKekBlob    KEK blob that will be added
5719 *
5720 *  Return:
5721 *   tiSuccess       The request is being processed
5722 *   tiError         An invalid parameter was specified
5723 *   tiBusy          A KEK operation is already in progress
5724 *
5725 *****************************************************************************/
5726
5727 osGLOBAL bit32 tiCOMEncryptKekAdd(tiRoot_t            *tiRoot,
5728                                   bit32               kekIndex,
5729                                   bit32               wrapperKekIndex,
5730                                   bit32               blobFormat,
5731                                   tiEncryptKekBlob_t *encryptKekBlob)
5732 {
5733   tdsaRoot_t        *tdsaRoot;
5734   tdsaContext_t     *tdsaAllShared;
5735   agsaRoot_t        *agRoot;
5736
5737   bit32           returnCode= AGSA_RC_BUSY;
5738   bit32           tiStatus= tiError;
5739
5740   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5741   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5742
5743   agRoot = &(tdsaAllShared->agRootNonInt);
5744
5745   TI_DBG1(("tiCOMEncryptDekInvalidate: kekIndex 0x%x wrapperKekIndex 0x%x\n", kekIndex , wrapperKekIndex));
5746
5747   returnCode = saEncryptKekUpdate(agRoot,
5748                                   agNULL,
5749                                   0,
5750                                   AGSA_ENCRYPT_STORE_NVRAM,
5751                                   kekIndex,
5752                                   wrapperKekIndex,
5753                                   blobFormat,
5754                                   (agsaEncryptKekBlob_t *) encryptKekBlob);
5755
5756   if (returnCode == AGSA_RC_SUCCESS)
5757   {
5758     tiStatus = tiSuccess;
5759   }
5760   else if (returnCode == AGSA_RC_BUSY)
5761   {
5762     tiStatus = tiBusy;
5763   }
5764   else
5765   {
5766     tiStatus = tiError;
5767   }
5768
5769   return(tiStatus);
5770 }
5771 #ifdef HIALEAH_ENCRYPTION
5772
5773 osGLOBAL bit32 tiCOMEncryptHilSet(tiRoot_t            *tiRoot )
5774 {
5775   tdsaRoot_t        *tdsaRoot;
5776   tdsaContext_t     *tdsaAllShared;
5777   agsaRoot_t        *agRoot;
5778   agsaEncryptInfo_t agsaEncryptInfo;
5779
5780   bit32           returnCode= tiBusy;
5781   bit32           tiStatus= tiError;
5782
5783   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5784   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5785
5786   agRoot = &(tdsaAllShared->agRootNonInt);
5787
5788
5789   returnCode = saEncryptGetMode(agRoot,agNULL, &agsaEncryptInfo);
5790   TI_DBG1(("tiCOMEncryptHilSet: saEncryptGetMode returnCode 0x%x agsaEncryptInfo status 0x%x Smode 0x%x CMode 0x%x\n",
5791           returnCode,
5792           agsaEncryptInfo.status,
5793           agsaEncryptInfo.encryptionSecurityMode,
5794           agsaEncryptInfo.encryptionCipherMode ));
5795
5796   if (returnCode == AGSA_RC_FAILURE)
5797   {
5798    TI_DBG1(("tiCOMEncryptHilSet:agsaEncryptInfo.status 0x%x\n",agsaEncryptInfo.status ));
5799     if(agsaEncryptInfo.status == 0x81)
5800     {
5801           TI_DBG1(("tiCOMEncryptHilSet: status 0x80 KEY CARD MISMATCH agsaEncryptInfo.status 0x%x\n",agsaEncryptInfo.status ));
5802       returnCode = saEncryptHilUpdate(agRoot,
5803                                       agNULL,
5804                                       0 );
5805       if (returnCode == AGSA_RC_SUCCESS)
5806       {
5807         TI_DBG1(("tiCOMEncryptHilSet:AGSA_RC_SUCCESS\n"));
5808       }
5809     }
5810         else if(agsaEncryptInfo.status == 0x80)
5811     {
5812                 ostidisableEncryption(tiRoot);
5813                 TI_DBG1(("tiCOMEncryptHilSet: status 0x80 KEY CARD MISSING agsaEncryptInfo.status 0x%x\n",agsaEncryptInfo.status ));
5814         returnCode = AGSA_RC_SUCCESS;
5815         }
5816     else
5817     {
5818       TI_DBG1(("tiCOMEncryptHilSet: not status 0x81 agsaEncryptInfo.status 0x%x\n",agsaEncryptInfo.status ));
5819       returnCode = AGSA_RC_FAILURE;
5820     }
5821   }
5822
5823   if (returnCode == AGSA_RC_SUCCESS)
5824   {
5825     tiStatus = tiSuccess;
5826   }
5827   else if (returnCode == AGSA_RC_BUSY)
5828   {
5829     TI_DBG1(("tiCOMEncryptHilSet:AGSA_RC_BUSY\n"));
5830     tiStatus = tiBusy;
5831   }
5832   else
5833   {
5834     TI_DBG1(("tiCOMEncryptHilSet:tiError\n"));
5835     tiStatus = tiError;
5836   }
5837
5838   return(tiStatus);
5839 }
5840 #endif /* HIALEAH_ENCRYPTION */
5841
5842 /*****************************************************************************
5843 *
5844 * tiCOMEncryptKekStore
5845 *
5846 *  Purpose:  This function is called to store a KEK in NVRAM. If -1 is specified
5847 *            as the KEK index, then all KEKs will be stored.
5848 *
5849 *  Parameters:
5850 *
5851 *    tiRoot:        Pointer to driver/port instance.
5852 *    kekIndex:      The KEK to be stored in NVRAM
5853 *
5854 *  Return:
5855 *   tiSuccess       The request is being processed
5856 *   tiError         An invalid parameter was specified
5857 *   tiBusy          A KEK operation is already in progress
5858 *
5859 *****************************************************************************/
5860
5861 osGLOBAL bit32 tiCOMEncryptKekStore(tiRoot_t  *tiRoot,
5862                                     bit32      kekIndex)
5863 {
5864 #ifdef NOT_YET
5865     tdsaRoot_t        *tdsaRoot;
5866     tdsaContext_t     *tdsaAllShared;
5867     agsaRoot_t        *agRoot;
5868 #endif
5869 /*
5870     bit32           returnCode= AGSA_RC_BUSY;
5871 */
5872     bit32           tiStatus = tiError;
5873
5874 #ifdef NOT_YET
5875     tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5876     tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5877
5878     agRoot = &(tdsaAllShared->agRootNonInt);
5879 #endif
5880
5881     TI_DBG1(("tiCOMEncryptKekStore: Needs code !!!! kekIndex 0x%x\n", kekIndex ));
5882 /*
5883     returnCode = fcEncryptKekStore(agRoot, kekIndex);
5884
5885     if (returnCode == AGSA_RC_SUCCESS)
5886     {
5887         tiStatus = tiSuccess;
5888     }
5889     else if (returnCode == AGSA_RC_BUSY)
5890     {
5891         tiStatus = tiBusy;
5892     }
5893     else
5894     {
5895         tiStatus;
5896     }
5897 */
5898     return(tiStatus);
5899 }
5900
5901 /*****************************************************************************
5902 *
5903 * tiCOMEncryptKekLoad
5904 *
5905 *  Purpose:  This function is called to load a KEK from NVRAM. If -1 is specified
5906 *            as the KEK index, then all KEKs will be loaded.
5907 *
5908 *  Parameters:
5909 *
5910 *    tiRoot:        Pointer to driver/port instance.
5911 *    kekIndex:      The KEK to be loaded in NVRAM
5912 *
5913 *  Return:
5914 *   tiSuccess       The request is being processed
5915 *   tiError         An invalid parameter was specified
5916 *   tiBusy          A KEK operation is already in progress
5917 *
5918 *****************************************************************************/
5919
5920 osGLOBAL bit32 tiCOMEncryptKekLoad(tiRoot_t            *tiRoot,
5921                                    bit32               kekIndex)
5922 {
5923 #ifdef NOT_YET
5924     tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
5925     tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5926     agsaRoot_t      *agRoot;
5927     //bit32           returnCode;
5928 #endif
5929     bit32           tiStatus = tiError;
5930
5931 #ifdef NOT_YET
5932     agRoot = &(tdsaAllShared->agRootNonInt);
5933 #endif
5934 /*
5935     returnCode = fcEncryptKekLoad(agRoot, kekIndex);
5936
5937     if (returnCode == AGSA_RC_SUCCESS)
5938     {
5939         tiStatus = tiSuccess;
5940     }
5941     else if (returnCode == AGSA_RC_BUSY)
5942     {
5943         tiStatus = tiBusy;
5944     }
5945     else
5946     {
5947         tiStatus = tiError;
5948     }
5949 */
5950     return(tiStatus);
5951 }
5952
5953 /*****************************************************************************
5954 *
5955 * tiCOMEncryptSelfTest
5956 *
5957 *  Purpose:  This function starts the encryption self test. For the encryption self test, IOs must be quiesced.
5958 *                The completion of this function is via ostiPortEvent().
5959 *
5960 *  Parameters:
5961 *
5962 *    tiRoot:      Pointer to driver/port instance.
5963 *    type:        Types of test
5964                       0x1: tiBISTTest
5965                       0x2: tiHMACTest
5966                       Others are reserved.
5967 *    length:
5968                    Size of the test descriptor in bytes, e.g.,
5969                    Sizeof(tiEncryptSelfTestDescriptor_t)
5970                    Sizeof(tiEncryptHMACTestDescriptor_t)
5971 *    TestDescriptor       address of the test descriptor structure.
5972 *
5973 *  Return:
5974 *   tiSuccess     The request is being processed
5975 *   tiError          An invalid parameter was specified
5976 *   tiBusy          A encrytion operation is already in progress
5977 *
5978 *****************************************************************************/
5979 osGLOBAL bit32 tiCOMEncryptSelfTest(
5980                         tiRoot_t  *tiRoot,
5981                         bit32      type,
5982                         bit32      length,
5983                         void      *TestDescriptor
5984                         )
5985 {
5986   tdsaRoot_t     *tdsaRoot       = agNULL;
5987   tdsaContext_t  *tdsaAllShared  = agNULL;
5988   agsaRoot_t     *agRoot         = agNULL;
5989
5990   bit32           returnCode     = AGSA_RC_BUSY;
5991   bit32           tiStatus       = tiError;
5992
5993   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
5994   TD_ASSERT(tdsaRoot != agNULL, "tdsaRoot is NULL !!!");
5995
5996   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5997   TD_ASSERT(tdsaAllShared != agNULL, "tdsaAllShared is NULL !!!");
5998
5999   agRoot = &(tdsaAllShared->agRootNonInt);
6000   TD_ASSERT(agRoot != agNULL, "agRoot is NULL !!!");
6001
6002   TI_DBG1(("tiCOMEncryptSelfTest: type =  0x%x length = 0x%x\n", type, length));
6003
6004   /*do some sanity checking */
6005   if ( ((type == TI_ENCRYPTION_TEST_TYPE_BIST) && (length != sizeof(tiEncryptSelfTestDescriptor_t )))  ||
6006        ((type == TI_ENCRYPTION_TEST_TYPE_HMAC) && (length != sizeof(tiEncryptHMACTestDescriptor_t))) )
6007   {
6008     TI_DBG1(("tiCOMEncryptSelfTest: type or length error, type 0x%x length 0x%x\n", type, length));
6009     tiStatus = tiError;
6010   }
6011   else
6012   {
6013     returnCode = saEncryptSelftestExecute(agRoot,
6014                                       agNULL,
6015                                       0,
6016                                       type,
6017                                       length,
6018                                       TestDescriptor
6019                                       );
6020
6021     if (returnCode == AGSA_RC_SUCCESS)
6022     {
6023       tiStatus = tiSuccess;
6024     }
6025     else if (returnCode == AGSA_RC_BUSY)
6026     {
6027       tiStatus = tiBusy;
6028     }
6029     else
6030     {
6031       tiStatus = tiError;
6032     }
6033   }
6034
6035   return(tiStatus);
6036 }
6037
6038 /*****************************************************************************
6039 *
6040 * tiCOMSetOperator
6041 *
6042 *  Purpose:  This function is called to login to or logout out from the controller by an operator.
6043                   The status is reported via ostiPortEvent().
6044 *
6045 *  Parameters:
6046 *
6047 *    tiRoot:      Pointer to driver/port instance.
6048 *    flag:         operator flag.
6049                      Bits 0-3: Access type (ACS)
6050                        0x1: Login
6051                        0x2: Logout
6052                        All others are reserved.
6053                      Bit 4: KEYopr pinned in the KEK table (PIN)
6054                        0: Not pinned. Operator ID table will be searched during authentication.
6055                        1: Pinned. OPRIDX is referenced to unwrap the certificate.
6056                      Bits 5-7: Reserved
6057                      Bits 8-15: KEKopr Index in the KEK Table (OPRIDX). If KEKopr is pinned in the KEK table, OPRIDX is to reference the KEK for authentication
6058                      Bits 16-31: Reserved.
6059
6060      cert:         The pointer to the operator's certificate. The size of the certificate is 40 bytes.
6061 *
6062 *  Return:
6063 *   tiSuccess     Log in or log out was started.
6064 *   tiError          Log in or log out was not started.
6065 *   tiBusy          A operator management operation is already in progress
6066 *
6067 *****************************************************************************/
6068 osGLOBAL bit32 tiCOMSetOperator(
6069                         tiRoot_t      *tiRoot,
6070                         bit32          flag,
6071                         void          *cert
6072                         )
6073 {
6074   tdsaRoot_t     *tdsaRoot       = agNULL;
6075   tdsaContext_t  *tdsaAllShared  = agNULL;
6076   agsaRoot_t     *agRoot         = agNULL;
6077
6078   bit32           returnCode     = AGSA_RC_FAILURE;
6079   bit32           tiStatus       = tiError;
6080
6081   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
6082   TD_ASSERT(tdsaRoot != agNULL, "tdsaRoot is NULL !!!");
6083
6084   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6085   TD_ASSERT(tdsaAllShared != agNULL, "tdsaAllShared is NULL !!!");
6086
6087   agRoot = &(tdsaAllShared->agRootNonInt);
6088   TD_ASSERT(agRoot != agNULL, "agRoot is NULL !!!");
6089
6090   TI_DBG1(("tiCOMSetOperator: flag =  0x%x \n", flag));
6091
6092   returnCode = saSetOperator(agRoot,
6093                              agNULL,
6094                              0,
6095                              flag,
6096                              cert);
6097
6098   if (returnCode == AGSA_RC_SUCCESS)
6099   {
6100     tiStatus = tiSuccess;
6101   }
6102   else if (returnCode == AGSA_RC_BUSY)
6103   {
6104     tiStatus = tiBusy;
6105   }
6106   else
6107   {
6108     tiStatus = tiError;
6109   }
6110
6111   return(tiStatus);
6112 }
6113
6114 /*****************************************************************************
6115 *
6116 * tiCOMGetOperator
6117 *
6118 *  Purpose:  This function is used to retrieve the role and ID of the current operator or all operators.
6119                   The status is reported via ostiPortEvent().
6120 *
6121 *  Parameters:
6122 *
6123 *    tiRoot:      Pointer to driver/port instance.
6124 *    option:     Types of get operations
6125                        0x1: Current operator only
6126                        0x2: All operators
6127                        All others are reserved.
6128       AddrHi      Upper 32-bit host physical address to store operator certificates.
6129                     This field is used only when option is 0x2
6130       AddrLo     Lower 32-bit host physical address to store operator certificates.
6131                     This field is used only when option is 0x2
6132 *
6133 *  Return:
6134 *   tiSuccess     The operation was started..
6135 *   tiError          The operation was not started.
6136 *   tiBusy          A operator management operation is already in progress
6137 *
6138 *****************************************************************************/
6139 osGLOBAL bit32 tiCOMGetOperator(
6140                            tiRoot_t   *tiRoot,
6141                            bit32       option,
6142                            bit32       AddrHi,
6143                            bit32       AddrLo
6144                            )
6145 {
6146   tdsaRoot_t     *tdsaRoot       = agNULL;
6147   tdsaContext_t  *tdsaAllShared  = agNULL;
6148   agsaRoot_t     *agRoot         = agNULL;
6149
6150   bit32           returnCode     = AGSA_RC_FAILURE;
6151   bit32           tiStatus       = tiError;
6152
6153   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
6154   TD_ASSERT(tdsaRoot != agNULL, "tdsaRoot is NULL !!!");
6155
6156   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6157   TD_ASSERT(tdsaAllShared != agNULL, "tdsaAllShared is NULL !!!");
6158
6159   agRoot = &(tdsaAllShared->agRootNonInt);
6160   TD_ASSERT(agRoot != agNULL, "agRoot is NULL !!!");
6161
6162   TI_DBG1(("tiCOMGetOperator: option = 0x%x \n", option));
6163
6164   returnCode = saGetOperator(agRoot,
6165                              agNULL,
6166                              0,
6167                              option,
6168                              AddrHi,
6169                              AddrLo);
6170
6171   if (returnCode == AGSA_RC_SUCCESS)
6172   {
6173     tiStatus = tiSuccess;
6174   }
6175   else if (returnCode == AGSA_RC_BUSY)
6176   {
6177     tiStatus = tiBusy;
6178   }
6179   else
6180   {
6181     tiStatus = tiError;
6182   }
6183
6184   return(tiStatus);
6185 }
6186
6187 /*****************************************************************************
6188 *
6189 * tiCOMOperationManagement
6190 *
6191 *  Purpose:  this function is used to manage operators,  e.g. adding or deleting an operator..
6192 *
6193 *  Parameters:
6194 *
6195 *   tiRoot:      Pointer to driver/port instance.
6196 *   flag:         operation flag.
6197                     Bits 0-7: Operator Management Operation(OMO)
6198                        0: Add an operator.
6199                        1: Delete an operator.
6200                        2: Delete all operators.
6201                        Others are reserved.
6202                     Bit 8: Pinned to KEK RAM (PKR)
6203                       0: Operator's KEK is stored in the operator ID table(OID_TLB) only.
6204                       1: Operator's KEK is pinned to the internal KEK RAM (1 of the 16 entries) and is also stored in OID_TLB.
6205                     Bits 9-10: KEKopr blob format (KBF)
6206                       00b: Reserved.
6207                       01b: AGSA_ENCRYPTED_KEK_PMCA.
6208                       10b: AGSA_ENCRYPTED_KEK_PMCB.
6209                       11b: Reserved.
6210                     Bits 11-15: Reserved
6211                     Bits 16-23: KEKauth Index in the KEK Table (AUTIDX)
6212                     Bits 24-31: KEKopr Index in the KEK Table (OPRIDX). This field is valid only when PKR is 1.
6213
6214        role        Role
6215                        01b: Crypto officer role.
6216                        10b: User role.
6217                        All others are reserved.
6218
6219 *    idString:         Pointer to the tiID_t structure describing the ID string
6220 *    kekBlob          Pointer to the tiEncryptKekBlob_t structure describing KBLOB.
6221 *
6222 *  Return:
6223 *   tiSuccess     The request is being processed
6224 *   tiError          An invalid parameter was specified
6225 *   tiBusy          A operator management operation is already in progress
6226 *
6227 *****************************************************************************/
6228 osGLOBAL bit32 tiCOMOperatorManagement(
6229                         tiRoot_t            *tiRoot,
6230                         bit32                flag,
6231                         bit8                 role,
6232                         tiID_t              *idString,
6233                         tiEncryptKekBlob_t  *kekBlob
6234                         )
6235 {
6236   tdsaRoot_t     *tdsaRoot       = agNULL;
6237   tdsaContext_t  *tdsaAllShared  = agNULL;
6238   agsaRoot_t     *agRoot         = agNULL;
6239
6240   bit32           returnCode     = AGSA_RC_BUSY;
6241   bit32           tiStatus       = tiError;
6242
6243   tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
6244   TD_ASSERT(tdsaRoot != agNULL, "tdsaRoot is NULL !!!");
6245
6246   tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6247   TD_ASSERT(tdsaAllShared != agNULL, "tdsaAllShared is NULL !!!");
6248
6249   agRoot = &(tdsaAllShared->agRootNonInt);
6250   TD_ASSERT(agRoot != agNULL, "agRoot is NULL !!!");
6251
6252   TI_DBG1(("tiCOMOperatorManagement: flag =  0x%x role = 0x%x\n", flag, role));
6253
6254   returnCode = saOperatorManagement(agRoot,
6255                                     agNULL,
6256                                     0,
6257                                     flag,
6258                                     role,
6259                                     (agsaID_t*)idString,
6260                                     (agsaEncryptKekBlob_t *)kekBlob
6261                                     );
6262
6263   if (returnCode == AGSA_RC_SUCCESS)
6264   {
6265     tiStatus = tiSuccess;
6266   }
6267   else if (returnCode == AGSA_RC_BUSY)
6268   {
6269     tiStatus = tiBusy;
6270   }
6271   else
6272   {
6273     tiStatus = tiError;
6274   }
6275
6276   return(tiStatus);
6277 }
6278
6279 /*****************************************************************************
6280 *! \brief tdssRemoveSASSATAFromSharedcontext
6281 *
6282 *  Purpose:  This function removes all discovered devices belonging to
6283 *            a given portcontext from device list
6284 *
6285 *
6286 *  \param   agRoot                   Pointer to the root data structure of
6287 *                                    TD and Lower layer
6288 *  \param   tsddPortContext_Instance Pointer to the target port context
6289 *
6290 *  \Return: none
6291 *
6292 *****************************************************************************/
6293 #ifdef INITIATOR_DRIVER                     /*TBD: added to compile tgt_drv. (TP)*/
6294 osGLOBAL void
6295 tdssRemoveSASSATAFromSharedcontext(
6296                           agsaRoot_t           *agRoot,
6297                           tdsaPortContext_t    *PortContext_Instance
6298                           )
6299 {
6300   tdsaDeviceData_t  *oneDeviceData = agNULL;
6301   tdList_t          *DeviceListList;
6302   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6303   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6304   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6305   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6306
6307   TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: start\n"));
6308   TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: pid %d\n", PortContext_Instance->id));
6309
6310   /* find oneDeviceData belonging to the portcontext */
6311   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6312   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6313   {
6314     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6315     if (oneDeviceData == agNULL)
6316     {
6317       TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: oneDeviceData is NULL!!!\n"));
6318       return;
6319     }
6320     if (oneDeviceData->tdPortContext == PortContext_Instance)
6321     {
6322       TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: pid %d did %d\n", PortContext_Instance->id, oneDeviceData->id));
6323       TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
6324       TI_DBG1(("tdssRemoveSASSATAFromSharedcontext: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
6325
6326       /* reset valid bit */
6327       oneDeviceData->valid = agFALSE;
6328       oneDeviceData->valid2 = agFALSE;
6329       oneDeviceData->registered = agFALSE;
6330       /* notify only reported devices to OS layer*/
6331       if ( DEVICE_IS_SSP_TARGET(oneDeviceData) ||
6332            DEVICE_IS_STP_TARGET(oneDeviceData) ||
6333            DEVICE_IS_SATA_DEVICE(oneDeviceData)
6334         )
6335       {
6336         ostiInitiatorEvent(
6337                          tiRoot,
6338                          PortContext_Instance->tiPortalContext,
6339                          &(oneDeviceData->tiDeviceHandle),
6340                          tiIntrEventTypeDeviceChange,
6341                          tiDeviceRemoval,
6342                          agNULL
6343                          );
6344       }
6345       DeviceListList = DeviceListList->flink;
6346     /* to-do: deregister */
6347 #ifdef REMOVED  /* don't remove device from the device list. May screw up ordering */
6348       TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
6349       TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
6350 #endif
6351     }
6352     else
6353     {
6354       TI_DBG6(("tdssRemoveSASSATAFromSharedcontext: move to the next\n"));
6355       DeviceListList = DeviceListList->flink;
6356     }
6357   } /* while */
6358
6359   return;
6360 }
6361
6362 /*****************************************************************************
6363 *! \brief tdssRemoveSASSATAFromSharedcontextByReset
6364 *
6365 *  Purpose:  This function removes all ports and discovered devices
6366 *
6367 *
6368 *  \param   agRoot                   Pointer to the root data structure of
6369 *                                    TD and Lower layer
6370 *
6371 *  \Return: none
6372 *
6373 *****************************************************************************/
6374 osGLOBAL void
6375 tdssRemoveSASSATAFromSharedcontextByReset(
6376                                           agsaRoot_t           *agRoot
6377                                           )
6378 {
6379   tdsaPortContext_t *onePortContext = agNULL;
6380   tdsaDeviceData_t  *oneDeviceData = agNULL;
6381   tdList_t          *PortContextList;
6382   tdList_t          *DeviceListList;
6383   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6384   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6385   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6386   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6387 #ifdef FDS_DM
6388   dmRoot_t          *dmRoot = agNULL;
6389   dmPortContext_t   *dmPortContext = agNULL;
6390   dmPortInfo_t      dmPortInfo;
6391 #endif
6392 #ifdef FDS_SM
6393   smRoot_t          *smRoot = &(tdsaAllShared->smRoot);
6394   smDeviceHandle_t  *smDeviceHandle = agNULL;
6395   agsaDevHandle_t   *agDevHandle = agNULL;
6396 #endif
6397
6398   TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: start\n"));
6399
6400 #ifdef FDS_DM
6401   dmRoot = &(tdsaAllShared->dmRoot);
6402 #endif
6403   /* looping throuhg all portcontext */
6404   PortContextList = tdsaAllShared->MainPortContextList.flink;
6405   while (PortContextList != &(tdsaAllShared->MainPortContextList))
6406   {
6407     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
6408     if (onePortContext == agNULL)
6409     {
6410       TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: onePortContext is NULL!!!\n"));
6411       return;
6412     }
6413     TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: oneportContext pid %d\n", onePortContext->id));
6414     TI_DBG3(("tdssRemoveSASSATAFromSharedcontextByReset: sasAddressHi 0x%08x\n", onePortContext->sasLocalAddressHi));
6415     TI_DBG3(("tdssRemoveSASSATAFromSharedcontextByReset: sasAddressLo 0x%08x\n", onePortContext->sasLocalAddressLo));
6416 #ifdef FDS_DM
6417     if (onePortContext->UseDM == agTRUE)
6418     {
6419       dmPortContext = &(onePortContext->dmPortContext);
6420       dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo);
6421     }
6422 #endif
6423
6424     tdsaPortContextReInit(tiRoot, onePortContext);
6425
6426     PortContextList = PortContextList->flink;
6427     tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
6428     TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
6429     TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
6430     tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
6431   }
6432
6433   /* reinitialize the device data belonging to this portcontext */
6434   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6435   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6436   {
6437     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6438     if (oneDeviceData == agNULL)
6439     {
6440       TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: oneDeviceData is NULL!!!\n"));
6441       return;
6442     }
6443
6444     TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: did %d\n", oneDeviceData->id));
6445     TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
6446     TI_DBG1(("tdssRemoveSASSATAFromSharedcontextByReset: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
6447
6448 #ifdef FDS_SM
6449     agDevHandle = oneDeviceData->agDevHandle;
6450     smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
6451     smDeregisterDevice(smRoot, agDevHandle, smDeviceHandle);
6452 #endif
6453
6454     tdsaDeviceDataReInit(tiRoot, oneDeviceData);
6455
6456     DeviceListList = DeviceListList->flink;
6457     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6458     osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
6459     TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
6460     TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
6461     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6462     /* no dequeue from Mainlink for consistant ordering of devices */
6463   }
6464
6465
6466   return;
6467 }
6468
6469 #endif
6470
6471
6472 /*****************************************************************************
6473 *! \brief tdssAddSASToSharedcontext
6474 *
6475 *  Purpose:  This function adds a discovered device to a device list of
6476 *            a shared context
6477 *
6478 *  \param   tsddPortContext_Instance Pointer to the target port context
6479 *  \param   agRoot                   Pointer to the root data structure of
6480 *                                    TD and Lower layer
6481 *  \param   agDevHandle              Pointer to a device handle
6482 *
6483 *  \Return: none
6484 *
6485 *****************************************************************************/
6486 osGLOBAL void
6487 tdssAddSASToSharedcontext(
6488                           tdsaPortContext_t    *tdsaPortContext_Instance,
6489                           agsaRoot_t           *agRoot,
6490                           agsaDevHandle_t      *agDevHandle, /* this is NULL */
6491                           tdsaSASSubID_t       *agSASSubID,
6492                           bit32                 registered, /* no longer in use */
6493                           bit8                  phyID,
6494                           bit32                 flag
6495                           )
6496 {
6497
6498   tdsaPortContext_t *onePortContext = agNULL;
6499   tdList_t          *PortContextList;
6500   tdsaDeviceData_t  *oneDeviceData = agNULL;
6501   tdList_t          *DeviceListList;
6502   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6503   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6504   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6505   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6506   bit32             new_device = agTRUE;
6507   bit32             Indenom = tdsaAllShared->QueueConfig.numInboundQueues;
6508   bit32             Outdenom = tdsaAllShared->QueueConfig.numOutboundQueues;
6509   bit8              dev_s_rate = 0;
6510   bit8              sasorsata = 1;
6511   bit8              connectionRate;
6512   bit32             found = agFALSE;
6513
6514   TI_DBG3(("tdssAddSASToSharedcontext: start\n"));
6515   /*
6516     find a right portcontext
6517     then, get devicedata from FreeLink in DeviceList
6518     then, do pointer operations
6519     then, add the devicedata to the portcontext
6520   */
6521
6522   /* find a right portcontext */
6523   PortContextList = tdsaAllShared->MainPortContextList.flink;
6524   while (PortContextList != &(tdsaAllShared->MainPortContextList))
6525   {
6526     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
6527     if (onePortContext == tdsaPortContext_Instance)
6528     {
6529       TI_DBG3(("tdssAddSASToSharedContext: found; oneportContext ID %d\n", onePortContext->id));
6530       found = agTRUE;
6531       break;
6532     }
6533     PortContextList = PortContextList->flink;
6534   }
6535
6536   if (found == agTRUE)
6537   {
6538     TI_DBG3(("tdssAddSASToSharedcontext: found pid %d\n", onePortContext->id));
6539   }
6540   else
6541   {
6542     TI_DBG1(("tdssAddSASToSharedcontext: Error!!! no portcontext found!!!\n"));
6543     return;
6544   }
6545
6546   /* find a device's existence */
6547   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6548   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6549   {
6550     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6551     if (oneDeviceData == agNULL)
6552     {
6553       TI_DBG1(("tdssAddSASToSharedcontext: oneDeviceData is NULL!!!\n"));
6554       return;
6555     }
6556     if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) &&
6557         (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) &&
6558         (oneDeviceData->tdPortContext == onePortContext)
6559          )
6560     {
6561       TI_DBG1(("tdssAddSASToSharedcontext: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
6562       new_device = agFALSE;
6563       break;
6564     }
6565     DeviceListList = DeviceListList->flink;
6566   }
6567
6568   /* new device */
6569   if (new_device == agTRUE)
6570   {
6571     TI_DBG3(("tdssAddSASToSharedcontext: new device\n"));
6572
6573     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6574     if (!TDLIST_NOT_EMPTY(&(tdsaAllShared->FreeDeviceList)))
6575     {
6576       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6577       TI_DBG1(("tdssAddSASToSharedContext: empty DeviceData FreeLink\n"));
6578       return;
6579     }
6580
6581     TDLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(tdsaAllShared->FreeDeviceList));
6582     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6583     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, DeviceListList);
6584
6585     TI_DBG3(("tdssAddSASToSharedcontext: oneDeviceData %p\n", oneDeviceData));
6586
6587     onePortContext->Count++;
6588     oneDeviceData->DeviceType = TD_SAS_DEVICE;
6589     oneDeviceData->agRoot = agRoot;
6590
6591     if (flag == TD_OPERATION_TARGET)
6592     {
6593       oneDeviceData->agDevHandle = agDevHandle;
6594       agDevHandle->osData = oneDeviceData; /* TD layer */
6595     }
6596
6597     /* saving sas address */
6598     oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo;
6599     oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi;
6600     oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp;
6601     oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp;
6602
6603     oneDeviceData->tdPortContext = onePortContext;
6604     oneDeviceData->valid = agTRUE;
6605
6606     /* new */
6607     oneDeviceData->directlyAttached = agTRUE;
6608     /* parse sasIDframe to fill in agDeviceInfo */
6609     DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
6610     DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)tdsaAllShared->itNexusTimeout);
6611     DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, 0);
6612     /* enable TLR */
6613     DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
6614
6615     sasorsata = SAS_DEVICE_TYPE; /* SAS target (SAS disk or expander) */
6616     connectionRate = onePortContext->LinkRate;
6617     dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4));
6618     dev_s_rate = (bit8)(dev_s_rate | connectionRate);
6619     DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
6620
6621
6622     DEVINFO_PUT_SAS_ADDRESSLO(
6623                               &oneDeviceData->agDeviceInfo,
6624                               agSASSubID->sasAddressLo
6625                               );
6626     DEVINFO_PUT_SAS_ADDRESSHI(
6627                               &oneDeviceData->agDeviceInfo,
6628                               agSASSubID->sasAddressHi
6629                               );
6630
6631     oneDeviceData->agContext.osData = oneDeviceData;
6632     oneDeviceData->agContext.sdkData = agNULL;
6633
6634     if (flag == TD_OPERATION_INITIATOR)
6635     {
6636       if (oneDeviceData->registered == agFALSE )
6637       {
6638         if( tdsaAllShared->sflag )
6639         {
6640           if( ! DEVICE_IS_SMP_TARGET(oneDeviceData))
6641           {
6642             TI_DBG1(("tdssAddSASToSharedcontext: First, saRegisterNewDevice sflag %d\n", tdsaAllShared->sflag));
6643             oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | TD_XFER_RDY_PRIORTY_DEVICE_FLAG;
6644           }
6645         }
6646
6647         saRegisterNewDevice( /* tdssAddSASToSharedcontext */
6648                             agRoot,
6649                             &oneDeviceData->agContext,
6650                             0,
6651                             &oneDeviceData->agDeviceInfo,
6652                             onePortContext->agPortContext,
6653                             0
6654                            );
6655       }
6656     }
6657     oneDeviceData->phyID = phyID;
6658     oneDeviceData->InQID = oneDeviceData->id % Indenom;
6659
6660 #ifdef TARGET_DRIVER
6661     {
6662       bit32 localId = oneDeviceData->id;
6663       localId += 1;
6664       oneDeviceData->OutQID = localId % Outdenom;
6665       TI_DBG1(("tdssAddSASToSharedcontext: OutQID %d\n", oneDeviceData->OutQID)); /* tdsaRotateQnumber for tgt*/
6666
6667     }
6668 #endif /* TARGET_DRIVER */
6669
6670     TI_DBG4(("tdssAddSASToSharedcontext: SSP target %d STP target %d SATA device %d\n", DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
6671     /* add the devicedata to the portcontext */
6672     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6673     TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList));
6674     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6675     TI_DBG4(("tdssAddSASToSharedContext: one case pid %d did %d \n", onePortContext->id, oneDeviceData->id));
6676     TI_DBG4(("tdssAddSASToSharedContext: new case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
6677
6678   }
6679   else /* old device */
6680   {
6681     TI_DBG3(("tdssAddSASToSharedcontext: old device\n"));
6682     TI_DBG3(("tdssAddSASToSharedcontext: oneDeviceData %p\n", oneDeviceData));
6683
6684     oneDeviceData->DeviceType = TD_SAS_DEVICE;
6685     oneDeviceData->agRoot = agRoot;
6686
6687     if (flag == TD_OPERATION_TARGET)
6688     {
6689       oneDeviceData->agDevHandle = agDevHandle;
6690       agDevHandle->osData = oneDeviceData; /* TD layer */
6691     }
6692
6693     /* saving sas address */
6694     oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo;
6695     oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi;
6696     oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp;
6697     oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp;
6698
6699
6700     oneDeviceData->tdPortContext = onePortContext;
6701     oneDeviceData->valid = agTRUE;
6702
6703     oneDeviceData->directlyAttached = agTRUE;
6704     /* new */
6705     if (oneDeviceData->registered == agFALSE)
6706     {
6707       TI_DBG1(("tdssAddSASToSharedcontext: registering\n"));
6708       /* parse sasIDframe to fill in agDeviceInfo */
6709       DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
6710       DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)tdsaAllShared->itNexusTimeout);
6711       DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, 0);
6712       DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
6713
6714       sasorsata = SAS_DEVICE_TYPE; /* SAS target (SAS disk or expander) */
6715       connectionRate = onePortContext->LinkRate;
6716       dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4));
6717       dev_s_rate = (bit8)(dev_s_rate | connectionRate);
6718       DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
6719
6720
6721       DEVINFO_PUT_SAS_ADDRESSLO(
6722                                 &oneDeviceData->agDeviceInfo,
6723                                 agSASSubID->sasAddressLo
6724                                 );
6725       DEVINFO_PUT_SAS_ADDRESSHI(
6726                                 &oneDeviceData->agDeviceInfo,
6727                                 agSASSubID->sasAddressHi
6728                                 );
6729
6730       oneDeviceData->agContext.osData = oneDeviceData;
6731       oneDeviceData->agContext.sdkData = agNULL;
6732
6733       if (flag == TD_OPERATION_INITIATOR)
6734       {
6735         if( tdsaAllShared->sflag )
6736         {
6737           if( ! DEVICE_IS_SMP_TARGET(oneDeviceData))
6738           {
6739             TI_DBG1(("tdssAddSASToSharedcontext: Second, saRegisterNewDevice sflag %d\n", tdsaAllShared->sflag));
6740             oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | TD_XFER_RDY_PRIORTY_DEVICE_FLAG;
6741           }
6742         }
6743         saRegisterNewDevice( /* tdssAddSASToSharedcontext */
6744                             agRoot,
6745                             &oneDeviceData->agContext,
6746                             0,
6747                             &oneDeviceData->agDeviceInfo,
6748                             onePortContext->agPortContext,
6749                             0
6750                             );
6751       }
6752     }
6753
6754
6755
6756
6757
6758
6759     oneDeviceData->phyID = phyID;
6760     oneDeviceData->InQID = oneDeviceData->id % Indenom;
6761     oneDeviceData->OutQID = oneDeviceData->id % Outdenom;
6762
6763     TI_DBG1(("tdssAddSASToSharedcontext: A OutQID %d\n", oneDeviceData->OutQID));
6764     TI_DBG4(("tdssAddSASToSharedcontext: SSP target %d STP target %d SATA device %d\n", DEVICE_IS_SSP_TARGET(oneDeviceData), DEVICE_IS_STP_TARGET(oneDeviceData), DEVICE_IS_SATA_DEVICE(oneDeviceData)));
6765     TI_DBG4(("tdssAddSASToSharedContext: old case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
6766   }
6767
6768   return;
6769 }
6770
6771
6772
6773
6774 /*****************************************************************************
6775 *! \brief tdssRemoveDevicedataFromSharedcontext
6776 *
6777 *  Purpose:  This function removes a discovered device from a device list of
6778 *            a port context
6779 *
6780 *  \param   tsddPortContext_Ins      Pointer to the target port context
6781 *  \param   tdsaDeviceData_Ins       Pointer to the target device
6782 *  \param   agRoot                   Pointer to the root data structure of
6783 *                                    TD and Lower layer
6784
6785 *
6786 *  \Return: none
6787 *
6788 *****************************************************************************/
6789 osGLOBAL void
6790 tdssRemoveSASFromSharedcontext(
6791                                tdsaPortContext_t *tdsaPortContext_Ins,
6792                                tdsaDeviceData_t  *tdsaDeviceData_Ins,
6793                                agsaRoot_t        *agRoot
6794                                )
6795 {
6796   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6797   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6798   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6799   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6800   tdsaPortContext_t *onePortContext = agNULL;
6801   tdList_t          *PortContextList;
6802   tdsaDeviceData_t  *oneDeviceData = agNULL;
6803   tdList_t          *DeviceListList;
6804   bit32             found = agTRUE;
6805
6806   TI_DBG3(("tdssRemoveSASFromSharedcontext: start\n"));
6807   /* find a right portcontext */
6808   PortContextList = tdsaAllShared->MainPortContextList.flink;
6809   while (PortContextList != &(tdsaAllShared->MainPortContextList))
6810   {
6811     onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
6812     if (onePortContext == agNULL)
6813     {
6814       TI_DBG1(("tdssRemoveDevicedataFromSharedcontext: onePortContext is NULL!!!\n"));
6815       return;
6816     }
6817     if (onePortContext == tdsaPortContext_Ins)
6818     {
6819       TI_DBG4(("tdssRemoveDevicedataFromSharedcontext: found; oneportContext ID %d\n", onePortContext->id));
6820       break;
6821     }
6822     PortContextList = PortContextList->flink;
6823   }
6824
6825   /* find a device's existence */
6826   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6827   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6828   {
6829     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6830     if (oneDeviceData == agNULL)
6831     {
6832       TI_DBG1(("tdssRemoveDevicedataFromSharedcontext: oneDeviceData is NULL!!!\n"));
6833       return;
6834     }
6835     if ((oneDeviceData->SASAddressID.sasAddressHi
6836          == SA_DEVINFO_GET_SAS_ADDRESSHI(&tdsaDeviceData_Ins->agDeviceInfo))
6837         &&
6838         (oneDeviceData->SASAddressID.sasAddressLo ==
6839          SA_DEVINFO_GET_SAS_ADDRESSLO(&tdsaDeviceData_Ins->agDeviceInfo)))
6840     {
6841       TI_DBG4(("tdssRemoveDevicedataFromSharedcontext: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
6842       found = agFALSE;
6843       break;
6844     }
6845     DeviceListList = DeviceListList->flink;
6846   }
6847
6848   if (found == agFALSE)
6849   {
6850     TI_DBG6(("tdssRemoveDevicedataFromSharedcontext: can't find the right devicedata in MainLink\n"));
6851     return;
6852   }
6853
6854   /* remove it and put it back to FreeLink of Devicedata */
6855   TI_DBG6(("tdssRemoveDevicedataFromSharedcontext: removing ... pid %d did %d\n", onePortContext->id, oneDeviceData->id));
6856
6857   /* invalidate the device but keep it on the list for persistency */
6858   oneDeviceData->valid = agFALSE;
6859
6860   return;
6861 }
6862
6863 /*****************************************************************************
6864 *! \brief tdssRemoveAllDevicedataFromPortcontext
6865 *
6866 *  Purpose:  This function removes all discovered devices from a device list of
6867 *            a port context
6868 *
6869 *  \param   tdsaDeviceData           Pointer to a device header
6870 *
6871 *  \Return: none
6872 *
6873 *****************************************************************************/
6874 osGLOBAL void
6875 tdssRemoveAllDevicelistFromPortcontext(
6876                                        tdsaPortContext_t *PortContext_Ins,
6877                                        agsaRoot_t        *agRoot
6878                                        )
6879 {
6880
6881   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6882   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6883   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6884   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6885   tdsaDeviceData_t  *oneDeviceData = agNULL;
6886   tdList_t          *DeviceListList;
6887
6888   TI_DBG6(("tdssRemoveAllDevicedataFromPortcontext: start\n"));
6889
6890   /*
6891     loop through device list and find the matching portcontext. Then invalidate the
6892     matching devices
6893   */
6894   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6895   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6896   {
6897     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6898     if (oneDeviceData == agNULL)
6899     {
6900       TI_DBG1(("tdssRemoveAllDevicelistFromPortcontext: oneDeviceData is NULL!!!\n"));
6901       return;
6902     }
6903     if (oneDeviceData->tdPortContext == PortContext_Ins)
6904     {
6905       TI_DBG4(("tdssRemoveAllDevicelistFromPortcontext: pid %d did %d\n", PortContext_Ins->id, oneDeviceData->id));
6906       PortContext_Ins->Count--;
6907       oneDeviceData->valid = agFALSE;
6908     }
6909     DeviceListList = DeviceListList->flink;
6910   }
6911
6912   return;
6913 }
6914
6915
6916 #ifdef INITIATOR_DRIVER
6917 #ifdef TD_DISCOVER
6918 /*****************************************************************************
6919 *! \brief tdssNewAddSASToSharedcontext
6920 *
6921 *  Purpose:  This function adds a discovered SAS device to a device list of
6922 *            a shared context. Used only in discovery.
6923 *
6924 *  \param   agRoot          Pointer to chip/driver Instance.
6925 *  \param   onePortContext  Pointer to the target port context
6926 *  \param   agSASSubID      Pointer to the SAS identification.
6927 *
6928 *  \Return:
6929 *           Pointer to the device data
6930 *
6931 *****************************************************************************/
6932 osGLOBAL tdsaDeviceData_t *
6933 tdssNewAddSASToSharedcontext(
6934                              agsaRoot_t           *agRoot,
6935                              tdsaPortContext_t    *onePortContext,
6936                              tdsaSASSubID_t       *agSASSubID,
6937                              tdsaDeviceData_t     *oneExpDeviceData,
6938                              bit8                 phyID
6939                              )
6940 {
6941   tdsaDeviceData_t  *oneDeviceData = agNULL;
6942   tdList_t          *DeviceListList;
6943   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
6944   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
6945   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
6946   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6947   bit32             new_device = agTRUE;
6948
6949   TI_DBG3(("tdssNewAddSASToSharedcontext: start\n"));
6950   /*
6951     find a right portcontext
6952     then, get devicedata from FreeLink in DeviceList
6953     then, do pointer operations
6954     then, add the devicedata to the portcontext
6955   */
6956
6957
6958   TI_DBG3(("tdssNewAddSASToSharedcontext: oneportContext ID %d\n", onePortContext->id));
6959   /* find a device's existence */
6960   DeviceListList = tdsaAllShared->MainDeviceList.flink;
6961   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
6962   {
6963     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
6964     if (oneDeviceData == agNULL)
6965     {
6966       TI_DBG1(("tdssNewAddSASToSharedcontext: oneDeviceData is NULL!!!\n"));
6967       return agNULL;
6968     }
6969     if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) &&
6970         (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) &&
6971         (oneDeviceData->tdPortContext == onePortContext)
6972         )
6973     {
6974       TI_DBG3(("tdssNewAddSASToSharedcontext: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
6975       new_device = agFALSE;
6976       break;
6977     }
6978     DeviceListList = DeviceListList->flink;
6979   }
6980
6981   /* new device */
6982   if (new_device == agTRUE)
6983   {
6984     TI_DBG3(("tdssNewAddSASToSharedcontext: new device\n"));
6985     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6986     if (!TDLIST_NOT_EMPTY(&(tdsaAllShared->FreeDeviceList)))
6987     {
6988       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6989       TI_DBG1(("tdssNewAddSASToSharedcontext: empty DeviceData FreeLink\n"));
6990       return agNULL;
6991     }
6992
6993     TDLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(tdsaAllShared->FreeDeviceList));
6994     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6995     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, DeviceListList);
6996
6997     TI_DBG3(("tdssNewAddSASToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
6998
6999     onePortContext->Count++;
7000     oneDeviceData->agRoot = agRoot;
7001     /* saving sas address */
7002     oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo;
7003     oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi;
7004     oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp;
7005     oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp;
7006     oneDeviceData->tdPortContext = onePortContext;
7007     /* handles both SAS target and STP-target, SATA-device */
7008     if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData))
7009     {
7010       oneDeviceData->DeviceType = TD_SAS_DEVICE;
7011     }
7012     else
7013     {
7014       oneDeviceData->DeviceType = TD_SATA_DEVICE;
7015     }
7016
7017     oneDeviceData->ExpDevice = oneExpDeviceData;
7018     /* set phyID only when it has initial value of 0xFF */
7019     if (oneDeviceData->phyID == 0xFF)
7020     {
7021       oneDeviceData->phyID = phyID;
7022     }
7023 #ifdef FDS_DM
7024     oneDeviceData->valid = agTRUE;
7025 #else
7026
7027     /* incremental discovery */
7028     /* add device to incremental-related link. Report using this link
7029        when incremental discovery is done */
7030     if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_INCREMENTAL_START)
7031     {
7032       TI_DBG3(("tdssNewAddSASToSharedcontext: incremental discovery\n"));
7033       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
7034       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
7035       oneDeviceData->valid2 = agTRUE;
7036     }
7037     else
7038     {
7039       TI_DBG3(("tdssNewAddSASToSharedcontext: full discovery\n"));
7040       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
7041       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
7042       oneDeviceData->valid = agTRUE;
7043     }
7044 #endif
7045     /* add the devicedata to the portcontext */
7046     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
7047     TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList));
7048     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7049     TI_DBG4(("tdssNewAddSASToSharedcontext: one case pid %d did %d \n", onePortContext->id, oneDeviceData->id));
7050     TI_DBG4(("tdssNewAddSASToSharedcontext: new case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
7051   }
7052   else /* old device */
7053   {
7054     TI_DBG3(("tdssNewAddSASToSharedcontext: old device\n"));
7055     TI_DBG3(("tdssNewAddSASToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
7056
7057     oneDeviceData->agRoot = agRoot;
7058     /* saving sas address */
7059     oneDeviceData->SASAddressID.sasAddressLo = agSASSubID->sasAddressLo;
7060     oneDeviceData->SASAddressID.sasAddressHi = agSASSubID->sasAddressHi;
7061     oneDeviceData->initiator_ssp_stp_smp = agSASSubID->initiator_ssp_stp_smp;
7062     oneDeviceData->target_ssp_stp_smp = agSASSubID->target_ssp_stp_smp;
7063     oneDeviceData->tdPortContext = onePortContext;
7064     /* handles both SAS target and STP-target, SATA-device */
7065     if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData))
7066     {
7067       oneDeviceData->DeviceType = TD_SAS_DEVICE;
7068     }
7069     else
7070     {
7071       oneDeviceData->DeviceType = TD_SATA_DEVICE;
7072     }
7073
7074     oneDeviceData->ExpDevice = oneExpDeviceData;
7075     /* set phyID only when it has initial value of 0xFF */
7076     if (oneDeviceData->phyID == 0xFF)
7077     {
7078       oneDeviceData->phyID = phyID;
7079     }
7080
7081 #ifdef FDS_DM
7082     oneDeviceData->valid = agTRUE;
7083 #else
7084     if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_INCREMENTAL_START)
7085     {
7086       TI_DBG3(("tdssNewAddSASToSharedcontext: incremental discovery\n"));
7087       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
7088       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
7089       oneDeviceData->valid2 = agTRUE;
7090     }
7091     else
7092     {
7093       TI_DBG3(("tdssNewAddSASToSharedcontext: full discovery\n"));
7094       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
7095       TI_DBG3(("tdssNewAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
7096       oneDeviceData->valid = agTRUE;
7097     }
7098 #endif
7099     TI_DBG4(("tdssNewAddSASToSharedcontext: old case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
7100
7101   }
7102   return oneDeviceData;
7103 }
7104
7105 /*****************************************************************************
7106 *! \brief tdsaFindRegNValid
7107 *
7108 *  Purpose:  This function finds a device which is registered and valid in
7109 *            the device list. Used only in incremental discovery.
7110 *
7111 *  \param   agRoot          Pointer to chip/driver Instance.
7112 *  \param   onePortContext  Pointer to the target port context
7113 *  \param   tdsaDeviceData  Pointer to a device list header
7114 *  \param   agSASSubID      Pointer to the SAS identification.
7115 *
7116 *  \Return:
7117 *           Pointer to the device data
7118 *
7119 *****************************************************************************/
7120 osGLOBAL tdsaDeviceData_t *
7121 tdsaFindRegNValid(
7122                   agsaRoot_t           *agRoot,
7123                   tdsaPortContext_t    *onePortContext,
7124                   tdsaSASSubID_t       *agSASSubID
7125                   )
7126 {
7127   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
7128   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
7129   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7130   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7131   tdsaDeviceData_t  *oneDeviceData = agNULL;
7132   tdList_t          *DeviceListList;
7133   bit32             found = agFALSE;
7134
7135   TI_DBG3(("tdsaFindRegNValid: start\n"));
7136
7137   /* find a device's existence */
7138   DeviceListList = tdsaAllShared->MainDeviceList.flink;
7139   if (onePortContext->discovery.type == TDSA_DISCOVERY_OPTION_FULL_START)
7140   {
7141     TI_DBG3(("tdsaFindRegNValid: Full discovery\n"));
7142     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
7143     {
7144       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
7145       if (oneDeviceData == agNULL)
7146       {
7147         TI_DBG1(("tdsaFindRegNValid: oneDeviceData is NULL!!!\n"));
7148         return agNULL;
7149       }
7150       if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) &&
7151           (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) &&
7152           (oneDeviceData->registered == agTRUE) &&
7153           (oneDeviceData->valid == agTRUE) &&
7154           (oneDeviceData->tdPortContext == onePortContext)
7155           )
7156       {
7157         TI_DBG3(("tdsaFindRegNValid: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
7158         TI_DBG3(("tdsaFindRegNValid: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
7159         TI_DBG3(("tdsaFindRegNValid: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
7160         found = agTRUE;
7161         break;
7162       }
7163       DeviceListList = DeviceListList->flink;
7164     }
7165   }
7166   else
7167   {
7168     /* incremental discovery */
7169     TI_DBG3(("tdsaFindRegNValid: Incremental discovery\n"));
7170     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
7171     {
7172       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
7173       if (oneDeviceData == agNULL)
7174       {
7175         TI_DBG1(("tdsaFindRegNValid: oneDeviceData is NULL!!!\n"));
7176         return agNULL;
7177       }
7178       if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) &&
7179           (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) &&
7180           (oneDeviceData->registered == agTRUE) &&
7181           (oneDeviceData->valid2 == agTRUE) &&
7182           (oneDeviceData->tdPortContext == onePortContext)
7183           )
7184       {
7185         TI_DBG3(("tdsaFindRegNValid: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
7186         TI_DBG3(("tdsaFindRegNValid: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
7187         TI_DBG3(("tdsaFindRegNValid: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
7188         found = agTRUE;
7189         break;
7190       }
7191       DeviceListList = DeviceListList->flink;
7192     }
7193   }
7194
7195
7196
7197   if (found == agFALSE)
7198   {
7199     TI_DBG3(("tdsaFindRegNValid: end returning NULL\n"));
7200     return agNULL;
7201   }
7202   else
7203   {
7204     TI_DBG3(("tdsaFindRegNValid: end returning NOT NULL\n"));
7205     return oneDeviceData;
7206   }
7207
7208 }
7209
7210 //registered to LL or not
7211 /*****************************************************************************
7212 *! \brief tdssNewSASorNot
7213 *
7214 *  Purpose:  This function finds whether a device is registered or not
7215 *
7216 *  \param   agRoot          Pointer to chip/driver Instance.
7217 *  \param   onePortContext  Pointer to the target port context
7218 *  \param   agSASSubID      Pointer to the SAS identification.
7219 *
7220 *  \Return:
7221 *           agTRUE   Device is not registered (New device).
7222 *           agFALSE  Device is registered (Old device).
7223 *
7224 *****************************************************************************/
7225 bit32
7226 tdssNewSASorNot(
7227                                  agsaRoot_t           *agRoot,
7228                                  tdsaPortContext_t    *onePortContext,
7229                                  tdsaSASSubID_t       *agSASSubID
7230                                  )
7231 {
7232   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
7233   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
7234   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7235   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7236   tdsaDeviceData_t  *oneDeviceData = agNULL;
7237   tdList_t          *DeviceListList;
7238   bit32             ret = agTRUE;
7239
7240   TI_DBG3(("tdssNewSASorNot: start\n"));
7241
7242   /* find a device's existence */
7243   DeviceListList = tdsaAllShared->MainDeviceList.flink;
7244   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
7245   {
7246     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
7247     if ((oneDeviceData->SASAddressID.sasAddressHi == agSASSubID->sasAddressHi) &&
7248         (oneDeviceData->SASAddressID.sasAddressLo == agSASSubID->sasAddressLo) &&
7249         (oneDeviceData->registered == agTRUE) &&
7250         (oneDeviceData->tdPortContext == onePortContext)
7251         )
7252     {
7253       TI_DBG3(("tdssNewSASorNot: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
7254       ret = agFALSE;
7255       break;
7256     }
7257     DeviceListList = DeviceListList->flink;
7258   }
7259
7260
7261
7262   TI_DBG3(("tdssNewSASorNot: end\n"));
7263
7264   return ret;
7265 }
7266
7267
7268
7269 /*****************************************************************************
7270 *! \brief  tdssSASDiscoveringExpanderAlloc
7271 *
7272 *  Purpose:  This function allocates an expander from the pre-allocated memory
7273 *            pool.
7274 *
7275 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7276 *                   instance.
7277 *  \param   onePortContext: Pointer to the portal context instance.
7278 *  \param   oneDeviceData:  Pointer to the device data.
7279 *
7280 *  \return:
7281 *           Pointer to expander on success
7282 *           agNULL              on failure
7283 *
7284 *   \note:
7285 *
7286 *****************************************************************************/
7287 osGLOBAL tdsaExpander_t *
7288 tdssSASDiscoveringExpanderAlloc(
7289                                 tiRoot_t                 *tiRoot,
7290                                 tdsaPortContext_t        *onePortContext,
7291                                 tdsaDeviceData_t         *oneDeviceData
7292                                 )
7293 {
7294   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7295   tdsaContext_t     *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7296   tdsaExpander_t    *oneExpander = agNULL;
7297   tdList_t          *ExpanderList;
7298
7299   /*
7300     move the expander from freeExpanderList
7301     and ground the expander by TDLIST_DEQUEUE_THIS
7302   */
7303
7304
7305   TI_DBG3(("tdssSASDiscoveringExpanderAlloc: start\n"));
7306   TI_DBG3(("tdssSASDiscoveringExpanderAlloc: did %d\n", oneDeviceData->id));
7307   TI_DBG3(("tdssSASDiscoveringExpanderAlloc: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
7308   TI_DBG3(("tdssSASDiscoveringExpanderAlloc: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
7309
7310   if (onePortContext->valid == agFALSE)
7311   {
7312     TI_DBG1(("tdssSASDiscoveringExpanderAlloc: aborting discovery\n"));
7313     tdsaSASDiscoverAbort(tiRoot, onePortContext);
7314     return agNULL;
7315   }
7316
7317   tdsaDumpAllFreeExp(tiRoot);
7318
7319   if (TDLIST_EMPTY(&(tdsaAllShared->freeExpanderList)))
7320   {
7321     TI_DBG1(("tdssSASDiscoveringExpanderAlloc: no free expanders\n"));
7322     return agNULL;
7323   }
7324
7325   tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
7326   TDLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(tdsaAllShared->freeExpanderList));
7327   tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
7328   //  oneExpander = TDLIST_OBJECT_BASE(tdsaContext_t, freeExpanderList, ExpanderList);
7329   oneExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
7330
7331   if (oneExpander != agNULL)
7332   {
7333     TI_DBG3(("tdssSASDiscoveringExpanderAlloc: expander id %d\n", oneExpander->id));
7334
7335     tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
7336     TDLIST_DEQUEUE_THIS(&(oneExpander->linkNode));
7337     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
7338
7339     oneExpander->tdDevice = oneDeviceData;
7340     oneExpander->tdUpStreamExpander = agNULL;
7341     oneExpander->tdCurrentDownStreamExpander = agNULL;
7342     oneExpander->tdReturnginExpander = agNULL;
7343     oneExpander->hasUpStreamDevice = agFALSE;
7344     oneExpander->numOfUpStreamPhys = 0;
7345     oneExpander->currentUpStreamPhyIndex = 0;
7346     oneExpander->discoveringPhyId = 0;
7347     oneExpander->underDiscovering = agFALSE;
7348     osti_memset( &(oneExpander->currentIndex), 0, sizeof(oneExpander->currentIndex));
7349
7350     oneDeviceData->tdExpander = oneExpander;
7351   }
7352
7353   return oneExpander;
7354 }
7355
7356 /*****************************************************************************
7357 *! \brief  tdssSASDiscoveringExpanderAdd
7358 *
7359 *  Purpose:  This function adds an expander to the expander list.
7360 *
7361 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7362 *                   instance.
7363 *  \param   onePortContext: Pointer to the portal context instance.
7364 *  \param   oneExpander: Pointer to the expander data.
7365 *
7366 *  \return:
7367 *           None
7368 *
7369 *   \note:
7370 *
7371 *****************************************************************************/
7372 osGLOBAL void
7373 tdssSASDiscoveringExpanderAdd(
7374                               tiRoot_t                 *tiRoot,
7375                               tdsaPortContext_t        *onePortContext,
7376                               tdsaExpander_t           *oneExpander
7377                               )
7378 {
7379 #ifdef TD_INTERNAL_DEBUG
7380   tdList_t          *ExpanderList;
7381   tdsaExpander_t    *tempExpander;
7382 #endif
7383
7384   /* move the expander to discoveringExpanderList */
7385
7386   TI_DBG3(("tdssSASDiscoveringExpanderAdd: start\n"));
7387   TI_DBG3(("tdssSASDiscoveringExpanderAdd: expander id %d\n", oneExpander->id));
7388   TI_DBG3(("tdssSASDiscoveringExpanderAdd: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
7389   TI_DBG3(("tdssSASDiscoveringExpanderAdd: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
7390
7391   if (onePortContext->valid == agFALSE)
7392   {
7393     TI_DBG1(("tdssSASDiscoveringExpanderAdd: aborting discovery\n"));
7394     tdsaSASDiscoverAbort(tiRoot, onePortContext);
7395     return;
7396   }
7397
7398
7399   if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
7400   {
7401     TI_DBG3(("tdssSASDiscoveringExpanderAdd: UPSTREAM\n"));
7402   }
7403   else if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
7404   {
7405     TI_DBG3(("tdssSASDiscoveringExpanderAdd: DOWNSTREAM\n"));
7406   }
7407   else
7408   {
7409     TI_DBG3(("tdssSASDiscoveringExpanderAdd: status %d\n", onePortContext->discovery.status));
7410   }
7411
7412   TI_DBG3(("tdssSASDiscoveringExpanderAdd: BEFORE\n"));
7413   tdsaDumpAllExp(tiRoot, onePortContext, oneExpander);
7414
7415
7416   if ( oneExpander->underDiscovering == agFALSE)
7417   {
7418     TI_DBG3(("tdssSASDiscoveringExpanderAdd: ADDED \n"));
7419
7420     oneExpander->underDiscovering = agTRUE;
7421     tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
7422     TDLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));
7423     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
7424   }
7425
7426   TI_DBG3(("tdssSASDiscoveringExpanderAdd: AFTER\n"));
7427   tdsaDumpAllExp(tiRoot, onePortContext, oneExpander);
7428
7429 #ifdef TD_INTERNAL_DEBUG
7430   /* debugging */
7431   if (TDLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
7432   {
7433     TI_DBG3(("tdssSASDiscoveringExpanderAdd: empty discoveringExpanderList\n"));
7434     return;
7435   }
7436   ExpanderList = onePortContext->discovery.discoveringExpanderList.flink;
7437   while (ExpanderList != &(onePortContext->discovery.discoveringExpanderList))
7438   {
7439     tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
7440     TI_DBG3(("tdssSASDiscoveringExpanderAdd: expander id %d\n", tempExpander->id));
7441     ExpanderList = ExpanderList->flink;
7442   }
7443 #endif
7444
7445   return;
7446 }
7447
7448 /* temp */
7449 osGLOBAL bit32
7450 tdssSASFindDiscoveringExpander(
7451                tiRoot_t                 *tiRoot,
7452                tdsaPortContext_t        *onePortContext,
7453                tdsaExpander_t           *oneExpander
7454               )
7455 {
7456   tdList_t          *ExpanderList;
7457   tdsaExpander_t    *tempExpander;
7458   tdsaPortContext_t *tmpOnePortContext = onePortContext;
7459   bit32             ret = agFALSE;
7460
7461   TI_DBG3(("tdssSASFindDiscoveringExpander: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
7462   TI_DBG3(("tdssSASFindDiscoveringExpander: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
7463
7464   if (TDLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
7465   {
7466     TI_DBG1(("tdssSASFindDiscoveringExpander: empty discoveringExpanderList\n"));
7467     return ret;
7468   }
7469   ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
7470   while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
7471   {
7472     tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
7473     if (tempExpander == oneExpander)
7474     {
7475       TI_DBG3(("tdssSASFindDiscoveringExpander: match!!! expander id %d\n", tempExpander->id));
7476       TI_DBG3(("tdssSASFindDiscoveringExpander: exp addrHi 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressHi));
7477       TI_DBG3(("tdssSASFindDiscoveringExpander: exp addrLo 0x%08x\n", tempExpander->tdDevice->SASAddressID.sasAddressLo));
7478       ret = agTRUE;
7479       break;
7480     }
7481
7482     ExpanderList = ExpanderList->flink;
7483   }
7484
7485
7486   return ret;
7487
7488 }
7489 /* to be tested */
7490 /* move the expander to freeExpanderList */
7491 /*****************************************************************************
7492 *! \brief  tdssSASDiscoveringExpanderRemove
7493 *
7494 *  Purpose:  This function removes an expander from the expander list.
7495 *
7496 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7497 *                   instance.
7498 *  \param   onePortContext: Pointer to the portal context instance.
7499 *  \param   oneExpander: Pointer to the expander data.
7500 *
7501 *  \return:
7502 *           None
7503 *
7504 *   \note:
7505 *
7506 *****************************************************************************/
7507 osGLOBAL void
7508 tdssSASDiscoveringExpanderRemove(
7509                                  tiRoot_t                 *tiRoot,
7510                                  tdsaPortContext_t        *onePortContext,
7511                                  tdsaExpander_t           *oneExpander
7512                                  )
7513 {
7514   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7515   tdsaContext_t     *tdsaAllShared   = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7516 #ifdef TD_INTERNAL_DEBUG
7517   tdList_t          *ExpanderList;
7518   tdsaExpander_t    *tempExpander;
7519 #endif
7520
7521   TI_DBG3(("tdssSASDiscoveringExpanderRemove: start\n"));
7522   TI_DBG3(("tdssSASDiscoveringExpanderRemove: expander id %d\n", oneExpander->id));
7523   TI_DBG3(("tdssSASDiscoveringExpanderRemove: exp addrHi 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressHi));
7524   TI_DBG3(("tdssSASDiscoveringExpanderRemove: exp addrLo 0x%08x\n", oneExpander->tdDevice->SASAddressID.sasAddressLo));
7525
7526
7527   TI_DBG3(("tdssSASDiscoveringExpanderRemove: BEFORE\n"));
7528   tdsaDumpAllExp(tiRoot, onePortContext, oneExpander);
7529   tdsaDumpAllUpExp(tiRoot, onePortContext, oneExpander);
7530   tdsaDumpAllFreeExp(tiRoot);
7531
7532 #ifdef TD_INTERNAL_DEBUG
7533   /* debugging */
7534   TI_DBG3(("tdssSASDiscoveringExpanderRemove: BEFORE\n"));
7535   if (TDLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
7536   {
7537     TI_DBG3(("tdssSASDiscoveringExpanderRemove: empty discoveringExpanderList\n"));
7538   }
7539   ExpanderList = onePortContext->discovery.discoveringExpanderList.flink;
7540   while (ExpanderList != &(onePortContext->discovery.discoveringExpanderList))
7541   {
7542     tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
7543     TI_DBG3(("tdssSASDiscoveringExpanderRemove: expander id %d\n", tempExpander->id));
7544     ExpanderList = ExpanderList->flink;
7545   }
7546 #endif
7547
7548   // if is temporary till smp problem is fixed
7549   if (tdssSASFindDiscoveringExpander(tiRoot, onePortContext, oneExpander) == agTRUE)
7550   {
7551     oneExpander->underDiscovering = agFALSE;
7552     oneExpander->discoveringPhyId = 0;
7553     tdsaSingleThreadedEnter(tiRoot, TD_DISC_LOCK);
7554     TDLIST_DEQUEUE_THIS(&(oneExpander->linkNode));
7555
7556     if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
7557     {
7558       TI_DBG3(("tdssSASDiscoveringExpanderRemove: DISCOVERY_UP_STREAM\n"));
7559       TDLIST_ENQUEUE_AT_TAIL(&(oneExpander->upNode), &(onePortContext->discovery.UpdiscoveringExpanderList));
7560       onePortContext->discovery.NumOfUpExp++;
7561     }
7562     else
7563     {
7564       TI_DBG3(("tdssSASDiscoveringExpanderRemove: Status %d\n", onePortContext->discovery.status));
7565       TDLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(tdsaAllShared->freeExpanderList));
7566     }
7567
7568     tdsaSingleThreadedLeave(tiRoot, TD_DISC_LOCK);
7569   } //end temp if
7570   else
7571   {
7572     TI_DBG1(("tdssSASDiscoveringExpanderRemove: !!! problem !!!\n"));
7573   }
7574
7575   TI_DBG3(("tdssSASDiscoveringExpanderRemove: AFTER\n"));
7576   tdsaDumpAllExp(tiRoot, onePortContext, oneExpander);
7577   tdsaDumpAllUpExp(tiRoot, onePortContext, oneExpander);
7578
7579   tdsaDumpAllFreeExp(tiRoot);
7580
7581 #ifdef TD_INTERNAL_DEBUG
7582   /* debugging */
7583   TI_DBG3(("tdssSASDiscoveringExpanderRemove: AFTER\n"));
7584   if (TDLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
7585   {
7586     TI_DBG3(("tdssSASDiscoveringExpanderRemove: empty discoveringExpanderList\n"));
7587   }
7588   ExpanderList = onePortContext->discovery.discoveringExpanderList.flink;
7589   while (ExpanderList != &(onePortContext->discovery.discoveringExpanderList))
7590   {
7591     tempExpander = TDLIST_OBJECT_BASE(tdsaExpander_t, linkNode, ExpanderList);
7592     TI_DBG3(("tdssSASDiscoveringExpanderRemove: expander id %d\n", tempExpander->id));
7593     ExpanderList = ExpanderList->flink;
7594   }
7595 #endif
7596
7597   return;
7598 }
7599
7600 #ifdef SATA_ENABLE
7601
7602 /*****************************************************************************
7603 *! \brief tdssNewAddSATAToSharedcontext
7604 *
7605 *  Purpose:  This function adds a discovered SATA device to a device list of
7606 *            a shared context. Used only in discovery.
7607 *
7608 *  \param   tiRoot  Pointer to the OS Specific module allocated tiRoot_t
7609 *                   instance.
7610 *  \param   agRoot          Pointer to chip/driver Instance.
7611 *  \param   onePortContext  Pointer to the target port context
7612 *  \param   tdsaDeviceData  Pointer to a device list header
7613 *  \param   agSATADeviceInfo      Pointer to the SATA device information.
7614 *  \param   Signature       Pointer to SATA signature
7615 *  \param   pm              Port multiplier
7616 *  \param   pmField         Port multiplier field
7617 *  \param   connectionRate  Connection rate
7618 *
7619 *  \Return:
7620 *           Pointer to the device data
7621 *
7622 *****************************************************************************/
7623 osGLOBAL tdsaDeviceData_t *
7624 tdssNewAddSATAToSharedcontext(tiRoot_t             *tiRoot,
7625                               agsaRoot_t           *agRoot,
7626                               tdsaPortContext_t    *onePortContext,
7627                               agsaSATADeviceInfo_t *agSATADeviceInfo,
7628                               bit8                    *Signature,
7629                               bit8                    pm,
7630                               bit8                    pmField,
7631                               bit32                   connectionRate,
7632                               tdsaDeviceData_t        *oneExpDeviceData,
7633                               bit8                    phyID
7634                               )
7635 {
7636   tdsaDeviceData_t  *oneDeviceData = agNULL;
7637   tdList_t          *DeviceListList;
7638   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7639   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7640   int               new_device = agTRUE;
7641
7642   TI_DBG5(("tdssNewAddSATAToSharedcontext: start\n"));
7643
7644
7645
7646   TI_DBG5(("tdssNewAddSATAToSharedcontext: oneportContext ID %d\n", onePortContext->id));
7647
7648
7649 #ifdef RPM_SOC
7650   /* Find a device's existence */
7651   DeviceListList = tdsaAllShared->MainDeviceList.flink;
7652   while (DeviceListList != &(tdsaAllShared->MainDeviceList))
7653   {
7654     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
7655
7656     if ((osti_memcmp (((char *)&oneDeviceData->satDevData.satIdentifyData),
7657                       ((char *)&agSATADeviceInfo->sataIdentifyData),
7658                       sizeof(agsaSATAIdentifyData_t)) == 0))
7659     {
7660       TI_DBG5(("tdssNewAddSATAToSharedcontext: pid %d did %d\n",
7661         onePortContext->id, oneDeviceData->id));
7662       new_device = agFALSE;
7663       break;
7664     }
7665     DeviceListList = DeviceListList->flink;
7666   }
7667 #else
7668
7669
7670 #endif
7671
7672   /* New device */
7673   if (new_device == agTRUE)
7674   {
7675     TI_DBG5(("tdssNewAddSATAToSharedcontext: new device\n"));
7676
7677     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
7678     if (!TDLIST_NOT_EMPTY(&(tdsaAllShared->FreeDeviceList)))
7679     {
7680       tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7681       TI_DBG1(("tdssNewAddSATAToSharedcontext: ERROR empty DeviceData FreeLink\n"));
7682       return oneDeviceData;
7683     }
7684
7685     TDLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(tdsaAllShared->FreeDeviceList));
7686     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7687     oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, DeviceListList);
7688
7689     onePortContext->Count++;
7690     oneDeviceData->DeviceType = TD_SATA_DEVICE;
7691     oneDeviceData->agRoot = agRoot;
7692     TI_DBG5(("tdssNewAddSATAToSharedcontext: oneDeviceData %p\n", oneDeviceData));
7693     TI_DBG5(("tdssNewAddSATAToSharedcontext: pSatDevData=%p\n", &oneDeviceData->satDevData));
7694
7695
7696     /* saving PortMultiplier(PM) field */
7697     oneDeviceData->satDevData.satPMField = pmField;
7698
7699     /* saving signature */
7700     osti_memcpy(&(oneDeviceData->satDevData.satSignature), Signature, 8);
7701
7702     /*
7703       saving device type
7704       ATA device type; here should be either ATA_ATA_DEVICE or ATA_ATAPI_DEVICE
7705     */
7706      oneDeviceData->satDevData.satDeviceType = tdssSATADeviceTypeDecode(agSATADeviceInfo->signature);
7707      TI_DBG3(("tdssNewAddSATAToSharedcontext: device type %d\n",  oneDeviceData->satDevData.satDeviceType));
7708
7709 #ifdef RPM_SOC_REMOVED
7710     /* print device signature - Word8 */
7711     TI_DBG3(("tdssNewAddSATAToSharedcontext: Word8 %x signature: %x %x %x %x %x %x %x %x\n",
7712              agSATADeviceInfo->sataIdentifyData.word1_9[7],
7713              agSATADeviceInfo->signature[0], agSATADeviceInfo->signature[1],
7714              agSATADeviceInfo->signature[2], agSATADeviceInfo->signature[3],
7715              agSATADeviceInfo->signature[4], agSATADeviceInfo->signature[5],
7716              agSATADeviceInfo->signature[6], agSATADeviceInfo->signature[7] ));
7717 #endif
7718
7719
7720
7721     oneDeviceData->tdPortContext = onePortContext;
7722     oneDeviceData->valid = agTRUE;
7723
7724     oneDeviceData->ExpDevice = oneExpDeviceData;
7725     oneDeviceData->phyID = phyID;
7726
7727     /* Add the devicedata to the portcontext */
7728     tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
7729     TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList));
7730     tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7731     TI_DBG5(("tdssNewAddSATAToSharedcontext: one case pid %d did %d \n",
7732       onePortContext->id, oneDeviceData->id));
7733   }
7734   else /* old device */
7735   {
7736     TI_DBG5(("tdssNewAddSATAToSharedcontext: old device\n"));
7737
7738     onePortContext->Count++;
7739
7740     oneDeviceData->DeviceType = TD_SATA_DEVICE;
7741     oneDeviceData->agRoot = agRoot;
7742
7743     oneDeviceData->tdPortContext = onePortContext;
7744     oneDeviceData->valid = agTRUE;
7745
7746     oneDeviceData->ExpDevice = oneExpDeviceData;
7747     oneDeviceData->phyID = phyID;
7748
7749   }
7750
7751   return oneDeviceData;
7752
7753 }
7754 #endif /* SATA_ENABLE */
7755 #endif /* TD_DISCOVER */
7756 #endif /* INITIATOR_DRIVER */
7757
7758 #ifdef TARGET_DRIVER
7759 /*****************************************************************************
7760 *! \brief  tdssReportRemovals
7761 *
7762 *  Purpose:  This function goes through device list and removes all devices
7763 *            belong to the portcontext. This function also deregiters those
7764 *            devices. This function is called in case of incremental discovery
7765 *            failure.
7766 *
7767 *  \param   agRoot        :  Pointer to chip/driver Instance.
7768 *  \param   onePortContext: Pointer to the portal context instance.
7769 *  \param   oneDeviceData: Pointer to the device data.
7770 *
7771 *  \return:
7772 *           None
7773 *
7774 *   \note:
7775 *
7776 *****************************************************************************/
7777 osGLOBAL void
7778 ttdssReportRemovals(
7779                   agsaRoot_t           *agRoot,
7780                   tdsaPortContext_t    *onePortContext,
7781                   bit32                flag
7782                   )
7783 {
7784   tdsaDeviceData_t  *oneDeviceData = agNULL;
7785   tdList_t          *DeviceListList;
7786   tdsaRootOsData_t  *osData = (tdsaRootOsData_t *)agRoot->osData;
7787   tiRoot_t          *tiRoot = (tiRoot_t *)osData->tiRoot;
7788   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
7789   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7790   bit32             removed = agFALSE;
7791   agsaEventSource_t *eventSource;
7792   bit32             PhyID;
7793   bit32             HwAckSatus;
7794   tdsaDeviceData_t  *tmpDeviceData = agNULL;
7795
7796   TI_DBG1(("ttdssReportRemovals: start\n"));
7797   /* in case nothing was registered */
7798   PhyID = onePortContext->eventPhyID;
7799   if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
7800       onePortContext->RegisteredDevNums == 0 &&
7801       PhyID != 0xFF
7802       )
7803   {
7804     TI_DBG1(("ttdssReportRemovals: calling saHwEventAck\n"));
7805     eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
7806     HwAckSatus = saHwEventAck(
7807                               agRoot,
7808                               agNULL, /* agContext */
7809                               0,
7810                               eventSource, /* agsaEventSource_t */
7811                               0,
7812                               0
7813                               );
7814     if ( HwAckSatus != AGSA_RC_SUCCESS)
7815     {
7816       TI_DBG1(("ttdssReportRemovals: failing in saHwEventAck; status %d\n", HwAckSatus));
7817     }
7818
7819     /* toggle */
7820     tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
7821     if (onePortContext->valid == agFALSE)
7822     {
7823       tdsaPortContextReInit(tiRoot, onePortContext);
7824       /*
7825         put all devices belonging to the onePortContext
7826         back to the free link
7827        */
7828       tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
7829       TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
7830       TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
7831       tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
7832     }
7833   }
7834   else
7835   {
7836     if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
7837     {
7838       TI_DBG1(("ttdssReportRemovals: empty device list\n"));
7839       return;
7840     }
7841
7842     DeviceListList = tdsaAllShared->MainDeviceList.flink;
7843     while (DeviceListList != &(tdsaAllShared->MainDeviceList))
7844     {
7845       oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
7846       if( oneDeviceData == agNULL )
7847       {
7848         break;
7849       }
7850       TI_DBG1(("ttdssReportRemovals: loop did %d\n", oneDeviceData->id));
7851       TI_DBG1(("ttdssReportRemovals: sasAddrHi 0x%08x sasAddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
7852       TI_DBG1(("ttdssReportRemovals: valid %d valid2 %d\n", oneDeviceData->valid, oneDeviceData->valid2));
7853       TI_DBG1(("ttdssReportRemovals: directlyAttached %d registered %d\n", oneDeviceData->directlyAttached, oneDeviceData->registered));
7854       if ( oneDeviceData->tdPortContext == onePortContext)
7855       {
7856         TI_DBG1(("ttdssReportRemovals: right portcontext pid %d\n", onePortContext->id));
7857         if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE)
7858         {
7859           TI_DBG1(("ttdssReportRemovals: removing\n"));
7860
7861           /* notify only reported devices to OS layer*/
7862           removed = agTRUE;
7863
7864           /* all targets except expanders */
7865           TI_DBG1(("ttdssReportRemovals: calling tdsaAbortAll\n"));
7866           TI_DBG1(("ttdssReportRemovals: did %d\n", oneDeviceData->id));
7867           TI_DBG1(("ttdssReportRemovals: sasAddrHi 0x%08x sasAddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
7868           tmpDeviceData = oneDeviceData;
7869           ttdsaAbortAll(tiRoot, agRoot, oneDeviceData);
7870
7871
7872           /* reset valid bit */
7873           oneDeviceData->valid = agFALSE;
7874           oneDeviceData->valid2 = agFALSE;
7875           oneDeviceData->registered = agFALSE;
7876         }
7877         /* called by port invalid case */
7878         if (flag == agTRUE)
7879         {
7880           oneDeviceData->tdPortContext = agNULL;
7881         }
7882 #ifdef REMOVED /* removed */
7883         /* directly attached SATA -> always remove it */
7884         if (oneDeviceData->DeviceType == TD_SATA_DEVICE &&
7885             oneDeviceData->directlyAttached == agTRUE)
7886         {
7887           TI_DBG1(("ttdssReportRemovals: device did %d\n", oneDeviceData->id));
7888           tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
7889           TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
7890           TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceLis));
7891           DeviceListList = tdsaAllShared->MainDeviceList.flink;
7892           if (TDLIST_EMPTY(&(tdsaAllShared->MainDeviceList)))
7893           {
7894             tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7895             break;
7896           }
7897           else
7898           {
7899             tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
7900           }
7901         }
7902         else
7903         {
7904           DeviceListList = DeviceListList->flink;
7905         }
7906 #endif /* REMOVED */
7907         DeviceListList = DeviceListList->flink;
7908       }
7909       else
7910       {
7911         if (oneDeviceData->tdPortContext != agNULL)
7912         {
7913           TI_DBG1(("ttdssReportRemovals: different portcontext; oneDeviceData->tdPortContext pid %d oneportcontext pid %d\n", oneDeviceData->tdPortContext->id, onePortContext->id));
7914         }
7915         else
7916         {
7917           TI_DBG1(("ttdssReportRemovals: different portcontext; oneDeviceData->tdPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
7918         }
7919         DeviceListList = DeviceListList->flink;
7920       }
7921     }
7922
7923     if (removed == agTRUE)
7924     {
7925       TI_DBG1(("ttdssReportRemovals: removed at the end\n"));
7926       ostiTargetEvent(
7927                       tiRoot,
7928                       onePortContext->tiPortalContext,
7929                       &(tmpDeviceData->tiDeviceHandle),
7930                       tiTgtEventTypeDeviceChange,
7931                       tiDeviceRemoval,
7932                       agNULL
7933                       );
7934     }
7935   } /* big else */
7936   return;
7937 }
7938 #endif /* TARGET_DRIVER */
7939
7940
7941 /*****************************************************************************
7942 *! \brief  tdsaRotateQnumber
7943 *
7944 *  Purpose:  This function generates inbound queue number.
7945 *
7946 *  \param   tiRoot: Pointer to the OS Specific module allocated tiRoot_t
7947 *                   instance.
7948 *
7949 *  \return:
7950 *           Queue number
7951 *
7952 *   \note:
7953 *
7954 *****************************************************************************/
7955 FORCEINLINE bit32
7956 tdsaRotateQnumber(tiRoot_t                *tiRoot,
7957                   tdsaDeviceData_t        *oneDeviceData )
7958 {
7959   bit32             ret = 0;
7960
7961   TI_DBG6(("tdsaRotateQnumber: start\n"));
7962   if (oneDeviceData == agNULL)
7963   {
7964     return 0;
7965   }
7966   ret = (oneDeviceData->OutQID << 16) | oneDeviceData->InQID;
7967   return ret;
7968 }
7969
7970 osGLOBAL bit32
7971 tdsaRotateQnumber1(tiRoot_t                *tiRoot,
7972                   tdsaDeviceData_t        *oneDeviceData )
7973 {
7974   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
7975   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7976 //  static int Last_Q;
7977 //  bit32             denom = tdsaAllShared->QueueConfig.numOutboundQueues;
7978   bit32             ret = 0;
7979   if (oneDeviceData == agNULL)
7980   {
7981 //    Last_Q= 0;
7982     return 0;
7983   }
7984
7985 /* alway use highest Q number */
7986   ret = ((tdsaAllShared->QueueConfig.numOutboundQueues-1) << 16) | (tdsaAllShared->QueueConfig.numInboundQueues-1);
7987
7988   return(ret);
7989 }
7990
7991 #ifdef REMOVED
7992 osGLOBAL bit32
7993 tdsaRotateQnumber(tiRoot_t                *tiRoot,
7994                   tdsaDeviceData_t        *oneDeviceData )
7995 {
7996   tdsaRoot_t        *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
7997   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
7998   bit32             denom = tdsaAllShared->QueueConfig.numInboundQueues;
7999   bit32             ret = 0;
8000
8001   /* inbound queue number */
8002   tdsaAllShared->IBQnumber++;
8003   if (tdsaAllShared->IBQnumber % denom == 0) /* % Qnumber*/
8004   {
8005     tdsaAllShared->IBQnumber = 0;
8006   }
8007   TI_DBG6(("tdsaRotateQnumber: IBQnumber %d\n", tdsaAllShared->IBQnumber));
8008
8009
8010   /* outbound queue number */
8011   tdsaAllShared->OBQnumber++;
8012   denom = tdsaAllShared->QueueConfig.numOutboundQueues;
8013   if (tdsaAllShared->OBQnumber % denom == 0) /* % Qnumber*/
8014   {
8015     tdsaAllShared->OBQnumber = 0;
8016   }
8017   TI_DBG6(("tdsaRotateQnumber: OBQnumber %d\n", tdsaAllShared->OBQnumber));
8018
8019   ret = (tdsaAllShared->OBQnumber << 16) | tdsaAllShared->IBQnumber;
8020   return ret;
8021 }
8022 #endif
8023
8024
8025 void t_MacroCheck(  agsaRoot_t       *agRoot)
8026 {
8027   TI_DBG1(("t_MacroCheck:tIsSPC           %d\n",tIsSPC(agRoot)));
8028   TI_DBG1(("t_MacroCheck:tIsSPCHIL        %d\n",tIsSPCHIL(agRoot)));
8029   TI_DBG1(("t_MacroCheck:tIsSPCv          %d\n",tIsSPCv(agRoot)));
8030   TI_DBG1(("t_MacroCheck:tIsSPCve         %d\n",tIsSPCve(agRoot)));
8031   TI_DBG1(("t_MacroCheck:tIsSPCvplus      %d\n",tIsSPCvplus(agRoot)));
8032   TI_DBG1(("t_MacroCheck:tIsSPCveplus     %d\n",tIsSPCveplus(agRoot)));
8033   TI_DBG1(("t_MacroCheck:tIsSPCADAPvplus  %d\n",tIsSPCADAPvplus(agRoot)));
8034   TI_DBG1(("t_MacroCheck:tIsSPCADAPveplus %d\n",tIsSPCADAPveplus(agRoot)));
8035   TI_DBG1(("t_MacroCheck:tIsSPC12Gv       %d\n",tIsSPC12Gv(agRoot)));
8036   TI_DBG1(("t_MacroCheck:tIsSPC12Gve      %d\n",tIsSPC12Gve(agRoot)));
8037   TI_DBG1(("t_MacroCheck:tIsSPC12Gvplus   %d\n",tIsSPC12Gvplus(agRoot)));
8038   TI_DBG1(("t_MacroCheck:tIsSPC12Gveplus  %d\n",tIsSPC12Gveplus(agRoot)));
8039   TI_DBG1(("t_MacroCheck:tiIS_SPC         %d\n",tiIS_SPC(agRoot)   ));
8040   TI_DBG1(("t_MacroCheck:tiIS_HIL         %d\n",tiIS_HIL(agRoot)   ));
8041   TI_DBG1(("t_MacroCheck:tiIS_SPC6V       %d\n",tiIS_SPC6V(agRoot) ));
8042   TI_DBG1(("t_MacroCheck:tiIS_SPC_ENC     %d\n",tiIS_SPC_ENC(agRoot) ));
8043   TI_DBG1(("t_MacroCheck:tIsSPCV12G       %d\n",tIsSPCV12G(agRoot) ));
8044 }