Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * musb_trace.h - MUSB Controller Trace Support
4 *
5 * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com
6 *
7 * Author: Bin Liu <b-liu@ti.com>
8 */
9
10#undef TRACE_SYSTEM
11#define TRACE_SYSTEM musb
12
13#if !defined(__MUSB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
14#define __MUSB_TRACE_H
15
16#include <linux/types.h>
17#include <linux/tracepoint.h>
18#include <linux/usb.h>
19#include "musb_core.h"
20#ifdef CONFIG_USB_TI_CPPI41_DMA
21#include "cppi_dma.h"
22#endif
23
24#define MUSB_MSG_MAX 500
25
26TRACE_EVENT(musb_log,
27 TP_PROTO(struct musb *musb, struct va_format *vaf),
28 TP_ARGS(musb, vaf),
29 TP_STRUCT__entry(
30 __string(name, dev_name(musb->controller))
31 __dynamic_array(char, msg, MUSB_MSG_MAX)
32 ),
33 TP_fast_assign(
34 __assign_str(name, dev_name(musb->controller));
35 vsnprintf(__get_str(msg), MUSB_MSG_MAX, vaf->fmt, *vaf->va);
36 ),
37 TP_printk("%s: %s", __get_str(name), __get_str(msg))
38);
39
40DECLARE_EVENT_CLASS(musb_regb,
41 TP_PROTO(void *caller, const void __iomem *addr,
42 unsigned int offset, u8 data),
43 TP_ARGS(caller, addr, offset, data),
44 TP_STRUCT__entry(
45 __field(void *, caller)
46 __field(const void __iomem *, addr)
47 __field(unsigned int, offset)
48 __field(u8, data)
49 ),
50 TP_fast_assign(
51 __entry->caller = caller;
52 __entry->addr = addr;
53 __entry->offset = offset;
54 __entry->data = data;
55 ),
56 TP_printk("%pS: %p + %04x: %02x",
57 __entry->caller, __entry->addr, __entry->offset, __entry->data)
58);
59
60DEFINE_EVENT(musb_regb, musb_readb,
61 TP_PROTO(void *caller, const void __iomem *addr,
62 unsigned int offset, u8 data),
63 TP_ARGS(caller, addr, offset, data)
64);
65
66DEFINE_EVENT(musb_regb, musb_writeb,
67 TP_PROTO(void *caller, const void __iomem *addr,
68 unsigned int offset, u8 data),
69 TP_ARGS(caller, addr, offset, data)
70);
71
72DECLARE_EVENT_CLASS(musb_regw,
73 TP_PROTO(void *caller, const void __iomem *addr,
74 unsigned int offset, u16 data),
75 TP_ARGS(caller, addr, offset, data),
76 TP_STRUCT__entry(
77 __field(void *, caller)
78 __field(const void __iomem *, addr)
79 __field(unsigned int, offset)
80 __field(u16, data)
81 ),
82 TP_fast_assign(
83 __entry->caller = caller;
84 __entry->addr = addr;
85 __entry->offset = offset;
86 __entry->data = data;
87 ),
88 TP_printk("%pS: %p + %04x: %04x",
89 __entry->caller, __entry->addr, __entry->offset, __entry->data)
90);
91
92DEFINE_EVENT(musb_regw, musb_readw,
93 TP_PROTO(void *caller, const void __iomem *addr,
94 unsigned int offset, u16 data),
95 TP_ARGS(caller, addr, offset, data)
96);
97
98DEFINE_EVENT(musb_regw, musb_writew,
99 TP_PROTO(void *caller, const void __iomem *addr,
100 unsigned int offset, u16 data),
101 TP_ARGS(caller, addr, offset, data)
102);
103
104DECLARE_EVENT_CLASS(musb_regl,
105 TP_PROTO(void *caller, const void __iomem *addr,
106 unsigned int offset, u32 data),
107 TP_ARGS(caller, addr, offset, data),
108 TP_STRUCT__entry(
109 __field(void *, caller)
110 __field(const void __iomem *, addr)
111 __field(unsigned int, offset)
112 __field(u32, data)
113 ),
114 TP_fast_assign(
115 __entry->caller = caller;
116 __entry->addr = addr;
117 __entry->offset = offset;
118 __entry->data = data;
119 ),
120 TP_printk("%pS: %p + %04x: %08x",
121 __entry->caller, __entry->addr, __entry->offset, __entry->data)
122);
123
124DEFINE_EVENT(musb_regl, musb_readl,
125 TP_PROTO(void *caller, const void __iomem *addr,
126 unsigned int offset, u32 data),
127 TP_ARGS(caller, addr, offset, data)
128);
129
130DEFINE_EVENT(musb_regl, musb_writel,
131 TP_PROTO(void *caller, const void __iomem *addr,
132 unsigned int offset, u32 data),
133 TP_ARGS(caller, addr, offset, data)
134);
135
136TRACE_EVENT(musb_isr,
137 TP_PROTO(struct musb *musb),
138 TP_ARGS(musb),
139 TP_STRUCT__entry(
140 __string(name, dev_name(musb->controller))
141 __field(u8, int_usb)
142 __field(u16, int_tx)
143 __field(u16, int_rx)
144 ),
145 TP_fast_assign(
146 __assign_str(name, dev_name(musb->controller));
147 __entry->int_usb = musb->int_usb;
148 __entry->int_tx = musb->int_tx;
149 __entry->int_rx = musb->int_rx;
150 ),
151 TP_printk("%s: usb %02x, tx %04x, rx %04x",
152 __get_str(name), __entry->int_usb,
153 __entry->int_tx, __entry->int_rx
154 )
155);
156
157DECLARE_EVENT_CLASS(musb_urb,
158 TP_PROTO(struct musb *musb, struct urb *urb),
159 TP_ARGS(musb, urb),
160 TP_STRUCT__entry(
161 __string(name, dev_name(musb->controller))
162 __field(struct urb *, urb)
163 __field(unsigned int, pipe)
164 __field(int, status)
165 __field(unsigned int, flag)
166 __field(u32, buf_len)
167 __field(u32, actual_len)
168 ),
169 TP_fast_assign(
170 __assign_str(name, dev_name(musb->controller));
171 __entry->urb = urb;
172 __entry->pipe = urb->pipe;
173 __entry->status = urb->status;
174 __entry->flag = urb->transfer_flags;
175 __entry->buf_len = urb->transfer_buffer_length;
176 __entry->actual_len = urb->actual_length;
177 ),
178 TP_printk("%s: %p, dev%d ep%d%s, flag 0x%x, len %d/%d, status %d",
179 __get_str(name), __entry->urb,
180 usb_pipedevice(__entry->pipe),
181 usb_pipeendpoint(__entry->pipe),
182 usb_pipein(__entry->pipe) ? "in" : "out",
183 __entry->flag,
184 __entry->actual_len, __entry->buf_len,
185 __entry->status
186 )
187);
188
189DEFINE_EVENT(musb_urb, musb_urb_start,
190 TP_PROTO(struct musb *musb, struct urb *urb),
191 TP_ARGS(musb, urb)
192);
193
194DEFINE_EVENT(musb_urb, musb_urb_gb,
195 TP_PROTO(struct musb *musb, struct urb *urb),
196 TP_ARGS(musb, urb)
197);
198
199DEFINE_EVENT(musb_urb, musb_urb_rx,
200 TP_PROTO(struct musb *musb, struct urb *urb),
201 TP_ARGS(musb, urb)
202);
203
204DEFINE_EVENT(musb_urb, musb_urb_tx,
205 TP_PROTO(struct musb *musb, struct urb *urb),
206 TP_ARGS(musb, urb)
207);
208
209DEFINE_EVENT(musb_urb, musb_urb_enq,
210 TP_PROTO(struct musb *musb, struct urb *urb),
211 TP_ARGS(musb, urb)
212);
213
214DEFINE_EVENT(musb_urb, musb_urb_deq,
215 TP_PROTO(struct musb *musb, struct urb *urb),
216 TP_ARGS(musb, urb)
217);
218
219DECLARE_EVENT_CLASS(musb_req,
220 TP_PROTO(struct musb_request *req),
221 TP_ARGS(req),
222 TP_STRUCT__entry(
223 __field(struct usb_request *, req)
224 __field(u8, is_tx)
225 __field(u8, epnum)
226 __field(int, status)
227 __field(unsigned int, buf_len)
228 __field(unsigned int, actual_len)
229 __field(unsigned int, zero)
230 __field(unsigned int, short_not_ok)
231 __field(unsigned int, no_interrupt)
232 ),
233 TP_fast_assign(
234 __entry->req = &req->request;
235 __entry->is_tx = req->tx;
236 __entry->epnum = req->epnum;
237 __entry->status = req->request.status;
238 __entry->buf_len = req->request.length;
239 __entry->actual_len = req->request.actual;
240 __entry->zero = req->request.zero;
241 __entry->short_not_ok = req->request.short_not_ok;
242 __entry->no_interrupt = req->request.no_interrupt;
243 ),
244 TP_printk("%p, ep%d %s, %s%s%s, len %d/%d, status %d",
245 __entry->req, __entry->epnum,
246 __entry->is_tx ? "tx/IN" : "rx/OUT",
247 __entry->zero ? "Z" : "z",
248 __entry->short_not_ok ? "S" : "s",
249 __entry->no_interrupt ? "I" : "i",
250 __entry->actual_len, __entry->buf_len,
251 __entry->status
252 )
253);
254
255DEFINE_EVENT(musb_req, musb_req_gb,
256 TP_PROTO(struct musb_request *req),
257 TP_ARGS(req)
258);
259
260DEFINE_EVENT(musb_req, musb_req_tx,
261 TP_PROTO(struct musb_request *req),
262 TP_ARGS(req)
263);
264
265DEFINE_EVENT(musb_req, musb_req_rx,
266 TP_PROTO(struct musb_request *req),
267 TP_ARGS(req)
268);
269
270DEFINE_EVENT(musb_req, musb_req_alloc,
271 TP_PROTO(struct musb_request *req),
272 TP_ARGS(req)
273);
274
275DEFINE_EVENT(musb_req, musb_req_free,
276 TP_PROTO(struct musb_request *req),
277 TP_ARGS(req)
278);
279
280DEFINE_EVENT(musb_req, musb_req_start,
281 TP_PROTO(struct musb_request *req),
282 TP_ARGS(req)
283);
284
285DEFINE_EVENT(musb_req, musb_req_enq,
286 TP_PROTO(struct musb_request *req),
287 TP_ARGS(req)
288);
289
290DEFINE_EVENT(musb_req, musb_req_deq,
291 TP_PROTO(struct musb_request *req),
292 TP_ARGS(req)
293);
294
295#ifdef CONFIG_USB_TI_CPPI41_DMA
296DECLARE_EVENT_CLASS(musb_cppi41,
297 TP_PROTO(struct cppi41_dma_channel *ch),
298 TP_ARGS(ch),
299 TP_STRUCT__entry(
300 __field(struct cppi41_dma_channel *, ch)
301 __string(name, dev_name(ch->hw_ep->musb->controller))
302 __field(u8, hwep)
303 __field(u8, port)
304 __field(u8, is_tx)
305 __field(u32, len)
306 __field(u32, prog_len)
307 __field(u32, xferred)
308 ),
309 TP_fast_assign(
310 __entry->ch = ch;
311 __assign_str(name, dev_name(ch->hw_ep->musb->controller));
312 __entry->hwep = ch->hw_ep->epnum;
313 __entry->port = ch->port_num;
314 __entry->is_tx = ch->is_tx;
315 __entry->len = ch->total_len;
316 __entry->prog_len = ch->prog_len;
317 __entry->xferred = ch->transferred;
318 ),
319 TP_printk("%s: %p, hwep%d ch%d%s, prog_len %d, len %d/%d",
320 __get_str(name), __entry->ch, __entry->hwep,
321 __entry->port, __entry->is_tx ? "tx" : "rx",
322 __entry->prog_len, __entry->xferred, __entry->len
323 )
324);
325
326DEFINE_EVENT(musb_cppi41, musb_cppi41_done,
327 TP_PROTO(struct cppi41_dma_channel *ch),
328 TP_ARGS(ch)
329);
330
331DEFINE_EVENT(musb_cppi41, musb_cppi41_gb,
332 TP_PROTO(struct cppi41_dma_channel *ch),
333 TP_ARGS(ch)
334);
335
336DEFINE_EVENT(musb_cppi41, musb_cppi41_config,
337 TP_PROTO(struct cppi41_dma_channel *ch),
338 TP_ARGS(ch)
339);
340
341DEFINE_EVENT(musb_cppi41, musb_cppi41_cont,
342 TP_PROTO(struct cppi41_dma_channel *ch),
343 TP_ARGS(ch)
344);
345
346DEFINE_EVENT(musb_cppi41, musb_cppi41_alloc,
347 TP_PROTO(struct cppi41_dma_channel *ch),
348 TP_ARGS(ch)
349);
350
351DEFINE_EVENT(musb_cppi41, musb_cppi41_abort,
352 TP_PROTO(struct cppi41_dma_channel *ch),
353 TP_ARGS(ch)
354);
355
356DEFINE_EVENT(musb_cppi41, musb_cppi41_free,
357 TP_PROTO(struct cppi41_dma_channel *ch),
358 TP_ARGS(ch)
359);
360#endif /* CONFIG_USB_TI_CPPI41_DMA */
361
362#endif /* __MUSB_TRACE_H */
363
364/* this part has to be here */
365
366#undef TRACE_INCLUDE_PATH
367#define TRACE_INCLUDE_PATH .
368
369#undef TRACE_INCLUDE_FILE
370#define TRACE_INCLUDE_FILE musb_trace
371
372#include <trace/define_trace.h>
1/*
2 * musb_trace.h - MUSB Controller Trace Support
3 *
4 * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com
5 *
6 * Author: Bin Liu <b-liu@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 musb
20
21#if !defined(__MUSB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
22#define __MUSB_TRACE_H
23
24#include <linux/types.h>
25#include <linux/tracepoint.h>
26#include <linux/usb.h>
27#include "musb_core.h"
28#ifdef CONFIG_USB_TI_CPPI41_DMA
29#include "cppi_dma.h"
30#endif
31
32#define MUSB_MSG_MAX 500
33
34TRACE_EVENT(musb_log,
35 TP_PROTO(struct musb *musb, struct va_format *vaf),
36 TP_ARGS(musb, vaf),
37 TP_STRUCT__entry(
38 __string(name, dev_name(musb->controller))
39 __dynamic_array(char, msg, MUSB_MSG_MAX)
40 ),
41 TP_fast_assign(
42 __assign_str(name, dev_name(musb->controller));
43 vsnprintf(__get_str(msg), MUSB_MSG_MAX, vaf->fmt, *vaf->va);
44 ),
45 TP_printk("%s: %s", __get_str(name), __get_str(msg))
46);
47
48DECLARE_EVENT_CLASS(musb_regb,
49 TP_PROTO(void *caller, const void *addr, unsigned int offset, u8 data),
50 TP_ARGS(caller, addr, offset, data),
51 TP_STRUCT__entry(
52 __field(void *, caller)
53 __field(const void *, addr)
54 __field(unsigned int, offset)
55 __field(u8, data)
56 ),
57 TP_fast_assign(
58 __entry->caller = caller;
59 __entry->addr = addr;
60 __entry->offset = offset;
61 __entry->data = data;
62 ),
63 TP_printk("%pS: %p + %04x: %02x",
64 __entry->caller, __entry->addr, __entry->offset, __entry->data)
65);
66
67DEFINE_EVENT(musb_regb, musb_readb,
68 TP_PROTO(void *caller, const void *addr, unsigned int offset, u8 data),
69 TP_ARGS(caller, addr, offset, data)
70);
71
72DEFINE_EVENT(musb_regb, musb_writeb,
73 TP_PROTO(void *caller, const void *addr, unsigned int offset, u8 data),
74 TP_ARGS(caller, addr, offset, data)
75);
76
77DECLARE_EVENT_CLASS(musb_regw,
78 TP_PROTO(void *caller, const void *addr, unsigned int offset, u16 data),
79 TP_ARGS(caller, addr, offset, data),
80 TP_STRUCT__entry(
81 __field(void *, caller)
82 __field(const void *, addr)
83 __field(unsigned int, offset)
84 __field(u16, data)
85 ),
86 TP_fast_assign(
87 __entry->caller = caller;
88 __entry->addr = addr;
89 __entry->offset = offset;
90 __entry->data = data;
91 ),
92 TP_printk("%pS: %p + %04x: %04x",
93 __entry->caller, __entry->addr, __entry->offset, __entry->data)
94);
95
96DEFINE_EVENT(musb_regw, musb_readw,
97 TP_PROTO(void *caller, const void *addr, unsigned int offset, u16 data),
98 TP_ARGS(caller, addr, offset, data)
99);
100
101DEFINE_EVENT(musb_regw, musb_writew,
102 TP_PROTO(void *caller, const void *addr, unsigned int offset, u16 data),
103 TP_ARGS(caller, addr, offset, data)
104);
105
106DECLARE_EVENT_CLASS(musb_regl,
107 TP_PROTO(void *caller, const void *addr, unsigned int offset, u32 data),
108 TP_ARGS(caller, addr, offset, data),
109 TP_STRUCT__entry(
110 __field(void *, caller)
111 __field(const void *, addr)
112 __field(unsigned int, offset)
113 __field(u32, data)
114 ),
115 TP_fast_assign(
116 __entry->caller = caller;
117 __entry->addr = addr;
118 __entry->offset = offset;
119 __entry->data = data;
120 ),
121 TP_printk("%pS: %p + %04x: %08x",
122 __entry->caller, __entry->addr, __entry->offset, __entry->data)
123);
124
125DEFINE_EVENT(musb_regl, musb_readl,
126 TP_PROTO(void *caller, const void *addr, unsigned int offset, u32 data),
127 TP_ARGS(caller, addr, offset, data)
128);
129
130DEFINE_EVENT(musb_regl, musb_writel,
131 TP_PROTO(void *caller, const void *addr, unsigned int offset, u32 data),
132 TP_ARGS(caller, addr, offset, data)
133);
134
135TRACE_EVENT(musb_isr,
136 TP_PROTO(struct musb *musb),
137 TP_ARGS(musb),
138 TP_STRUCT__entry(
139 __string(name, dev_name(musb->controller))
140 __field(u8, int_usb)
141 __field(u16, int_tx)
142 __field(u16, int_rx)
143 ),
144 TP_fast_assign(
145 __assign_str(name, dev_name(musb->controller));
146 __entry->int_usb = musb->int_usb;
147 __entry->int_tx = musb->int_tx;
148 __entry->int_rx = musb->int_rx;
149 ),
150 TP_printk("%s: usb %02x, tx %04x, rx %04x",
151 __get_str(name), __entry->int_usb,
152 __entry->int_tx, __entry->int_rx
153 )
154);
155
156DECLARE_EVENT_CLASS(musb_urb,
157 TP_PROTO(struct musb *musb, struct urb *urb),
158 TP_ARGS(musb, urb),
159 TP_STRUCT__entry(
160 __string(name, dev_name(musb->controller))
161 __field(struct urb *, urb)
162 __field(unsigned int, pipe)
163 __field(int, status)
164 __field(unsigned int, flag)
165 __field(u32, buf_len)
166 __field(u32, actual_len)
167 ),
168 TP_fast_assign(
169 __assign_str(name, dev_name(musb->controller));
170 __entry->urb = urb;
171 __entry->pipe = urb->pipe;
172 __entry->status = urb->status;
173 __entry->flag = urb->transfer_flags;
174 __entry->buf_len = urb->transfer_buffer_length;
175 __entry->actual_len = urb->actual_length;
176 ),
177 TP_printk("%s: %p, dev%d ep%d%s, flag 0x%x, len %d/%d, status %d",
178 __get_str(name), __entry->urb,
179 usb_pipedevice(__entry->pipe),
180 usb_pipeendpoint(__entry->pipe),
181 usb_pipein(__entry->pipe) ? "in" : "out",
182 __entry->flag,
183 __entry->actual_len, __entry->buf_len,
184 __entry->status
185 )
186);
187
188DEFINE_EVENT(musb_urb, musb_urb_start,
189 TP_PROTO(struct musb *musb, struct urb *urb),
190 TP_ARGS(musb, urb)
191);
192
193DEFINE_EVENT(musb_urb, musb_urb_gb,
194 TP_PROTO(struct musb *musb, struct urb *urb),
195 TP_ARGS(musb, urb)
196);
197
198DEFINE_EVENT(musb_urb, musb_urb_rx,
199 TP_PROTO(struct musb *musb, struct urb *urb),
200 TP_ARGS(musb, urb)
201);
202
203DEFINE_EVENT(musb_urb, musb_urb_tx,
204 TP_PROTO(struct musb *musb, struct urb *urb),
205 TP_ARGS(musb, urb)
206);
207
208DEFINE_EVENT(musb_urb, musb_urb_enq,
209 TP_PROTO(struct musb *musb, struct urb *urb),
210 TP_ARGS(musb, urb)
211);
212
213DEFINE_EVENT(musb_urb, musb_urb_deq,
214 TP_PROTO(struct musb *musb, struct urb *urb),
215 TP_ARGS(musb, urb)
216);
217
218DECLARE_EVENT_CLASS(musb_req,
219 TP_PROTO(struct musb_request *req),
220 TP_ARGS(req),
221 TP_STRUCT__entry(
222 __field(struct usb_request *, req)
223 __field(u8, is_tx)
224 __field(u8, epnum)
225 __field(int, status)
226 __field(unsigned int, buf_len)
227 __field(unsigned int, actual_len)
228 __field(unsigned int, zero)
229 __field(unsigned int, short_not_ok)
230 __field(unsigned int, no_interrupt)
231 ),
232 TP_fast_assign(
233 __entry->req = &req->request;
234 __entry->is_tx = req->tx;
235 __entry->epnum = req->epnum;
236 __entry->status = req->request.status;
237 __entry->buf_len = req->request.length;
238 __entry->actual_len = req->request.actual;
239 __entry->zero = req->request.zero;
240 __entry->short_not_ok = req->request.short_not_ok;
241 __entry->no_interrupt = req->request.no_interrupt;
242 ),
243 TP_printk("%p, ep%d %s, %s%s%s, len %d/%d, status %d",
244 __entry->req, __entry->epnum,
245 __entry->is_tx ? "tx/IN" : "rx/OUT",
246 __entry->zero ? "Z" : "z",
247 __entry->short_not_ok ? "S" : "s",
248 __entry->no_interrupt ? "I" : "i",
249 __entry->actual_len, __entry->buf_len,
250 __entry->status
251 )
252);
253
254DEFINE_EVENT(musb_req, musb_req_gb,
255 TP_PROTO(struct musb_request *req),
256 TP_ARGS(req)
257);
258
259DEFINE_EVENT(musb_req, musb_req_tx,
260 TP_PROTO(struct musb_request *req),
261 TP_ARGS(req)
262);
263
264DEFINE_EVENT(musb_req, musb_req_rx,
265 TP_PROTO(struct musb_request *req),
266 TP_ARGS(req)
267);
268
269DEFINE_EVENT(musb_req, musb_req_alloc,
270 TP_PROTO(struct musb_request *req),
271 TP_ARGS(req)
272);
273
274DEFINE_EVENT(musb_req, musb_req_free,
275 TP_PROTO(struct musb_request *req),
276 TP_ARGS(req)
277);
278
279DEFINE_EVENT(musb_req, musb_req_start,
280 TP_PROTO(struct musb_request *req),
281 TP_ARGS(req)
282);
283
284DEFINE_EVENT(musb_req, musb_req_enq,
285 TP_PROTO(struct musb_request *req),
286 TP_ARGS(req)
287);
288
289DEFINE_EVENT(musb_req, musb_req_deq,
290 TP_PROTO(struct musb_request *req),
291 TP_ARGS(req)
292);
293
294#ifdef CONFIG_USB_TI_CPPI41_DMA
295DECLARE_EVENT_CLASS(musb_cppi41,
296 TP_PROTO(struct cppi41_dma_channel *ch),
297 TP_ARGS(ch),
298 TP_STRUCT__entry(
299 __field(struct cppi41_dma_channel *, ch)
300 __string(name, dev_name(ch->hw_ep->musb->controller))
301 __field(u8, hwep)
302 __field(u8, port)
303 __field(u8, is_tx)
304 __field(u32, len)
305 __field(u32, prog_len)
306 __field(u32, xferred)
307 ),
308 TP_fast_assign(
309 __entry->ch = ch;
310 __assign_str(name, dev_name(ch->hw_ep->musb->controller));
311 __entry->hwep = ch->hw_ep->epnum;
312 __entry->port = ch->port_num;
313 __entry->is_tx = ch->is_tx;
314 __entry->len = ch->total_len;
315 __entry->prog_len = ch->prog_len;
316 __entry->xferred = ch->transferred;
317 ),
318 TP_printk("%s: %p, hwep%d ch%d%s, prog_len %d, len %d/%d",
319 __get_str(name), __entry->ch, __entry->hwep,
320 __entry->port, __entry->is_tx ? "tx" : "rx",
321 __entry->prog_len, __entry->xferred, __entry->len
322 )
323);
324
325DEFINE_EVENT(musb_cppi41, musb_cppi41_done,
326 TP_PROTO(struct cppi41_dma_channel *ch),
327 TP_ARGS(ch)
328);
329
330DEFINE_EVENT(musb_cppi41, musb_cppi41_gb,
331 TP_PROTO(struct cppi41_dma_channel *ch),
332 TP_ARGS(ch)
333);
334
335DEFINE_EVENT(musb_cppi41, musb_cppi41_config,
336 TP_PROTO(struct cppi41_dma_channel *ch),
337 TP_ARGS(ch)
338);
339
340DEFINE_EVENT(musb_cppi41, musb_cppi41_cont,
341 TP_PROTO(struct cppi41_dma_channel *ch),
342 TP_ARGS(ch)
343);
344
345DEFINE_EVENT(musb_cppi41, musb_cppi41_alloc,
346 TP_PROTO(struct cppi41_dma_channel *ch),
347 TP_ARGS(ch)
348);
349
350DEFINE_EVENT(musb_cppi41, musb_cppi41_abort,
351 TP_PROTO(struct cppi41_dma_channel *ch),
352 TP_ARGS(ch)
353);
354
355DEFINE_EVENT(musb_cppi41, musb_cppi41_free,
356 TP_PROTO(struct cppi41_dma_channel *ch),
357 TP_ARGS(ch)
358);
359#endif /* CONFIG_USB_TI_CPPI41_DMA */
360
361#endif /* __MUSB_TRACE_H */
362
363/* this part has to be here */
364
365#undef TRACE_INCLUDE_PATH
366#define TRACE_INCLUDE_PATH .
367
368#undef TRACE_INCLUDE_FILE
369#define TRACE_INCLUDE_FILE musb_trace
370
371#include <trace/define_trace.h>