[mirror_ubuntu-jammy-kernel.git] / drivers / usb / host / xhci-trace.h

// SPDX-License-Identifier: GPL-2.0
/*
 * xHCI host controller driver
 *
 * Copyright (C) 2013 Xenia Ragiadakou
 *
 * Author: Xenia Ragiadakou
 * Email : burzalodowa@gmail.com
 */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM xhci-hcd

/*
 * 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 xhci_hcd

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

#include <linux/tracepoint.h>
#include "xhci.h"
#include "xhci-dbgcap.h"

#define XHCI_MSG_MAX	500

DECLARE_EVENT_CLASS(xhci_log_msg,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf),
	TP_STRUCT__entry(__dynamic_array(char, msg, XHCI_MSG_MAX)),
	TP_fast_assign(
		vsnprintf(__get_str(msg), XHCI_MSG_MAX, vaf->fmt, *vaf->va);
	),
	TP_printk("%s", __get_str(msg))
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_address,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_context_change,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_quirks,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_reset_ep,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_cancel_urb,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_init,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DEFINE_EVENT(xhci_log_msg, xhci_dbg_ring_expansion,
	TP_PROTO(struct va_format *vaf),
	TP_ARGS(vaf)
);

DECLARE_EVENT_CLASS(xhci_log_ctx,
	TP_PROTO(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
		 unsigned int ep_num),
	TP_ARGS(xhci, ctx, ep_num),
	TP_STRUCT__entry(
		__field(int, ctx_64)
		__field(unsigned, ctx_type)
		__field(dma_addr_t, ctx_dma)
		__field(u8 *, ctx_va)
		__field(unsigned, ctx_ep_num)
		__field(int, slot_id)
		__dynamic_array(u32, ctx_data,
			((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 8) *
			((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1))
	),
	TP_fast_assign(
		struct usb_device *udev;

		udev = to_usb_device(xhci_to_hcd(xhci)->self.controller);
		__entry->ctx_64 = HCC_64BYTE_CONTEXT(xhci->hcc_params);
		__entry->ctx_type = ctx->type;
		__entry->ctx_dma = ctx->dma;
		__entry->ctx_va = ctx->bytes;
		__entry->slot_id = udev->slot_id;
		__entry->ctx_ep_num = ep_num;
		memcpy(__get_dynamic_array(ctx_data), ctx->bytes,
			((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 32) *
			((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1));
	),
	TP_printk("ctx_64=%d, ctx_type=%u, ctx_dma=@%llx, ctx_va=@%p",
			__entry->ctx_64, __entry->ctx_type,
			(unsigned long long) __entry->ctx_dma, __entry->ctx_va
	)
);

DEFINE_EVENT(xhci_log_ctx, xhci_address_ctx,
	TP_PROTO(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
		 unsigned int ep_num),
	TP_ARGS(xhci, ctx, ep_num)
);

DECLARE_EVENT_CLASS(xhci_log_trb,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb),
	TP_STRUCT__entry(
		__field(u32, type)
		__field(u32, field0)
		__field(u32, field1)
		__field(u32, field2)
		__field(u32, field3)
	),
	TP_fast_assign(
		__entry->type = ring->type;
		__entry->field0 = le32_to_cpu(trb->field[0]);
		__entry->field1 = le32_to_cpu(trb->field[1]);
		__entry->field2 = le32_to_cpu(trb->field[2]);
		__entry->field3 = le32_to_cpu(trb->field[3]);
	),
	TP_printk("%s: %s", xhci_ring_type_string(__entry->type),
			xhci_decode_trb(__entry->field0, __entry->field1,
					__entry->field2, __entry->field3)
	)
);

DEFINE_EVENT(xhci_log_trb, xhci_handle_event,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_handle_command,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_handle_transfer,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_queue_trb,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_event,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_transfer,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DEFINE_EVENT(xhci_log_trb, xhci_dbc_gadget_ep_queue,
	TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
	TP_ARGS(ring, trb)
);

DECLARE_EVENT_CLASS(xhci_log_free_virt_dev,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev),
	TP_STRUCT__entry(
		__field(void *, vdev)
		__field(unsigned long long, out_ctx)
		__field(unsigned long long, in_ctx)
		__field(u8, fake_port)
		__field(u8, real_port)
		__field(u16, current_mel)

	),
	TP_fast_assign(
		__entry->vdev = vdev;
		__entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
		__entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
		__entry->fake_port = (u8) vdev->fake_port;
		__entry->real_port = (u8) vdev->real_port;
		__entry->current_mel = (u16) vdev->current_mel;
		),
	TP_printk("vdev %p ctx %llx | %llx fake_port %d real_port %d current_mel %d",
		__entry->vdev, __entry->in_ctx, __entry->out_ctx,
		__entry->fake_port, __entry->real_port, __entry->current_mel
	)
);

DEFINE_EVENT(xhci_log_free_virt_dev, xhci_free_virt_device,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev)
);

DECLARE_EVENT_CLASS(xhci_log_virt_dev,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev),
	TP_STRUCT__entry(
		__field(void *, vdev)
		__field(unsigned long long, out_ctx)
		__field(unsigned long long, in_ctx)
		__field(int, devnum)
		__field(int, state)
		__field(int, speed)
		__field(u8, portnum)
		__field(u8, level)
		__field(int, slot_id)
	),
	TP_fast_assign(
		__entry->vdev = vdev;
		__entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
		__entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
		__entry->devnum = vdev->udev->devnum;
		__entry->state = vdev->udev->state;
		__entry->speed = vdev->udev->speed;
		__entry->portnum = vdev->udev->portnum;
		__entry->level = vdev->udev->level;
		__entry->slot_id = vdev->udev->slot_id;
	),
	TP_printk("vdev %p ctx %llx | %llx num %d state %d speed %d port %d level %d slot %d",
		__entry->vdev, __entry->in_ctx, __entry->out_ctx,
		__entry->devnum, __entry->state, __entry->speed,
		__entry->portnum, __entry->level, __entry->slot_id
	)
);

DEFINE_EVENT(xhci_log_virt_dev, xhci_alloc_virt_device,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev)
);

DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_device,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev)
);

DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_addressable_virt_device,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev)
);

DEFINE_EVENT(xhci_log_virt_dev, xhci_stop_device,
	TP_PROTO(struct xhci_virt_device *vdev),
	TP_ARGS(vdev)
);

DECLARE_EVENT_CLASS(xhci_log_urb,
	TP_PROTO(struct urb *urb),
	TP_ARGS(urb),
	TP_STRUCT__entry(
		__field(void *, urb)
		__field(unsigned int, pipe)
		__field(unsigned int, stream)
		__field(int, status)
		__field(unsigned int, flags)
		__field(int, num_mapped_sgs)
		__field(int, num_sgs)
		__field(int, length)
		__field(int, actual)
		__field(int, epnum)
		__field(int, dir_in)
		__field(int, type)
		__field(int, slot_id)
	),
	TP_fast_assign(
		__entry->urb = urb;
		__entry->pipe = urb->pipe;
		__entry->stream = urb->stream_id;
		__entry->status = urb->status;
		__entry->flags = urb->transfer_flags;
		__entry->num_mapped_sgs = urb->num_mapped_sgs;
		__entry->num_sgs = urb->num_sgs;
		__entry->length = urb->transfer_buffer_length;
		__entry->actual = urb->actual_length;
		__entry->epnum = usb_endpoint_num(&urb->ep->desc);
		__entry->dir_in = usb_endpoint_dir_in(&urb->ep->desc);
		__entry->type = usb_endpoint_type(&urb->ep->desc);
		__entry->slot_id = urb->dev->slot_id;
	),
	TP_printk("ep%d%s-%s: urb %p pipe %u slot %d length %d/%d sgs %d/%d stream %d flags %08x",
			__entry->epnum, __entry->dir_in ? "in" : "out",
			({ char *s;
			switch (__entry->type) {
			case USB_ENDPOINT_XFER_INT:
				s = "intr";
				break;
			case USB_ENDPOINT_XFER_CONTROL:
				s = "control";
				break;
			case USB_ENDPOINT_XFER_BULK:
				s = "bulk";
				break;
			case USB_ENDPOINT_XFER_ISOC:
				s = "isoc";
				break;
			default:
				s = "UNKNOWN";
			} s; }), __entry->urb, __entry->pipe, __entry->slot_id,
			__entry->actual, __entry->length, __entry->num_mapped_sgs,
			__entry->num_sgs, __entry->stream, __entry->flags
		)
);

DEFINE_EVENT(xhci_log_urb, xhci_urb_enqueue,
	TP_PROTO(struct urb *urb),
	TP_ARGS(urb)
);

DEFINE_EVENT(xhci_log_urb, xhci_urb_giveback,
	TP_PROTO(struct urb *urb),
	TP_ARGS(urb)
);

DEFINE_EVENT(xhci_log_urb, xhci_urb_dequeue,
	TP_PROTO(struct urb *urb),
	TP_ARGS(urb)
);

DECLARE_EVENT_CLASS(xhci_log_ep_ctx,
	TP_PROTO(struct xhci_ep_ctx *ctx),
	TP_ARGS(ctx),
	TP_STRUCT__entry(
		__field(u32, info)
		__field(u32, info2)
		__field(u64, deq)
		__field(u32, tx_info)
	),
	TP_fast_assign(
		__entry->info = le32_to_cpu(ctx->ep_info);
		__entry->info2 = le32_to_cpu(ctx->ep_info2);
		__entry->deq = le64_to_cpu(ctx->deq);
		__entry->tx_info = le32_to_cpu(ctx->tx_info);
	),
	TP_printk("%s", xhci_decode_ep_context(__entry->info,
		__entry->info2, __entry->deq, __entry->tx_info)
	)
);

DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_stop_ep,
	TP_PROTO(struct xhci_ep_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_set_deq_ep,
	TP_PROTO(struct xhci_ep_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_reset_ep,
	TP_PROTO(struct xhci_ep_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_config_ep,
	TP_PROTO(struct xhci_ep_ctx *ctx),
	TP_ARGS(ctx)
);

DECLARE_EVENT_CLASS(xhci_log_slot_ctx,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx),
	TP_STRUCT__entry(
		__field(u32, info)
		__field(u32, info2)
		__field(u32, tt_info)
		__field(u32, state)
	),
	TP_fast_assign(
		__entry->info = le32_to_cpu(ctx->dev_info);
		__entry->info2 = le32_to_cpu(ctx->dev_info2);
		__entry->tt_info = le64_to_cpu(ctx->tt_info);
		__entry->state = le32_to_cpu(ctx->dev_state);
	),
	TP_printk("%s", xhci_decode_slot_context(__entry->info,
			__entry->info2, __entry->tt_info,
			__entry->state)
	)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_alloc_dev,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_free_dev,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_disable_slot,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_discover_or_reset_device,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_setup_device_slot,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_addr_dev,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_reset_dev,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_set_deq,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(xhci_log_slot_ctx, xhci_configure_endpoint,
	TP_PROTO(struct xhci_slot_ctx *ctx),
	TP_ARGS(ctx)
);

DECLARE_EVENT_CLASS(xhci_log_ctrl_ctx,
	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	TP_ARGS(ctrl_ctx),
	TP_STRUCT__entry(
		__field(u32, drop)
		__field(u32, add)
	),
	TP_fast_assign(
		__entry->drop = le32_to_cpu(ctrl_ctx->drop_flags);
		__entry->add = le32_to_cpu(ctrl_ctx->add_flags);
	),
	TP_printk("%s", xhci_decode_ctrl_ctx(__entry->drop, __entry->add)
	)
);

DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_address_ctrl_ctx,
	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	TP_ARGS(ctrl_ctx)
);

DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_configure_endpoint_ctrl_ctx,
	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	TP_ARGS(ctrl_ctx)
);

DECLARE_EVENT_CLASS(xhci_log_ring,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring),
	TP_STRUCT__entry(
		__field(u32, type)
		__field(void *, ring)
		__field(dma_addr_t, enq)
		__field(dma_addr_t, deq)
		__field(dma_addr_t, enq_seg)
		__field(dma_addr_t, deq_seg)
		__field(unsigned int, num_segs)
		__field(unsigned int, stream_id)
		__field(unsigned int, cycle_state)
		__field(unsigned int, num_trbs_free)
		__field(unsigned int, bounce_buf_len)
	),
	TP_fast_assign(
		__entry->ring = ring;
		__entry->type = ring->type;
		__entry->num_segs = ring->num_segs;
		__entry->stream_id = ring->stream_id;
		__entry->enq_seg = ring->enq_seg->dma;
		__entry->deq_seg = ring->deq_seg->dma;
		__entry->cycle_state = ring->cycle_state;
		__entry->num_trbs_free = ring->num_trbs_free;
		__entry->bounce_buf_len = ring->bounce_buf_len;
		__entry->enq = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
		__entry->deq = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
	),
	TP_printk("%s %p: enq %pad(%pad) deq %pad(%pad) segs %d stream %d free_trbs %d bounce %d cycle %d",
			xhci_ring_type_string(__entry->type), __entry->ring,
			&__entry->enq, &__entry->enq_seg,
			&__entry->deq, &__entry->deq_seg,
			__entry->num_segs,
			__entry->stream_id,
			__entry->num_trbs_free,
			__entry->bounce_buf_len,
			__entry->cycle_state
		)
);

DEFINE_EVENT(xhci_log_ring, xhci_ring_alloc,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring)
);

DEFINE_EVENT(xhci_log_ring, xhci_ring_free,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring)
);

DEFINE_EVENT(xhci_log_ring, xhci_ring_expansion,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring)
);

DEFINE_EVENT(xhci_log_ring, xhci_inc_enq,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring)
);

DEFINE_EVENT(xhci_log_ring, xhci_inc_deq,
	TP_PROTO(struct xhci_ring *ring),
	TP_ARGS(ring)
);

DECLARE_EVENT_CLASS(xhci_log_portsc,
		    TP_PROTO(u32 portnum, u32 portsc),
		    TP_ARGS(portnum, portsc),
		    TP_STRUCT__entry(
				     __field(u32, portnum)
				     __field(u32, portsc)
				     ),
		    TP_fast_assign(
				   __entry->portnum = portnum;
				   __entry->portsc = portsc;
				   ),
		    TP_printk("port-%d: %s",
			      __entry->portnum,
			      xhci_decode_portsc(__entry->portsc)
			      )
);

DEFINE_EVENT(xhci_log_portsc, xhci_handle_port_status,
	     TP_PROTO(u32 portnum, u32 portsc),
	     TP_ARGS(portnum, portsc)
);

DEFINE_EVENT(xhci_log_portsc, xhci_get_port_status,
	     TP_PROTO(u32 portnum, u32 portsc),
	     TP_ARGS(portnum, portsc)
);

DEFINE_EVENT(xhci_log_portsc, xhci_hub_status_data,
	     TP_PROTO(u32 portnum, u32 portsc),
	     TP_ARGS(portnum, portsc)
);

DECLARE_EVENT_CLASS(xhci_dbc_log_request,
	TP_PROTO(struct dbc_request *req),
	TP_ARGS(req),
	TP_STRUCT__entry(
		__field(struct dbc_request *, req)
		__field(bool, dir)
		__field(unsigned int, actual)
		__field(unsigned int, length)
		__field(int, status)
	),
	TP_fast_assign(
		__entry->req = req;
		__entry->dir = req->direction;
		__entry->actual = req->actual;
		__entry->length = req->length;
		__entry->status = req->status;
	),
	TP_printk("%s: req %p length %u/%u ==> %d",
		__entry->dir ? "bulk-in" : "bulk-out",
		__entry->req, __entry->actual,
		__entry->length, __entry->status
	)
);

DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_alloc_request,
	TP_PROTO(struct dbc_request *req),
	TP_ARGS(req)
);

DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_free_request,
	TP_PROTO(struct dbc_request *req),
	TP_ARGS(req)
);

DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_queue_request,
	TP_PROTO(struct dbc_request *req),
	TP_ARGS(req)
);

DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_giveback_request,
	TP_PROTO(struct dbc_request *req),
	TP_ARGS(req)
);
#endif /* __XHCI_TRACE_H */

