Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * xHCI host controller driver
0004  *
0005  * Copyright (C) 2013 Xenia Ragiadakou
0006  *
0007  * Author: Xenia Ragiadakou
0008  * Email : burzalodowa@gmail.com
0009  */
0010 
0011 #undef TRACE_SYSTEM
0012 #define TRACE_SYSTEM xhci-hcd
0013 
0014 /*
0015  * The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a
0016  * legitimate C variable. It is not exported to user space.
0017  */
0018 #undef TRACE_SYSTEM_VAR
0019 #define TRACE_SYSTEM_VAR xhci_hcd
0020 
0021 #if !defined(__XHCI_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0022 #define __XHCI_TRACE_H
0023 
0024 #include <linux/tracepoint.h>
0025 #include "xhci.h"
0026 #include "xhci-dbgcap.h"
0027 
0028 DECLARE_EVENT_CLASS(xhci_log_msg,
0029     TP_PROTO(struct va_format *vaf),
0030     TP_ARGS(vaf),
0031     TP_STRUCT__entry(__vstring(msg, vaf->fmt, vaf->va)),
0032     TP_fast_assign(
0033         __assign_vstr(msg, vaf->fmt, vaf->va);
0034     ),
0035     TP_printk("%s", __get_str(msg))
0036 );
0037 
0038 DEFINE_EVENT(xhci_log_msg, xhci_dbg_address,
0039     TP_PROTO(struct va_format *vaf),
0040     TP_ARGS(vaf)
0041 );
0042 
0043 DEFINE_EVENT(xhci_log_msg, xhci_dbg_context_change,
0044     TP_PROTO(struct va_format *vaf),
0045     TP_ARGS(vaf)
0046 );
0047 
0048 DEFINE_EVENT(xhci_log_msg, xhci_dbg_quirks,
0049     TP_PROTO(struct va_format *vaf),
0050     TP_ARGS(vaf)
0051 );
0052 
0053 DEFINE_EVENT(xhci_log_msg, xhci_dbg_reset_ep,
0054     TP_PROTO(struct va_format *vaf),
0055     TP_ARGS(vaf)
0056 );
0057 
0058 DEFINE_EVENT(xhci_log_msg, xhci_dbg_cancel_urb,
0059     TP_PROTO(struct va_format *vaf),
0060     TP_ARGS(vaf)
0061 );
0062 
0063 DEFINE_EVENT(xhci_log_msg, xhci_dbg_init,
0064     TP_PROTO(struct va_format *vaf),
0065     TP_ARGS(vaf)
0066 );
0067 
0068 DEFINE_EVENT(xhci_log_msg, xhci_dbg_ring_expansion,
0069     TP_PROTO(struct va_format *vaf),
0070     TP_ARGS(vaf)
0071 );
0072 
0073 DECLARE_EVENT_CLASS(xhci_log_ctx,
0074     TP_PROTO(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
0075          unsigned int ep_num),
0076     TP_ARGS(xhci, ctx, ep_num),
0077     TP_STRUCT__entry(
0078         __field(int, ctx_64)
0079         __field(unsigned, ctx_type)
0080         __field(dma_addr_t, ctx_dma)
0081         __field(u8 *, ctx_va)
0082         __field(unsigned, ctx_ep_num)
0083         __field(int, slot_id)
0084         __dynamic_array(u32, ctx_data,
0085             ((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 8) *
0086             ((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1))
0087     ),
0088     TP_fast_assign(
0089         struct usb_device *udev;
0090 
0091         udev = to_usb_device(xhci_to_hcd(xhci)->self.controller);
0092         __entry->ctx_64 = HCC_64BYTE_CONTEXT(xhci->hcc_params);
0093         __entry->ctx_type = ctx->type;
0094         __entry->ctx_dma = ctx->dma;
0095         __entry->ctx_va = ctx->bytes;
0096         __entry->slot_id = udev->slot_id;
0097         __entry->ctx_ep_num = ep_num;
0098         memcpy(__get_dynamic_array(ctx_data), ctx->bytes,
0099             ((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 32) *
0100             ((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1));
0101     ),
0102     TP_printk("ctx_64=%d, ctx_type=%u, ctx_dma=@%llx, ctx_va=@%p",
0103             __entry->ctx_64, __entry->ctx_type,
0104             (unsigned long long) __entry->ctx_dma, __entry->ctx_va
0105     )
0106 );
0107 
0108 DEFINE_EVENT(xhci_log_ctx, xhci_address_ctx,
0109     TP_PROTO(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
0110          unsigned int ep_num),
0111     TP_ARGS(xhci, ctx, ep_num)
0112 );
0113 
0114 DECLARE_EVENT_CLASS(xhci_log_trb,
0115     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0116     TP_ARGS(ring, trb),
0117     TP_STRUCT__entry(
0118         __field(u32, type)
0119         __field(u32, field0)
0120         __field(u32, field1)
0121         __field(u32, field2)
0122         __field(u32, field3)
0123         __dynamic_array(char, str, XHCI_MSG_MAX)
0124     ),
0125     TP_fast_assign(
0126         __entry->type = ring->type;
0127         __entry->field0 = le32_to_cpu(trb->field[0]);
0128         __entry->field1 = le32_to_cpu(trb->field[1]);
0129         __entry->field2 = le32_to_cpu(trb->field[2]);
0130         __entry->field3 = le32_to_cpu(trb->field[3]);
0131     ),
0132     TP_printk("%s: %s", xhci_ring_type_string(__entry->type),
0133           xhci_decode_trb(__get_str(str), XHCI_MSG_MAX, __entry->field0, __entry->field1,
0134                     __entry->field2, __entry->field3)
0135     )
0136 );
0137 
0138 DEFINE_EVENT(xhci_log_trb, xhci_handle_event,
0139     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0140     TP_ARGS(ring, trb)
0141 );
0142 
0143 DEFINE_EVENT(xhci_log_trb, xhci_handle_command,
0144     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0145     TP_ARGS(ring, trb)
0146 );
0147 
0148 DEFINE_EVENT(xhci_log_trb, xhci_handle_transfer,
0149     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0150     TP_ARGS(ring, trb)
0151 );
0152 
0153 DEFINE_EVENT(xhci_log_trb, xhci_queue_trb,
0154     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0155     TP_ARGS(ring, trb)
0156 );
0157 
0158 DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_event,
0159     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0160     TP_ARGS(ring, trb)
0161 );
0162 
0163 DEFINE_EVENT(xhci_log_trb, xhci_dbc_handle_transfer,
0164     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0165     TP_ARGS(ring, trb)
0166 );
0167 
0168 DEFINE_EVENT(xhci_log_trb, xhci_dbc_gadget_ep_queue,
0169     TP_PROTO(struct xhci_ring *ring, struct xhci_generic_trb *trb),
0170     TP_ARGS(ring, trb)
0171 );
0172 
0173 DECLARE_EVENT_CLASS(xhci_log_free_virt_dev,
0174     TP_PROTO(struct xhci_virt_device *vdev),
0175     TP_ARGS(vdev),
0176     TP_STRUCT__entry(
0177         __field(void *, vdev)
0178         __field(unsigned long long, out_ctx)
0179         __field(unsigned long long, in_ctx)
0180         __field(u8, fake_port)
0181         __field(u8, real_port)
0182         __field(u16, current_mel)
0183 
0184     ),
0185     TP_fast_assign(
0186         __entry->vdev = vdev;
0187         __entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
0188         __entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
0189         __entry->fake_port = (u8) vdev->fake_port;
0190         __entry->real_port = (u8) vdev->real_port;
0191         __entry->current_mel = (u16) vdev->current_mel;
0192         ),
0193     TP_printk("vdev %p ctx %llx | %llx fake_port %d real_port %d current_mel %d",
0194         __entry->vdev, __entry->in_ctx, __entry->out_ctx,
0195         __entry->fake_port, __entry->real_port, __entry->current_mel
0196     )
0197 );
0198 
0199 DEFINE_EVENT(xhci_log_free_virt_dev, xhci_free_virt_device,
0200     TP_PROTO(struct xhci_virt_device *vdev),
0201     TP_ARGS(vdev)
0202 );
0203 
0204 DECLARE_EVENT_CLASS(xhci_log_virt_dev,
0205     TP_PROTO(struct xhci_virt_device *vdev),
0206     TP_ARGS(vdev),
0207     TP_STRUCT__entry(
0208         __field(void *, vdev)
0209         __field(unsigned long long, out_ctx)
0210         __field(unsigned long long, in_ctx)
0211         __field(int, devnum)
0212         __field(int, state)
0213         __field(int, speed)
0214         __field(u8, portnum)
0215         __field(u8, level)
0216         __field(int, slot_id)
0217     ),
0218     TP_fast_assign(
0219         __entry->vdev = vdev;
0220         __entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
0221         __entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
0222         __entry->devnum = vdev->udev->devnum;
0223         __entry->state = vdev->udev->state;
0224         __entry->speed = vdev->udev->speed;
0225         __entry->portnum = vdev->udev->portnum;
0226         __entry->level = vdev->udev->level;
0227         __entry->slot_id = vdev->udev->slot_id;
0228     ),
0229     TP_printk("vdev %p ctx %llx | %llx num %d state %d speed %d port %d level %d slot %d",
0230         __entry->vdev, __entry->in_ctx, __entry->out_ctx,
0231         __entry->devnum, __entry->state, __entry->speed,
0232         __entry->portnum, __entry->level, __entry->slot_id
0233     )
0234 );
0235 
0236 DEFINE_EVENT(xhci_log_virt_dev, xhci_alloc_virt_device,
0237     TP_PROTO(struct xhci_virt_device *vdev),
0238     TP_ARGS(vdev)
0239 );
0240 
0241 DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_device,
0242     TP_PROTO(struct xhci_virt_device *vdev),
0243     TP_ARGS(vdev)
0244 );
0245 
0246 DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_addressable_virt_device,
0247     TP_PROTO(struct xhci_virt_device *vdev),
0248     TP_ARGS(vdev)
0249 );
0250 
0251 DEFINE_EVENT(xhci_log_virt_dev, xhci_stop_device,
0252     TP_PROTO(struct xhci_virt_device *vdev),
0253     TP_ARGS(vdev)
0254 );
0255 
0256 DECLARE_EVENT_CLASS(xhci_log_urb,
0257     TP_PROTO(struct urb *urb),
0258     TP_ARGS(urb),
0259     TP_STRUCT__entry(
0260         __field(void *, urb)
0261         __field(unsigned int, pipe)
0262         __field(unsigned int, stream)
0263         __field(int, status)
0264         __field(unsigned int, flags)
0265         __field(int, num_mapped_sgs)
0266         __field(int, num_sgs)
0267         __field(int, length)
0268         __field(int, actual)
0269         __field(int, epnum)
0270         __field(int, dir_in)
0271         __field(int, type)
0272         __field(int, slot_id)
0273     ),
0274     TP_fast_assign(
0275         __entry->urb = urb;
0276         __entry->pipe = urb->pipe;
0277         __entry->stream = urb->stream_id;
0278         __entry->status = urb->status;
0279         __entry->flags = urb->transfer_flags;
0280         __entry->num_mapped_sgs = urb->num_mapped_sgs;
0281         __entry->num_sgs = urb->num_sgs;
0282         __entry->length = urb->transfer_buffer_length;
0283         __entry->actual = urb->actual_length;
0284         __entry->epnum = usb_endpoint_num(&urb->ep->desc);
0285         __entry->dir_in = usb_endpoint_dir_in(&urb->ep->desc);
0286         __entry->type = usb_endpoint_type(&urb->ep->desc);
0287         __entry->slot_id = urb->dev->slot_id;
0288     ),
0289     TP_printk("ep%d%s-%s: urb %p pipe %u slot %d length %d/%d sgs %d/%d stream %d flags %08x",
0290             __entry->epnum, __entry->dir_in ? "in" : "out",
0291             __print_symbolic(__entry->type,
0292                    { USB_ENDPOINT_XFER_INT, "intr" },
0293                    { USB_ENDPOINT_XFER_CONTROL, "control" },
0294                    { USB_ENDPOINT_XFER_BULK,    "bulk" },
0295                    { USB_ENDPOINT_XFER_ISOC,    "isoc" }),
0296             __entry->urb, __entry->pipe, __entry->slot_id,
0297             __entry->actual, __entry->length, __entry->num_mapped_sgs,
0298             __entry->num_sgs, __entry->stream, __entry->flags
0299         )
0300 );
0301 
0302 DEFINE_EVENT(xhci_log_urb, xhci_urb_enqueue,
0303     TP_PROTO(struct urb *urb),
0304     TP_ARGS(urb)
0305 );
0306 
0307 DEFINE_EVENT(xhci_log_urb, xhci_urb_giveback,
0308     TP_PROTO(struct urb *urb),
0309     TP_ARGS(urb)
0310 );
0311 
0312 DEFINE_EVENT(xhci_log_urb, xhci_urb_dequeue,
0313     TP_PROTO(struct urb *urb),
0314     TP_ARGS(urb)
0315 );
0316 
0317 DECLARE_EVENT_CLASS(xhci_log_ep_ctx,
0318     TP_PROTO(struct xhci_ep_ctx *ctx),
0319     TP_ARGS(ctx),
0320     TP_STRUCT__entry(
0321         __field(u32, info)
0322         __field(u32, info2)
0323         __field(u64, deq)
0324         __field(u32, tx_info)
0325         __dynamic_array(char, str, XHCI_MSG_MAX)
0326     ),
0327     TP_fast_assign(
0328         __entry->info = le32_to_cpu(ctx->ep_info);
0329         __entry->info2 = le32_to_cpu(ctx->ep_info2);
0330         __entry->deq = le64_to_cpu(ctx->deq);
0331         __entry->tx_info = le32_to_cpu(ctx->tx_info);
0332     ),
0333     TP_printk("%s", xhci_decode_ep_context(__get_str(str),
0334         __entry->info, __entry->info2, __entry->deq, __entry->tx_info)
0335     )
0336 );
0337 
0338 DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_stop_ep,
0339     TP_PROTO(struct xhci_ep_ctx *ctx),
0340     TP_ARGS(ctx)
0341 );
0342 
0343 DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_set_deq_ep,
0344     TP_PROTO(struct xhci_ep_ctx *ctx),
0345     TP_ARGS(ctx)
0346 );
0347 
0348 DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_reset_ep,
0349     TP_PROTO(struct xhci_ep_ctx *ctx),
0350     TP_ARGS(ctx)
0351 );
0352 
0353 DEFINE_EVENT(xhci_log_ep_ctx, xhci_handle_cmd_config_ep,
0354     TP_PROTO(struct xhci_ep_ctx *ctx),
0355     TP_ARGS(ctx)
0356 );
0357 
0358 DEFINE_EVENT(xhci_log_ep_ctx, xhci_add_endpoint,
0359     TP_PROTO(struct xhci_ep_ctx *ctx),
0360     TP_ARGS(ctx)
0361 );
0362 
0363 DECLARE_EVENT_CLASS(xhci_log_slot_ctx,
0364     TP_PROTO(struct xhci_slot_ctx *ctx),
0365     TP_ARGS(ctx),
0366     TP_STRUCT__entry(
0367         __field(u32, info)
0368         __field(u32, info2)
0369         __field(u32, tt_info)
0370         __field(u32, state)
0371         __dynamic_array(char, str, XHCI_MSG_MAX)
0372     ),
0373     TP_fast_assign(
0374         __entry->info = le32_to_cpu(ctx->dev_info);
0375         __entry->info2 = le32_to_cpu(ctx->dev_info2);
0376         __entry->tt_info = le64_to_cpu(ctx->tt_info);
0377         __entry->state = le32_to_cpu(ctx->dev_state);
0378     ),
0379     TP_printk("%s", xhci_decode_slot_context(__get_str(str),
0380             __entry->info, __entry->info2,
0381             __entry->tt_info, __entry->state)
0382     )
0383 );
0384 
0385 DEFINE_EVENT(xhci_log_slot_ctx, xhci_alloc_dev,
0386     TP_PROTO(struct xhci_slot_ctx *ctx),
0387     TP_ARGS(ctx)
0388 );
0389 
0390 DEFINE_EVENT(xhci_log_slot_ctx, xhci_free_dev,
0391     TP_PROTO(struct xhci_slot_ctx *ctx),
0392     TP_ARGS(ctx)
0393 );
0394 
0395 DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_disable_slot,
0396     TP_PROTO(struct xhci_slot_ctx *ctx),
0397     TP_ARGS(ctx)
0398 );
0399 
0400 DEFINE_EVENT(xhci_log_slot_ctx, xhci_discover_or_reset_device,
0401     TP_PROTO(struct xhci_slot_ctx *ctx),
0402     TP_ARGS(ctx)
0403 );
0404 
0405 DEFINE_EVENT(xhci_log_slot_ctx, xhci_setup_device_slot,
0406     TP_PROTO(struct xhci_slot_ctx *ctx),
0407     TP_ARGS(ctx)
0408 );
0409 
0410 DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_addr_dev,
0411     TP_PROTO(struct xhci_slot_ctx *ctx),
0412     TP_ARGS(ctx)
0413 );
0414 
0415 DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_reset_dev,
0416     TP_PROTO(struct xhci_slot_ctx *ctx),
0417     TP_ARGS(ctx)
0418 );
0419 
0420 DEFINE_EVENT(xhci_log_slot_ctx, xhci_handle_cmd_set_deq,
0421     TP_PROTO(struct xhci_slot_ctx *ctx),
0422     TP_ARGS(ctx)
0423 );
0424 
0425 DEFINE_EVENT(xhci_log_slot_ctx, xhci_configure_endpoint,
0426     TP_PROTO(struct xhci_slot_ctx *ctx),
0427     TP_ARGS(ctx)
0428 );
0429 
0430 DECLARE_EVENT_CLASS(xhci_log_ctrl_ctx,
0431     TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
0432     TP_ARGS(ctrl_ctx),
0433     TP_STRUCT__entry(
0434         __field(u32, drop)
0435         __field(u32, add)
0436         __dynamic_array(char, str, XHCI_MSG_MAX)
0437     ),
0438     TP_fast_assign(
0439         __entry->drop = le32_to_cpu(ctrl_ctx->drop_flags);
0440         __entry->add = le32_to_cpu(ctrl_ctx->add_flags);
0441     ),
0442     TP_printk("%s", xhci_decode_ctrl_ctx(__get_str(str), __entry->drop, __entry->add)
0443     )
0444 );
0445 
0446 DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_address_ctrl_ctx,
0447     TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
0448     TP_ARGS(ctrl_ctx)
0449 );
0450 
0451 DEFINE_EVENT(xhci_log_ctrl_ctx, xhci_configure_endpoint_ctrl_ctx,
0452     TP_PROTO(struct xhci_input_control_ctx *ctrl_ctx),
0453     TP_ARGS(ctrl_ctx)
0454 );
0455 
0456 DECLARE_EVENT_CLASS(xhci_log_ring,
0457     TP_PROTO(struct xhci_ring *ring),
0458     TP_ARGS(ring),
0459     TP_STRUCT__entry(
0460         __field(u32, type)
0461         __field(void *, ring)
0462         __field(dma_addr_t, enq)
0463         __field(dma_addr_t, deq)
0464         __field(dma_addr_t, enq_seg)
0465         __field(dma_addr_t, deq_seg)
0466         __field(unsigned int, num_segs)
0467         __field(unsigned int, stream_id)
0468         __field(unsigned int, cycle_state)
0469         __field(unsigned int, num_trbs_free)
0470         __field(unsigned int, bounce_buf_len)
0471     ),
0472     TP_fast_assign(
0473         __entry->ring = ring;
0474         __entry->type = ring->type;
0475         __entry->num_segs = ring->num_segs;
0476         __entry->stream_id = ring->stream_id;
0477         __entry->enq_seg = ring->enq_seg->dma;
0478         __entry->deq_seg = ring->deq_seg->dma;
0479         __entry->cycle_state = ring->cycle_state;
0480         __entry->num_trbs_free = ring->num_trbs_free;
0481         __entry->bounce_buf_len = ring->bounce_buf_len;
0482         __entry->enq = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
0483         __entry->deq = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
0484     ),
0485     TP_printk("%s %p: enq %pad(%pad) deq %pad(%pad) segs %d stream %d free_trbs %d bounce %d cycle %d",
0486             xhci_ring_type_string(__entry->type), __entry->ring,
0487             &__entry->enq, &__entry->enq_seg,
0488             &__entry->deq, &__entry->deq_seg,
0489             __entry->num_segs,
0490             __entry->stream_id,
0491             __entry->num_trbs_free,
0492             __entry->bounce_buf_len,
0493             __entry->cycle_state
0494         )
0495 );
0496 
0497 DEFINE_EVENT(xhci_log_ring, xhci_ring_alloc,
0498     TP_PROTO(struct xhci_ring *ring),
0499     TP_ARGS(ring)
0500 );
0501 
0502 DEFINE_EVENT(xhci_log_ring, xhci_ring_free,
0503     TP_PROTO(struct xhci_ring *ring),
0504     TP_ARGS(ring)
0505 );
0506 
0507 DEFINE_EVENT(xhci_log_ring, xhci_ring_expansion,
0508     TP_PROTO(struct xhci_ring *ring),
0509     TP_ARGS(ring)
0510 );
0511 
0512 DEFINE_EVENT(xhci_log_ring, xhci_inc_enq,
0513     TP_PROTO(struct xhci_ring *ring),
0514     TP_ARGS(ring)
0515 );
0516 
0517 DEFINE_EVENT(xhci_log_ring, xhci_inc_deq,
0518     TP_PROTO(struct xhci_ring *ring),
0519     TP_ARGS(ring)
0520 );
0521 
0522 DECLARE_EVENT_CLASS(xhci_log_portsc,
0523             TP_PROTO(u32 portnum, u32 portsc),
0524             TP_ARGS(portnum, portsc),
0525             TP_STRUCT__entry(
0526                      __field(u32, portnum)
0527                      __field(u32, portsc)
0528                      __dynamic_array(char, str, XHCI_MSG_MAX)
0529                      ),
0530             TP_fast_assign(
0531                    __entry->portnum = portnum;
0532                    __entry->portsc = portsc;
0533                    ),
0534             TP_printk("port-%d: %s",
0535                   __entry->portnum,
0536                   xhci_decode_portsc(__get_str(str), __entry->portsc)
0537                   )
0538 );
0539 
0540 DEFINE_EVENT(xhci_log_portsc, xhci_handle_port_status,
0541          TP_PROTO(u32 portnum, u32 portsc),
0542          TP_ARGS(portnum, portsc)
0543 );
0544 
0545 DEFINE_EVENT(xhci_log_portsc, xhci_get_port_status,
0546          TP_PROTO(u32 portnum, u32 portsc),
0547          TP_ARGS(portnum, portsc)
0548 );
0549 
0550 DEFINE_EVENT(xhci_log_portsc, xhci_hub_status_data,
0551          TP_PROTO(u32 portnum, u32 portsc),
0552          TP_ARGS(portnum, portsc)
0553 );
0554 
0555 DECLARE_EVENT_CLASS(xhci_log_doorbell,
0556     TP_PROTO(u32 slot, u32 doorbell),
0557     TP_ARGS(slot, doorbell),
0558     TP_STRUCT__entry(
0559         __field(u32, slot)
0560         __field(u32, doorbell)
0561         __dynamic_array(char, str, XHCI_MSG_MAX)
0562     ),
0563     TP_fast_assign(
0564         __entry->slot = slot;
0565         __entry->doorbell = doorbell;
0566     ),
0567     TP_printk("Ring doorbell for %s",
0568           xhci_decode_doorbell(__get_str(str), __entry->slot, __entry->doorbell)
0569     )
0570 );
0571 
0572 DEFINE_EVENT(xhci_log_doorbell, xhci_ring_ep_doorbell,
0573          TP_PROTO(u32 slot, u32 doorbell),
0574          TP_ARGS(slot, doorbell)
0575 );
0576 
0577 DEFINE_EVENT(xhci_log_doorbell, xhci_ring_host_doorbell,
0578          TP_PROTO(u32 slot, u32 doorbell),
0579          TP_ARGS(slot, doorbell)
0580 );
0581 
0582 DECLARE_EVENT_CLASS(xhci_dbc_log_request,
0583     TP_PROTO(struct dbc_request *req),
0584     TP_ARGS(req),
0585     TP_STRUCT__entry(
0586         __field(struct dbc_request *, req)
0587         __field(bool, dir)
0588         __field(unsigned int, actual)
0589         __field(unsigned int, length)
0590         __field(int, status)
0591     ),
0592     TP_fast_assign(
0593         __entry->req = req;
0594         __entry->dir = req->direction;
0595         __entry->actual = req->actual;
0596         __entry->length = req->length;
0597         __entry->status = req->status;
0598     ),
0599     TP_printk("%s: req %p length %u/%u ==> %d",
0600         __entry->dir ? "bulk-in" : "bulk-out",
0601         __entry->req, __entry->actual,
0602         __entry->length, __entry->status
0603     )
0604 );
0605 
0606 DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_alloc_request,
0607     TP_PROTO(struct dbc_request *req),
0608     TP_ARGS(req)
0609 );
0610 
0611 DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_free_request,
0612     TP_PROTO(struct dbc_request *req),
0613     TP_ARGS(req)
0614 );
0615 
0616 DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_queue_request,
0617     TP_PROTO(struct dbc_request *req),
0618     TP_ARGS(req)
0619 );
0620 
0621 DEFINE_EVENT(xhci_dbc_log_request, xhci_dbc_giveback_request,
0622     TP_PROTO(struct dbc_request *req),
0623     TP_ARGS(req)
0624 );
0625 #endif /* __XHCI_TRACE_H */
0626 
0627 /* this part must be outside header guard */
0628 
0629 #undef TRACE_INCLUDE_PATH
0630 #define TRACE_INCLUDE_PATH .
0631 
0632 #undef TRACE_INCLUDE_FILE
0633 #define TRACE_INCLUDE_FILE xhci-trace
0634 
0635 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!