1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * USBHS-DEV device controller driver.
4  * Trace support header file.
5  *
6  * Copyright (C) 2023 Cadence.
7  *
8  * Author: Pawel Laszczak <pawell@cadence.com>
9  */
10 
11 #undef TRACE_SYSTEM
12 #define TRACE_SYSTEM cdns2-dev
13 
14 /*
15  * The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a
16  * legitimate C variable. It is not exported to user space.
17  */
18 #undef TRACE_SYSTEM_VAR
19 #define TRACE_SYSTEM_VAR cdns2_dev
20 
21 #if !defined(__LINUX_CDNS2_TRACE) || defined(TRACE_HEADER_MULTI_READ)
22 #define __LINUX_CDNS2_TRACE
23 
24 #include <linux/types.h>
25 #include <linux/tracepoint.h>
26 #include <asm/byteorder.h>
27 #include <linux/usb/ch9.h>
28 #include "cdns2-gadget.h"
29 #include "cdns2-debug.h"
30 
31 #define CDNS2_MSG_MAX	500
32 
33 DECLARE_EVENT_CLASS(cdns2_log_enable_disable,
34 	TP_PROTO(int set),
35 	TP_ARGS(set),
36 	TP_STRUCT__entry(
37 		__field(int, set)
38 	),
39 	TP_fast_assign(
40 		__entry->set = set;
41 	),
42 	TP_printk("%s", __entry->set ? "enabled" : "disabled")
43 );
44 
45 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_pullup,
46 	TP_PROTO(int set),
47 	TP_ARGS(set)
48 );
49 
50 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_lpm,
51 	TP_PROTO(int set),
52 	TP_ARGS(set)
53 );
54 
55 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_may_wakeup,
56 	TP_PROTO(int set),
57 	TP_ARGS(set)
58 );
59 
60 DECLARE_EVENT_CLASS(cdns2_log_simple,
61 	TP_PROTO(char *msg),
62 	TP_ARGS(msg),
63 	TP_STRUCT__entry(
64 		__string(text, msg)
65 	),
66 	TP_fast_assign(
67 		__assign_str(text, msg);
68 	),
69 	TP_printk("%s", __get_str(text))
70 );
71 
72 DEFINE_EVENT(cdns2_log_simple, cdns2_no_room_on_ring,
73 	TP_PROTO(char *msg),
74 	TP_ARGS(msg)
75 );
76 
77 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_status_stage,
78 	TP_PROTO(char *msg),
79 	TP_ARGS(msg)
80 );
81 
82 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_set_config,
83 	TP_PROTO(char *msg),
84 	TP_ARGS(msg)
85 );
86 
87 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_setup,
88 	TP_PROTO(char *msg),
89 	TP_ARGS(msg)
90 );
91 
92 DEFINE_EVENT(cdns2_log_simple, cdns2_device_state,
93 	TP_PROTO(char *msg),
94 	TP_ARGS(msg)
95 );
96 
97 TRACE_EVENT(cdns2_ep_halt,
98 	TP_PROTO(struct cdns2_endpoint *ep_priv, u8 halt, u8 flush),
99 	TP_ARGS(ep_priv, halt, flush),
100 	TP_STRUCT__entry(
101 		__string(name, ep_priv->name)
102 		__field(u8, halt)
103 		__field(u8, flush)
104 	),
105 	TP_fast_assign(
106 		__assign_str(name, ep_priv->name);
107 		__entry->halt = halt;
108 		__entry->flush = flush;
109 	),
110 	TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
111 		  __get_str(name), __entry->halt ? "set" : "cleared")
112 );
113 
114 TRACE_EVENT(cdns2_wa1,
115 	TP_PROTO(struct cdns2_endpoint *ep_priv, char *msg),
116 	TP_ARGS(ep_priv, msg),
117 	TP_STRUCT__entry(
118 		__string(ep_name, ep_priv->name)
119 		__string(msg, msg)
120 	),
121 	TP_fast_assign(
122 		__assign_str(ep_name, ep_priv->name);
123 		__assign_str(msg, msg);
124 	),
125 	TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
126 );
127 
128 DECLARE_EVENT_CLASS(cdns2_log_doorbell,
129 	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
130 	TP_ARGS(pep, ep_trbaddr),
131 	TP_STRUCT__entry(
132 		__string(name, pep->num ? pep->name :
133 				(pep->dir ? "ep0in" : "ep0out"))
134 		__field(u32, ep_trbaddr)
135 	),
136 	TP_fast_assign(
137 		__assign_str(name, pep->name);
138 		__entry->ep_trbaddr = ep_trbaddr;
139 	),
140 	TP_printk("%s, ep_trbaddr %08x", __get_str(name),
141 		  __entry->ep_trbaddr)
142 );
143 
144 DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_ep0,
145 	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
146 	TP_ARGS(pep, ep_trbaddr)
147 );
148 
149 DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_epx,
150 	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
151 	TP_ARGS(pep, ep_trbaddr)
152 );
153 
154 DECLARE_EVENT_CLASS(cdns2_log_usb_irq,
155 	TP_PROTO(u32 usb_irq, u32 ext_irq),
156 	TP_ARGS(usb_irq, ext_irq),
157 	TP_STRUCT__entry(
158 		__field(u32, usb_irq)
159 		__field(u32, ext_irq)
160 	),
161 	TP_fast_assign(
162 		__entry->usb_irq = usb_irq;
163 		__entry->ext_irq = ext_irq;
164 	),
165 	TP_printk("%s", cdns2_decode_usb_irq(__get_buf(CDNS2_MSG_MAX),
166 					     CDNS2_MSG_MAX,
167 					     __entry->usb_irq,
168 					     __entry->ext_irq))
169 );
170 
171 DEFINE_EVENT(cdns2_log_usb_irq, cdns2_usb_irq,
172 	TP_PROTO(u32 usb_irq, u32 ext_irq),
173 	TP_ARGS(usb_irq, ext_irq)
174 );
175 
176 TRACE_EVENT(cdns2_dma_ep_ists,
177 	TP_PROTO(u32 dma_ep_ists),
178 	TP_ARGS(dma_ep_ists),
179 	TP_STRUCT__entry(
180 		__field(u32, dma_ep_ists)
181 	),
182 	TP_fast_assign(
183 		__entry->dma_ep_ists = dma_ep_ists;
184 	),
185 	TP_printk("OUT: 0x%04x, IN: 0x%04x", (u16)__entry->dma_ep_ists,
186 		  __entry->dma_ep_ists >> 16)
187 );
188 
189 DECLARE_EVENT_CLASS(cdns2_log_epx_irq,
190 	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
191 	TP_ARGS(pdev, pep),
192 	TP_STRUCT__entry(
193 		__string(ep_name, pep->name)
194 		__field(u32, ep_sts)
195 		__field(u32, ep_ists)
196 		__field(u32, ep_traddr)
197 	),
198 	TP_fast_assign(
199 		__assign_str(ep_name, pep->name);
200 		__entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
201 		__entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
202 		__entry->ep_traddr = readl(&pdev->adma_regs->ep_traddr);
203 	),
204 	TP_printk("%s, ep_traddr: %08x",
205 		  cdns2_decode_epx_irq(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
206 				       __get_str(ep_name),
207 				       __entry->ep_ists, __entry->ep_sts),
208 		  __entry->ep_traddr)
209 );
210 
211 DEFINE_EVENT(cdns2_log_epx_irq, cdns2_epx_irq,
212 	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
213 	TP_ARGS(pdev, pep)
214 );
215 
216 DECLARE_EVENT_CLASS(cdns2_log_ep0_irq,
217 	TP_PROTO(struct cdns2_device *pdev),
218 	TP_ARGS(pdev),
219 	TP_STRUCT__entry(
220 		__field(int, ep_dir)
221 		__field(u32, ep_ists)
222 		__field(u32, ep_sts)
223 	),
224 	TP_fast_assign(
225 		__entry->ep_dir = pdev->selected_ep;
226 		__entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
227 		__entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
228 	),
229 	TP_printk("%s", cdns2_decode_ep0_irq(__get_buf(CDNS2_MSG_MAX),
230 					     CDNS2_MSG_MAX,
231 					     __entry->ep_ists, __entry->ep_sts,
232 					     __entry->ep_dir))
233 );
234 
235 DEFINE_EVENT(cdns2_log_ep0_irq, cdns2_ep0_irq,
236 	TP_PROTO(struct cdns2_device *pdev),
237 	TP_ARGS(pdev)
238 );
239 
240 DECLARE_EVENT_CLASS(cdns2_log_ctrl,
241 	TP_PROTO(struct usb_ctrlrequest *ctrl),
242 	TP_ARGS(ctrl),
243 	TP_STRUCT__entry(
244 		__field(u8, bRequestType)
245 		__field(u8, bRequest)
246 		__field(u16, wValue)
247 		__field(u16, wIndex)
248 		__field(u16, wLength)
249 	),
250 	TP_fast_assign(
251 		__entry->bRequestType = ctrl->bRequestType;
252 		__entry->bRequest = ctrl->bRequest;
253 		__entry->wValue = le16_to_cpu(ctrl->wValue);
254 		__entry->wIndex = le16_to_cpu(ctrl->wIndex);
255 		__entry->wLength = le16_to_cpu(ctrl->wLength);
256 	),
257 	TP_printk("%s", usb_decode_ctrl(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
258 					__entry->bRequestType,
259 					__entry->bRequest, __entry->wValue,
260 					__entry->wIndex, __entry->wLength)
261 	)
262 );
263 
264 DEFINE_EVENT(cdns2_log_ctrl, cdns2_ctrl_req,
265 	TP_PROTO(struct usb_ctrlrequest *ctrl),
266 	TP_ARGS(ctrl)
267 );
268 
269 DECLARE_EVENT_CLASS(cdns2_log_request,
270 	TP_PROTO(struct cdns2_request *preq),
271 	TP_ARGS(preq),
272 	TP_STRUCT__entry(
273 		__string(name, preq->pep->name)
274 		__field(struct usb_request *, request)
275 		__field(struct cdns2_request *, preq)
276 		__field(void *, buf)
277 		__field(unsigned int, actual)
278 		__field(unsigned int, length)
279 		__field(int, status)
280 		__field(dma_addr_t, dma)
281 		__field(int, zero)
282 		__field(int, short_not_ok)
283 		__field(int, no_interrupt)
284 		__field(struct scatterlist*, sg)
285 		__field(unsigned int, num_sgs)
286 		__field(unsigned int, num_mapped_sgs)
287 		__field(int, start_trb)
288 		__field(int, end_trb)
289 	),
290 	TP_fast_assign(
291 		__assign_str(name, preq->pep->name);
292 		__entry->request = &preq->request;
293 		__entry->preq = preq;
294 		__entry->buf = preq->request.buf;
295 		__entry->actual = preq->request.actual;
296 		__entry->length = preq->request.length;
297 		__entry->status = preq->request.status;
298 		__entry->dma = preq->request.dma;
299 		__entry->zero = preq->request.zero;
300 		__entry->short_not_ok = preq->request.short_not_ok;
301 		__entry->no_interrupt = preq->request.no_interrupt;
302 		__entry->sg = preq->request.sg;
303 		__entry->num_sgs = preq->request.num_sgs;
304 		__entry->num_mapped_sgs = preq->request.num_mapped_sgs;
305 		__entry->start_trb = preq->start_trb;
306 		__entry->end_trb = preq->end_trb;
307 	),
308 	TP_printk("%s: req: %p, preq: %p, req buf: %p, length: %u/%u, status: %d,"
309 		  "buf dma: (%pad), %s%s%s, sg: %p, num_sgs: %d, num_m_sgs: %d,"
310 		  "trb: [start: %d, end: %d]",
311 		  __get_str(name), __entry->request, __entry->preq,
312 		  __entry->buf, __entry->actual, __entry->length,
313 		  __entry->status, &__entry->dma,
314 		  __entry->zero ? "Z" : "z",
315 		  __entry->short_not_ok ? "S" : "s",
316 		  __entry->no_interrupt ? "I" : "i",
317 		  __entry->sg, __entry->num_sgs, __entry->num_mapped_sgs,
318 		  __entry->start_trb,
319 		  __entry->end_trb
320 	)
321 );
322 
323 DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue,
324 	TP_PROTO(struct cdns2_request *preq),
325 	TP_ARGS(preq)
326 );
327 
328 DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue_error,
329 	TP_PROTO(struct cdns2_request *preq),
330 	TP_ARGS(preq)
331 );
332 
333 DEFINE_EVENT(cdns2_log_request, cdns2_alloc_request,
334 	TP_PROTO(struct cdns2_request *preq),
335 	TP_ARGS(preq)
336 );
337 
338 DEFINE_EVENT(cdns2_log_request, cdns2_free_request,
339 	TP_PROTO(struct cdns2_request *preq),
340 	TP_ARGS(preq)
341 );
342 
343 DEFINE_EVENT(cdns2_log_request, cdns2_ep_queue,
344 	TP_PROTO(struct cdns2_request *preq),
345 	TP_ARGS(preq)
346 );
347 
348 DEFINE_EVENT(cdns2_log_request, cdns2_request_dequeue,
349 	TP_PROTO(struct cdns2_request *preq),
350 	TP_ARGS(preq)
351 );
352 
353 DEFINE_EVENT(cdns2_log_request, cdns2_request_giveback,
354 	TP_PROTO(struct cdns2_request *preq),
355 	TP_ARGS(preq)
356 );
357 
358 TRACE_EVENT(cdns2_ep0_enqueue,
359 	TP_PROTO(struct cdns2_device *dev_priv, struct usb_request *request),
360 	TP_ARGS(dev_priv, request),
361 	TP_STRUCT__entry(
362 		__field(int, dir)
363 		__field(int, length)
364 	),
365 	TP_fast_assign(
366 		__entry->dir = dev_priv->eps[0].dir;
367 		__entry->length = request->length;
368 	),
369 	TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
370 		  __entry->length)
371 );
372 
373 DECLARE_EVENT_CLASS(cdns2_log_map_request,
374 	TP_PROTO(struct cdns2_request *priv_req),
375 	TP_ARGS(priv_req),
376 	TP_STRUCT__entry(
377 		__string(name, priv_req->pep->name)
378 		__field(struct usb_request *, req)
379 		__field(void *, buf)
380 		__field(dma_addr_t, dma)
381 	),
382 	TP_fast_assign(
383 		__assign_str(name, priv_req->pep->name);
384 		__entry->req = &priv_req->request;
385 		__entry->buf = priv_req->request.buf;
386 		__entry->dma = priv_req->request.dma;
387 	),
388 	TP_printk("%s: req: %p, req buf %p, dma %p",
389 		  __get_str(name), __entry->req, __entry->buf, &__entry->dma
390 	)
391 );
392 
393 DEFINE_EVENT(cdns2_log_map_request, cdns2_map_request,
394 	     TP_PROTO(struct cdns2_request *req),
395 	     TP_ARGS(req)
396 );
397 DEFINE_EVENT(cdns2_log_map_request, cdns2_mapped_request,
398 	     TP_PROTO(struct cdns2_request *req),
399 	     TP_ARGS(req)
400 );
401 
402 DECLARE_EVENT_CLASS(cdns2_log_trb,
403 	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
404 	TP_ARGS(pep, trb),
405 	TP_STRUCT__entry(
406 		__string(name, pep->name)
407 		__field(struct cdns2_trb *, trb)
408 		__field(u32, buffer)
409 		__field(u32, length)
410 		__field(u32, control)
411 		__field(u32, type)
412 	),
413 	TP_fast_assign(
414 		__assign_str(name, pep->name);
415 		__entry->trb = trb;
416 		__entry->buffer = le32_to_cpu(trb->buffer);
417 		__entry->length = le32_to_cpu(trb->length);
418 		__entry->control = le32_to_cpu(trb->control);
419 		__entry->type = usb_endpoint_type(pep->endpoint.desc);
420 	),
421 	TP_printk("%s: trb V: %p, dma buf: P: 0x%08x, %s",
422 		 __get_str(name), __entry->trb, __entry->buffer,
423 		 cdns2_decode_trb(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
424 				  __entry->control, __entry->length,
425 				  __entry->buffer))
426 );
427 
428 DEFINE_EVENT(cdns2_log_trb, cdns2_queue_trb,
429 	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
430 	TP_ARGS(pep, trb)
431 );
432 
433 DEFINE_EVENT(cdns2_log_trb, cdns2_complete_trb,
434 	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
435 	TP_ARGS(pep, trb)
436 );
437 
438 DECLARE_EVENT_CLASS(cdns2_log_ring,
439 	TP_PROTO(struct cdns2_endpoint *pep),
440 	TP_ARGS(pep),
441 	TP_STRUCT__entry(
442 		__dynamic_array(u8, tr_seg, TR_SEG_SIZE)
443 		__dynamic_array(u8, pep, sizeof(struct cdns2_endpoint))
444 		__dynamic_array(char, buffer,
445 				(TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX)
446 	),
447 	TP_fast_assign(
448 		memcpy(__get_dynamic_array(pep), pep,
449 		       sizeof(struct cdns2_endpoint));
450 		memcpy(__get_dynamic_array(tr_seg), pep->ring.trbs,
451 		       TR_SEG_SIZE);
452 	),
453 
454 	TP_printk("%s",
455 		  cdns2_raw_ring((struct cdns2_endpoint *)__get_str(pep),
456 				    (struct cdns2_trb *)__get_str(tr_seg),
457 				    __get_str(buffer),
458 				    (TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX))
459 );
460 
461 DEFINE_EVENT(cdns2_log_ring, cdns2_ring,
462 	TP_PROTO(struct cdns2_endpoint *pep),
463 	TP_ARGS(pep)
464 );
465 
466 DECLARE_EVENT_CLASS(cdns2_log_ep,
467 	TP_PROTO(struct cdns2_endpoint *pep),
468 	TP_ARGS(pep),
469 	TP_STRUCT__entry(
470 		__string(name, pep->name)
471 		__field(unsigned int, maxpacket)
472 		__field(unsigned int, maxpacket_limit)
473 		__field(unsigned int, flags)
474 		__field(unsigned int, dir)
475 		__field(u8, enqueue)
476 		__field(u8, dequeue)
477 	),
478 	TP_fast_assign(
479 		__assign_str(name, pep->name);
480 		__entry->maxpacket = pep->endpoint.maxpacket;
481 		__entry->maxpacket_limit = pep->endpoint.maxpacket_limit;
482 		__entry->flags = pep->ep_state;
483 		__entry->dir = pep->dir;
484 		__entry->enqueue = pep->ring.enqueue;
485 		__entry->dequeue = pep->ring.dequeue;
486 	),
487 	TP_printk("%s: mps: %d/%d, enq idx: %d, deq idx: %d, "
488 		  "flags: %s%s%s%s, dir: %s",
489 		__get_str(name), __entry->maxpacket,
490 		__entry->maxpacket_limit, __entry->enqueue,
491 		__entry->dequeue,
492 		__entry->flags & EP_ENABLED ? "EN | " : "",
493 		__entry->flags & EP_STALLED ? "STALLED | " : "",
494 		__entry->flags & EP_WEDGE ? "WEDGE | " : "",
495 		__entry->flags & EP_RING_FULL ? "RING FULL |" : "",
496 		__entry->dir ? "IN" : "OUT"
497 	)
498 );
499 
500 DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_enable,
501 	TP_PROTO(struct cdns2_endpoint *pep),
502 	TP_ARGS(pep)
503 );
504 
505 DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_disable,
506 	TP_PROTO(struct cdns2_endpoint *pep),
507 	TP_ARGS(pep)
508 );
509 
510 DEFINE_EVENT(cdns2_log_ep, cdns2_iso_out_ep_disable,
511 	TP_PROTO(struct cdns2_endpoint *pep),
512 	TP_ARGS(pep)
513 );
514 
515 DEFINE_EVENT(cdns2_log_ep, cdns2_ep_busy_try_halt_again,
516 	TP_PROTO(struct cdns2_endpoint *pep),
517 	TP_ARGS(pep)
518 );
519 
520 DECLARE_EVENT_CLASS(cdns2_log_request_handled,
521 	TP_PROTO(struct cdns2_request *priv_req, int current_index,
522 		 int handled),
523 	TP_ARGS(priv_req, current_index, handled),
524 	TP_STRUCT__entry(
525 		__field(struct cdns2_request *, priv_req)
526 		__field(unsigned int, dma_position)
527 		__field(unsigned int, handled)
528 		__field(unsigned int, dequeue_idx)
529 		__field(unsigned int, enqueue_idx)
530 		__field(unsigned int, start_trb)
531 		__field(unsigned int, end_trb)
532 	),
533 	TP_fast_assign(
534 		__entry->priv_req = priv_req;
535 		__entry->dma_position = current_index;
536 		__entry->handled = handled;
537 		__entry->dequeue_idx = priv_req->pep->ring.dequeue;
538 		__entry->enqueue_idx = priv_req->pep->ring.enqueue;
539 		__entry->start_trb = priv_req->start_trb;
540 		__entry->end_trb = priv_req->end_trb;
541 	),
542 	TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
543 		  " start trb: %d, end trb: %d",
544 		__entry->priv_req,
545 		__entry->handled ? "handled" : "not handled",
546 		__entry->dma_position, __entry->dequeue_idx,
547 		__entry->enqueue_idx, __entry->start_trb,
548 		__entry->end_trb
549 	)
550 );
551 
552 DEFINE_EVENT(cdns2_log_request_handled, cdns2_request_handled,
553 	TP_PROTO(struct cdns2_request *priv_req, int current_index,
554 		 int handled),
555 	TP_ARGS(priv_req, current_index, handled)
556 );
557 
558 DECLARE_EVENT_CLASS(cdns2_log_epx_reg_config,
559 	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
560 	TP_ARGS(pdev, pep),
561 	TP_STRUCT__entry(
562 		__string(ep_name, pep->name)
563 		__field(u8, burst_size)
564 		__field(__le16, maxpack_reg)
565 		__field(__u8, con_reg)
566 		__field(u32, ep_sel_reg)
567 		__field(u32, ep_sts_en_reg)
568 		__field(u32, ep_cfg_reg)
569 	),
570 	TP_fast_assign(
571 		__assign_str(ep_name, pep->name);
572 		__entry->burst_size = pep->trb_burst_size;
573 		__entry->maxpack_reg = pep->dir ? readw(&pdev->epx_regs->txmaxpack[pep->num - 1]) :
574 						  readw(&pdev->epx_regs->rxmaxpack[pep->num - 1]);
575 		__entry->con_reg = pep->dir ? readb(&pdev->epx_regs->ep[pep->num - 1].txcon) :
576 					      readb(&pdev->epx_regs->ep[pep->num - 1].rxcon);
577 		__entry->ep_sel_reg = readl(&pdev->adma_regs->ep_sel);
578 		__entry->ep_sts_en_reg = readl(&pdev->adma_regs->ep_sts_en);
579 		__entry->ep_cfg_reg = readl(&pdev->adma_regs->ep_cfg);
580 	),
581 
582 	TP_printk("%s, maxpack: %d, con: %02x, dma_ep_sel: %08x, dma_ep_sts_en: %08x"
583 		  " dma_ep_cfg %08x",
584 		  __get_str(ep_name), __entry->maxpack_reg, __entry->con_reg,
585 		  __entry->ep_sel_reg, __entry->ep_sts_en_reg,
586 		  __entry->ep_cfg_reg
587 	)
588 );
589 
590 DEFINE_EVENT(cdns2_log_epx_reg_config, cdns2_epx_hw_cfg,
591 	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
592 	TP_ARGS(pdev, pep)
593 );
594 
595 #endif /* __LINUX_CDNS2_TRACE */
596 
597 /* This part must be outside header guard. */
598 
599 #undef TRACE_INCLUDE_PATH
600 #define TRACE_INCLUDE_PATH .
601 
602 #undef TRACE_INCLUDE_FILE
603 #define TRACE_INCLUDE_FILE cdns2-trace
604 
605 #include <trace/define_trace.h>
606