[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",
			__print_symbolic(__entry->type,
				   { USB_ENDPOINT_XFER_INT,	"intr" },
				   { USB_ENDPOINT_XFER_CONTROL,	"control" },
				   { USB_ENDPOINT_XFER_BULK,	"bulk" },
				   { USB_ENDPOINT_XFER_ISOC,	"isoc" }),
			__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)
);

DEFINE_EVENT(xhci_log_ep_ctx, xhci_add_endpoint,
	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_log_doorbell,
	TP_PROTO(u32 slot, u32 doorbell),
	TP_ARGS(slot, doorbell),
	TP_STRUCT__entry(
		__field(u32, slot)
		__field(u32, doorbell)
	),
	TP_fast_assign(
		__entry->slot = slot;
		__entry->doorbell = doorbell;
	),
	TP_printk("Ring doorbell for %s",
		xhci_decode_doorbell(__entry->slot, __entry->doorbell)
	)
);

DEFINE_EVENT(xhci_log_doorbell, xhci_ring_ep_doorbell,
	     TP_PROTO(u32 slot, u32 doorbell),
	     TP_ARGS(slot, doorbell)
);

DEFINE_EVENT(xhci_log_doorbell, xhci_ring_host_doorbell,
	     TP_PROTO(u32 slot, u32 doorbell),
	     TP_ARGS(slot, doorbell)
);

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
3e45ed3c	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	291	__entry->epnum, __entry->dir_in ? "in" : "out",
045706bf SRV	292	__print_symbolic(__entry->type,
	293	{ USB_ENDPOINT_XFER_INT, "intr" },
	294	{ USB_ENDPOINT_XFER_CONTROL, "control" },
	295	{ USB_ENDPOINT_XFER_BULK, "bulk" },
	296	{ USB_ENDPOINT_XFER_ISOC, "isoc" }),
	297	__entry->urb, __entry->pipe, __entry->slot_id,
eaa9eb71	298	__entry->actual, __entry->length, __entry->num_mapped_sgs,
5abdc2e6 FB	299	__entry->num_sgs, __entry->stream, __entry->flags
	300	)
	301	);
	302
	303	DEFINE_EVENT(xhci_log_urb, xhci_urb_enqueue,
	304	TP_PROTO(struct urb *urb),
	305	TP_ARGS(urb)
	306	);
	307
	308	DEFINE_EVENT(xhci_log_urb, xhci_urb_giveback,
	309	TP_PROTO(struct urb *urb),
	310	TP_ARGS(urb)
	311	);
	312
	313	DEFINE_EVENT(xhci_log_urb, xhci_urb_dequeue,
	314	TP_PROTO(struct urb *urb),
	315	TP_ARGS(urb)
	316	);
	317
19a7d0d6 FB	318	DECLARE_EVENT_CLASS(xhci_log_ep_ctx,
	319	TP_PROTO(struct xhci_ep_ctx *ctx),
	320	TP_ARGS(ctx),
	321	TP_STRUCT__entry(
	322	__field(u32, info)
	323	__field(u32, info2)
	324	__field(u64, deq)
	325	__field(u32, tx_info)
	326	),
	327	TP_fast_assign(
	328	__entry->info = le32_to_cpu(ctx->ep_info);
	329	__entry->info2 = le32_to_cpu(ctx->ep_info2);
	330	__entry->deq = le64_to_cpu(ctx->deq);
	331	__entry->tx_info = le32_to_cpu(ctx->tx_info);
	332	),
	333	TP_printk("%s", xhci_decode_ep_context(__entry->info,
	334	__entry->info2, __entry->deq, __entry->tx_info)
	335	)
	336	);
	337
	338	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_stop_ep,
	339	TP_PROTO(struct xhci_ep_ctx *ctx),
	340	TP_ARGS(ctx)
	341	);
	342
	343	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_set_deq_ep,
	344	TP_PROTO(struct xhci_ep_ctx *ctx),
	345	TP_ARGS(ctx)
	346	);
	347
	348	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_reset_ep,
	349	TP_PROTO(struct xhci_ep_ctx *ctx),
	350	TP_ARGS(ctx)
	351	);
	352
	353	DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_config_ep,
	354	TP_PROTO(struct xhci_ep_ctx *ctx),