/* this part must be outside header guard */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .

#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE xhci-trace

#include <trace/define_trace.h>
Commit	Line	Data
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0
84a99f6f XR	2	/*
	3	* xHCI host controller driver
	4	*
	5	* Copyright (C) 2013 Xenia Ragiadakou
	6	*
	7	* Author: Xenia Ragiadakou
	8	* Email : burzalodowa@gmail.com
84a99f6f XR	9	*/
	10
	11	#undef TRACE_SYSTEM
	12	#define TRACE_SYSTEM xhci-hcd
	13
7267b238 SRRH	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 xhci_hcd
	20
84a99f6f XR	21	#if !defined(__XHCI_TRACE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	22	#define __XHCI_TRACE_H
	23
	24	#include <linux/tracepoint.h>
1d27fabe	25	#include "xhci.h"
dfba2174	26	#include "xhci-dbgcap.h"
84a99f6f XR	27
	28	#define XHCI_MSG_MAX 500
	29
	30	DECLARE_EVENT_CLASS(xhci_log_msg,
	31	TP_PROTO(struct va_format *vaf),
	32	TP_ARGS(vaf),
	33	TP_STRUCT__entry(__dynamic_array(char, msg, XHCI_MSG_MAX)),
	34	TP_fast_assign(
	35	vsnprintf(__get_str(msg), XHCI_MSG_MAX, vaf->fmt, *vaf->va);
	36	),
	37	TP_printk("%s", __get_str(msg))
	38	);
	39
	40	DEFINE_EVENT(xhci_log_msg, xhci_dbg_address,
	41	TP_PROTO(struct va_format *vaf),
	42	TP_ARGS(vaf)
	43	);
	44
