[linux-2.6-block.git] / drivers / usb / gadget / udc / cdns2 / cdns2-trace.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * USBHS-DEV device controller driver.
 * Trace support header file.
 *
 * Copyright (C) 2023 Cadence.
 *
 * Author: Pawel Laszczak <pawell@cadence.com>
 */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM cdns2-dev

/*
 * The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a
 * legitimate C variable. It is not exported to user space.
 */
#undef TRACE_SYSTEM_VAR
#define TRACE_SYSTEM_VAR cdns2_dev

#if !defined(__LINUX_CDNS2_TRACE) || defined(TRACE_HEADER_MULTI_READ)
#define __LINUX_CDNS2_TRACE

#include <linux/types.h>
#include <linux/tracepoint.h>
#include <asm/byteorder.h>
#include <linux/usb/ch9.h>
#include "cdns2-gadget.h"
#include "cdns2-debug.h"

#define CDNS2_MSG_MAX	500

DECLARE_EVENT_CLASS(cdns2_log_enable_disable,
	TP_PROTO(int set),
	TP_ARGS(set),
	TP_STRUCT__entry(
		__field(int, set)
	),
	TP_fast_assign(
		__entry->set = set;
	),
	TP_printk("%s", __entry->set ? "enabled" : "disabled")
);

DEFINE_EVENT(cdns2_log_enable_disable, cdns2_pullup,
	TP_PROTO(int set),
	TP_ARGS(set)
);

DEFINE_EVENT(cdns2_log_enable_disable, cdns2_lpm,
	TP_PROTO(int set),
	TP_ARGS(set)
);

DEFINE_EVENT(cdns2_log_enable_disable, cdns2_may_wakeup,
	TP_PROTO(int set),
	TP_ARGS(set)
);

DECLARE_EVENT_CLASS(cdns2_log_simple,
	TP_PROTO(char *msg),
	TP_ARGS(msg),
	TP_STRUCT__entry(
		__string(text, msg)
	),
	TP_fast_assign(
		__assign_str(text);
	),
	TP_printk("%s", __get_str(text))
);

DEFINE_EVENT(cdns2_log_simple, cdns2_no_room_on_ring,
	TP_PROTO(char *msg),
	TP_ARGS(msg)
);

DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_status_stage,
	TP_PROTO(char *msg),
	TP_ARGS(msg)
);

DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_set_config,
	TP_PROTO(char *msg),
	TP_ARGS(msg)
);

DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_setup,
	TP_PROTO(char *msg),
	TP_ARGS(msg)
);

DEFINE_EVENT(cdns2_log_simple, cdns2_device_state,
	TP_PROTO(char *msg),
	TP_ARGS(msg)
);

TRACE_EVENT(cdns2_ep_halt,
	TP_PROTO(struct cdns2_endpoint *ep_priv, u8 halt, u8 flush),
	TP_ARGS(ep_priv, halt, flush),
	TP_STRUCT__entry(
		__string(name, ep_priv->name)
		__field(u8, halt)
		__field(u8, flush)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->halt = halt;
		__entry->flush = flush;
	),
	TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
		  __get_str(name), __entry->halt ? "set" : "cleared")
);

TRACE_EVENT(cdns2_wa1,
	TP_PROTO(struct cdns2_endpoint *ep_priv, char *msg),
	TP_ARGS(ep_priv, msg),
	TP_STRUCT__entry(
		__string(ep_name, ep_priv->name)
		__string(msg, msg)
	),
	TP_fast_assign(
		__assign_str(ep_name);
		__assign_str(msg);
	),
	TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
);

DECLARE_EVENT_CLASS(cdns2_log_doorbell,
	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
	TP_ARGS(pep, ep_trbaddr),
	TP_STRUCT__entry(
		__string(name, pep->num ? pep->name :
				(pep->dir ? "ep0in" : "ep0out"))
		__field(u32, ep_trbaddr)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->ep_trbaddr = ep_trbaddr;
	),
	TP_printk("%s, ep_trbaddr %08x", __get_str(name),
		  __entry->ep_trbaddr)
);

DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_ep0,
	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
	TP_ARGS(pep, ep_trbaddr)
);

DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_epx,
	TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
	TP_ARGS(pep, ep_trbaddr)
);

DECLARE_EVENT_CLASS(cdns2_log_usb_irq,
	TP_PROTO(u32 usb_irq, u32 ext_irq),
	TP_ARGS(usb_irq, ext_irq),
	TP_STRUCT__entry(
		__field(u32, usb_irq)
		__field(u32, ext_irq)
	),
	TP_fast_assign(
		__entry->usb_irq = usb_irq;
		__entry->ext_irq = ext_irq;
	),
	TP_printk("%s", cdns2_decode_usb_irq(__get_buf(CDNS2_MSG_MAX),
					     CDNS2_MSG_MAX,
					     __entry->usb_irq,
					     __entry->ext_irq))
);

DEFINE_EVENT(cdns2_log_usb_irq, cdns2_usb_irq,
	TP_PROTO(u32 usb_irq, u32 ext_irq),
	TP_ARGS(usb_irq, ext_irq)
);

TRACE_EVENT(cdns2_dma_ep_ists,
	TP_PROTO(u32 dma_ep_ists),
	TP_ARGS(dma_ep_ists),
	TP_STRUCT__entry(
		__field(u32, dma_ep_ists)
	),
	TP_fast_assign(
		__entry->dma_ep_ists = dma_ep_ists;
	),
	TP_printk("OUT: 0x%04x, IN: 0x%04x", (u16)__entry->dma_ep_ists,
		  __entry->dma_ep_ists >> 16)
);

DECLARE_EVENT_CLASS(cdns2_log_epx_irq,
	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
	TP_ARGS(pdev, pep),
	TP_STRUCT__entry(
		__string(ep_name, pep->name)
		__field(u32, ep_sts)
		__field(u32, ep_ists)
		__field(u32, ep_traddr)
	),
	TP_fast_assign(
		__assign_str(ep_name);
		__entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
		__entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
		__entry->ep_traddr = readl(&pdev->adma_regs->ep_traddr);
	),
	TP_printk("%s, ep_traddr: %08x",
		  cdns2_decode_epx_irq(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
				       __get_str(ep_name),
				       __entry->ep_ists, __entry->ep_sts),
		  __entry->ep_traddr)
);

DEFINE_EVENT(cdns2_log_epx_irq, cdns2_epx_irq,
	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
	TP_ARGS(pdev, pep)
);

DECLARE_EVENT_CLASS(cdns2_log_ep0_irq,
	TP_PROTO(struct cdns2_device *pdev),
	TP_ARGS(pdev),
	TP_STRUCT__entry(
		__field(int, ep_dir)
		__field(u32, ep_ists)
		__field(u32, ep_sts)
	),
	TP_fast_assign(
		__entry->ep_dir = pdev->selected_ep;
		__entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
		__entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
	),
	TP_printk("%s", cdns2_decode_ep0_irq(__get_buf(CDNS2_MSG_MAX),
					     CDNS2_MSG_MAX,
					     __entry->ep_ists, __entry->ep_sts,
					     __entry->ep_dir))
);

DEFINE_EVENT(cdns2_log_ep0_irq, cdns2_ep0_irq,
	TP_PROTO(struct cdns2_device *pdev),
	TP_ARGS(pdev)
);

DECLARE_EVENT_CLASS(cdns2_log_ctrl,
	TP_PROTO(struct usb_ctrlrequest *ctrl),
	TP_ARGS(ctrl),
	TP_STRUCT__entry(
		__field(u8, bRequestType)
		__field(u8, bRequest)
		__field(u16, wValue)
		__field(u16, wIndex)
		__field(u16, wLength)
	),
	TP_fast_assign(
		__entry->bRequestType = ctrl->bRequestType;
		__entry->bRequest = ctrl->bRequest;
		__entry->wValue = le16_to_cpu(ctrl->wValue);
		__entry->wIndex = le16_to_cpu(ctrl->wIndex);
		__entry->wLength = le16_to_cpu(ctrl->wLength);
	),
	TP_printk("%s", usb_decode_ctrl(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
					__entry->bRequestType,
					__entry->bRequest, __entry->wValue,
					__entry->wIndex, __entry->wLength)
	)
);

