xref: /linux/drivers/usb/cdns3/cdns3-trace.h (revision dc1308bee1ed03b4d698d77c8bd670d399dcd04d) 
1  /* SPDX-License-Identifier: GPL-2.0 */
2  /*
3   * USBSS device controller driver.
4   * Trace support header file.
5   *
6   * Copyright (C) 2018-2019 Cadence.
7   *
8   * Author: Pawel Laszczak <pawell@cadence.com>
9   */
10  
11  #undef TRACE_SYSTEM
12  #define TRACE_SYSTEM cdns3
13  
14  #if !defined(__LINUX_CDNS3_TRACE) || defined(TRACE_HEADER_MULTI_READ)
15  #define __LINUX_CDNS3_TRACE
16  
17  #include <linux/types.h>
18  #include <linux/tracepoint.h>
19  #include <asm/byteorder.h>
20  #include <linux/usb/ch9.h>
21  #include "core.h"
22  #include "cdns3-gadget.h"
23  #include "cdns3-debug.h"
24  
25  #define CDNS3_MSG_MAX	500
26  
27  TRACE_EVENT(cdns3_halt,
28  	TP_PROTO(struct cdns3_endpoint *ep_priv, u8 halt, u8 flush),
29  	TP_ARGS(ep_priv, halt, flush),
30  	TP_STRUCT__entry(
31  		__string(name, ep_priv->name)
32  		__field(u8, halt)
33  		__field(u8, flush)
34  	),
35  	TP_fast_assign(
36  		__assign_str(name);
37  		__entry->halt = halt;
38  		__entry->flush = flush;
39  	),
40  	TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
41  		  __get_str(name), __entry->halt ? "set" : "cleared")
42  );
43  
44  TRACE_EVENT(cdns3_wa1,
45  	TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
46  	TP_ARGS(ep_priv, msg),
47  	TP_STRUCT__entry(
48  		__string(ep_name, ep_priv->name)
49  		__string(msg, msg)
50  	),
51  	TP_fast_assign(
52  		__assign_str(ep_name);
53  		__assign_str(msg);
54  	),
55  	TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
56  );
57  
58  TRACE_EVENT(cdns3_wa2,
59  	TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
60  	TP_ARGS(ep_priv, msg),
61  	TP_STRUCT__entry(
62  		__string(ep_name, ep_priv->name)
63  		__string(msg, msg)
64  	),
65  	TP_fast_assign(
66  		__assign_str(ep_name);
67  		__assign_str(msg);
68  	),
69  	TP_printk("WA2: %s %s", __get_str(ep_name), __get_str(msg))
70  );
71  
72  DECLARE_EVENT_CLASS(cdns3_log_doorbell,
73  	TP_PROTO(const char *ep_name, u32 ep_trbaddr),
74  	TP_ARGS(ep_name, ep_trbaddr),
75  	TP_STRUCT__entry(
76  		__string(name, ep_name)
77  		__field(u32, ep_trbaddr)
78  	),
79  	TP_fast_assign(
80  		__assign_str(name);
81  		__entry->ep_trbaddr = ep_trbaddr;
82  	),
83  	TP_printk("%s, ep_trbaddr %08x", __get_str(name),
84  		  __entry->ep_trbaddr)
85  );
86  
87  DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_ep0,
88  	TP_PROTO(const char *ep_name, u32 ep_trbaddr),
89  	TP_ARGS(ep_name, ep_trbaddr)
90  );
91  
92  DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_epx,
93  	TP_PROTO(const char *ep_name, u32 ep_trbaddr),
94  	TP_ARGS(ep_name, ep_trbaddr)
95  );
96  
97  DECLARE_EVENT_CLASS(cdns3_log_usb_irq,
98  	TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
99  	TP_ARGS(priv_dev, usb_ists),
100  	TP_STRUCT__entry(
101  		__field(enum usb_device_speed, speed)
102  		__field(u32, usb_ists)
103  	),
104  	TP_fast_assign(
105  		__entry->speed = cdns3_get_speed(priv_dev);
106  		__entry->usb_ists = usb_ists;
107  	),
108  	TP_printk("%s", cdns3_decode_usb_irq(__get_buf(CDNS3_MSG_MAX), __entry->speed,
109  					     __entry->usb_ists))
110  );
111  
112  DEFINE_EVENT(cdns3_log_usb_irq, cdns3_usb_irq,
113  	TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
114  	TP_ARGS(priv_dev, usb_ists)
115  );
116  
117  DECLARE_EVENT_CLASS(cdns3_log_epx_irq,
118  	TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
119  	TP_ARGS(priv_dev, priv_ep),
120  	TP_STRUCT__entry(
121  		__string(ep_name, priv_ep->name)
122  		__field(u32, ep_sts)
123  		__field(u32, ep_traddr)
124  		__field(u32, ep_last_sid)
125  		__field(u32, use_streams)
126  	),
127  	TP_fast_assign(
128  		__assign_str(ep_name);
129  		__entry->ep_sts = readl(&priv_dev->regs->ep_sts);
130  		__entry->ep_traddr = readl(&priv_dev->regs->ep_traddr);
131  		__entry->ep_last_sid = priv_ep->last_stream_id;
132  		__entry->use_streams = priv_ep->use_streams;
133  	),
134  	TP_printk("%s, ep_traddr: %08x ep_last_sid: %08x use_streams: %d",
135  		  cdns3_decode_epx_irq(__get_buf(CDNS3_MSG_MAX),
136  				       __get_str(ep_name),
137  				       __entry->ep_sts),
138  		  __entry->ep_traddr,
139  		  __entry->ep_last_sid,
140  		  __entry->use_streams)
141  );
142  
143  DEFINE_EVENT(cdns3_log_epx_irq, cdns3_epx_irq,
144  	TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
145  	TP_ARGS(priv_dev, priv_ep)
146  );
147  
148  DECLARE_EVENT_CLASS(cdns3_log_ep0_irq,
149  	TP_PROTO(struct cdns3_device *priv_dev,  u32 ep_sts),
150  	TP_ARGS(priv_dev, ep_sts),
151  	TP_STRUCT__entry(
152  		__field(int, ep_dir)
153  		__field(u32, ep_sts)
154  	),
155  	TP_fast_assign(
156  		__entry->ep_dir = priv_dev->selected_ep;
157  		__entry->ep_sts = ep_sts;
158  	),
159  	TP_printk("%s", cdns3_decode_ep0_irq(__get_buf(CDNS3_MSG_MAX),
160  					     __entry->ep_dir,
161  					     __entry->ep_sts))
162  );
163  
164  DEFINE_EVENT(cdns3_log_ep0_irq, cdns3_ep0_irq,
165  	TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts),
166  	TP_ARGS(priv_dev, ep_sts)
167  );
168  
169  DECLARE_EVENT_CLASS(cdns3_log_ctrl,
170  	TP_PROTO(struct usb_ctrlrequest *ctrl),
171  	TP_ARGS(ctrl),
172  	TP_STRUCT__entry(
173  		__field(u8, bRequestType)
174  		__field(u8, bRequest)
175  		__field(u16, wValue)
176  		__field(u16, wIndex)
177  		__field(u16, wLength)
178  	),
179  	TP_fast_assign(
180  		__entry->bRequestType = ctrl->bRequestType;
181  		__entry->bRequest = ctrl->bRequest;
182  		__entry->wValue = le16_to_cpu(ctrl->wValue);
183  		__entry->wIndex = le16_to_cpu(ctrl->wIndex);
184  		__entry->wLength = le16_to_cpu(ctrl->wLength);
185  	),
186  	TP_printk("%s", usb_decode_ctrl(__get_buf(CDNS3_MSG_MAX), CDNS3_MSG_MAX,
187  					__entry->bRequestType,
188  					__entry->bRequest, __entry->wValue,
189  					__entry->wIndex, __entry->wLength)
190  	)
191  );
192  
193  DEFINE_EVENT(cdns3_log_ctrl, cdns3_ctrl_req,
194  	TP_PROTO(struct usb_ctrlrequest *ctrl),
195  	TP_ARGS(ctrl)
196  );
197  
198  DECLARE_EVENT_CLASS(cdns3_log_request,
199  	TP_PROTO(struct cdns3_request *req),
200  	TP_ARGS(req),
201  	TP_STRUCT__entry(
202  		__string(name, req->priv_ep->name)
203  		__field(struct cdns3_request *, req)
204  		__field(void *, buf)
205  		__field(unsigned int, actual)
206  		__field(unsigned int, length)
207  		__field(int, status)
208  		__field(int, zero)
209  		__field(int, short_not_ok)
210  		__field(int, no_interrupt)
211  		__field(int, start_trb)
212  		__field(int, end_trb)
213  		__field(int, flags)
214  		__field(unsigned int, stream_id)
215  	),
216  	TP_fast_assign(
217  		__assign_str(name);
218  		__entry->req = req;
219  		__entry->buf = req->request.buf;
220  		__entry->actual = req->request.actual;
221  		__entry->length = req->request.length;
222  		__entry->status = req->request.status;
223  		__entry->zero = req->request.zero;
224  		__entry->short_not_ok = req->request.short_not_ok;
225  		__entry->no_interrupt = req->request.no_interrupt;
226  		__entry->start_trb = req->start_trb;
227  		__entry->end_trb = req->end_trb;
228  		__entry->flags = req->flags;
229  		__entry->stream_id = req->request.stream_id;
230  	),
231  	TP_printk("%s: req: %p, req buff %p, length: %u/%u %s%s%s, status: %d,"
232  		  " trb: [start:%d, end:%d], flags:%x SID: %u",
233  		__get_str(name), __entry->req, __entry->buf, __entry->actual,
234  		__entry->length,
235  		__entry->zero ? "Z" : "z",
236  		__entry->short_not_ok ? "S" : "s",
237  		__entry->no_interrupt ? "I" : "i",
238  		__entry->status,
239  		__entry->start_trb,
240  		__entry->end_trb,
241  		__entry->flags,
242  		__entry->stream_id
243  	)
244  );
245  
246  DEFINE_EVENT(cdns3_log_request, cdns3_alloc_request,
247  	TP_PROTO(struct cdns3_request *req),
248  	TP_ARGS(req)
249  );
250  
251  DEFINE_EVENT(cdns3_log_request, cdns3_free_request,
252  	TP_PROTO(struct cdns3_request *req),
253  	TP_ARGS(req)
254  );
255  
256  DEFINE_EVENT(cdns3_log_request, cdns3_ep_queue,
257  	TP_PROTO(struct cdns3_request *req),
258  	TP_ARGS(req)
259  );
260  
261  DEFINE_EVENT(cdns3_log_request, cdns3_ep_dequeue,
262  	TP_PROTO(struct cdns3_request *req),
263  	TP_ARGS(req)
264  );
265  
266  DEFINE_EVENT(cdns3_log_request, cdns3_gadget_giveback,
267  	TP_PROTO(struct cdns3_request *req),
268  	TP_ARGS(req)
269  );
270  
271  TRACE_EVENT(cdns3_ep0_queue,
272  	TP_PROTO(struct cdns3_device *dev_priv, struct usb_request *request),
273  	TP_ARGS(dev_priv, request),
274  	TP_STRUCT__entry(
275  		__field(int, dir)
276  		__field(int, length)
277  	),
278  	TP_fast_assign(
279  		__entry->dir = dev_priv->ep0_data_dir;
280  		__entry->length = request->length;
281  	),
282  	TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
283  		  __entry->length)
284  );
285  
286  DECLARE_EVENT_CLASS(cdns3_stream_split_transfer_len,
287  	TP_PROTO(struct cdns3_request *req),
288  	TP_ARGS(req),
289  	TP_STRUCT__entry(
290  		__string(name, req->priv_ep->name)
291  		__field(struct cdns3_request *, req)
292  		__field(unsigned int, length)
293  		__field(unsigned int, actual)
294  		__field(unsigned int, stream_id)
295  	),
296  	TP_fast_assign(
297  		__assign_str(name);
298  		__entry->req = req;
299  		__entry->actual = req->request.length;
300  		__entry->length = req->request.actual;
301  		__entry->stream_id = req->request.stream_id;
302  	),
303  	TP_printk("%s: req: %p,request length: %u actual length: %u  SID: %u",
304  		  __get_str(name), __entry->req, __entry->length,
305  		  __entry->actual, __entry->stream_id)
306  );
307  
308  DEFINE_EVENT(cdns3_stream_split_transfer_len, cdns3_stream_transfer_split,
309  	     TP_PROTO(struct cdns3_request *req),
310  	     TP_ARGS(req)
311  );
312  
313  DEFINE_EVENT(cdns3_stream_split_transfer_len,
314  	     cdns3_stream_transfer_split_next_part,
315  	     TP_PROTO(struct cdns3_request *req),
316  	     TP_ARGS(req)
317  );
318  
319  DECLARE_EVENT_CLASS(cdns3_log_aligned_request,
320  	TP_PROTO(struct cdns3_request *priv_req),
321  	TP_ARGS(priv_req),
322  	TP_STRUCT__entry(
323  		__string(name, priv_req->priv_ep->name)
324  		__field(struct usb_request *, req)
325  		__field(void *, buf)
326  		__field(dma_addr_t, dma)
327  		__field(void *, aligned_buf)
328  		__field(dma_addr_t, aligned_dma)
329  		__field(u32, aligned_buf_size)
330  	),
331  	TP_fast_assign(
332  		__assign_str(name);
333  		__entry->req = &priv_req->request;
334  		__entry->buf = priv_req->request.buf;
335  		__entry->dma = priv_req->request.dma;
336  		__entry->aligned_buf = priv_req->aligned_buf->buf;
337  		__entry->aligned_dma = priv_req->aligned_buf->dma;
338  		__entry->aligned_buf_size = priv_req->aligned_buf->size;
339  	),
340  	TP_printk("%s: req: %p, req buf %p, dma %pad a_buf %p a_dma %pad, size %d",
341  		__get_str(name), __entry->req, __entry->buf, &__entry->dma,
342  		__entry->aligned_buf, &__entry->aligned_dma,
343  		__entry->aligned_buf_size
344  	)
345  );
346  
347  DEFINE_EVENT(cdns3_log_aligned_request, cdns3_free_aligned_request,
348  	TP_PROTO(struct cdns3_request *req),
349  	TP_ARGS(req)
350  );
351  
352  DEFINE_EVENT(cdns3_log_aligned_request, cdns3_prepare_aligned_request,
353  	TP_PROTO(struct cdns3_request *req),
354  	TP_ARGS(req)
355  );
356  
357  DECLARE_EVENT_CLASS(cdns3_log_map_request,
358  	TP_PROTO(struct cdns3_request *priv_req),
359  	TP_ARGS(priv_req),
360  	TP_STRUCT__entry(
361  		__string(name, priv_req->priv_ep->name)
362  		__field(struct usb_request *, req)
363  		__field(void *, buf)
364  		__field(dma_addr_t, dma)
365  	),
366  	TP_fast_assign(
367  		__assign_str(name);
368  		__entry->req = &priv_req->request;
369  		__entry->buf = priv_req->request.buf;
370  		__entry->dma = priv_req->request.dma;
371  	),
372  	TP_printk("%s: req: %p, req buf %p, dma %p",
373  		  __get_str(name), __entry->req, __entry->buf, &__entry->dma
374  	)
375  );
376  DEFINE_EVENT(cdns3_log_map_request, cdns3_map_request,
377  	     TP_PROTO(struct cdns3_request *req),
378  	     TP_ARGS(req)
379  );
380  DEFINE_EVENT(cdns3_log_map_request, cdns3_mapped_request,
381  	     TP_PROTO(struct cdns3_request *req),
382  	     TP_ARGS(req)
383  );
384  
385  DECLARE_EVENT_CLASS(cdns3_log_trb,
386  	TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
387  	TP_ARGS(priv_ep, trb),
388  	TP_STRUCT__entry(
389  		__string(name, priv_ep->name)
390  		__field(struct cdns3_trb *, trb)
391  		__field(u32, buffer)
392  		__field(u32, length)
393  		__field(u32, control)
394  		__field(u32, type)
395  		__field(unsigned int, last_stream_id)
396  	),
397  	TP_fast_assign(
398  		__assign_str(name);
399  		__entry->trb = trb;
400  		__entry->buffer = le32_to_cpu(trb->buffer);
401  		__entry->length = le32_to_cpu(trb->length);
402  		__entry->control = le32_to_cpu(trb->control);
403  		__entry->type = usb_endpoint_type(priv_ep->endpoint.desc);
404  		__entry->last_stream_id = priv_ep->last_stream_id;
405  	),
406  	TP_printk("%s: trb %p, dma buf: 0x%08x, size: %ld, burst: %d ctrl: 0x%08x (%s%s%s%s%s%s%s) SID:%lu LAST_SID:%u",
407  		__get_str(name), __entry->trb, __entry->buffer,
408  		TRB_LEN(__entry->length),
409  		(u8)TRB_BURST_LEN_GET(__entry->length),
410  		__entry->control,
411  		__entry->control & TRB_CYCLE ? "C=1, " : "C=0, ",
412  		__entry->control & TRB_TOGGLE ? "T=1, " : "T=0, ",
413  		__entry->control & TRB_ISP ? "ISP, " : "",
414  		__entry->control & TRB_FIFO_MODE ? "FIFO, " : "",
415  		__entry->control & TRB_CHAIN ? "CHAIN, " : "",
416  		__entry->control & TRB_IOC ? "IOC, " : "",
417  		TRB_FIELD_TO_TYPE(__entry->control) == TRB_NORMAL ? "Normal" : "LINK",
418  		TRB_FIELD_TO_STREAMID(__entry->control),
419  		__entry->last_stream_id
420  	)
421  );
422  
423  DEFINE_EVENT(cdns3_log_trb, cdns3_prepare_trb,
424  	TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
425  	TP_ARGS(priv_ep, trb)
426  );
427  
428  DEFINE_EVENT(cdns3_log_trb, cdns3_complete_trb,
429  	TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
430  	TP_ARGS(priv_ep, trb)
431  );
432  
433  DECLARE_EVENT_CLASS(cdns3_log_ring,
434  	TP_PROTO(struct cdns3_endpoint *priv_ep),
435  	TP_ARGS(priv_ep),
436  	TP_STRUCT__entry(
437  		__dynamic_array(char, buffer,
438  				GET_TRBS_PER_SEGMENT(priv_ep->type) > TRBS_PER_SEGMENT ?
439  				CDNS3_MSG_MAX :
440  				(GET_TRBS_PER_SEGMENT(priv_ep->type) * 65) + CDNS3_MSG_MAX)
441  	),
442  	TP_fast_assign(
443  		cdns3_dbg_ring(priv_ep, __get_str(buffer));
444  	),
445  
446  	TP_printk("%s", __get_str(buffer))
447  );
448  
449  DEFINE_EVENT(cdns3_log_ring, cdns3_ring,
450  	TP_PROTO(struct cdns3_endpoint *priv_ep),
451  	TP_ARGS(priv_ep)
452  );
453  
454  DECLARE_EVENT_CLASS(cdns3_log_ep,
455  	TP_PROTO(struct cdns3_endpoint *priv_ep),
456  	TP_ARGS(priv_ep),
457  	TP_STRUCT__entry(
458  		__string(name, priv_ep->name)
459  		__field(unsigned int, maxpacket)
460  		__field(unsigned int, maxpacket_limit)
461  		__field(unsigned int, max_streams)
462  		__field(unsigned int, use_streams)
463  		__field(unsigned int, maxburst)
464  		__field(unsigned int, flags)
465  		__field(unsigned int, dir)
466  		__field(u8, enqueue)
467  		__field(u8, dequeue)
468  	),
469  	TP_fast_assign(
470  		__assign_str(name);
471  		__entry->maxpacket = priv_ep->endpoint.maxpacket;
472  		__entry->maxpacket_limit = priv_ep->endpoint.maxpacket_limit;
473  		__entry->max_streams = priv_ep->endpoint.max_streams;
474  		__entry->use_streams = priv_ep->use_streams;
475  		__entry->maxburst = priv_ep->endpoint.maxburst;
476  		__entry->flags = priv_ep->flags;
477  		__entry->dir = priv_ep->dir;
478  		__entry->enqueue = priv_ep->enqueue;
479  		__entry->dequeue = priv_ep->dequeue;
480  	),
481  	TP_printk("%s: mps: %d/%d. streams: %d, stream enable: %d, burst: %d, "
482  		  "enq idx: %d, deq idx: %d, flags %s%s%s%s%s%s%s%s, dir: %s",
483  		__get_str(name), __entry->maxpacket,
484  		__entry->maxpacket_limit, __entry->max_streams,
485  		__entry->use_streams,
486  		__entry->maxburst, __entry->enqueue,
487  		__entry->dequeue,
488  		__entry->flags & EP_ENABLED ? "EN | " : "",
489  		__entry->flags & EP_STALLED ? "STALLED | " : "",
490  		__entry->flags & EP_WEDGE ? "WEDGE | " : "",
491  		__entry->flags & EP_TRANSFER_STARTED ? "STARTED | " : "",
492  		__entry->flags & EP_UPDATE_EP_TRBADDR ? "UPD TRB | " : "",
493  		__entry->flags & EP_PENDING_REQUEST ? "REQ PEN | " : "",
494  		__entry->flags & EP_RING_FULL ? "RING FULL |" : "",
495  		__entry->flags & EP_CLAIMED ?  "CLAIMED " : "",
496  		__entry->dir ? "IN" : "OUT"
497  	)
498  );
499  
500  DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_enable,
501  	TP_PROTO(struct cdns3_endpoint *priv_ep),
502  	TP_ARGS(priv_ep)
503  );
504  
505  DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_disable,
506  	TP_PROTO(struct cdns3_endpoint *priv_ep),
507  	TP_ARGS(priv_ep)
508  );
509  
510  DECLARE_EVENT_CLASS(cdns3_log_request_handled,
511  	TP_PROTO(struct cdns3_request *priv_req, int current_index,
512  		 int handled),
513  	TP_ARGS(priv_req, current_index, handled),
514  	TP_STRUCT__entry(
515  		__field(struct cdns3_request *, priv_req)
516  		__field(unsigned int, dma_position)
517  		__field(unsigned int, handled)
518  		__field(unsigned int, dequeue_idx)
519  		__field(unsigned int, enqueue_idx)
520  		__field(unsigned int, start_trb)
521  		__field(unsigned int, end_trb)
522  	),
523  	TP_fast_assign(
524  		__entry->priv_req = priv_req;
525  		__entry->dma_position = current_index;
526  		__entry->handled = handled;
527  		__entry->dequeue_idx = priv_req->priv_ep->dequeue;
528  		__entry->enqueue_idx = priv_req->priv_ep->enqueue;
529  		__entry->start_trb = priv_req->start_trb;
530  		__entry->end_trb = priv_req->end_trb;
531  	),
532  	TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
533  		  " start trb: %d, end trb: %d",
534  		__entry->priv_req,
535  		__entry->handled ? "handled" : "not handled",
536  		__entry->dma_position, __entry->dequeue_idx,
537  		__entry->enqueue_idx, __entry->start_trb,
538  		__entry->end_trb
539  	)
540  );
541  
542  DEFINE_EVENT(cdns3_log_request_handled, cdns3_request_handled,
543  	TP_PROTO(struct cdns3_request *priv_req, int current_index,
544  		 int handled),
545  	TP_ARGS(priv_req, current_index, handled)
546  );
547  #endif /* __LINUX_CDNS3_TRACE */
548  
549  /* this part must be outside header guard */
550  
551  #undef TRACE_INCLUDE_PATH
552  #define TRACE_INCLUDE_PATH .
553  
554  #undef TRACE_INCLUDE_FILE
555  #define TRACE_INCLUDE_FILE cdns3-trace
556  
557  #include <trace/define_trace.h>
558