3a7fa5be XR	45	DEFINE_EVENT(xhci_log_msg, xhci_dbg_context_change,
	46	TP_PROTO(struct va_format *vaf),
	47	TP_ARGS(vaf)
	48	);
	49
4bdfe4c3 XR	50	DEFINE_EVENT(xhci_log_msg, xhci_dbg_quirks,
	51	TP_PROTO(struct va_format *vaf),
	52	TP_ARGS(vaf)
	53	);
	54
a0254324 XR	55	DEFINE_EVENT(xhci_log_msg, xhci_dbg_reset_ep,
	56	TP_PROTO(struct va_format *vaf),
	57	TP_ARGS(vaf)
	58	);
	59
aa50b290 XR	60	DEFINE_EVENT(xhci_log_msg, xhci_dbg_cancel_urb,
	61	TP_PROTO(struct va_format *vaf),
	62	TP_ARGS(vaf)
	63	);
	64
d195fcff XR	65	DEFINE_EVENT(xhci_log_msg, xhci_dbg_init,
	66	TP_PROTO(struct va_format *vaf),
	67	TP_ARGS(vaf)
	68	);
	69
68ffb011 XR	70	DEFINE_EVENT(xhci_log_msg, xhci_dbg_ring_expansion,
	71	TP_PROTO(struct va_format *vaf),
	72	TP_ARGS(vaf)
	73	);
	74
