NOTICE OF RELOCATION
[keystone-rtos/fvid2.git] / include / trace.h
1 /*
2  *  Copyright (c) Texas Instruments Incorporated 2018
3  *
4  *  Redistribution and use in source and binary forms, with or without
5  *  modification, are permitted provided that the following conditions
6  *  are met:
7  *
8  *    Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  *    Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the
14  *    distribution.
15  *
16  *    Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /**
34  *  \file       trace.h
35  *
36  *  \brief      Kernel Trace enabling/disabling/application interface.
37  *
38  *              This will have the definitions for kernel side traces
39  *              statements and also details of variable traces
40  *              supported in existing implementation.
41  */
43 #ifndef FVID2TRACE_H_
44 #define FVID2TRACE_H_
46 #include <ti/csl/tistdtypes.h>
48 #ifdef __cplusplus
49 extern "C" {
50 #endif
52 /*!
53  *  @def    GT_TRACESTATE_MASK
54  *  @brief  Trace state mask
55  */
56 #define GT_TRACESTATE_MASK              (0x0000000FU)
57 /*!
58  *  @def    GT_TRACESTATE_SHIFT
59  *  @brief  Bit shift for trace state
60  */
61 #define GT_TRACESTATE_SHIFT             (0U)
62 /*!
63  *  @def    GT_TRACECLASS_MASK
64  *  @brief  GT class mask
65  */
66 #define GT_TRACECLASS_MASK              (0x000F0000U)
67 /*!
68  *  @def    GT_TRACECLASS_SHIFT
69  *  @brief  Bit shift for GT class mask
70  */
71 #define GT_TRACECLASS_SHIFT             (16U)
73 /*!
74  *  @brief  Default Mask to use with GT_assert
75  */
76 #define GT_DEFAULT_MASK                 (GT_ERR | GT_TraceState_Enable)
78 /**
79  *  \anchor GT_TraceState
80  *  \name trace state
81  *  @{
82  */
83 /*!
84  *  @brief   Enumerates the types of states of trace (enable/disable)
85  */
86 typedef uint32_t GT_TraceState;
87 #define    GT_TraceState_Disable    (0x00000000U)
88 /*!< Disable trace */
89 #define    GT_TraceState_Enable     (0x00000001U)
90 /*!< Enable trace */
91 #define    GT_TraceState_EndValue   (0x00000002U)
92 /*!< End delimiter indicating start of invalid values for this enum */
93 /* @} */
95 /**
96  *  \anchor GT_TraceClass
97  *  \name trace class
98  *  @{
99  */
100 /*!
101  *  @brief   Enumerates the types of trace classes
102  */
103 typedef uint32_t GT_TraceClass;
104 #define    GT_ERR                   (0x00010000U)
105 /*!< Class 1 trace: Used for errors/warnings */
106 #define    GT_CRIT                  (0x00020000U)
107 /*!< Class 2 trace: Used for critical information */
108 #define    GT_INFO                  (0x00030000U)
109 /*!< Class 3 trace: Used for additional information */
110 #define    GT_INFO1                 (0x00040000U)
111 /*!< Class 4 trace: Used for additional information (sub level 1) */
112 #define    GT_DEBUG                 (0x00050000U)
113 /*!< Class 5 trace: Used for block level information */
114 #define    GT_ENTER                 (0x00060000U)
115 /*!< Indicates a function entry class of trace */
116 #define    GT_LEAVE                 (0x00070000U)
117 /*!< Indicates a function leave class of trace */
118 /* @} */
120 /** \brief Log enable for FVID2 Utils. */
121 #define Fvid2Trace                      (GT_DEFAULT_MASK)
123 /**
124  *  \brief Prints to Shared memory and CCS console
125  *
126  *  This function prints the provided formatted string to shared memory and CCS
127  *  console
128  *
129  *  \param format       [IN] Formatted string followed by variable arguments
130  *
131  */
132 void Fvid2_printf(const char *format, ...);
134 #if defined (FVID2_CFG_ASSERT_ENABLE)
136 /** \brief assert function. */
137 void GT_assertLocal(uint32_t    enableMask,
138                     uint32_t    condition,
139                     const char *str,
140                     const char *fileName,
141                     int32_t     lineNum);
143 /** \brief GT_assert */
144 #define GT_assert(x, y)                                           \
145     (GT_assertLocal((uint32_t) (x), (uint32_t) (y), (const char *) # y, \
146                     (const char *) __FILE__, (int32_t) __LINE__))
148 #else
150 #define GT_assert(x, y)
152 #endif
154 /**
155  *  \brief Log the trace with zero parameters and information string.
156  *
157  *  \param  maskType   [IN] Trace mask
158  *  \param  classType  [IN] Trace class type
159  *  \param  fileName   [IN] File Name
160  *  \param  lineNum    [IN] Line Number
161  *  \param  infoString [IN] Print string
162  *
163  */
164 void GT_trace0(uint32_t      maskType,
165                GT_TraceClass classType,
166                const char   *fileName,
167                int32_t       lineNum,
168                const char   *infoString);
169 /**
170  *  \brief Function to log the trace with one additional parameter.
171  *
172  *  \param  maskType   [IN] Trace mask
173  *  \param  classType  [IN] Trace class type
174  *  \param  fileName   [IN] File Name
175  *  \param  lineNum    [IN] Line Number
176  *  \param  infoString [IN] Print string
177  *  \param  param0     [IN] Parameter 0
178  *
179  */
180 void GT_trace1(uint32_t      maskType,
181                GT_TraceClass classType,
182                const char   *fileName,
183                int32_t       lineNum,
184                const char   *infoString,
185                uintptr_t     param0);
187 /**
188  *  \brief Function to log the trace with two additional parameters.
189  *
190  *  \param  maskType   [IN] Trace mask
191  *  \param  classType  [IN] Trace class type
192  *  \param  fileName   [IN] File Name
193  *  \param  lineNum    [IN] Line Number
194  *  \param  infoString [IN] Print string
195  *  \param  param0     [IN] Parameter 0
196  *  \param  param1     [IN] Parameter 1
197  *
198  */
199 void GT_trace2(uint32_t      maskType,
200                GT_TraceClass classType,
201                const char   *fileName,
202                int32_t       lineNum,
203                const char   *infoString,
204                uintptr_t     param0,
205                uintptr_t     param1);
207 /**
208  *  \brief Function to log the trace with three additional parameters.
209  *
210  *  \param  maskType   [IN] Trace mask
211  *  \param  classType  [IN] Trace class type
212  *  \param  fileName   [IN] File Name
213  *  \param  lineNum    [IN] Line Number
214  *  \param  infoString [IN] Print string
215  *  \param  param0     [IN] Parameter 0
216  *  \param  param1     [IN] Parameter 1
217  *  \param  param2     [IN] Parameter 2
218  *
219  */
220 void GT_trace3(uint32_t      maskType,
221                GT_TraceClass classType,
222                const char   *fileName,
223                int32_t       lineNum,
224                const char   *infoString,
225                uintptr_t     param0,
226                uintptr_t     param1,
227                uintptr_t     param2);
229 /**
230  *  \brief Function to log the trace with four additional parameters.
231  *
232  *  \param  maskType   [IN] Trace mask
233  *  \param  classType  [IN] Trace class type
234  *  \param  fileName   [IN] File Name
235  *  \param  lineNum    [IN] Line Number
236  *  \param  infoString [IN] Print string
237  *  \param  param0     [IN] Parameter 0
238  *  \param  param1     [IN] Parameter 1
239  *  \param  param2     [IN] Parameter 2
240  *  \param  param3     [IN] Parameter 3
241  *
242  */
243 void GT_trace4(uint32_t      maskType,
244                GT_TraceClass classType,
245                const char   *fileName,
246                int32_t       lineNum,
247                const char   *infoString,
248                uintptr_t     param0,
249                uintptr_t     param1,
250                uintptr_t     param2,
251                uintptr_t     param3);
253 /**
254  *  \brief Function to log the trace with five additional parameters.
255  *
256  *  \param  maskType   [IN] Trace mask
257  *  \param  classType  [IN] Trace class type
258  *  \param  fileName   [IN] File Name
259  *  \param  lineNum    [IN] Line Number
260  *  \param  infoString [IN] Print string
261  *  \param  param0     [IN] Parameter 0
262  *  \param  param1     [IN] Parameter 1
263  *  \param  param2     [IN] Parameter 2
264  *  \param  param3     [IN] Parameter 3
265  *  \param  param4     [IN] Parameter 4
266  *
267  */
268 void GT_trace5(uint32_t      maskType,
269                GT_TraceClass classType,
270                const char   *fileName,
271                int32_t       lineNum,
272                const char   *infoString,
273                uintptr_t     param0,
274                uintptr_t     param1,
275                uintptr_t     param2,
276                uintptr_t     param3,
277                uintptr_t     param4);
279 /**
280  *  \brief Function to log the trace with six additional parameters.
281  *
282  *  \param  maskType   [IN] Trace mask
283  *  \param  classType  [IN] Trace class type
284  *  \param  fileName   [IN] File Name
285  *  \param  lineNum    [IN] Line Number
286  *  \param  infoString [IN] Print string
287  *  \param  param0     [IN] Parameter 0
288  *  \param  param1     [IN] Parameter 1
289  *  \param  param2     [IN] Parameter 2
290  *  \param  param3     [IN] Parameter 3
291  *  \param  param4     [IN] Parameter 4
292  *  \param  param5     [IN] Parameter 5
293  *
294  */
295 void GT_trace6(uint32_t      maskType,
296                GT_TraceClass classType,
297                const char   *fileName,
298                int32_t       lineNum,
299                const char   *infoString,
300                uintptr_t     param0,
301                uintptr_t     param1,
302                uintptr_t     param2,
303                uintptr_t     param3,
304                uintptr_t     param4,
305                uintptr_t     param5);
307 /**
308  *  \brief Function to log the trace with seven additional parameters.
309  *
310  *  \param  maskType   [IN] Trace mask
311  *  \param  classType  [IN] Trace class type
312  *  \param  fileName   [IN] File Name
313  *  \param  lineNum    [IN] Line Number
314  *  \param  infoString [IN] Print string
315  *  \param  param0     [IN] Parameter 0
316  *  \param  param1     [IN] Parameter 1
317  *  \param  param2     [IN] Parameter 2
318  *  \param  param3     [IN] Parameter 3
319  *  \param  param4     [IN] Parameter 4
320  *  \param  param5     [IN] Parameter 5
321  *  \param  param6     [IN] Parameter 6
322  *
323  */
324 void GT_trace7(uint32_t      maskType,
325                GT_TraceClass classType,
326                const char   *fileName,
327                int32_t       lineNum,
328                const char   *infoString,
329                uintptr_t     param0,
330                uintptr_t     param1,
331                uintptr_t     param2,
332                uintptr_t     param3,
333                uintptr_t     param4,
334                uintptr_t     param5,
335                uintptr_t     param6);
337 #if defined (FVID2_CFG_TRACE_ENABLE)
338 /** \brief Log the trace with zero parameters and information string. */
339 #define GT_0trace(maskType, classType, infoString)                          \
340     (GT_trace0((maskType), (classType),                                     \
341                (const char *) __FILE__, (int32_t) __LINE__,                 \
342                (const char *) (infoString)))
344 /** \brief Function to log the trace with one additional parameters. */
345 #define GT_1trace(maskType, classType, infoString, param0)                  \
346     (GT_trace1((maskType), (classType),                                     \
347                (const char *) __FILE__, (int32_t) __LINE__,                 \
348                (const char *) (infoString), (uintptr_t) (param0)))
350 /** \brief Function to log the trace with two additional parameters. */
351 #define GT_2trace(maskType, classType, infoString, param0, param1)          \
352     (GT_trace2((maskType), (classType),                                     \
353                (const char *) __FILE__, (int32_t) __LINE__,                 \
354                (const char *) (infoString), (uintptr_t) (param0), (uintptr_t) (param1)))
356 /** \brief Function to log the trace with three additional parameters. */
357 #define GT_3trace(maskType, classType, infoString, param0, param1, param2)  \
358     (GT_trace3((maskType), (classType),                                     \
359                (const char *) __FILE__, (int32_t) __LINE__,                 \
360                (const char *) (infoString),                                 \
361                (uintptr_t) (param0),                                        \
362                (uintptr_t) (param1),                                        \
363                (uintptr_t) (param2)))
365 /** \brief Function to log the trace with four additional parameters. */
366 #define GT_4trace(maskType, classType, infoString,                          \
367                   param0, param1, param2, param3)                           \
368     (GT_trace4((maskType), (classType),                                     \
369                (const char *) __FILE__, (int32_t) __LINE__,                 \
370                (const char *) (infoString),                                 \
371                (uintptr_t) (param0),                                        \
372                (uintptr_t) (param1),                                        \
373                (uintptr_t) (param2),                                        \
374                (uintptr_t) (param3)))
376 /** \brief Function to log the trace with five additional parameters. */
377 #define GT_5trace(maskType, classType, infoString,                          \
378                   param0, param1, param2, param3, param4)                   \
379     (GT_trace5((maskType), (classType),                                     \
380                (const char *) __FILE__, (int32_t) __LINE__,                 \
381                (const char *) (infoString),                                 \
382                (uintptr_t) (param0),                                        \
383                (uintptr_t) (param1),                                        \
384                (uintptr_t) (param2),                                        \
385                (uintptr_t) (param3),                                        \
386                (uintptr_t) (param4)))
388 /** \brief Function to log the trace with six additional parameters. */
389 #define GT_6trace(maskType, classType, infoString,                          \
390                   param0, param1, param2, param3, param4, param5)           \
391     (GT_trace6((maskType), (classType),                                     \
392                (const char *) __FILE__, (int32_t) __LINE__,                 \
393                (const char *) (infoString),                                 \
394                (uintptr_t) (param0),                                        \
395                (uintptr_t) (param1),                                        \
396                (uintptr_t) (param2),                                        \
397                (uintptr_t) (param3),                                        \
398                (uintptr_t) (param4),                                        \
399                (uintptr_t) (param5)))
401 /** \brief Function to log the trace with seven additional parameters. */
402 #define GT_7trace(maskType, classType, infoString,                          \
403                   param0, param1, param2, param3, param4, param5, param6)   \
404     (GT_trace7((maskType), (classType),                                     \
405                (const char *) __FILE__, (int32_t) __LINE__,                 \
406                (const char *) (infoString),                                 \
407                (uintptr_t) (param0),                                        \
408                (uintptr_t) (param1),                                        \
409                (uintptr_t) (param2),                                        \
410                (uintptr_t) (param3),                                        \
411                (uintptr_t) (param4),                                        \
412                (uintptr_t) (param5),                                        \
413                (uintptr_t) (param6)))
415 #else   /* if defined (FVID2_CFG_TRACE_ENABLE) */
417 /** \brief Log the trace with zero parameters and information string. */
418 #define GT_0trace(maskType, classType, infoString)
419 /** \brief Function to log the trace with one additional parameter. */
420 #define GT_1trace(maskType, classType, infoString, param0)
421 /** \brief Function to log the trace with two additional parameters. */
422 #define GT_2trace(maskType, classType, infoString, param0, param1)
423 /** \brief Function to log the trace with three additional parameters. */
424 #define GT_3trace(maskType, classType, infoString, param0, param1, param2)
425 /** \brief Function to log the trace with four additional parameters. */
426 #define GT_4trace(maskType, classType, infoString, param0, param1, param2, \
427                   param3)
428 /** \brief Function to log the trace with five additional parameters. */
429 #define GT_5trace(maskType, classType, infoString, param0, param1, param2, \
430                   param3, param4)
431 /** \brief Function to log the trace with six additional parameters. */
432 #define GT_6trace(maskType, classType, infoString, param0, param1, param2, \
433                   param3, param4, param5)
434 /** \brief Function to log the trace with seven additional parameters. */
435 #define GT_7trace(maskType, classType, infoString, param0, param1, param2, \
436                   param3, param4, param5, param6)
438 #endif  /* if defined (FVID2_CFG_TRACE_ENABLE) */
440 #ifdef __cplusplus
442 #endif
444 #endif /* ifndef FVID2TRACE_H_ */