sys/dev/pms/RefTisa/sallsdk/spc/mpidebug.c

   1 /*******************************************************************************
   2 *Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
   3 *
   4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
   5 *that the following conditions are met:
   6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
   7 *following disclaimer.
   8 *2. Redistributions in binary form must reproduce the above copyright notice,
   9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
  10 *with the distribution.
  11 *
  12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
  13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  20
  21 ********************************************************************************/
  22
  23 /*******************************************************************************/
  24 /*! \file mpidebug.c
  25  *  \brief The file is a MPI Libraries to implement the MPI debug and trace functions
  26  *
  27  * The file implements the MPI functions.
  28  *
  29  */
  30 /*******************************************************************************/
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33 #include <dev/pms/config.h>
  34
  35 #include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
  36 #ifdef MPI_DEBUG_TRACE_ENABLE /* enable with CCBUILD_MPI_TRACE*/
  37
  38 /*******************************************************************************/
  39
  40 #ifdef OSLAYER_USE_HI_RES_TIMER
  41 unsigned __int64
  42 GetHiResTimeStamp(void);
  43 #endif /* OSLAYER_USE_HI_RES_TIMER */
  44 /*******************************************************************************/
  45 /*******************************************************************************/
  46 /* FUNCTIONS                                                                   */
  47 /*******************************************************************************/
  48 mpiDebugObTrace_t obTraceData;
  49 mpiDebugIbTrace_t ibTraceData;
  50
  51 void mpiTraceInit(void)
  52 {
  53
  54   SA_DBG1(("mpiTraceInit:obTraceData @ %p\n",&obTraceData ));
  55   SA_DBG1(("mpiTraceInit:ibTraceData @ %p\n",&ibTraceData ));
  56   SA_DBG1(("mpiTraceInit: num enties %d Ib Iomb size %d Ob Iomb size %d\n",
  57                MPI_DEBUG_TRACE_BUFFER_MAX,
  58                MPI_DEBUG_TRACE_IB_IOMB_SIZE,
  59                MPI_DEBUG_TRACE_OB_IOMB_SIZE ));
  60
  61   si_memset(&obTraceData, 0, sizeof(obTraceData));
  62   si_memset(&ibTraceData, 0, sizeof(ibTraceData));
  63 }
  64
  65 void mpiTraceAdd( bit32 q,bit32 pici,bit32 ib, void *iomb, bit32 numBytes)
  66 {
  67   bit32                  curIdx;
  68   mpiDebugIbTraceEntry_t *curIbTrace;
  69   mpiDebugObTraceEntry_t *curObTrace;
  70
  71   mpiDebugIbTrace_t * ibTrace = &ibTraceData;
  72   mpiDebugObTrace_t * obTrace = &obTraceData;
  73
  74   if (ib)
  75   {
  76     if(ibTrace->Idx >= MPI_DEBUG_TRACE_BUFFER_MAX)
  77     {
  78       ibTrace->Idx = 0;
  79     }
  80     curIdx = ibTrace->Idx;
  81
  82     curIbTrace = &ibTrace->Data[curIdx];
  83     curIbTrace->pEntry =  iomb;
  84     curIbTrace->QNum = q;
  85     curIbTrace->pici = pici;
  86 #ifdef OSLAYER_USE_HI_RES_TIMER
  87 #ifdef SA_64BIT_TIMESTAMP
  88   curIbTrace->Time = ossaTimeStamp64(agNULL);
  89 #else /* SA_64BIT_TIMESTAMP */
  90   curIbTrace->Time = ossaTimeStamp(agNULL);
  91 #endif /* SA_64BIT_TIMESTAMP */
  92 #else /* OSLAYER_USE_HI_RES_TIMER */
  93   curIbTrace->Time = 0;
  94 #endif
  95     si_memcpy(curIbTrace->Iomb, iomb, MIN(numBytes, MPI_DEBUG_TRACE_IB_IOMB_SIZE));
  96     ibTrace->Idx++;
  97   }
  98   else
  99   {
 100     if(obTrace->Idx >= MPI_DEBUG_TRACE_BUFFER_MAX )
 101     {
 102       obTrace->Idx = 0;
 103     }
 104     curIdx = obTrace->Idx;
 105     curObTrace = &obTrace->Data[curIdx];
 106     curObTrace->pEntry =  iomb;
 107     curObTrace->QNum = q;
 108     curObTrace->pici = pici;
 109 #ifdef OSLAYER_USE_HI_RES_TIMER
 110 #ifdef SA_64BIT_TIMESTAMP
 111     curObTrace->Time = ossaTimeStamp64(agNULL);
 112 #else /* SA_64BIT_TIMESTAMP */
 113     curObTrace->Time = ossaTimeStamp(agNULL);
 114 #endif /* SA_64BIT_TIMESTAMP */
 115 #else /* OSLAYER_USE_HI_RES_TIMER */
 116     curObTrace->Time = 0;
 117 #endif
 118     si_memcpy(curObTrace->Iomb, iomb, MIN(numBytes, MPI_DEBUG_TRACE_OB_IOMB_SIZE));
 119     obTrace->Idx++;
 120   }
 121
 122
 123   return;
 124 }
 125
 126 #endif /* MPI_DEBUG_TRACE_ENABLE */
 127
 128
 129
 130 #ifdef SA_ENABLE_TRACE_FUNCTIONS
 131
 132 /**
 133  * fiEnableTracing
 134  *
 135  *    This fucntion is called to initialize tracing of FC layer.
 136  *
 137  */
 138 void siEnableTracing (agsaRoot_t  *agRoot)
 139 {
 140
 141   agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 142   agsaSwConfig_t    *swC  = &saRoot->swConfig;
 143   bit32 count;
 144
 145   OS_ASSERT(saRoot != NULL, "");
 146
 147   if( saRoot->TraceBlockReInit != 0)
 148   {
 149     return;
 150   }
 151
 152
 153   /* Initialize tracing first */
 154
 155   for (count = 0; count < 10; count++)
 156   {
 157       saRoot->traceBuffLookup[count] = (bit8)('0' + count);
 158   }
 159   for (count = 0; count < 6; count++)
 160   {
 161       saRoot->traceBuffLookup[(bitptr)count + 10] = (bit8)('a' + count);
 162   }
 163
 164
 165   saRoot->TraceDestination = swC->TraceDestination;
 166   saRoot->TraceMask = swC->TraceMask;
 167   saRoot->CurrentTraceIndexWrapCount = 0;
 168   saRoot->CurrentTraceIndex = 0;
 169   saRoot->TraceBlockReInit = 1;
 170
 171
 172   SA_DBG1(("siEnableTracing: \n" ));
 173
 174   SA_DBG1 (("      length       = %08x\n", saRoot->TraceBufferLength ));
 175   SA_DBG1 (("      virt         = %p\n",   saRoot->TraceBuffer ));
 176   SA_DBG1 (("    traceMask        = %08x @ %p\n", saRoot->TraceMask, &saRoot->TraceMask));
 177   SA_DBG1 (("    last trace entry @ %p\n", &saRoot->CurrentTraceIndex));
 178   SA_DBG1 (("    TraceWrapAround  = %x\n", saRoot->TraceMask & hpDBG_TraceBufferWrapAround ? 1 : 0));
 179   SA_DBG1 (("    da %p l %x\n",saRoot->TraceBuffer ,saRoot->TraceBufferLength));
 180
 181 #ifdef SA_PRINTOUT_IN_WINDBG
 182 #ifndef DBG
 183   DbgPrint("siTraceEnable: \n" );
 184
 185   DbgPrint("      length       = %08x\n", saRoot->TraceBufferLength );
 186   DbgPrint("      virt         = %p\n",   saRoot->TraceBuffer );
 187   DbgPrint("    last trace entry @ %p\n", &saRoot->CurrentTraceIndex);
 188   DbgPrint("    traceMask      = %08x @ %p\n", saRoot->TraceMask, &saRoot->TraceMask);
 189   DbgPrint("    da %p l %x\n",saRoot->TraceBuffer ,saRoot->TraceBufferLength);
 190 #endif /* DBG  */
 191 #endif /* SA_PRINTOUT_IN_WINDBG  */
 192   /*
 193   ** Init trace buffer with all spaces
 194   */
 195   for (count = 0; count < saRoot->TraceBufferLength; count++)
 196   {
 197       saRoot->TraceBuffer[count] = (bit8)' ';
 198   }
 199
 200 }
 201
 202
 203
 204 /**
 205  * IF_DO_TRACE
 206  *
 207  * PURPOSE:     convenience macro for the "to output or not to output" logic
 208  *
 209  * PARAMETERS:
 210  *
 211  * CALLS:
 212  *
 213  * SIDE EFFECTS & CAVEATS:
 214  *
 215  * ALGORITHM:
 216  *
 217  *
 218  *
 219  *     MODIFICATION HISTORY     ***********************
 220  *
 221  * ENGINEER NAME      DATE     DESCRIPTION
 222  * -------------    --------   -----------
 223  */
 224
 225 #define IF_DO_TRACE                                     \
 226   if ( (saRoot != NULL) &&                              \
 227        (saRoot->TraceDestination & siTraceDestMask) &&  \
 228        (mask & saRoot->TraceMask) )                     \
 229
 230
 231 /* #define TRACE_ENTER_LOCK  ossaSingleThreadedEnter(agRoot, LL_TRACE_LOCK); */
 232 /* #define TRACE_LEAVE_LOCK  ossaSingleThreadedLeave(agRoot, LL_TRACE_LOCK); */
 233 #define TRACE_ENTER_LOCK
 234 #define TRACE_LEAVE_LOCK
 235 /**
 236  * BUFFER_WRAP_CHECK
 237  *
 238  * PURPOSE: Checks if the tracing buffer tracing index is too high.  If it is,
 239  *          the buffer index gets reset to 0 or tracing stops..
 240  */
 241 #define BUFFER_WRAP_CHECK                                           \
 242     if( (saRoot->CurrentTraceIndex + TMP_TRACE_BUFF_SIZE)               \
 243                            >= saRoot->TraceBufferLength )               \
 244     {                                                                   \
 245         /* Trace wrap-Around is enabled.  */                            \
 246         if( saRoot->TraceMask & hpDBG_TraceBufferWrapAround )           \
 247         {                                                               \
 248             /* Fill the end of the buffer with spaces */                \
 249             for( i = saRoot->CurrentTraceIndex;                         \
 250                      i < saRoot->TraceBufferLength; i++ )               \
 251             {                                                           \
 252                 saRoot->TraceBuffer[i] = (bit8)' ';                     \
 253             }                                                           \
 254             /* Wrap the current trace index back to 0.. */              \
 255             saRoot->CurrentTraceIndex = 0;                              \
 256             saRoot->CurrentTraceIndexWrapCount++;                       \
 257         }                                                               \
 258         else                                                            \
 259         {                                                               \
 260             /* Don't do anything -- trace buffer is filled up */        \
 261             return;                                                     \
 262         }                                                               \
 263     }
 264
 265 /**
 266  * LOCAL_OS_LOG_DEBUG_STRING
 267  *
 268  * PURPOSE:     protects against a change in the api for this function
 269  *
 270  * PARAMETERS:
 271  *
 272  * CALLS:
 273  *
 274  * SIDE EFFECTS & CAVEATS:
 275  *
 276  * ALGORITHM:
 277  *
 278  *
 279  *
 280  *     MODIFICATION HISTORY     ***********************
 281  *
 282  * ENGINEER NAME      DATE     DESCRIPTION
 283  * -------------    --------   -----------
 284  * Laurent Chavey   03/09/00   - changed cast of 3rd parameter to (char *)
 285  */
 286     #define LOCAL_OS_LOG_DEBUG_STRING(H,S)  \
 287             osLogDebugString(H,hpDBG_ALWAYS,(char *)(S))
 288
 289 /******************************************************************************
 290 *******************************************************************************
 291 **
 292 ** copyHex
 293 **
 294 ** PURPOSE:  Copies a hex version of a bit32 into a bit8 buffer
 295 **
 296 *******************************************************************************
 297 ******************************************************************************/
 298 #define copyHex(bit32Val, bitSize)                                     \
 299 {                                                                      \
 300   bit32 nibbleLen = bitSize / 4;                                       \
 301   bit32 scratch = 0;                                                   \
 302   for( i = 0; i < nibbleLen; i++ )                                     \
 303   {                                                                    \
 304     bPtr[pos++] =                                                      \
 305         saRoot->traceBuffLookup[0xf & (bit32Val >> ((bitSize - 4) - (i << 2)))];  \
 306     i++;                                                               \
 307     bPtr[pos++] =                                                      \
 308     saRoot->traceBuffLookup[0xf & (bit32Val >> ((bitSize - 4) - (i << 2)))]; \
 309     /* Skip leading 0-s to save memory buffer space */                 \
 310     if( !scratch                                                       \
 311           && (bPtr[pos-2] == '0')                                      \
 312           && (bPtr[pos-1] == '0') )                                    \
 313     {                                                                  \
 314       pos -= 2;                                                        \
 315       continue;                                                        \
 316     }                                                                  \
 317     else                                                               \
 318     {                                                                  \
 319       scratch = 1;                                                     \
 320     }                                                                  \
 321   }                                                                    \
 322   if( scratch == 0 )                                                   \
 323   {                                                                    \
 324     /* The value is 0 and nothing got put in the buffer.  Do       */  \
 325     /* print at least two zeros.                                   */  \
 326     bPtr[pos++] = '0';                                                 \
 327     bPtr[pos++] = '0';                                                 \
 328   }                                                                    \
 329 }
 330
 331
 332 /**
 333  * TRACE_OTHER_DEST
 334  *
 335  * PURPOSE:  Check if any other destinations are enabled.  If yes, use them
 336  *           for debug log.
 337  */
 338 #define TRACE_OTHER_DEST                                                \
 339     {                                                                   \
 340     bit32 bitptrscratch;                                                \
 341     if( saRoot->TraceDestination & smTraceDestDebugger )                \
 342     {                                                                   \
 343         bPtr[pos++] = (bit8)'\n';                                       \
 344         bPtr[pos++] = (bit8)0;                                          \
 345         LOCAL_OS_LOG_DEBUG_STRING(hpRoot, (char *)bPtr);                \
 346     }                                                                   \
 347     if( saRoot->TraceDestination & smTraceDestRegister )                \
 348     {                                                                   \
 349         while( (pos & 0x3) != 0x3 )                                     \
 350         {                                                               \
 351             bPtr[pos++] = (bit8)' ';                                    \
 352         }                                                               \
 353         bPtr[pos] = ' ';                                                \
 354         for( i = 0; i < pos; i = i + 4 )                                \
 355         {                                                               \
 356             bitptrscratch =  bPtr[i+0];                                 \
 357             bitptrscratch <<= 8;                                        \
 358             bitptrscratch |= bPtr[i+1];                                 \
 359             bitptrscratch <<= 8;                                        \
 360             bitptrscratch |= bPtr[i+2];                                 \
 361             bitptrscratch <<= 8;                                        \
 362             bitptrscratch |= bPtr[i+3];                                 \
 363             osChipRegWrite(hpRoot,                                      \
 364                  FC_rFMReceivedALPA, (bit32)bitptrscratch );            \
 365         }                                                               \
 366     }                                                                   \
 367     }
 368
 369
 370
 371 /**
 372  * siGetCurrentTraceIndex()
 373  *
 374  * PURPOSE:     Returns the current tracing index ( if tracing buffer is
 375  *              used ).
 376  *
 377  * PARAMETERS:
 378  *
 379  * CALLS:
 380  *
 381  * SIDE EFFECTS & CAVEATS:
 382  *
 383  * ALGORITHM:
 384  *
 385  *
 386  *     MODIFICATION HISTORY     ***********************
 387  *
 388  * ENGINEER NAME      DATE     DESCRIPTION
 389  * -------------    --------   -----------
 390  * Tom Nalepa       02/27/03
 391  *
 392  * @param hpRoot
 393  *
 394  * @return
 395  */
 396 GLOBAL bit32 siGetCurrentTraceIndex(agsaRoot_t  *agRoot)
 397 {
 398     agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 399     return(saRoot->CurrentTraceIndex);
 400 }
 401
 402
 403
 404
 405 /**
 406  * siResetTraceBuffer
 407  *
 408  * PURPOSE:     Sets saRoot->CurrentTraceIndex to 0.
 409  *
 410  * @param hpRoot
 411  *
 412  * @return
 413  */
 414 GLOBAL void siResetTraceBuffer(agsaRoot_t  *agRoot)
 415 {
 416     bit32 count;
 417     agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 418     saRoot->CurrentTraceIndex = 0;
 419
 420     for ( count = 0; count < saRoot->TraceBufferLength; count++ )
 421     {
 422         saRoot->TraceBuffer[count] = (bit8)' ';
 423     }
 424 }
 425
 426
 427 /**
 428  * siTraceFuncEnter
 429  *
 430  * PURPOSE:     Format a function entry trace and post it to the appropriate
 431  *              destination.
 432  *
 433  * PARAMETERS:
 434  *
 435  * CALLS:
 436  *
 437  * SIDE EFFECTS & CAVEATS:
 438  *
 439  * ALGORITHM:
 440  *
 441  * siTraceFuncEnter  :    _[Xxxxx_
 442  *                 fileid---^  ^------funcid
 443  *
 444  *
 445  *     MODIFICATION HISTORY     ***********************
 446  *
 447  * ENGINEER NAME      DATE     DESCRIPTION
 448  * -------------    --------   -----------
 449  *
 450  * @param hpRoot
 451  * @param mask
 452  * @param fileid
 453  * @param funcid
 454  *
 455  * @return
 456  */
 457
 458 #define TMP_TRACE_BUFF_SIZE 32
 459
 460
 461 GLOBAL void siTraceFuncEnter( agsaRoot_t  *agRoot,
 462                              bit32        mask,
 463                              bit32        fileid,
 464                              char       * funcid)
 465 {
 466 agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 467     bitptr         i;
 468     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 469     bit8          *bPtr;
 470     bit8           pos = 0;
 471
 472     IF_DO_TRACE
 473     {
 474       TRACE_ENTER_LOCK
 475       if ( saRoot->TraceDestination & smTraceDestBuffer )
 476       {
 477         BUFFER_WRAP_CHECK
 478         bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 479       }
 480       else
 481       {
 482         bPtr = tmpB;
 483       }
 484       bPtr[pos++] = (bit8)'[';
 485
 486 #ifndef FC_DO_NOT_INCLUDE_FILE_NAME_TAGS_IN_ENTER_EXIT_TRACE
 487         bPtr[pos++] = (bit8)fileid;
 488 #endif
 489
 490         for ( i=0; i<4; i++ )
 491         {
 492             if ( funcid[i] == 0 )
 493             {
 494                 break;
 495             }
 496             bPtr[pos++] = (bit8)funcid[i];
 497         }
 498         bPtr[pos++] = ' ';
 499         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 500         {
 501             bPtr[pos++] = '\r';
 502             bPtr[pos++] = '\n';
 503             saRoot->traceLineFeedCnt = 0;
 504         }
 505         saRoot->CurrentTraceIndex += pos;
 506 //        TRACE_OTHER_DEST
 507     TRACE_LEAVE_LOCK
 508
 509     }
 510     return;
 511 }
 512
 513
 514 /**
 515  * siTraceFuncExit
 516  *
 517  * PURPOSE:     Format a function exit trace and post it to the appropriate
 518  *              destination.
 519  *
 520  * PARAMETERS:
 521  *
 522  * CALLS:
 523  *
 524  * SIDE EFFECTS & CAVEATS:
 525  *
 526  * ALGORITHM:
 527  *
 528  * siTraceFuncExit         _Xxxxx]_
 529  *                 fileid---^  ^------funcid
 530  *
 531  *
 532  *     MODIFICATION HISTORY     ***********************
 533  *
 534  * ENGINEER NAME      DATE     DESCRIPTION
 535  * -------------    --------   -----------
 536  *
 537  * @param hpRoot
 538  * @param mask
 539  * @param fileid
 540  * @param funcid
 541  * @param exitId
 542  *
 543  * @return
 544  */
 545 GLOBAL void siTraceFuncExit(   agsaRoot_t  *agRoot,  bit32   mask, char  fileid, char  * funcid, char  exitId )
 546 {
 547     bitptr         i;
 548     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 549     bit8          *bPtr;
 550     bit8           pos = 0;
 551
 552     agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 553
 554     IF_DO_TRACE
 555     {
 556       TRACE_ENTER_LOCK
 557       if ( saRoot->TraceDestination & smTraceDestBuffer )
 558       {
 559         BUFFER_WRAP_CHECK
 560         bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 561       }
 562       else
 563       {
 564         bPtr = tmpB;
 565       }
 566
 567 #ifndef FC_DO_NOT_INCLUDE_FILE_NAME_TAGS_IN_ENTER_EXIT_TRACE
 568         bPtr[pos++] = (bit8)fileid;
 569 #endif
 570
 571         for ( i=0; i<4; i++ )
 572         {
 573             if ( funcid[i] == 0 )
 574             {
 575                 break;
 576             }
 577             bPtr[pos++] = (bit8)funcid[i];
 578         }
 579         bPtr[pos++] = (bit8)exitId;
 580         bPtr[pos++] = (bit8)']';
 581         bPtr[pos++] = (bit8)' ';
 582         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 583         {
 584             bPtr[pos++] = '\r';
 585             bPtr[pos++] = '\n';
 586             saRoot->traceLineFeedCnt = 0;
 587         }
 588         saRoot->CurrentTraceIndex += pos;
 589 //        TRACE_OTHER_DEST
 590     TRACE_LEAVE_LOCK
 591     }
 592     return;
 593 }
 594
 595 /**
 596  * siTraceListRemove
 597  *
 598  * PURPOSE:     Adds a trace tag for an exchange that is removed from a list
 599  *
 600  * PARAMETERS:
 601  *
 602  * CALLS:
 603  *
 604  * SIDE EFFECTS & CAVEATS:
 605  *
 606  * ALGORITHM:
 607  *
 608  *
 609  *     MODIFICATION HISTORY     ***********************
 610  *
 611  * ENGINEER NAME      DATE     DESCRIPTION
 612  * -------------    --------   -----------
 613  * Tom Nalepa       12/16/02   Initial Developmet
 614  *
 615  * @param hpRoot
 616  * @param mask
 617  * @param listId
 618  * @param exchangeId
 619  *
 620  * @return
 621  */
 622 GLOBAL void siTraceListRemove(agsaRoot_t  *agRoot,
 623                               bit32        mask,
 624                               char         listId,
 625                               bitptr       exchangeId)
 626 {
 627     agsaLLRoot_t      *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
 628     bitptr         i;
 629     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 630     bit8          *bPtr;
 631     bit8           pos = 0;
 632
 633     IF_DO_TRACE
 634     {
 635      TRACE_ENTER_LOCK
 636         if ( saRoot->TraceDestination & smTraceDestBuffer )
 637         {
 638             BUFFER_WRAP_CHECK
 639             bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 640         }
 641         else
 642         {
 643             bPtr = tmpB;
 644         }
 645         bPtr[pos++] = (bit8)'<';
 646         bPtr[pos++] = (bit8)listId;
 647         copyHex(exchangeId, 32);
 648         bPtr[pos++] = (bit8)' ';
 649         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 650         {
 651             bPtr[pos++] = '\r';
 652             bPtr[pos++] = '\n';
 653             saRoot->traceLineFeedCnt = 0;
 654         }
 655         saRoot->CurrentTraceIndex += pos;
 656 //        TRACE_OTHER_DEST
 657     TRACE_LEAVE_LOCK
 658     }
 659     return;
 660 }
 661
 662 /**
 663  * siTraceListAdd
 664  *
 665  * PURPOSE:     Adds a trace tag for an exchange that is added to a list
 666  *
 667  * PARAMETERS:
 668  *
 669  * CALLS:
 670  *
 671  * SIDE EFFECTS & CAVEATS:
 672  *
 673  * ALGORITHM:
 674  *
 675  *
 676  *     MODIFICATION HISTORY     ***********************
 677  *
 678  * ENGINEER NAME      DATE     DESCRIPTION
 679  * -------------    --------   -----------
 680  * Tom Nalepa       12/16/02   Initial Developmet
 681  *
 682  * @param hpRoot
 683  * @param mask
 684  * @param listId
 685  * @param exchangeId
 686  *
 687  * @return
 688  */
 689 GLOBAL void siTraceListAdd(agsaRoot_t      *agRoot,
 690                            bit32        mask,
 691                            char         listId,
 692                            bitptr       exchangeId)
 693 {
 694
 695   agsaLLRoot_t          *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
 696
 697     bitptr         i;
 698     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 699     bit8          *bPtr;
 700     bit8           pos = 0;
 701
 702     IF_DO_TRACE
 703     {
 704         if ( saRoot->TraceDestination & smTraceDestBuffer )
 705         {
 706             BUFFER_WRAP_CHECK
 707             bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 708         }
 709         else
 710         {
 711             bPtr = tmpB;
 712         }
 713         bPtr[pos++] = (bit8)'>';
 714         bPtr[pos++] = (bit8)listId;
 715         copyHex(exchangeId, 32);
 716         bPtr[pos++] = (bit8)' ';
 717         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 718         {
 719             bPtr[pos++] = '\r';
 720             bPtr[pos++] = '\n';
 721             saRoot->traceLineFeedCnt = 0;
 722         }
 723         saRoot->CurrentTraceIndex += pos;
 724 //        TRACE_OTHER_DEST
 725     }
 726     return;
 727 }
 728
 729 /**
 730  * siTrace64
 731  *
 732  * PURPOSE:     Format a function parameter trace and post it to the appropriate
 733  *              destination.
 734  *
 735  * PARAMETERS:
 736  *
 737  * CALLS:
 738  *
 739  * SIDE EFFECTS & CAVEATS:
 740  *
 741  * ALGORITHM:
 742  *
 743  * siTrace : index is 0 for return value, 1 for first parm after "("
 744  *           produces:   _nn" XXXXXXXXXX
 745  *           index-----^    value--^
 746  *
 747  *
 748  *     MODIFICATION HISTORY     ***********************
 749  *
 750  * ENGINEER NAME      DATE     DESCRIPTION
 751  * -------------    --------   -----------
 752  *
 753  * @param hpRoot
 754  * @param mask
 755  * @param uId
 756  * @param value
 757  *
 758  * @return
 759  */
 760 GLOBAL void siTrace64(agsaRoot_t      *agRoot,
 761                       bit32        mask,
 762                       char       * uId,
 763                       bit64        value,
 764                       bit32        dataSizeInBits)
 765 {
 766
 767     agsaLLRoot_t  *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
 768     bitptr         i;
 769     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 770     bit8          *bPtr;
 771     bit8           pos = 0;
 772
 773     IF_DO_TRACE
 774     {
 775         if ( saRoot->TraceDestination & smTraceDestBuffer )
 776         {
 777             BUFFER_WRAP_CHECK
 778             bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 779         }
 780         else
 781         {
 782             bPtr = tmpB;
 783         }
 784         bPtr[pos++] = (bit8)'"';
 785         bPtr[pos++] = (bit8)uId[0];
 786         bPtr[pos++] = (bit8)uId[1];
 787         bPtr[pos++] = (bit8)':';
 788         copyHex(value, dataSizeInBits);
 789         bPtr[pos++] = (bit8)' ';
 790         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 791         {
 792             bPtr[pos++] = '\r';
 793             bPtr[pos++] = '\n';
 794             saRoot->traceLineFeedCnt = 0;
 795         }
 796         saRoot->CurrentTraceIndex += pos;
 797 //        TRACE_OTHER_DEST
 798     }
 799     return;
 800 }
 801
 802
 803
 804 /**
 805  * siTrace
 806  *
 807  * PURPOSE:     Format a function parameter trace and post it to the appropriate
 808  *              destination.
 809  *
 810  * PARAMETERS:
 811  *
 812  * CALLS:
 813  *
 814  * SIDE EFFECTS & CAVEATS:
 815  *
 816  * ALGORITHM:
 817  *
 818  * fiTrace : index is 0 for return value, 1 for first parm after "("
 819  *           produces:   _nn" XXXXXXXXXX
 820  *           index-----^    value--^
 821  *
 822  *
 823  *     MODIFICATION HISTORY     ***********************
 824  *
 825  * ENGINEER NAME      DATE     DESCRIPTION
 826  * -------------    --------   -----------
 827  *
 828  * @param hpRoot
 829  * @param mask
 830  * @param uId
 831  * @param value
 832  *
 833  * @return
 834  */
 835 GLOBAL void siTrace( agsaRoot_t      *agRoot,
 836                     bit32        mask,
 837                     char       * uId,
 838                     bit32        value,
 839                     bit32        dataSizeInBits)
 840 {
 841
 842    agsaLLRoot_t   *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
 843
 844     bitptr         i;
 845     bit8           tmpB[TMP_TRACE_BUFF_SIZE];
 846     bit8          *bPtr;
 847     bit8           pos = 0;
 848
 849     IF_DO_TRACE
 850     {
 851         if ( saRoot->TraceDestination & smTraceDestBuffer )
 852         {
 853             BUFFER_WRAP_CHECK
 854             bPtr = &saRoot->TraceBuffer[saRoot->CurrentTraceIndex];
 855         }
 856         else
 857         {
 858             bPtr = tmpB;
 859         }
 860         bPtr[pos++] = (bit8)'"';
 861         bPtr[pos++] = (bit8)uId[0];
 862         bPtr[pos++] = (bit8)uId[1];
 863         bPtr[pos++] = (bit8)':';
 864         copyHex(value, dataSizeInBits);
 865         bPtr[pos++] = (bit8)' ';
 866         if ( saRoot->traceLineFeedCnt > FC_TRACE_LINE_SIZE )
 867         {
 868             bPtr[pos++] = '\r';
 869             bPtr[pos++] = '\n';
 870             saRoot->traceLineFeedCnt = 0;
 871         }
 872         saRoot->CurrentTraceIndex += pos;
 873 //        TRACE_OTHER_DEST
 874     }
 875     return;
 876 }
 877
 878
 879 /*Set Wrap 0 for Wrapping non zero stops when full  */
 880
 881
 882 GLOBAL void siTraceGetInfo(agsaRoot_t  *agRoot, hpTraceBufferParms_t * pBParms)
 883 {
 884     agsaLLRoot_t  *saRoot = (agsaLLRoot_t *)agRoot->sdkData;
 885
 886     pBParms->TraceCompiled  =  TRUE;
 887
 888     pBParms->TraceWrap                  = saRoot->TraceMask & 0x80000000;
 889     pBParms->CurrentTraceIndexWrapCount = saRoot->CurrentTraceIndexWrapCount;
 890     pBParms->BufferSize                 = saRoot->TraceBufferLength;
 891     pBParms->CurrentIndex               = saRoot->CurrentTraceIndex;
 892     pBParms->pTrace                     = saRoot->TraceBuffer;
 893     pBParms->pTraceIndexWrapCount       = &saRoot->CurrentTraceIndexWrapCount;
 894     pBParms->pTraceMask                 = &saRoot->TraceMask;
 895     pBParms->pCurrentTraceIndex         = &saRoot->CurrentTraceIndex;
 896 }
 897 /**/
 898
 899 GLOBAL void siTraceSetMask(agsaRoot_t  *agRoot, bit32 TraceMask  )
 900 {
 901     agsaLLRoot_t  *saRoot = (agsaLLRoot_t *)agRoot->sdkData;
 902     saRoot->TraceMask = TraceMask;
 903 }
 904
 905
 906
 907 #endif
 908
 909