1d27fabe XR	75	DECLARE_EVENT_CLASS(xhci_log_ctx,
	76	TP_PROTO(struct xhci_hcd xhci, struct xhci_container_ctx ctx,
	77	unsigned int ep_num),
	78	TP_ARGS(xhci, ctx, ep_num),
	79	TP_STRUCT__entry(
	80	__field(int, ctx_64)
	81	__field(unsigned, ctx_type)
	82	__field(dma_addr_t, ctx_dma)
	83	__field(u8 *, ctx_va)
	84	__field(unsigned, ctx_ep_num)
	85	__field(int, slot_id)
	86	__dynamic_array(u32, ctx_data,
	87	((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 8) *
	88	((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1))
	89	),
	90	TP_fast_assign(
	91	struct usb_device *udev;
	92
	93	udev = to_usb_device(xhci_to_hcd(xhci)->self.controller);
	94	__entry->ctx_64 = HCC_64BYTE_CONTEXT(xhci->hcc_params);
	95	__entry->ctx_type = ctx->type;
	96	__entry->ctx_dma = ctx->dma;
	97	__entry->ctx_va = ctx->bytes;
	98	__entry->slot_id = udev->slot_id;
	99	__entry->ctx_ep_num = ep_num;
	100	memcpy(__get_dynamic_array(ctx_data), ctx->bytes,
	101	((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 32) *
	102	((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1));
	103	),
d4d93e6c	104	TP_printk("ctx_64=%d, ctx_type=%u, ctx_dma=@%llx, ctx_va=@%p",
1d27fabe XR	105	__entry->ctx_64, __entry->ctx_type,
	106	(unsigned long long) __entry->ctx_dma, __entry->ctx_va
	107	)
	108	);
	109
	110	DEFINE_EVENT(xhci_log_ctx, xhci_address_ctx,
	111	TP_PROTO(struct xhci_hcd xhci, struct xhci_container_ctx ctx,
	112	unsigned int ep_num),
	113	TP_ARGS(xhci, ctx, ep_num)
	114	);
	115
a37c3f76 FB	116	DECLARE_EVENT_CLASS(xhci_log_trb,
	117	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	118	TP_ARGS(ring, trb),
63a23b9a	119	TP_STRUCT__entry(
a37c3f76 FB	120	__field(u32, type)
	121	__field(u32, field0)
	122	__field(u32, field1)
	123	__field(u32, field2)
	124	__field(u32, field3)
63a23b9a XR	125	),
63a23b9a XR	126	TP_fast_assign(
a37c3f76 FB	127	__entry->type = ring->type;
	128	__entry->field0 = le32_to_cpu(trb->field[0]);
	129	__entry->field1 = le32_to_cpu(trb->field[1]);
	130	__entry->field2 = le32_to_cpu(trb->field[2]);
	131	__entry->field3 = le32_to_cpu(trb->field[3]);
63a23b9a	132	),
a37c3f76 FB	133	TP_printk("%s: %s", xhci_ring_type_string(__entry->type),
	134	xhci_decode_trb(__entry->field0, __entry->field1,
	135	__entry->field2, __entry->field3)
63a23b9a XR	136	)
	137	);
	138
a37c3f76 FB	139	DEFINE_EVENT(xhci_log_trb, xhci_handle_event,
	140	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	141	TP_ARGS(ring, trb)
	142	);
	143
	144	DEFINE_EVENT(xhci_log_trb, xhci_handle_command,
	145	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	146	TP_ARGS(ring, trb)
	147	);
	148
	149	DEFINE_EVENT(xhci_log_trb, xhci_handle_transfer,
	150	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	151	TP_ARGS(ring, trb)
	152	);
	153
	154	DEFINE_EVENT(xhci_log_trb, xhci_queue_trb,
	155	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	156	TP_ARGS(ring, trb)
63a23b9a XR	157	);
63a23b9a XR	158
dfba2174 LB	159	DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_event,
	160	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	161	TP_ARGS(ring, trb)
	162	);
	163
	164	DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_transfer,
	165	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	166	TP_ARGS(ring, trb)
	167	);
	168
	169	DEFINE_EVENT(xhci_log_trb, xhci_dbc_gadget_ep_queue,
	170	TP_PROTO(struct xhci_ring ring, struct xhci_generic_trb trb),
	171	TP_ARGS(ring, trb)
	172	);
	173
d850c165 ZX	174	DECLARE_EVENT_CLASS(xhci_log_free_virt_dev,
	175	TP_PROTO(struct xhci_virt_device *vdev),
	176	TP_ARGS(vdev),
	177	TP_STRUCT__entry(
	178	__field(void *, vdev)
	179	__field(unsigned long long, out_ctx)
	180	__field(unsigned long long, in_ctx)
	181	__field(u8, fake_port)
	182	__field(u8, real_port)
	183	__field(u16, current_mel)
	184
	185	),
	186	TP_fast_assign(
	187	__entry->vdev = vdev;
	188	__entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
	189	__entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
	190	__entry->fake_port = (u8) vdev->fake_port;
	191	__entry->real_port = (u8) vdev->real_port;
	192	__entry->current_mel = (u16) vdev->current_mel;
	193	),
	194	TP_printk("vdev %p ctx %llx \| %llx fake_port %d real_port %d current_mel %d",
	195	__entry->vdev, __entry->in_ctx, __entry->out_ctx,
	196	__entry->fake_port, __entry->real_port, __entry->current_mel
	197	)
	198	);
	199
	200	DEFINE_EVENT(xhci_log_free_virt_dev, xhci_free_virt_device,
	201	TP_PROTO(struct xhci_virt_device *vdev),
	202	TP_ARGS(vdev)
	203	);
	204
a711edee FB	205	DECLARE_EVENT_CLASS(xhci_log_virt_dev,
	206	TP_PROTO(struct xhci_virt_device *vdev),
	207	TP_ARGS(vdev),
	208	TP_STRUCT__entry(
	209	__field(void *, vdev)
	210	__field(unsigned long long, out_ctx)
	211	__field(unsigned long long, in_ctx)
	212	__field(int, devnum)
	213	__field(int, state)
	214	__field(int, speed)
	215	__field(u8, portnum)
	216	__field(u8, level)
	217	__field(int, slot_id)
	218	),
	219	TP_fast_assign(
	220	__entry->vdev = vdev;
	221	__entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
	222	__entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
	223	__entry->devnum = vdev->udev->devnum;
	224	__entry->state = vdev->udev->state;
	225	__entry->speed = vdev->udev->speed;
	226	__entry->portnum = vdev->udev->portnum;
	227	__entry->level = vdev->udev->level;
	228	__entry->slot_id = vdev->udev->slot_id;
	229	),
	230	TP_printk("vdev %p ctx %llx \| %llx num %d state %d speed %d port %d level %d slot %d",
	231	__entry->vdev, __entry->in_ctx, __entry->out_ctx,
	232	__entry->devnum, __entry->state, __entry->speed,
	233	__entry->portnum, __entry->level, __entry->slot_id
	234	)
	235	);
	236
	237	DEFINE_EVENT(xhci_log_virt_dev, xhci_alloc_virt_device,
	238	TP_PROTO(struct xhci_virt_device *vdev),
	239	TP_ARGS(vdev)
	240	);
	241
a711edee FB	242	DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_device,
	243	TP_PROTO(struct xhci_virt_device *vdev),
	244	TP_ARGS(vdev)
	245	);
	246
	247	DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_addressable_virt_device,
	248	TP_PROTO(struct xhci_virt_device *vdev),
	249	TP_ARGS(vdev)
	250	);
	251
	252	DEFINE_EVENT(xhci_log_virt_dev, xhci_stop_device,
	253	TP_PROTO(struct xhci_virt_device *vdev),
	254	TP_ARGS(vdev)
	255	);
	256