DEFINE_EVENT(cdns2_log_ctrl, cdns2_ctrl_req,
	TP_PROTO(struct usb_ctrlrequest *ctrl),
	TP_ARGS(ctrl)
);

DECLARE_EVENT_CLASS(cdns2_log_request,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq),
	TP_STRUCT__entry(
		__string(name, preq->pep->name)
		__field(struct usb_request *, request)
		__field(struct cdns2_request *, preq)
		__field(void *, buf)
		__field(unsigned int, actual)
		__field(unsigned int, length)
		__field(int, status)
		__field(dma_addr_t, dma)
		__field(int, zero)
		__field(int, short_not_ok)
		__field(int, no_interrupt)
		__field(struct scatterlist*, sg)
		__field(unsigned int, num_sgs)
		__field(unsigned int, num_mapped_sgs)
		__field(int, start_trb)
		__field(int, end_trb)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->request = &preq->request;
		__entry->preq = preq;
		__entry->buf = preq->request.buf;
		__entry->actual = preq->request.actual;
		__entry->length = preq->request.length;
		__entry->status = preq->request.status;
		__entry->dma = preq->request.dma;
		__entry->zero = preq->request.zero;
		__entry->short_not_ok = preq->request.short_not_ok;
		__entry->no_interrupt = preq->request.no_interrupt;
		__entry->sg = preq->request.sg;
		__entry->num_sgs = preq->request.num_sgs;
		__entry->num_mapped_sgs = preq->request.num_mapped_sgs;
		__entry->start_trb = preq->start_trb;
		__entry->end_trb = preq->end_trb;
	),
	TP_printk("%s: req: %p, preq: %p, req buf: %p, length: %u/%u, status: %d,"
		  "buf dma: (%pad), %s%s%s, sg: %p, num_sgs: %d, num_m_sgs: %d,"
		  "trb: [start: %d, end: %d]",
		  __get_str(name), __entry->request, __entry->preq,
		  __entry->buf, __entry->actual, __entry->length,
		  __entry->status, &__entry->dma,
		  __entry->zero ? "Z" : "z",
		  __entry->short_not_ok ? "S" : "s",
		  __entry->no_interrupt ? "I" : "i",
		  __entry->sg, __entry->num_sgs, __entry->num_mapped_sgs,
		  __entry->start_trb,
		  __entry->end_trb
	)
);

DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue_error,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_alloc_request,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_free_request,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_ep_queue,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_request_dequeue,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

DEFINE_EVENT(cdns2_log_request, cdns2_request_giveback,
	TP_PROTO(struct cdns2_request *preq),
	TP_ARGS(preq)
);

TRACE_EVENT(cdns2_ep0_enqueue,
	TP_PROTO(struct cdns2_device *dev_priv, struct usb_request *request),
	TP_ARGS(dev_priv, request),
	TP_STRUCT__entry(
		__field(int, dir)
		__field(int, length)
	),
	TP_fast_assign(
		__entry->dir = dev_priv->eps[0].dir;
		__entry->length = request->length;
	),
	TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
		  __entry->length)
);

DECLARE_EVENT_CLASS(cdns2_log_map_request,
	TP_PROTO(struct cdns2_request *priv_req),
	TP_ARGS(priv_req),
	TP_STRUCT__entry(
		__string(name, priv_req->pep->name)
		__field(struct usb_request *, req)
		__field(void *, buf)
		__field(dma_addr_t, dma)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->req = &priv_req->request;
		__entry->buf = priv_req->request.buf;
		__entry->dma = priv_req->request.dma;
	),
	TP_printk("%s: req: %p, req buf %p, dma %p",
		  __get_str(name), __entry->req, __entry->buf, &__entry->dma
	)
);

