Linux Audio

Check our new training course

Loading...
v6.8
  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * trace.h - DesignWare USB3 DRD Controller Trace Support
  4 *
  5 * Copyright (C) 2014 Texas Instruments Incorporated - https://www.ti.com
  6 *
  7 * Author: Felipe Balbi <balbi@ti.com>
 
 
 
 
 
 
 
 
 
  8 */
  9
 10#undef TRACE_SYSTEM
 11#define TRACE_SYSTEM dwc3
 12
 13#if !defined(__DWC3_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
 14#define __DWC3_TRACE_H
 15
 16#include <linux/types.h>
 17#include <linux/tracepoint.h>
 18#include <asm/byteorder.h>
 19#include "core.h"
 20#include "debug.h"
 21
 22DECLARE_EVENT_CLASS(dwc3_log_io,
 23	TP_PROTO(void *base, u32 offset, u32 value),
 24	TP_ARGS(base, offset, value),
 25	TP_STRUCT__entry(
 26		__field(void *, base)
 27		__field(u32, offset)
 28		__field(u32, value)
 29	),
 30	TP_fast_assign(
 31		__entry->base = base;
 32		__entry->offset = offset;
 33		__entry->value = value;
 34	),
 35	TP_printk("addr %p offset %04x value %08x",
 36		__entry->base + __entry->offset,
 37		__entry->offset,
 38		__entry->value)
 
 
 39);
 40
 41DEFINE_EVENT(dwc3_log_io, dwc3_readl,
 42	TP_PROTO(void __iomem *base, u32 offset, u32 value),
 43	TP_ARGS(base, offset, value)
 44);
 45
 46DEFINE_EVENT(dwc3_log_io, dwc3_writel,
 47	TP_PROTO(void __iomem *base, u32 offset, u32 value),
 48	TP_ARGS(base, offset, value)
 
 
 
 
 
 
 
 
 
 
 49);
 50
 51DECLARE_EVENT_CLASS(dwc3_log_event,
 52	TP_PROTO(u32 event, struct dwc3 *dwc),
 53	TP_ARGS(event, dwc),
 54	TP_STRUCT__entry(
 55		__field(u32, event)
 56		__field(u32, ep0state)
 57	),
 58	TP_fast_assign(
 59		__entry->event = event;
 60		__entry->ep0state = dwc->ep0state;
 61	),
 62	TP_printk("event (%08x): %s", __entry->event,
 63			dwc3_decode_event(__get_buf(DWC3_MSG_MAX), DWC3_MSG_MAX,
 64					__entry->event, __entry->ep0state))
 65);
 66
 67DEFINE_EVENT(dwc3_log_event, dwc3_event,
 68	TP_PROTO(u32 event, struct dwc3 *dwc),
 69	TP_ARGS(event, dwc)
 70);
 71
 72DECLARE_EVENT_CLASS(dwc3_log_ctrl,
 73	TP_PROTO(struct usb_ctrlrequest *ctrl),
 74	TP_ARGS(ctrl),
 75	TP_STRUCT__entry(
 76		__field(__u8, bRequestType)
 77		__field(__u8, bRequest)
 78		__field(__u16, wValue)
 79		__field(__u16, wIndex)
 80		__field(__u16, wLength)
 81	),
 82	TP_fast_assign(
 83		__entry->bRequestType = ctrl->bRequestType;
 84		__entry->bRequest = ctrl->bRequest;
 85		__entry->wValue = le16_to_cpu(ctrl->wValue);
 86		__entry->wIndex = le16_to_cpu(ctrl->wIndex);
 87		__entry->wLength = le16_to_cpu(ctrl->wLength);
 88	),
 89	TP_printk("%s", usb_decode_ctrl(__get_buf(DWC3_MSG_MAX), DWC3_MSG_MAX,
 90					__entry->bRequestType,
 91					__entry->bRequest, __entry->wValue,
 92					__entry->wIndex, __entry->wLength)
 93	)
 94);
 95
 96DEFINE_EVENT(dwc3_log_ctrl, dwc3_ctrl_req,
 97	TP_PROTO(struct usb_ctrlrequest *ctrl),
 98	TP_ARGS(ctrl)
 99);