5abdc2e6 FB	257	DECLARE_EVENT_CLASS(xhci_log_urb,
	258	TP_PROTO(struct urb *urb),
	259	TP_ARGS(urb),
	260	TP_STRUCT__entry(
	261	__field(void *, urb)
	262	__field(unsigned int, pipe)
	263	__field(unsigned int, stream)
	264	__field(int, status)
	265	__field(unsigned int, flags)
	266	__field(int, num_mapped_sgs)
	267	__field(int, num_sgs)
	268	__field(int, length)
	269	__field(int, actual)
	270	__field(int, epnum)
	271	__field(int, dir_in)
	272	__field(int, type)
eaa9eb71	273	__field(int, slot_id)
5abdc2e6 FB	274	),
	275	TP_fast_assign(
	276	__entry->urb = urb;
	277	__entry->pipe = urb->pipe;
	278	__entry->stream = urb->stream_id;
	279	__entry->status = urb->status;
	280	__entry->flags = urb->transfer_flags;
	281	__entry->num_mapped_sgs = urb->num_mapped_sgs;
	282	__entry->num_sgs = urb->num_sgs;
	283	__entry->length = urb->transfer_buffer_length;
	284	__entry->actual = urb->actual_length;
	285	__entry->epnum = usb_endpoint_num(&urb->ep->desc);
	286	__entry->dir_in = usb_endpoint_dir_in(&urb->ep->desc);
	287	__entry->type = usb_endpoint_type(&urb->ep->desc);
eaa9eb71	288	__entry->slot_id = urb->dev->slot_id;
5abdc2e6	289	),
eaa9eb71	290	TP_printk("ep%d%s-%s: urb %p pipe %u slot %d length %d/%d sgs %d/%d stream %d flags %08x",
5abdc2e6 FB	291	__entry->epnum, __entry->dir_in ? "in" : "out",
	292	({ char *s;
	293	switch (__entry->type) {
	294	case USB_ENDPOINT_XFER_INT:
	295	s = "intr";
	296	break;
	297	case USB_ENDPOINT_XFER_CONTROL:
	298	s = "control";
	299	break;
	300	case USB_ENDPOINT_XFER_BULK:
	301	s = "bulk";
	302	break;
	303	case USB_ENDPOINT_XFER_ISOC:
	304	s = "isoc";
	305	break;
	306	default:
	307	s = "UNKNOWN";
eaa9eb71 FB	308	} s; }), __entry->urb, __entry->pipe, __entry->slot_id,
eaa9eb71 FB	309	__entry->actual, __entry->length, __entry->num_mapped_sgs,
5abdc2e6 FB	310	__entry->num_sgs, __entry->stream, __entry->flags
	311	)
	312	);
	313
	314	DEFINE_EVENT(xhci_log_urb, xhci_urb_enqueue,
	315	TP_PROTO(struct urb *urb),
	316	TP_ARGS(urb)
	317	);
	318
	319	DEFINE_EVENT(xhci_log_urb, xhci_urb_giveback,
	320	TP_PROTO(struct urb *urb),
	321	TP_ARGS(urb)
	322	);
	323
	324	DEFINE_EVENT(xhci_log_urb, xhci_urb_dequeue,
	325	TP_PROTO(struct urb *urb),
	326	TP_ARGS(urb)
	327	);
	328
