xref: /linux/drivers/usb/cdns3/cdns3-trace.h (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0) 
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