5afa0a5e MN	355	TP_ARGS(ctx)
	356	);
	357
	358	DEFINE_EVENT(xhci_log_ep_ctx, xhci_add_endpoint,
	359	TP_PROTO(struct xhci_ep_ctx *ctx),
19a7d0d6 FB	360	TP_ARGS(ctx)
	361	);
	362
	363	DECLARE_EVENT_CLASS(xhci_log_slot_ctx,
	364	TP_PROTO(struct xhci_slot_ctx *ctx),
	365	TP_ARGS(ctx),
	366	TP_STRUCT__entry(
	367	__field(u32, info)
	368	__field(u32, info2)
	369	__field(u32, tt_info)
	370	__field(u32, state)
	371	),
	372	TP_fast_assign(
	373	__entry->info = le32_to_cpu(ctx->dev_info);
	374	__entry->info2 = le32_to_cpu(ctx->dev_info2);
	375	__entry->tt_info = le64_to_cpu(ctx->tt_info);
	376	__entry->state = le32_to_cpu(ctx->dev_state);
	377	),
	378	TP_printk("%s", xhci_decode_slot_context(__entry->info,
	379	__entry->info2, __entry->tt_info,
	380	__entry->state)
	381	)
	382	);
	383
	384	DEFINE_EVENT(xhci_log_slot_ctx, xhci_alloc_dev,
	385	TP_PROTO(struct xhci_slot_ctx *ctx),
	386	TP_ARGS(ctx)
	387	);
	388
	389	DEFINE_EVENT(xhci_log_slot_ctx, xhci_free_dev,
	390	TP_PROTO(struct xhci_slot_ctx *ctx),
	391	TP_ARGS(ctx)
	392	);
	393
	394	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_disable_slot,
	395	TP_PROTO(struct xhci_slot_ctx *ctx),
	396	TP_ARGS(ctx)
	397	);
	398
	399	DEFINE_EVENT(xhci_log_slot_ctx, xhci_discover_or_reset_device,
	400	TP_PROTO(struct xhci_slot_ctx *ctx),
	401	TP_ARGS(ctx)
	402	);
	403
	404	DEFINE_EVENT(xhci_log_slot_ctx, xhci_setup_device_slot,
	405	TP_PROTO(struct xhci_slot_ctx *ctx),
	406	TP_ARGS(ctx)
	407	);
	408
	409	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_addr_dev,
	410	TP_PROTO(struct xhci_slot_ctx *ctx),
	411	TP_ARGS(ctx)
	412	);
	413
	414	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_reset_dev,
	415	TP_PROTO(struct xhci_slot_ctx *ctx),
	416	TP_ARGS(ctx)
	417	);
	418
	419	DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_set_deq,
	420	TP_PROTO(struct xhci_slot_ctx *ctx),
	421	TP_ARGS(ctx)
	422	);
	423
e3a78ff0 MN	424	DEFINE_EVENT(xhci_log_slot_ctx, xhci_configure_endpoint,
	425	TP_PROTO(struct xhci_slot_ctx *ctx),
	426	TP_ARGS(ctx)
	427	);
	428
