]>
Commit | Line | Data |
---|---|---|
07a3aef2 PL |
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( | |
2c92ca84 | 67 | __assign_str(text); |
07a3aef2 PL |
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( | |
2c92ca84 | 106 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 SRG |
122 | __assign_str(ep_name); |
123 | __assign_str(msg); | |
07a3aef2 PL |
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( | |
2c92ca84 | 137 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 | 199 | __assign_str(ep_name); |
07a3aef2 PL |
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( | |
2c92ca84 | 291 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 | 383 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 | 414 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 | 479 | __assign_str(name); |
07a3aef2 PL |
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( | |
2c92ca84 | 571 | __assign_str(ep_name); |
07a3aef2 PL |
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> |