Loading...
Note: File does not exist in v6.8.
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 "gadget.h"
23#include "debug.h"
24
25#define CDNS3_MSG_MAX 500
26
27TRACE_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, ep_priv->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
44TRACE_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, ep_priv->name);
53 __assign_str(msg, msg);
54 ),
55 TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
56);
57
58TRACE_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, ep_priv->name);
67 __assign_str(msg, msg);
68 ),
69 TP_printk("WA2: %s %s", __get_str(ep_name), __get_str(msg))
70);
71
72DECLARE_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, ep_name);
81 __entry->ep_trbaddr = ep_trbaddr;
82 ),
83 TP_printk("%s, ep_trbaddr %08x", __get_str(name),
84 __entry->ep_trbaddr)
85);
86
87DEFINE_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
92DEFINE_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
97DECLARE_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 __dynamic_array(char, str, CDNS3_MSG_MAX)
104 ),
105 TP_fast_assign(
106 __entry->speed = cdns3_get_speed(priv_dev);
107 __entry->usb_ists = usb_ists;
108 ),
109 TP_printk("%s", cdns3_decode_usb_irq(__get_str(str), __entry->speed,
110 __entry->usb_ists))
111);
112
113DEFINE_EVENT(cdns3_log_usb_irq, cdns3_usb_irq,
114 TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
115 TP_ARGS(priv_dev, usb_ists)
116);
117
118DECLARE_EVENT_CLASS(cdns3_log_epx_irq,
119 TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
120 TP_ARGS(priv_dev, priv_ep),
121 TP_STRUCT__entry(
122 __string(ep_name, priv_ep->name)
123 __field(u32, ep_sts)
124 __field(u32, ep_traddr)
125 __dynamic_array(char, str, CDNS3_MSG_MAX)
126 ),
127 TP_fast_assign(
128 __assign_str(ep_name, priv_ep->name);
129 __entry->ep_sts = readl(&priv_dev->regs->ep_sts);
130 __entry->ep_traddr = readl(&priv_dev->regs->ep_traddr);
131 ),
132 TP_printk("%s, ep_traddr: %08x",
133 cdns3_decode_epx_irq(__get_str(str),
134 __get_str(ep_name),
135 __entry->ep_sts),
136 __entry->ep_traddr)
137);
138
139DEFINE_EVENT(cdns3_log_epx_irq, cdns3_epx_irq,
140 TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
141 TP_ARGS(priv_dev, priv_ep)
142);
143
144DECLARE_EVENT_CLASS(cdns3_log_ep0_irq,
145 TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts),
146 TP_ARGS(priv_dev, ep_sts),
147 TP_STRUCT__entry(
148 __field(int, ep_dir)
149 __field(u32, ep_sts)
150 __dynamic_array(char, str, CDNS3_MSG_MAX)
151 ),
152 TP_fast_assign(
153 __entry->ep_dir = priv_dev->ep0_data_dir;
154 __entry->ep_sts = ep_sts;
155 ),
156 TP_printk("%s", cdns3_decode_ep0_irq(__get_str(str),
157 __entry->ep_dir,
158 __entry->ep_sts))
159);
160
161DEFINE_EVENT(cdns3_log_ep0_irq, cdns3_ep0_irq,
162 TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts),
163 TP_ARGS(priv_dev, ep_sts)
164);
165
166DECLARE_EVENT_CLASS(cdns3_log_ctrl,
167 TP_PROTO(struct usb_ctrlrequest *ctrl),
168 TP_ARGS(ctrl),
169 TP_STRUCT__entry(
170 __field(u8, bRequestType)
171 __field(u8, bRequest)
172 __field(u16, wValue)
173 __field(u16, wIndex)
174 __field(u16, wLength)
175 __dynamic_array(char, str, CDNS3_MSG_MAX)
176 ),
177 TP_fast_assign(
178 __entry->bRequestType = ctrl->bRequestType;
179 __entry->bRequest = ctrl->bRequest;
180 __entry->wValue = le16_to_cpu(ctrl->wValue);
181 __entry->wIndex = le16_to_cpu(ctrl->wIndex);
182 __entry->wLength = le16_to_cpu(ctrl->wLength);
183 ),
184 TP_printk("%s", usb_decode_ctrl(__get_str(str), CDNS3_MSG_MAX,
185 __entry->bRequestType,
186 __entry->bRequest, __entry->wValue,
187 __entry->wIndex, __entry->wLength)
188 )
189);
190
191DEFINE_EVENT(cdns3_log_ctrl, cdns3_ctrl_req,
192 TP_PROTO(struct usb_ctrlrequest *ctrl),
193 TP_ARGS(ctrl)
194);
195
196DECLARE_EVENT_CLASS(cdns3_log_request,
197 TP_PROTO(struct cdns3_request *req),
198 TP_ARGS(req),
199 TP_STRUCT__entry(
200 __string(name, req->priv_ep->name)
201 __field(struct cdns3_request *, req)
202 __field(void *, buf)
203 __field(unsigned int, actual)
204 __field(unsigned int, length)
205 __field(int, status)
206 __field(int, zero)
207 __field(int, short_not_ok)
208 __field(int, no_interrupt)
209 __field(int, start_trb)
210 __field(int, end_trb)
211 __field(struct cdns3_trb *, start_trb_addr)
212 __field(int, flags)
213 ),
214 TP_fast_assign(
215 __assign_str(name, req->priv_ep->name);
216 __entry->req = req;
217 __entry->buf = req->request.buf;
218 __entry->actual = req->request.actual;
219 __entry->length = req->request.length;
220 __entry->status = req->request.status;
221 __entry->zero = req->request.zero;
222 __entry->short_not_ok = req->request.short_not_ok;
223 __entry->no_interrupt = req->request.no_interrupt;
224 __entry->start_trb = req->start_trb;
225 __entry->end_trb = req->end_trb;
226 __entry->start_trb_addr = req->trb;
227 __entry->flags = req->flags;
228 ),
229 TP_printk("%s: req: %p, req buff %p, length: %u/%u %s%s%s, status: %d,"
230 " trb: [start:%d, end:%d: virt addr %pa], flags:%x ",
231 __get_str(name), __entry->req, __entry->buf, __entry->actual,
232 __entry->length,
233 __entry->zero ? "Z" : "z",
234 __entry->short_not_ok ? "S" : "s",
235 __entry->no_interrupt ? "I" : "i",
236 __entry->status,
237 __entry->start_trb,
238 __entry->end_trb,
239 __entry->start_trb_addr,
240 __entry->flags
241 )
242);
243
244DEFINE_EVENT(cdns3_log_request, cdns3_alloc_request,
245 TP_PROTO(struct cdns3_request *req),
246 TP_ARGS(req)
247);
248
249DEFINE_EVENT(cdns3_log_request, cdns3_free_request,
250 TP_PROTO(struct cdns3_request *req),
251 TP_ARGS(req)
252);
253
254DEFINE_EVENT(cdns3_log_request, cdns3_ep_queue,
255 TP_PROTO(struct cdns3_request *req),
256 TP_ARGS(req)
257);
258
259DEFINE_EVENT(cdns3_log_request, cdns3_ep_dequeue,
260 TP_PROTO(struct cdns3_request *req),
261 TP_ARGS(req)
262);
263
264DEFINE_EVENT(cdns3_log_request, cdns3_gadget_giveback,
265 TP_PROTO(struct cdns3_request *req),
266 TP_ARGS(req)
267);
268
269TRACE_EVENT(cdns3_ep0_queue,
270 TP_PROTO(struct cdns3_device *dev_priv, struct usb_request *request),
271 TP_ARGS(dev_priv, request),
272 TP_STRUCT__entry(
273 __field(int, dir)
274 __field(int, length)
275 ),
276 TP_fast_assign(
277 __entry->dir = dev_priv->ep0_data_dir;
278 __entry->length = request->length;
279 ),
280 TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
281 __entry->length)
282);
283
284DECLARE_EVENT_CLASS(cdns3_log_aligned_request,
285 TP_PROTO(struct cdns3_request *priv_req),
286 TP_ARGS(priv_req),
287 TP_STRUCT__entry(
288 __string(name, priv_req->priv_ep->name)
289 __field(struct usb_request *, req)
290 __field(void *, buf)
291 __field(dma_addr_t, dma)
292 __field(void *, aligned_buf)
293 __field(dma_addr_t, aligned_dma)
294 __field(u32, aligned_buf_size)
295 ),
296 TP_fast_assign(
297 __assign_str(name, priv_req->priv_ep->name);
298 __entry->req = &priv_req->request;
299 __entry->buf = priv_req->request.buf;
300 __entry->dma = priv_req->request.dma;
301 __entry->aligned_buf = priv_req->aligned_buf->buf;
302 __entry->aligned_dma = priv_req->aligned_buf->dma;
303 __entry->aligned_buf_size = priv_req->aligned_buf->size;
304 ),
305 TP_printk("%s: req: %p, req buf %p, dma %pad a_buf %p a_dma %pad, size %d",
306 __get_str(name), __entry->req, __entry->buf, &__entry->dma,
307 __entry->aligned_buf, &__entry->aligned_dma,
308 __entry->aligned_buf_size
309 )
310);
311
312DEFINE_EVENT(cdns3_log_aligned_request, cdns3_free_aligned_request,
313 TP_PROTO(struct cdns3_request *req),
314 TP_ARGS(req)
315);
316
317DEFINE_EVENT(cdns3_log_aligned_request, cdns3_prepare_aligned_request,
318 TP_PROTO(struct cdns3_request *req),
319 TP_ARGS(req)
320);
321
322DECLARE_EVENT_CLASS(cdns3_log_trb,
323 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
324 TP_ARGS(priv_ep, trb),
325 TP_STRUCT__entry(
326 __string(name, priv_ep->name)
327 __field(struct cdns3_trb *, trb)
328 __field(u32, buffer)
329 __field(u32, length)
330 __field(u32, control)
331 __field(u32, type)
332 ),
333 TP_fast_assign(
334 __assign_str(name, priv_ep->name);
335 __entry->trb = trb;
336 __entry->buffer = trb->buffer;
337 __entry->length = trb->length;
338 __entry->control = trb->control;
339 __entry->type = usb_endpoint_type(priv_ep->endpoint.desc);
340 ),
341 TP_printk("%s: trb %p, dma buf: 0x%08x, size: %ld, burst: %d ctrl: 0x%08x (%s%s%s%s%s%s%s)",
342 __get_str(name), __entry->trb, __entry->buffer,
343 TRB_LEN(__entry->length),
344 (u8)TRB_BURST_LEN_GET(__entry->length),
345 __entry->control,
346 __entry->control & TRB_CYCLE ? "C=1, " : "C=0, ",
347 __entry->control & TRB_TOGGLE ? "T=1, " : "T=0, ",
348 __entry->control & TRB_ISP ? "ISP, " : "",
349 __entry->control & TRB_FIFO_MODE ? "FIFO, " : "",
350 __entry->control & TRB_CHAIN ? "CHAIN, " : "",
351 __entry->control & TRB_IOC ? "IOC, " : "",
352 TRB_FIELD_TO_TYPE(__entry->control) == TRB_NORMAL ? "Normal" : "LINK"
353 )
354);
355
356DEFINE_EVENT(cdns3_log_trb, cdns3_prepare_trb,
357 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
358 TP_ARGS(priv_ep, trb)
359);
360
361DEFINE_EVENT(cdns3_log_trb, cdns3_complete_trb,
362 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
363 TP_ARGS(priv_ep, trb)
364);
365
366DECLARE_EVENT_CLASS(cdns3_log_ring,
367 TP_PROTO(struct cdns3_endpoint *priv_ep),
368 TP_ARGS(priv_ep),
369 TP_STRUCT__entry(
370 __dynamic_array(u8, ring, TRB_RING_SIZE)
371 __dynamic_array(u8, priv_ep, sizeof(struct cdns3_endpoint))
372 __dynamic_array(char, buffer,
373 (TRBS_PER_SEGMENT * 65) + CDNS3_MSG_MAX)
374 ),
375 TP_fast_assign(
376 memcpy(__get_dynamic_array(priv_ep), priv_ep,
377 sizeof(struct cdns3_endpoint));
378 memcpy(__get_dynamic_array(ring), priv_ep->trb_pool,
379 TRB_RING_SIZE);
380 ),
381
382 TP_printk("%s",
383 cdns3_dbg_ring((struct cdns3_endpoint *)__get_str(priv_ep),
384 (struct cdns3_trb *)__get_str(ring),
385 __get_str(buffer)))
386);
387
388DEFINE_EVENT(cdns3_log_ring, cdns3_ring,
389 TP_PROTO(struct cdns3_endpoint *priv_ep),
390 TP_ARGS(priv_ep)
391);
392
393DECLARE_EVENT_CLASS(cdns3_log_ep,
394 TP_PROTO(struct cdns3_endpoint *priv_ep),
395 TP_ARGS(priv_ep),
396 TP_STRUCT__entry(
397 __string(name, priv_ep->name)
398 __field(unsigned int, maxpacket)
399 __field(unsigned int, maxpacket_limit)
400 __field(unsigned int, max_streams)
401 __field(unsigned int, maxburst)
402 __field(unsigned int, flags)
403 __field(unsigned int, dir)
404 __field(u8, enqueue)
405 __field(u8, dequeue)
406 ),
407 TP_fast_assign(
408 __assign_str(name, priv_ep->name);
409 __entry->maxpacket = priv_ep->endpoint.maxpacket;
410 __entry->maxpacket_limit = priv_ep->endpoint.maxpacket_limit;
411 __entry->max_streams = priv_ep->endpoint.max_streams;
412 __entry->maxburst = priv_ep->endpoint.maxburst;
413 __entry->flags = priv_ep->flags;
414 __entry->dir = priv_ep->dir;
415 __entry->enqueue = priv_ep->enqueue;
416 __entry->dequeue = priv_ep->dequeue;
417 ),
418 TP_printk("%s: mps: %d/%d. streams: %d, burst: %d, enq idx: %d, "
419 "deq idx: %d, flags %s%s%s%s%s%s%s%s, dir: %s",
420 __get_str(name), __entry->maxpacket,
421 __entry->maxpacket_limit, __entry->max_streams,
422 __entry->maxburst, __entry->enqueue,
423 __entry->dequeue,
424 __entry->flags & EP_ENABLED ? "EN | " : "",
425 __entry->flags & EP_STALLED ? "STALLED | " : "",
426 __entry->flags & EP_WEDGE ? "WEDGE | " : "",
427 __entry->flags & EP_TRANSFER_STARTED ? "STARTED | " : "",
428 __entry->flags & EP_UPDATE_EP_TRBADDR ? "UPD TRB | " : "",
429 __entry->flags & EP_PENDING_REQUEST ? "REQ PEN | " : "",
430 __entry->flags & EP_RING_FULL ? "RING FULL |" : "",
431 __entry->flags & EP_CLAIMED ? "CLAIMED " : "",
432 __entry->dir ? "IN" : "OUT"
433 )
434);
435
436DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_enable,
437 TP_PROTO(struct cdns3_endpoint *priv_ep),
438 TP_ARGS(priv_ep)
439);
440
441DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_disable,
442 TP_PROTO(struct cdns3_endpoint *priv_ep),
443 TP_ARGS(priv_ep)
444);
445
446DECLARE_EVENT_CLASS(cdns3_log_request_handled,
447 TP_PROTO(struct cdns3_request *priv_req, int current_index,
448 int handled),
449 TP_ARGS(priv_req, current_index, handled),
450 TP_STRUCT__entry(
451 __field(struct cdns3_request *, priv_req)
452 __field(unsigned int, dma_position)
453 __field(unsigned int, handled)
454 __field(unsigned int, dequeue_idx)
455 __field(unsigned int, enqueue_idx)
456 __field(unsigned int, start_trb)
457 __field(unsigned int, end_trb)
458 ),
459 TP_fast_assign(
460 __entry->priv_req = priv_req;
461 __entry->dma_position = current_index;
462 __entry->handled = handled;
463 __entry->dequeue_idx = priv_req->priv_ep->dequeue;
464 __entry->enqueue_idx = priv_req->priv_ep->enqueue;
465 __entry->start_trb = priv_req->start_trb;
466 __entry->end_trb = priv_req->end_trb;
467 ),
468 TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
469 " start trb: %d, end trb: %d",
470 __entry->priv_req,
471 __entry->handled ? "handled" : "not handled",
472 __entry->dma_position, __entry->dequeue_idx,
473 __entry->enqueue_idx, __entry->start_trb,
474 __entry->end_trb
475 )
476);
477
478DEFINE_EVENT(cdns3_log_request_handled, cdns3_request_handled,
479 TP_PROTO(struct cdns3_request *priv_req, int current_index,
480 int handled),
481 TP_ARGS(priv_req, current_index, handled)
482);
483#endif /* __LINUX_CDNS3_TRACE */
484
485/* this part must be outside header guard */
486
487#undef TRACE_INCLUDE_PATH
488#define TRACE_INCLUDE_PATH .
489
490#undef TRACE_INCLUDE_FILE
491#define TRACE_INCLUDE_FILE trace
492
493#include <trace/define_trace.h>