90d6d573 MN	429	DECLARE_EVENT_CLASS(xhci_log_ctrl_ctx,
	430	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	431	TP_ARGS(ctrl_ctx),
	432	TP_STRUCT__entry(
	433	__field(u32, drop)
	434	__field(u32, add)
	435	),
	436	TP_fast_assign(
	437	__entry->drop = le32_to_cpu(ctrl_ctx->drop_flags);
	438	__entry->add = le32_to_cpu(ctrl_ctx->add_flags);
	439	),
	440	TP_printk("%s", xhci_decode_ctrl_ctx(__entry->drop, __entry->add)
	441	)
	442	);
	443
	444	DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_address_ctrl_ctx,
	445	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	446	TP_ARGS(ctrl_ctx)
	447	);
	448
	449	DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_configure_endpoint_ctrl_ctx,
	450	TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
	451	TP_ARGS(ctrl_ctx)
	452	);
	453
b2d6edbb LB	454	DECLARE_EVENT_CLASS(xhci_log_ring,
	455	TP_PROTO(struct xhci_ring *ring),
	456	TP_ARGS(ring),
	457	TP_STRUCT__entry(
	458	__field(u32, type)
	459	__field(void *, ring)
	460	__field(dma_addr_t, enq)
	461	__field(dma_addr_t, deq)
	462	__field(dma_addr_t, enq_seg)
	463	__field(dma_addr_t, deq_seg)
	464	__field(unsigned int, num_segs)
	465	__field(unsigned int, stream_id)
	466	__field(unsigned int, cycle_state)
	467	__field(unsigned int, num_trbs_free)
	468	__field(unsigned int, bounce_buf_len)
	469	),
	470	TP_fast_assign(
	471	__entry->ring = ring;
	472	__entry->type = ring->type;
	473	__entry->num_segs = ring->num_segs;
	474	__entry->stream_id = ring->stream_id;
	475	__entry->enq_seg = ring->enq_seg->dma;
	476	__entry->deq_seg = ring->deq_seg->dma;
	477	__entry->cycle_state = ring->cycle_state;
	478	__entry->num_trbs_free = ring->num_trbs_free;
	479	__entry->bounce_buf_len = ring->bounce_buf_len;
	480	__entry->enq = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
	481	__entry->deq = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
	482	),
	483	TP_printk("%s %p: enq %pad(%pad) deq %pad(%pad) segs %d stream %d free_trbs %d bounce %d cycle %d",
	484	xhci_ring_type_string(__entry->type), __entry->ring,
	485	&__entry->enq, &__entry->enq_seg,
	486	&__entry->deq, &__entry->deq_seg,
	487	__entry->num_segs,
	488	__entry->stream_id,
	489	__entry->num_trbs_free,
	490	__entry->bounce_buf_len,
	491	__entry->cycle_state
	492	)
	493	);
	494
	495	DEFINE_EVENT(xhci_log_ring, xhci_ring_alloc,
	496	TP_PROTO(struct xhci_ring *ring),
	497	TP_ARGS(ring)
	498	);
	499
	500	DEFINE_EVENT(xhci_log_ring, xhci_ring_free,
	501	TP_PROTO(struct xhci_ring *ring),
	502	TP_ARGS(ring)
	503	);
	504
	505	DEFINE_EVENT(xhci_log_ring, xhci_ring_expansion,
	506	TP_PROTO(struct xhci_ring *ring),
	507	TP_ARGS(ring)
	508	);
	509
	510	DEFINE_EVENT(xhci_log_ring, xhci_inc_enq,
	511	TP_PROTO(struct xhci_ring *ring),
	512	TP_ARGS(ring)
	513	);
	514
	515	DEFINE_EVENT(xhci_log_ring, xhci_inc_deq,
	516	TP_PROTO(struct xhci_ring *ring),
	517	TP_ARGS(ring)
518	);
8ca1358b MN	519
	520	DECLARE_EVENT_CLASS(xhci_log_portsc,
	521	TP_PROTO(u32 portnum, u32 portsc),
	522	TP_ARGS(portnum, portsc),
	523	TP_STRUCT__entry(
	524	__field(u32, portnum)
	525	__field(u32, portsc)
	526	),
	527	TP_fast_assign(
	528	__entry->portnum = portnum;
	529	__entry->portsc = portsc;
	530	),
	531	TP_printk("port-%d: %s",
	532	__entry->portnum,
	533	xhci_decode_portsc(__entry->portsc)
	534	)
	535	);
	536
	537	DEFINE_EVENT(xhci_log_portsc, xhci_handle_port_status,
	538	TP_PROTO(u32 portnum, u32 portsc),
	539	TP_ARGS(portnum, portsc)
	540	);
	541