DEFINE_EVENT(cdns2_log_map_request, cdns2_map_request,
	     TP_PROTO(struct cdns2_request *req),
	     TP_ARGS(req)
);
DEFINE_EVENT(cdns2_log_map_request, cdns2_mapped_request,
	     TP_PROTO(struct cdns2_request *req),
	     TP_ARGS(req)
);

DECLARE_EVENT_CLASS(cdns2_log_trb,
	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
	TP_ARGS(pep, trb),
	TP_STRUCT__entry(
		__string(name, pep->name)
		__field(struct cdns2_trb *, trb)
		__field(u32, buffer)
		__field(u32, length)
		__field(u32, control)
		__field(u32, type)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->trb = trb;
		__entry->buffer = le32_to_cpu(trb->buffer);
		__entry->length = le32_to_cpu(trb->length);
		__entry->control = le32_to_cpu(trb->control);
		__entry->type = usb_endpoint_type(pep->endpoint.desc);
	),
	TP_printk("%s: trb V: %p, dma buf: P: 0x%08x, %s",
		 __get_str(name), __entry->trb, __entry->buffer,
		 cdns2_decode_trb(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
				  __entry->control, __entry->length,
				  __entry->buffer))
);

DEFINE_EVENT(cdns2_log_trb, cdns2_queue_trb,
	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
	TP_ARGS(pep, trb)
);

DEFINE_EVENT(cdns2_log_trb, cdns2_complete_trb,
	TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
	TP_ARGS(pep, trb)
);

DECLARE_EVENT_CLASS(cdns2_log_ring,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep),
	TP_STRUCT__entry(
		__dynamic_array(u8, tr_seg, TR_SEG_SIZE)
		__dynamic_array(u8, pep, sizeof(struct cdns2_endpoint))
		__dynamic_array(char, buffer,
				(TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX)
	),
	TP_fast_assign(
		memcpy(__get_dynamic_array(pep), pep,
		       sizeof(struct cdns2_endpoint));
		memcpy(__get_dynamic_array(tr_seg), pep->ring.trbs,
		       TR_SEG_SIZE);
	),

	TP_printk("%s",
		  cdns2_raw_ring((struct cdns2_endpoint *)__get_str(pep),
				    (struct cdns2_trb *)__get_str(tr_seg),
				    __get_str(buffer),
				    (TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX))
);

DEFINE_EVENT(cdns2_log_ring, cdns2_ring,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep)
);

DECLARE_EVENT_CLASS(cdns2_log_ep,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep),
	TP_STRUCT__entry(
		__string(name, pep->name)
		__field(unsigned int, maxpacket)
		__field(unsigned int, maxpacket_limit)
		__field(unsigned int, flags)
		__field(unsigned int, dir)
		__field(u8, enqueue)
		__field(u8, dequeue)
	),
	TP_fast_assign(
		__assign_str(name);
		__entry->maxpacket = pep->endpoint.maxpacket;
		__entry->maxpacket_limit = pep->endpoint.maxpacket_limit;
		__entry->flags = pep->ep_state;
		__entry->dir = pep->dir;
		__entry->enqueue = pep->ring.enqueue;
		__entry->dequeue = pep->ring.dequeue;
	),
	TP_printk("%s: mps: %d/%d, enq idx: %d, deq idx: %d, "
		  "flags: %s%s%s%s, dir: %s",
		__get_str(name), __entry->maxpacket,
		__entry->maxpacket_limit, __entry->enqueue,
		__entry->dequeue,
		__entry->flags & EP_ENABLED ? "EN | " : "",
		__entry->flags & EP_STALLED ? "STALLED | " : "",
		__entry->flags & EP_WEDGE ? "WEDGE | " : "",
		__entry->flags & EP_RING_FULL ? "RING FULL |" : "",
		__entry->dir ? "IN" : "OUT"
	)
);

DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_enable,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep)
);

DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_disable,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep)
);

DEFINE_EVENT(cdns2_log_ep, cdns2_iso_out_ep_disable,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep)
);

DEFINE_EVENT(cdns2_log_ep, cdns2_ep_busy_try_halt_again,
	TP_PROTO(struct cdns2_endpoint *pep),
	TP_ARGS(pep)
);

DECLARE_EVENT_CLASS(cdns2_log_request_handled,
	TP_PROTO(struct cdns2_request *priv_req, int current_index,
		 int handled),
	TP_ARGS(priv_req, current_index, handled),
	TP_STRUCT__entry(
		__field(struct cdns2_request *, priv_req)
		__field(unsigned int, dma_position)
		__field(unsigned int, handled)
		__field(unsigned int, dequeue_idx)
		__field(unsigned int, enqueue_idx)
		__field(unsigned int, start_trb)
		__field(unsigned int, end_trb)
	),
	TP_fast_assign(
		__entry->priv_req = priv_req;
		__entry->dma_position = current_index;
		__entry->handled = handled;
		__entry->dequeue_idx = priv_req->pep->ring.dequeue;
		__entry->enqueue_idx = priv_req->pep->ring.enqueue;
		__entry->start_trb = priv_req->start_trb;
		__entry->end_trb = priv_req->end_trb;
	),
	TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
		  " start trb: %d, end trb: %d",
		__entry->priv_req,
		__entry->handled ? "handled" : "not handled",
		__entry->dma_position, __entry->dequeue_idx,
		__entry->enqueue_idx, __entry->start_trb,
		__entry->end_trb
	)
);

DEFINE_EVENT(cdns2_log_request_handled, cdns2_request_handled,
	TP_PROTO(struct cdns2_request *priv_req, int current_index,
		 int handled),
	TP_ARGS(priv_req, current_index, handled)
);

DECLARE_EVENT_CLASS(cdns2_log_epx_reg_config,
	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
	TP_ARGS(pdev, pep),
	TP_STRUCT__entry(
		__string(ep_name, pep->name)
		__field(u8, burst_size)
		__field(__le16, maxpack_reg)
		__field(__u8, con_reg)
		__field(u32, ep_sel_reg)
		__field(u32, ep_sts_en_reg)
		__field(u32, ep_cfg_reg)
	),
	TP_fast_assign(
		__assign_str(ep_name);
		__entry->burst_size = pep->trb_burst_size;
		__entry->maxpack_reg = pep->dir ? readw(&pdev->epx_regs->txmaxpack[pep->num - 1]) :
						  readw(&pdev->epx_regs->rxmaxpack[pep->num - 1]);
		__entry->con_reg = pep->dir ? readb(&pdev->epx_regs->ep[pep->num - 1].txcon) :
					      readb(&pdev->epx_regs->ep[pep->num - 1].rxcon);
		__entry->ep_sel_reg = readl(&pdev->adma_regs->ep_sel);
		__entry->ep_sts_en_reg = readl(&pdev->adma_regs->ep_sts_en);
		__entry->ep_cfg_reg = readl(&pdev->adma_regs->ep_cfg);
	),

	TP_printk("%s, maxpack: %d, con: %02x, dma_ep_sel: %08x, dma_ep_sts_en: %08x"
		  " dma_ep_cfg %08x",
		  __get_str(ep_name), __entry->maxpack_reg, __entry->con_reg,
		  __entry->ep_sel_reg, __entry->ep_sts_en_reg,
		  __entry->ep_cfg_reg
	)
);

DEFINE_EVENT(cdns2_log_epx_reg_config, cdns2_epx_hw_cfg,
	TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
	TP_ARGS(pdev, pep)
);

#endif /* __LINUX_CDNS2_TRACE */

/* This part must be outside header guard. */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .

#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE cdns2-trace

#include <trace/define_trace.h>
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);
2c92ca84 SRG	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>