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