cdns3-trace.h

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