19a7d0d6 FB	329	DECLARE_EVENT_CLASS(xhci_log_ep_ctx,
	330	TP_PROTO(struct xhci_ep_ctx *ctx),
	331	TP_ARGS(ctx),
	332	TP_STRUCT__entry(
	333	__field(u32, info)
	334	__field(u32, info2)
	335	__field(u64, deq)
	336	__field(u32, tx_info)
	337	),
	338	TP_fast_assign(
	339	__entry->info = le32_to_cpu(ctx->ep_info);
	340	__entry->info2 = le32_to_cpu(ctx->ep_info2);
	341	__entry->deq = le64_to_cpu(ctx->deq);
	342	__entry->tx_info = le32_to_cpu(ctx->tx_info);
	343	),
	344	TP_printk("%s", xhci_decode_ep_context(__entry->info,
	345	__entry->info2, __entry->deq, __entry->tx_info)
	346	)
	347	);
	348
	349	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_stop_ep,
	350	TP_PROTO(struct xhci_ep_ctx *ctx),
	351	TP_ARGS(ctx)
	352	);
	353
	354	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_set_deq_ep,
	355	TP_PROTO(struct xhci_ep_ctx *ctx),
	356	TP_ARGS(ctx)
	357	);
	358
	359	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_reset_ep,
	360	TP_PROTO(struct xhci_ep_ctx *ctx),
	361	TP_ARGS(ctx)
	362	);
	363
	364	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_config_ep,
	365	TP_PROTO(struct xhci_ep_ctx *ctx),
	366	TP_ARGS(ctx)
	367	);
	368
	369	DECLARE_EVENT_CLASS(xhci_log_slot_ctx,
	370	TP_PROTO(struct xhci_slot_ctx *ctx),
	371	TP_ARGS(ctx),
	372	TP_STRUCT__entry(
	373	__field(u32, info)
	374	__field(u32, info2)
	375	__field(u32, tt_info)
	376	__field(u32, state)
	377	),
	378	TP_fast_assign(
	379	__entry->info = le32_to_cpu(ctx->dev_info);
	380	__entry->info2 = le32_to_cpu(ctx->dev_info2);
	381	__entry->tt_info = le64_to_cpu(ctx->tt_info);
	382	__entry->state = le32_to_cpu(ctx->dev_state);
	383	),
	384	TP_printk("%s", xhci_decode_slot_context(__entry->info,
	385	__entry->info2, __entry->tt_info,
	386	__entry->state)
	387	)
	388	);
	389
	390	DEFINE_EVENT(xhci_log_slot_ctx, xhci_alloc_dev,
	391	TP_PROTO(struct xhci_slot_ctx *ctx),
	392	TP_ARGS(ctx)
393	);
394
395	DEFINE_EVENT(xhci_log_slot_ctx, xhci_free_dev,
396	TP_PROTO(struct xhci_slot_ctx *ctx),
397	TP_ARGS(ctx)
398	);
399
400	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_disable_slot,
401	TP_PROTO(struct xhci_slot_ctx *ctx),
402	TP_ARGS(ctx)
403	);
404
405	DEFINE_EVENT(xhci_log_slot_ctx, xhci_discover_or_reset_device,
406	TP_PROTO(struct xhci_slot_ctx *ctx),
407	TP_ARGS(ctx)
408	);
409
410	DEFINE_EVENT(xhci_log_slot_ctx, xhci_setup_device_slot,
411	TP_PROTO(struct xhci_slot_ctx *ctx),
412	TP_ARGS(ctx)
413	);
414
415	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_addr_dev,
416	TP_PROTO(struct xhci_slot_ctx *ctx),
417	TP_ARGS(ctx)
418	);
419
420	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_reset_dev,
421	TP_PROTO(struct xhci_slot_ctx *ctx),
422	TP_ARGS(ctx)
423	);
424
425	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_set_deq,
426	TP_PROTO(struct xhci_slot_ctx *ctx),
427	TP_ARGS(ctx)
428	);
429
e3a78ff0 MN	430	DEFINE_EVENT(xhci_log_slot_ctx, xhci_configure_endpoint,
	431	TP_PROTO(struct xhci_slot_ctx *ctx),
	432	TP_ARGS(ctx)
	433	);
	434
