mpidebug.c revision 285809 
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
41unsigned __int64
42GetHiResTimeStamp(void);
43#endif /* OSLAYER_USE_HI_RES_TIMER */
44/*******************************************************************************/
45/*******************************************************************************/
46/* FUNCTIONS                                                                   */
47/*******************************************************************************/
48mpiDebugObTrace_t obTraceData;
49mpiDebugIbTrace_t ibTraceData;
50
51void 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
65void 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 */
138void 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 */
396GLOBAL 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 */
414GLOBAL 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
461GLOBAL void siTraceFuncEnter( agsaRoot_t  *agRoot,
462                             bit32        mask,
463                             bit32        fileid,
464                             char       * funcid)
465{
466agsaLLRoot_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 */
545GLOBAL 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 */
622GLOBAL 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 */
689GLOBAL 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 */
760GLOBAL 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 */
835GLOBAL 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
882GLOBAL 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
899GLOBAL 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
910