100
101DECLARE_EVENT_CLASS(dwc3_log_request,
102	TP_PROTO(struct dwc3_request *req),
103	TP_ARGS(req),
104	TP_STRUCT__entry(
105		__string(name, req->dep->name)
106		__field(struct dwc3_request *, req)
107		__field(unsigned int, actual)
108		__field(unsigned int, length)
109		__field(int, status)
110		__field(int, zero)
111		__field(int, short_not_ok)
112		__field(int, no_interrupt)
113	),
114	TP_fast_assign(
115		__assign_str(name, req->dep->name);
116		__entry->req = req;
117		__entry->actual = req->request.actual;
118		__entry->length = req->request.length;
119		__entry->status = req->request.status;
120		__entry->zero = req->request.zero;
121		__entry->short_not_ok = req->request.short_not_ok;
122		__entry->no_interrupt = req->request.no_interrupt;
123	),
124	TP_printk("%s: req %p length %u/%u %s%s%s ==> %d",
125		__get_str(name), __entry->req, __entry->actual, __entry->length,
126		__entry->zero ? "Z" : "z",
127		__entry->short_not_ok ? "S" : "s",
128		__entry->no_interrupt ? "i" : "I",
129		__entry->status
130	)
131);
132
133DEFINE_EVENT(dwc3_log_request, dwc3_alloc_request,
134	TP_PROTO(struct dwc3_request *req),
135	TP_ARGS(req)
136);
137
138DEFINE_EVENT(dwc3_log_request, dwc3_free_request,
139	TP_PROTO(struct dwc3_request *req),
140	TP_ARGS(req)
141);
142
143DEFINE_EVENT(dwc3_log_request, dwc3_ep_queue,
144	TP_PROTO(struct dwc3_request *req),
145	TP_ARGS(req)
146);
147
148DEFINE_EVENT(dwc3_log_request, dwc3_ep_dequeue,
149	TP_PROTO(struct dwc3_request *req),
150	TP_ARGS(req)
151);
152
153DEFINE_EVENT(dwc3_log_request, dwc3_gadget_giveback,
154	TP_PROTO(struct dwc3_request *req),
155	TP_ARGS(req)
156);
157
158DECLARE_EVENT_CLASS(dwc3_log_generic_cmd,
159	TP_PROTO(unsigned int cmd, u32 param, int status),
160	TP_ARGS(cmd, param, status),
161	TP_STRUCT__entry(
162		__field(unsigned int, cmd)
163		__field(u32, param)
164		__field(int, status)
165	),
166	TP_fast_assign(
167		__entry->cmd = cmd;
168		__entry->param = param;
169		__entry->status = status;
170	),
171	TP_printk("cmd '%s' [%x] param %08x --> status: %s",
172		dwc3_gadget_generic_cmd_string(__entry->cmd),
173		__entry->cmd, __entry->param,
174		dwc3_gadget_generic_cmd_status_string(__entry->status)
175	)
176);
177
178DEFINE_EVENT(dwc3_log_generic_cmd, dwc3_gadget_generic_cmd,
179	TP_PROTO(unsigned int cmd, u32 param, int status),
180	TP_ARGS(cmd, param, status)
181);
182
183DECLARE_EVENT_CLASS(dwc3_log_gadget_ep_cmd,
184	TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
185		struct dwc3_gadget_ep_cmd_params *params, int cmd_status),
186	TP_ARGS(dep, cmd, params, cmd_status),
187	TP_STRUCT__entry(
188		__string(name, dep->name)
189		__field(unsigned int, cmd)
190		__field(u32, param0)
191		__field(u32, param1)
192		__field(u32, param2)
193		__field(int, cmd_status)
194	),
195	TP_fast_assign(
196		__assign_str(name, dep->name);
197		__entry->cmd = cmd;
198		__entry->param0 = params->param0;
199		__entry->param1 = params->param1;
200		__entry->param2 = params->param2;
201		__entry->cmd_status = cmd_status;
202	),
203	TP_printk("%s: cmd '%s' [%x] params %08x %08x %08x --> status: %s",
204		__get_str(name), dwc3_gadget_ep_cmd_string(__entry->cmd),
205		__entry->cmd, __entry->param0,
206		__entry->param1, __entry->param2,
207		dwc3_ep_cmd_status_string(__entry->cmd_status)
208	)
209);
210
211DEFINE_EVENT(dwc3_log_gadget_ep_cmd, dwc3_gadget_ep_cmd,
212	TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
213		struct dwc3_gadget_ep_cmd_params *params, int cmd_status),
214	TP_ARGS(dep, cmd, params, cmd_status)
215);
216
217DECLARE_EVENT_CLASS(dwc3_log_trb,
218	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
219	TP_ARGS(dep, trb),
220	TP_STRUCT__entry(
221		__string(name, dep->name)
222		__field(struct dwc3_trb *, trb)
223		__field(u32, bpl)
224		__field(u32, bph)
225		__field(u32, size)
226		__field(u32, ctrl)
227		__field(u32, type)
228		__field(u32, enqueue)
229		__field(u32, dequeue)
230	),
231	TP_fast_assign(
232		__assign_str(name, dep->name);
233		__entry->trb = trb;
234		__entry->bpl = trb->bpl;
235		__entry->bph = trb->bph;
236		__entry->size = trb->size;
237		__entry->ctrl = trb->ctrl;
238		__entry->type = usb_endpoint_type(dep->endpoint.desc);
239		__entry->enqueue = dep->trb_enqueue;
240		__entry->dequeue = dep->trb_dequeue;
241	),
242	TP_printk("%s: trb %p (E%d:D%d) buf %08x%08x size %s%d ctrl %08x sofn %08x (%c%c%c%c:%c%c:%s)",
243		__get_str(name), __entry->trb, __entry->enqueue,
244		__entry->dequeue, __entry->bph, __entry->bpl,
245		({char *s;
246		int pcm = ((__entry->size >> 24) & 3) + 1;
247
248		switch (__entry->type) {
249		case USB_ENDPOINT_XFER_INT:
250		case USB_ENDPOINT_XFER_ISOC:
251			switch (pcm) {
252			case 1:
253				s = "1x ";
254				break;
255			case 2:
256				s = "2x ";
257				break;
258			case 3:
259			default:
260				s = "3x ";
261				break;
262			}
263			break;
264		default:
265			s = "";
266		} s; }),
267		DWC3_TRB_SIZE_LENGTH(__entry->size), __entry->ctrl,
268		DWC3_TRB_CTRL_GET_SID_SOFN(__entry->ctrl),
269		__entry->ctrl & DWC3_TRB_CTRL_HWO ? 'H' : 'h',
270		__entry->ctrl & DWC3_TRB_CTRL_LST ? 'L' : 'l',
271		__entry->ctrl & DWC3_TRB_CTRL_CHN ? 'C' : 'c',
272		__entry->ctrl & DWC3_TRB_CTRL_CSP ? 'S' : 's',
273		__entry->ctrl & DWC3_TRB_CTRL_ISP_IMI ? 'S' : 's',
274		__entry->ctrl & DWC3_TRB_CTRL_IOC ? 'C' : 'c',
275		  dwc3_trb_type_string(DWC3_TRBCTL_TYPE(__entry->ctrl))
276	)
277);
278
279DEFINE_EVENT(dwc3_log_trb, dwc3_prepare_trb,
280	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
281	TP_ARGS(dep, trb)
282);
283
284DEFINE_EVENT(dwc3_log_trb, dwc3_complete_trb,
285	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
286	TP_ARGS(dep, trb)
287);
288
289DECLARE_EVENT_CLASS(dwc3_log_ep,
290	TP_PROTO(struct dwc3_ep *dep),
291	TP_ARGS(dep),
292	TP_STRUCT__entry(
293		__string(name, dep->name)
294		__field(unsigned int, maxpacket)
295		__field(unsigned int, maxpacket_limit)
296		__field(unsigned int, max_streams)
297		__field(unsigned int, maxburst)
298		__field(unsigned int, flags)
299		__field(unsigned int, direction)
300		__field(u8, trb_enqueue)
301		__field(u8, trb_dequeue)
302	),
303	TP_fast_assign(
304		__assign_str(name, dep->name);
305		__entry->maxpacket = dep->endpoint.maxpacket;
306		__entry->maxpacket_limit = dep->endpoint.maxpacket_limit;
307		__entry->max_streams = dep->endpoint.max_streams;
308		__entry->maxburst = dep->endpoint.maxburst;
309		__entry->flags = dep->flags;
310		__entry->direction = dep->direction;
311		__entry->trb_enqueue = dep->trb_enqueue;
312		__entry->trb_dequeue = dep->trb_dequeue;
313	),
314	TP_printk("%s: mps %d/%d streams %d burst %d ring %d/%d flags %c:%c%c%c%c:%c",
315		__get_str(name), __entry->maxpacket,
316		__entry->maxpacket_limit, __entry->max_streams,
317		__entry->maxburst, __entry->trb_enqueue,
318		__entry->trb_dequeue,
319		__entry->flags & DWC3_EP_ENABLED ? 'E' : 'e',
320		__entry->flags & DWC3_EP_STALL ? 'S' : 's',
321		__entry->flags & DWC3_EP_WEDGE ? 'W' : 'w',
322		__entry->flags & DWC3_EP_TRANSFER_STARTED ? 'B' : 'b',
323		__entry->flags & DWC3_EP_PENDING_REQUEST ? 'P' : 'p',
324		__entry->direction ? '<' : '>'
325	)
326);
327
328DEFINE_EVENT(dwc3_log_ep, dwc3_gadget_ep_enable,
329	TP_PROTO(struct dwc3_ep *dep),
330	TP_ARGS(dep)
331);
332
333DEFINE_EVENT(dwc3_log_ep, dwc3_gadget_ep_disable,
334	TP_PROTO(struct dwc3_ep *dep),
335	TP_ARGS(dep)
336);
337
338#endif /* __DWC3_TRACE_H */
339
340/* this part has to be here */
341
342#undef TRACE_INCLUDE_PATH
343#define TRACE_INCLUDE_PATH .
344
345#undef TRACE_INCLUDE_FILE
346#define TRACE_INCLUDE_FILE trace
347
348#include <trace/define_trace.h>
v4.6
  1/**
 
  2 * trace.h - DesignWare USB3 DRD Controller Trace Support
  3 *
  4 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
  5 *
  6 * Author: Felipe Balbi <balbi@ti.com>
  7 *
  8 * This program is free software: you can redistribute it and/or modify
  9 * it under the terms of the GNU General Public License version 2  of
 10 * the License as published by the Free Software Foundation.
 11 *
 12 * This program is distributed in the hope that it will be useful,
 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 * GNU General Public License for more details.
 16 */
 17
 18#undef TRACE_SYSTEM
 19#define TRACE_SYSTEM dwc3
 20
 21#if !defined(__DWC3_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
 22#define __DWC3_TRACE_H
 23
 24#include <linux/types.h>
 25#include <linux/tracepoint.h>
 26#include <asm/byteorder.h>
 27#include "core.h"
 28#include "debug.h"
 29
 30DECLARE_EVENT_CLASS(dwc3_log_msg,
 31	TP_PROTO(struct va_format *vaf),
 32	TP_ARGS(vaf),
 33	TP_STRUCT__entry(__dynamic_array(char, msg, DWC3_MSG_MAX)),
 
 
 
 
 34	TP_fast_assign(
 35		vsnprintf(__get_str(msg), DWC3_MSG_MAX, vaf->fmt, *vaf->va);
 
 
 36	),
 37	TP_printk("%s", __get_str(msg))
 38);
 39
 40DEFINE_EVENT(dwc3_log_msg, dwc3_readl,
 41	TP_PROTO(struct va_format *vaf),
 42	TP_ARGS(vaf)
 43);
 44
 45DEFINE_EVENT(dwc3_log_msg, dwc3_writel,
 46	TP_PROTO(struct va_format *vaf),
 47	TP_ARGS(vaf)
 48);
 49
 50DEFINE_EVENT(dwc3_log_msg, dwc3_gadget,
 51	TP_PROTO(struct va_format *vaf),
 52	TP_ARGS(vaf)
 53);
 54
 55DEFINE_EVENT(dwc3_log_msg, dwc3_core,
 56	TP_PROTO(struct va_format *vaf),
 57	TP_ARGS(vaf)
 58);
 59
 60DEFINE_EVENT(dwc3_log_msg, dwc3_ep0,
 61	TP_PROTO(struct va_format *vaf),
 62	TP_ARGS(vaf)
 63);
 64
 65DECLARE_EVENT_CLASS(dwc3_log_event,
 66	TP_PROTO(u32 event),
 67	TP_ARGS(event),
 68	TP_STRUCT__entry(
 69		__field(u32, event)
 
 70	),
 71	TP_fast_assign(
 72		__entry->event = event;
 
 73	),
 74	TP_printk("event %08x", __entry->event)
 
 
 75);
 76
 77DEFINE_EVENT(dwc3_log_event, dwc3_event,
 78	TP_PROTO(u32 event),
 79	TP_ARGS(event)
 80);
 81
 82DECLARE_EVENT_CLASS(dwc3_log_ctrl,
 83	TP_PROTO(struct usb_ctrlrequest *ctrl),
 84	TP_ARGS(ctrl),
 85	TP_STRUCT__entry(
 86		__field(__u8, bRequestType)
 87		__field(__u8, bRequest)
 88		__field(__le16, wValue)
 89		__field(__le16, wIndex)
 90		__field(__le16, wLength)
 91	),
 92	TP_fast_assign(
 93		__entry->bRequestType = ctrl->bRequestType;
 94		__entry->bRequest = ctrl->bRequest;
 95		__entry->wValue = ctrl->wValue;
 96		__entry->wIndex = ctrl->wIndex;
 97		__entry->wLength = ctrl->wLength;
 98	),
 99	TP_printk("bRequestType %02x bRequest %02x wValue %04x wIndex %04x wLength %d",
100		__entry->bRequestType, __entry->bRequest,
101		le16_to_cpu(__entry->wValue), le16_to_cpu(__entry->wIndex),
102		le16_to_cpu(__entry->wLength)
103	)
104);
105
106DEFINE_EVENT(dwc3_log_ctrl, dwc3_ctrl_req,
107	TP_PROTO(struct usb_ctrlrequest *ctrl),
108	TP_ARGS(ctrl)
109);
110
111DECLARE_EVENT_CLASS(dwc3_log_request,
112	TP_PROTO(struct dwc3_request *req),
113	TP_ARGS(req),
114	TP_STRUCT__entry(
115		__dynamic_array(char, name, DWC3_MSG_MAX)
116		__field(struct dwc3_request *, req)
117		__field(unsigned, actual)
118		__field(unsigned, length)
119		__field(int, status)
120		__field(int, zero)
121		__field(int, short_not_ok)
122		__field(int, no_interrupt)
123	),
124	TP_fast_assign(
125		snprintf(__get_str(name), DWC3_MSG_MAX, "%s", req->dep->name);
126		__entry->req = req;
127		__entry->actual = req->request.actual;
128		__entry->length = req->request.length;
129		__entry->status = req->request.status;
130		__entry->zero = req->request.zero;
131		__entry->short_not_ok = req->request.short_not_ok;
132		__entry->no_interrupt = req->request.no_interrupt;
133	),
134	TP_printk("%s: req %p length %u/%u %s%s%s ==> %d",
135		__get_str(name), __entry->req, __entry->actual, __entry->length,
136		__entry->zero ? "Z" : "z",
137		__entry->short_not_ok ? "S" : "s",
138		__entry->no_interrupt ? "i" : "I",
139		__entry->status
140	)
141);
142
143DEFINE_EVENT(dwc3_log_request, dwc3_alloc_request,
144	TP_PROTO(struct dwc3_request *req),
145	TP_ARGS(req)
146);
147
148DEFINE_EVENT(dwc3_log_request, dwc3_free_request,
149	TP_PROTO(struct dwc3_request *req),
150	TP_ARGS(req)
151);
152
153DEFINE_EVENT(dwc3_log_request, dwc3_ep_queue,
154	TP_PROTO(struct dwc3_request *req),
155	TP_ARGS(req)
156);
157
158DEFINE_EVENT(dwc3_log_request, dwc3_ep_dequeue,
159	TP_PROTO(struct dwc3_request *req),
160	TP_ARGS(req)
161);
162
163DEFINE_EVENT(dwc3_log_request, dwc3_gadget_giveback,
164	TP_PROTO(struct dwc3_request *req),
165	TP_ARGS(req)
166);
167
168DECLARE_EVENT_CLASS(dwc3_log_generic_cmd,
169	TP_PROTO(unsigned int cmd, u32 param),
170	TP_ARGS(cmd, param),
171	TP_STRUCT__entry(
172		__field(unsigned int, cmd)
173		__field(u32, param)
 
174	),
175	TP_fast_assign(
176		__entry->cmd = cmd;
177		__entry->param = param;
 
178	),
179	TP_printk("cmd '%s' [%d] param %08x",
180		dwc3_gadget_generic_cmd_string(__entry->cmd),
181		__entry->cmd, __entry->param
 
182	)
183);
184
185DEFINE_EVENT(dwc3_log_generic_cmd, dwc3_gadget_generic_cmd,
186	TP_PROTO(unsigned int cmd, u32 param),
187	TP_ARGS(cmd, param)
188);
189
190DECLARE_EVENT_CLASS(dwc3_log_gadget_ep_cmd,
191	TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
192		struct dwc3_gadget_ep_cmd_params *params),
193	TP_ARGS(dep, cmd, params),
194	TP_STRUCT__entry(
195		__dynamic_array(char, name, DWC3_MSG_MAX)
196		__field(unsigned int, cmd)
197		__field(u32, param0)
198		__field(u32, param1)
199		__field(u32, param2)
 
200	),
201	TP_fast_assign(
202		snprintf(__get_str(name), DWC3_MSG_MAX, "%s", dep->name);
203		__entry->cmd = cmd;
204		__entry->param0 = params->param0;
205		__entry->param1 = params->param1;
206		__entry->param2 = params->param2;
 
207	),
208	TP_printk("%s: cmd '%s' [%d] params %08x %08x %08x",
209		__get_str(name), dwc3_gadget_ep_cmd_string(__entry->cmd),
210		__entry->cmd, __entry->param0,
211		__entry->param1, __entry->param2
 
212	)
213);
214
215DEFINE_EVENT(dwc3_log_gadget_ep_cmd, dwc3_gadget_ep_cmd,
216	TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
217		struct dwc3_gadget_ep_cmd_params *params),
218	TP_ARGS(dep, cmd, params)
219);
220
221DECLARE_EVENT_CLASS(dwc3_log_trb,
222	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
223	TP_ARGS(dep, trb),
224	TP_STRUCT__entry(
225		__dynamic_array(char, name, DWC3_MSG_MAX)
226		__field(struct dwc3_trb *, trb)
227		__field(u32, bpl)
228		__field(u32, bph)
229		__field(u32, size)
230		__field(u32, ctrl)
 
 
 
231	),
232	TP_fast_assign(
233		snprintf(__get_str(name), DWC3_MSG_MAX, "%s", dep->name);
234		__entry->trb = trb;
235		__entry->bpl = trb->bpl;
236		__entry->bph = trb->bph;
237		__entry->size = trb->size;
238		__entry->ctrl = trb->ctrl;
239	),
240	TP_printk("%s: trb %p bph %08x bpl %08x size %08x ctrl %08x",
241		__get_str(name), __entry->trb, __entry->bph, __entry->bpl,
242		__entry->size, __entry->ctrl
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
243	)
244);
245
246DEFINE_EVENT(dwc3_log_trb, dwc3_prepare_trb,
247	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
248	TP_ARGS(dep, trb)
249);
250
251DEFINE_EVENT(dwc3_log_trb, dwc3_complete_trb,
252	TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
253	TP_ARGS(dep, trb)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
254);
255
256#endif /* __DWC3_TRACE_H */
257
258/* this part has to be here */
259
260#undef TRACE_INCLUDE_PATH
261#define TRACE_INCLUDE_PATH .
262
263#undef TRACE_INCLUDE_FILE
264#define TRACE_INCLUDE_FILE trace
265
266#include <trace/define_trace.h>