90d6d573 MN	435	DECLARE_EVENT_CLASS(xhci_log_ctrl_ctx,
	436	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	437	TP_ARGS(ctrl_ctx),
	438	TP_STRUCT__entry(
	439	__field(u32, drop)
	440	__field(u32, add)
	441	),
	442	TP_fast_assign(
	443	__entry->drop = le32_to_cpu(ctrl_ctx->drop_flags);
	444	__entry->add = le32_to_cpu(ctrl_ctx->add_flags);
	445	),
	446	TP_printk("%s", xhci_decode_ctrl_ctx(__entry->drop, __entry->add)
	447	)
	448	);
	449
	450	DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_address_ctrl_ctx,
	451	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	452	TP_ARGS(ctrl_ctx)
	453	);
	454
	455	DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_configure_endpoint_ctrl_ctx,
	456	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	457	TP_ARGS(ctrl_ctx)
	458	);
	459
b2d6edbb LB	460	DECLARE_EVENT_CLASS(xhci_log_ring,
	461	TP_PROTO(struct xhci_ring *ring),
	462	TP_ARGS(ring),
	463	TP_STRUCT__entry(
	464	__field(u32, type)
	465	__field(void *, ring)
	466	__field(dma_addr_t, enq)
	467	__field(dma_addr_t, deq)
	468	__field(dma_addr_t, enq_seg)
	469	__field(dma_addr_t, deq_seg)
	470	__field(unsigned int, num_segs)
	471	__field(unsigned int, stream_id)
	472	__field(unsigned int, cycle_state)
	473	__field(unsigned int, num_trbs_free)
	474	__field(unsigned int, bounce_buf_len)
	475	),
	476	TP_fast_assign(
	477	__entry->ring = ring;
	478	__entry->type = ring->type;
	479	__entry->num_segs = ring->num_segs;
	480	__entry->stream_id = ring->stream_id;
	481	__entry->enq_seg = ring->enq_seg->dma;
	482	__entry->deq_seg = ring->deq_seg->dma;
	483	__entry->cycle_state = ring->cycle_state;
	484	__entry->num_trbs_free = ring->num_trbs_free;
	485	__entry->bounce_buf_len = ring->bounce_buf_len;
	486	__entry->enq = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
	487	__entry->deq = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
	488	),
	489	TP_printk("%s %p: enq %pad(%pad) deq %pad(%pad) segs %d stream %d free_trbs %d bounce %d cycle %d",
	490	xhci_ring_type_string(__entry->type), __entry->ring,
	491	&__entry->enq, &__entry->enq_seg,
	492	&__entry->deq, &__entry->deq_seg,
	493	__entry->num_segs,
	494	__entry->stream_id,
	495	__entry->num_trbs_free,
	496	__entry->bounce_buf_len,
	497	__entry->cycle_state
	498	)
	499	);
	500
	501	DEFINE_EVENT(xhci_log_ring, xhci_ring_alloc,
	502	TP_PROTO(struct xhci_ring *ring),
	503	TP_ARGS(ring)
	504	);
	505
	506	DEFINE_EVENT(xhci_log_ring, xhci_ring_free,
	507	TP_PROTO(struct xhci_ring *ring),
	508	TP_ARGS(ring)
	509	);
	510
	511	DEFINE_EVENT(xhci_log_ring, xhci_ring_expansion,
	512	TP_PROTO(struct xhci_ring *ring),
	513	TP_ARGS(ring)
	514	);
	515
	516	DEFINE_EVENT(xhci_log_ring, xhci_inc_enq,
	517	TP_PROTO(struct xhci_ring *ring),
	518	TP_ARGS(ring)
	519	);
	520
	521	DEFINE_EVENT(xhci_log_ring, xhci_inc_deq,
	522	TP_PROTO(struct xhci_ring *ring),
	523	TP_ARGS(ring)
524	);
8ca1358b MN	525
	526	DECLARE_EVENT_CLASS(xhci_log_portsc,
	527	TP_PROTO(u32 portnum, u32 portsc),
	528	TP_ARGS(portnum, portsc),
	529	TP_STRUCT__entry(
	530	__field(u32, portnum)
	531	__field(u32, portsc)
	532	),
	533	TP_fast_assign(
	534	__entry->portnum = portnum;
	535	__entry->portsc = portsc;
	536	),
	537	TP_printk("port-%d: %s",
	538	__entry->portnum,
	539	xhci_decode_portsc(__entry->portsc)
	540	)
	541	);
	542
	543	DEFINE_EVENT(xhci_log_portsc, xhci_handle_port_status,
	544	TP_PROTO(u32 portnum, u32 portsc),
	545	TP_ARGS(portnum, portsc)
	546	);
	547