28c06e58 MN	542	DEFINE_EVENT(xhci_log_portsc, xhci_get_port_status,
	543	TP_PROTO(u32 portnum, u32 portsc),
	544	TP_ARGS(portnum, portsc)
	545	);
	546
3f8499ac MN	547	DEFINE_EVENT(xhci_log_portsc, xhci_hub_status_data,
	548	TP_PROTO(u32 portnum, u32 portsc),
	549	TP_ARGS(portnum, portsc)
	550	);
	551
58b9d71a MN	552	DECLARE_EVENT_CLASS(xhci_log_doorbell,
	553	TP_PROTO(u32 slot, u32 doorbell),
	554	TP_ARGS(slot, doorbell),
	555	TP_STRUCT__entry(
	556	__field(u32, slot)
	557	__field(u32, doorbell)
	558	),
	559	TP_fast_assign(
	560	__entry->slot = slot;
	561	__entry->doorbell = doorbell;
	562	),
	563	TP_printk("Ring doorbell for %s",
	564	xhci_decode_doorbell(__entry->slot, __entry->doorbell)
	565	)
	566	);
	567
	568	DEFINE_EVENT(xhci_log_doorbell, xhci_ring_ep_doorbell,
	569	TP_PROTO(u32 slot, u32 doorbell),
	570	TP_ARGS(slot, doorbell)
	571	);
	572
	573	DEFINE_EVENT(xhci_log_doorbell, xhci_ring_host_doorbell,
	574	TP_PROTO(u32 slot, u32 doorbell),
	575	TP_ARGS(slot, doorbell)
	576	);
	577
dfba2174 LB	578	DECLARE_EVENT_CLASS(xhci_dbc_log_request,
	579	TP_PROTO(struct dbc_request *req),
	580	TP_ARGS(req),
	581	TP_STRUCT__entry(
	582	__field(struct dbc_request *, req)
	583	__field(bool, dir)
	584	__field(unsigned int, actual)
	585	__field(unsigned int, length)
	586	__field(int, status)
	587	),
	588	TP_fast_assign(
	589	__entry->req = req;
	590	__entry->dir = req->direction;
	591	__entry->actual = req->actual;
	592	__entry->length = req->length;
	593	__entry->status = req->status;
	594	),
	595	TP_printk("%s: req %p length %u/%u ==> %d",
	596	__entry->dir ? "bulk-in" : "bulk-out",
	597	__entry->req, __entry->actual,
	598	__entry->length, __entry->status
	599	)
	600	);
	601
	602	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_alloc_request,
	603	TP_PROTO(struct dbc_request *req),
	604	TP_ARGS(req)
	605	);
	606
	607	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_free_request,
	608	TP_PROTO(struct dbc_request *req),
	609	TP_ARGS(req)
	610	);
	611
	612	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_queue_request,
	613	TP_PROTO(struct dbc_request *req),
	614	TP_ARGS(req)
	615	);
	616
	617	DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_giveback_request,
	618	TP_PROTO(struct dbc_request *req),
	619	TP_ARGS(req)
	620	);
84a99f6f XR	621	#endif /* __XHCI_TRACE_H */
	622
	623	/* this part must be outside header guard */
	624
	625	#undef TRACE_INCLUDE_PATH
	626	#define TRACE_INCLUDE_PATH .
	627
	628	#undef TRACE_INCLUDE_FILE
	629	#define TRACE_INCLUDE_FILE xhci-trace
	630
	631	#include <trace/define_trace.h>