28c06e58 MN	548	DEFINE_EVENT(xhci_log_portsc, xhci_get_port_status,
	549	TP_PROTO(u32 portnum, u32 portsc),
	550	TP_ARGS(portnum, portsc)
	551	);
	552
3f8499ac MN	553	DEFINE_EVENT(xhci_log_portsc, xhci_hub_status_data,
	554	TP_PROTO(u32 portnum, u32 portsc),
	555	TP_ARGS(portnum, portsc)
	556	);
	557
dfba2174 LB	558	DECLARE_EVENT_CLASS(xhci_dbc_log_request,
	559	TP_PROTO(struct dbc_request *req),
	560	TP_ARGS(req),
	561	TP_STRUCT__entry(
	562	__field(struct dbc_request *, req)
	563	__field(bool, dir)
	564	__field(unsigned int, actual)
	565	__field(unsigned int, length)
	566	__field(int, status)
	567	),
	568	TP_fast_assign(
	569	__entry->req = req;
	570	__entry->dir = req->direction;
	571	__entry->actual = req->actual;
	572	__entry->length = req->length;
	573	__entry->status = req->status;
	574	),
	575	TP_printk("%s: req %p length %u/%u ==> %d",
	576	__entry->dir ? "bulk-in" : "bulk-out",
	577	__entry->req, __entry->actual,
	578	__entry->length, __entry->status
	579	)
	580	);
	581
	582	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_alloc_request,
	583	TP_PROTO(struct dbc_request *req),
	584	TP_ARGS(req)
	585	);
	586
	587	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_free_request,
	588	TP_PROTO(struct dbc_request *req),
	589	TP_ARGS(req)
	590	);
	591
	592	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_queue_request,
	593	TP_PROTO(struct dbc_request *req),
	594	TP_ARGS(req)
	595	);
	596
	597	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_giveback_request,
	598	TP_PROTO(struct dbc_request *req),
	599	TP_ARGS(req)
	600	);
84a99f6f XR	601	#endif /* __XHCI_TRACE_H */
	602
	603	/* this part must be outside header guard */
	604
	605	#undef TRACE_INCLUDE_PATH
	606	#define TRACE_INCLUDE_PATH .
	607
	608	#undef TRACE_INCLUDE_FILE
	609	#define TRACE_INCLUDE_FILE xhci-trace
	610
	611	#include <trace/define_trace.h>