Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * USBSS device controller driver.
0004  * Trace support header file.
0005  *
0006  * Copyright (C) 2018-2019 Cadence.
0007  *
0008  * Author: Pawel Laszczak <pawell@cadence.com>
0009  */
0010 
0011 #undef TRACE_SYSTEM
0012 #define TRACE_SYSTEM cdns3
0013 
0014 #if !defined(__LINUX_CDNS3_TRACE) || defined(TRACE_HEADER_MULTI_READ)
0015 #define __LINUX_CDNS3_TRACE
0016 
0017 #include <linux/types.h>
0018 #include <linux/tracepoint.h>
0019 #include <asm/byteorder.h>
0020 #include <linux/usb/ch9.h>
0021 #include "core.h"
0022 #include "cdns3-gadget.h"
0023 #include "cdns3-debug.h"
0024 
0025 #define CDNS3_MSG_MAX   500
0026 
0027 TRACE_EVENT(cdns3_halt,
0028     TP_PROTO(struct cdns3_endpoint *ep_priv, u8 halt, u8 flush),
0029     TP_ARGS(ep_priv, halt, flush),
0030     TP_STRUCT__entry(
0031         __string(name, ep_priv->name)
0032         __field(u8, halt)
0033         __field(u8, flush)
0034     ),
0035     TP_fast_assign(
0036         __assign_str(name, ep_priv->name);
0037         __entry->halt = halt;
0038         __entry->flush = flush;
0039     ),
0040     TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
0041           __get_str(name), __entry->halt ? "set" : "cleared")
0042 );
0043 
0044 TRACE_EVENT(cdns3_wa1,
0045     TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
0046     TP_ARGS(ep_priv, msg),
0047     TP_STRUCT__entry(
0048         __string(ep_name, ep_priv->name)
0049         __string(msg, msg)
0050     ),
0051     TP_fast_assign(
0052         __assign_str(ep_name, ep_priv->name);
0053         __assign_str(msg, msg);
0054     ),
0055     TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
0056 );
0057 
0058 TRACE_EVENT(cdns3_wa2,
0059     TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
0060     TP_ARGS(ep_priv, msg),
0061     TP_STRUCT__entry(
0062         __string(ep_name, ep_priv->name)
0063         __string(msg, msg)
0064     ),
0065     TP_fast_assign(
0066         __assign_str(ep_name, ep_priv->name);
0067         __assign_str(msg, msg);
0068     ),
0069     TP_printk("WA2: %s %s", __get_str(ep_name), __get_str(msg))
0070 );
0071 
0072 DECLARE_EVENT_CLASS(cdns3_log_doorbell,
0073     TP_PROTO(const char *ep_name, u32 ep_trbaddr),
0074     TP_ARGS(ep_name, ep_trbaddr),
0075     TP_STRUCT__entry(
0076         __string(name, ep_name)
0077         __field(u32, ep_trbaddr)
0078     ),
0079     TP_fast_assign(
0080         __assign_str(name, ep_name);
0081         __entry->ep_trbaddr = ep_trbaddr;
0082     ),
0083     TP_printk("%s, ep_trbaddr %08x", __get_str(name),
0084           __entry->ep_trbaddr)
0085 );
0086 
0087 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_ep0,
0088     TP_PROTO(const char *ep_name, u32 ep_trbaddr),
0089     TP_ARGS(ep_name, ep_trbaddr)
0090 );
0091 
0092 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_epx,
0093     TP_PROTO(const char *ep_name, u32 ep_trbaddr),
0094     TP_ARGS(ep_name, ep_trbaddr)
0095 );
0096 
0097 DECLARE_EVENT_CLASS(cdns3_log_usb_irq,
0098     TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
0099     TP_ARGS(priv_dev, usb_ists),
0100     TP_STRUCT__entry(
0101         __field(enum usb_device_speed, speed)
0102         __field(u32, usb_ists)
0103         __dynamic_array(char, str, CDNS3_MSG_MAX)
0104     ),
0105     TP_fast_assign(
0106         __entry->speed = cdns3_get_speed(priv_dev);
0107         __entry->usb_ists = usb_ists;
0108     ),
0109     TP_printk("%s", cdns3_decode_usb_irq(__get_str(str), __entry->speed,
0110                          __entry->usb_ists))
0111 );
0112 
0113 DEFINE_EVENT(cdns3_log_usb_irq, cdns3_usb_irq,
0114     TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
0115     TP_ARGS(priv_dev, usb_ists)
0116 );
0117 
0118 DECLARE_EVENT_CLASS(cdns3_log_epx_irq,
0119     TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
0120     TP_ARGS(priv_dev, priv_ep),
0121     TP_STRUCT__entry(
0122         __string(ep_name, priv_ep->name)
0123         __field(u32, ep_sts)
0124         __field(u32, ep_traddr)
0125         __field(u32, ep_last_sid)
0126         __field(u32, use_streams)
0127         __dynamic_array(char, str, CDNS3_MSG_MAX)
0128     ),
0129     TP_fast_assign(
0130         __assign_str(ep_name, priv_ep->name);
0131         __entry->ep_sts = readl(&priv_dev->regs->ep_sts);
0132         __entry->ep_traddr = readl(&priv_dev->regs->ep_traddr);
0133         __entry->ep_last_sid = priv_ep->last_stream_id;
0134         __entry->use_streams = priv_ep->use_streams;
0135     ),
0136     TP_printk("%s, ep_traddr: %08x ep_last_sid: %08x use_streams: %d",
0137           cdns3_decode_epx_irq(__get_str(str),
0138                        __get_str(ep_name),
0139                        __entry->ep_sts),
0140           __entry->ep_traddr,
0141           __entry->ep_last_sid,
0142           __entry->use_streams)
0143 );
0144 
0145 DEFINE_EVENT(cdns3_log_epx_irq, cdns3_epx_irq,
0146     TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
0147     TP_ARGS(priv_dev, priv_ep)
0148 );
0149 
0150 DECLARE_EVENT_CLASS(cdns3_log_ep0_irq,
0151     TP_PROTO(struct cdns3_device *priv_dev,  u32 ep_sts),
0152     TP_ARGS(priv_dev, ep_sts),
0153     TP_STRUCT__entry(
0154         __field(int, ep_dir)
0155         __field(u32, ep_sts)
0156         __dynamic_array(char, str, CDNS3_MSG_MAX)
0157     ),
0158     TP_fast_assign(
0159         __entry->ep_dir = priv_dev->selected_ep;
0160         __entry->ep_sts = ep_sts;
0161     ),
0162     TP_printk("%s", cdns3_decode_ep0_irq(__get_str(str),
0163                          __entry->ep_dir,
0164                          __entry->ep_sts))
0165 );
0166 
0167 DEFINE_EVENT(cdns3_log_ep0_irq, cdns3_ep0_irq,
0168     TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts),
0169     TP_ARGS(priv_dev, ep_sts)
0170 );
0171 
0172 DECLARE_EVENT_CLASS(cdns3_log_ctrl,
0173     TP_PROTO(struct usb_ctrlrequest *ctrl),
0174     TP_ARGS(ctrl),
0175     TP_STRUCT__entry(
0176         __field(u8, bRequestType)
0177         __field(u8, bRequest)
0178         __field(u16, wValue)
0179         __field(u16, wIndex)
0180         __field(u16, wLength)
0181         __dynamic_array(char, str, CDNS3_MSG_MAX)
0182     ),
0183     TP_fast_assign(
0184         __entry->bRequestType = ctrl->bRequestType;
0185         __entry->bRequest = ctrl->bRequest;
0186         __entry->wValue = le16_to_cpu(ctrl->wValue);
0187         __entry->wIndex = le16_to_cpu(ctrl->wIndex);
0188         __entry->wLength = le16_to_cpu(ctrl->wLength);
0189     ),
0190     TP_printk("%s", usb_decode_ctrl(__get_str(str), CDNS3_MSG_MAX,
0191                     __entry->bRequestType,
0192                     __entry->bRequest, __entry->wValue,
0193                     __entry->wIndex, __entry->wLength)
0194     )
0195 );
0196 
0197 DEFINE_EVENT(cdns3_log_ctrl, cdns3_ctrl_req,
0198     TP_PROTO(struct usb_ctrlrequest *ctrl),
0199     TP_ARGS(ctrl)
0200 );
0201 
0202 DECLARE_EVENT_CLASS(cdns3_log_request,
0203     TP_PROTO(struct cdns3_request *req),
0204     TP_ARGS(req),
0205     TP_STRUCT__entry(
0206         __string(name, req->priv_ep->name)
0207         __field(struct cdns3_request *, req)
0208         __field(void *, buf)
0209         __field(unsigned int, actual)
0210         __field(unsigned int, length)
0211         __field(int, status)
0212         __field(int, zero)
0213         __field(int, short_not_ok)
0214         __field(int, no_interrupt)
0215         __field(int, start_trb)
0216         __field(int, end_trb)
0217         __field(int, flags)
0218         __field(unsigned int, stream_id)
0219     ),
0220     TP_fast_assign(
0221         __assign_str(name, req->priv_ep->name);
0222         __entry->req = req;
0223         __entry->buf = req->request.buf;
0224         __entry->actual = req->request.actual;
0225         __entry->length = req->request.length;
0226         __entry->status = req->request.status;
0227         __entry->zero = req->request.zero;
0228         __entry->short_not_ok = req->request.short_not_ok;
0229         __entry->no_interrupt = req->request.no_interrupt;
0230         __entry->start_trb = req->start_trb;
0231         __entry->end_trb = req->end_trb;
0232         __entry->flags = req->flags;
0233         __entry->stream_id = req->request.stream_id;
0234     ),
0235     TP_printk("%s: req: %p, req buff %p, length: %u/%u %s%s%s, status: %d,"
0236           " trb: [start:%d, end:%d], flags:%x SID: %u",
0237         __get_str(name), __entry->req, __entry->buf, __entry->actual,
0238         __entry->length,
0239         __entry->zero ? "Z" : "z",
0240         __entry->short_not_ok ? "S" : "s",
0241         __entry->no_interrupt ? "I" : "i",
0242         __entry->status,
0243         __entry->start_trb,
0244         __entry->end_trb,
0245         __entry->flags,
0246         __entry->stream_id
0247     )
0248 );
0249 
0250 DEFINE_EVENT(cdns3_log_request, cdns3_alloc_request,
0251     TP_PROTO(struct cdns3_request *req),
0252     TP_ARGS(req)
0253 );
0254 
0255 DEFINE_EVENT(cdns3_log_request, cdns3_free_request,
0256     TP_PROTO(struct cdns3_request *req),
0257     TP_ARGS(req)
0258 );
0259 
0260 DEFINE_EVENT(cdns3_log_request, cdns3_ep_queue,
0261     TP_PROTO(struct cdns3_request *req),
0262     TP_ARGS(req)
0263 );
0264 
0265 DEFINE_EVENT(cdns3_log_request, cdns3_ep_dequeue,
0266     TP_PROTO(struct cdns3_request *req),
0267     TP_ARGS(req)
0268 );
0269 
0270 DEFINE_EVENT(cdns3_log_request, cdns3_gadget_giveback,
0271     TP_PROTO(struct cdns3_request *req),
0272     TP_ARGS(req)
0273 );
0274 
0275 TRACE_EVENT(cdns3_ep0_queue,
0276     TP_PROTO(struct cdns3_device *dev_priv, struct usb_request *request),
0277     TP_ARGS(dev_priv, request),
0278     TP_STRUCT__entry(
0279         __field(int, dir)
0280         __field(int, length)
0281     ),
0282     TP_fast_assign(
0283         __entry->dir = dev_priv->ep0_data_dir;
0284         __entry->length = request->length;
0285     ),
0286     TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
0287           __entry->length)
0288 );
0289 
0290 DECLARE_EVENT_CLASS(cdns3_stream_split_transfer_len,
0291     TP_PROTO(struct cdns3_request *req),
0292     TP_ARGS(req),
0293     TP_STRUCT__entry(
0294         __string(name, req->priv_ep->name)
0295         __field(struct cdns3_request *, req)
0296         __field(unsigned int, length)
0297         __field(unsigned int, actual)
0298         __field(unsigned int, stream_id)
0299     ),
0300     TP_fast_assign(
0301         __assign_str(name, req->priv_ep->name);
0302         __entry->req = req;
0303         __entry->actual = req->request.length;
0304         __entry->length = req->request.actual;
0305         __entry->stream_id = req->request.stream_id;
0306     ),
0307     TP_printk("%s: req: %p,request length: %u actual length: %u  SID: %u",
0308           __get_str(name), __entry->req, __entry->length,
0309           __entry->actual, __entry->stream_id)
0310 );
0311 
0312 DEFINE_EVENT(cdns3_stream_split_transfer_len, cdns3_stream_transfer_split,
0313          TP_PROTO(struct cdns3_request *req),
0314          TP_ARGS(req)
0315 );
0316 
0317 DEFINE_EVENT(cdns3_stream_split_transfer_len,
0318          cdns3_stream_transfer_split_next_part,
0319          TP_PROTO(struct cdns3_request *req),
0320          TP_ARGS(req)
0321 );
0322 
0323 DECLARE_EVENT_CLASS(cdns3_log_aligned_request,
0324     TP_PROTO(struct cdns3_request *priv_req),
0325     TP_ARGS(priv_req),
0326     TP_STRUCT__entry(
0327         __string(name, priv_req->priv_ep->name)
0328         __field(struct usb_request *, req)
0329         __field(void *, buf)
0330         __field(dma_addr_t, dma)
0331         __field(void *, aligned_buf)
0332         __field(dma_addr_t, aligned_dma)
0333         __field(u32, aligned_buf_size)
0334     ),
0335     TP_fast_assign(
0336         __assign_str(name, priv_req->priv_ep->name);
0337         __entry->req = &priv_req->request;
0338         __entry->buf = priv_req->request.buf;
0339         __entry->dma = priv_req->request.dma;
0340         __entry->aligned_buf = priv_req->aligned_buf->buf;
0341         __entry->aligned_dma = priv_req->aligned_buf->dma;
0342         __entry->aligned_buf_size = priv_req->aligned_buf->size;
0343     ),
0344     TP_printk("%s: req: %p, req buf %p, dma %pad a_buf %p a_dma %pad, size %d",
0345         __get_str(name), __entry->req, __entry->buf, &__entry->dma,
0346         __entry->aligned_buf, &__entry->aligned_dma,
0347         __entry->aligned_buf_size
0348     )
0349 );
0350 
0351 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_free_aligned_request,
0352     TP_PROTO(struct cdns3_request *req),
0353     TP_ARGS(req)
0354 );
0355 
0356 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_prepare_aligned_request,
0357     TP_PROTO(struct cdns3_request *req),
0358     TP_ARGS(req)
0359 );
0360 
0361 DECLARE_EVENT_CLASS(cdns3_log_map_request,
0362     TP_PROTO(struct cdns3_request *priv_req),
0363     TP_ARGS(priv_req),
0364     TP_STRUCT__entry(
0365         __string(name, priv_req->priv_ep->name)
0366         __field(struct usb_request *, req)
0367         __field(void *, buf)
0368         __field(dma_addr_t, dma)
0369     ),
0370     TP_fast_assign(
0371         __assign_str(name, priv_req->priv_ep->name);
0372         __entry->req = &priv_req->request;
0373         __entry->buf = priv_req->request.buf;
0374         __entry->dma = priv_req->request.dma;
0375     ),
0376     TP_printk("%s: req: %p, req buf %p, dma %p",
0377           __get_str(name), __entry->req, __entry->buf, &__entry->dma
0378     )
0379 );
0380 DEFINE_EVENT(cdns3_log_map_request, cdns3_map_request,
0381          TP_PROTO(struct cdns3_request *req),
0382          TP_ARGS(req)
0383 );
0384 DEFINE_EVENT(cdns3_log_map_request, cdns3_mapped_request,
0385          TP_PROTO(struct cdns3_request *req),
0386          TP_ARGS(req)
0387 );
0388 
0389 DECLARE_EVENT_CLASS(cdns3_log_trb,
0390     TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
0391     TP_ARGS(priv_ep, trb),
0392     TP_STRUCT__entry(
0393         __string(name, priv_ep->name)
0394         __field(struct cdns3_trb *, trb)
0395         __field(u32, buffer)
0396         __field(u32, length)
0397         __field(u32, control)
0398         __field(u32, type)
0399         __field(unsigned int, last_stream_id)
0400     ),
0401     TP_fast_assign(
0402         __assign_str(name, priv_ep->name);
0403         __entry->trb = trb;
0404         __entry->buffer = le32_to_cpu(trb->buffer);
0405         __entry->length = le32_to_cpu(trb->length);
0406         __entry->control = le32_to_cpu(trb->control);
0407         __entry->type = usb_endpoint_type(priv_ep->endpoint.desc);
0408         __entry->last_stream_id = priv_ep->last_stream_id;
0409     ),
0410     TP_printk("%s: trb %p, dma buf: 0x%08x, size: %ld, burst: %d ctrl: 0x%08x (%s%s%s%s%s%s%s) SID:%lu LAST_SID:%u",
0411         __get_str(name), __entry->trb, __entry->buffer,
0412         TRB_LEN(__entry->length),
0413         (u8)TRB_BURST_LEN_GET(__entry->length),
0414         __entry->control,
0415         __entry->control & TRB_CYCLE ? "C=1, " : "C=0, ",
0416         __entry->control & TRB_TOGGLE ? "T=1, " : "T=0, ",
0417         __entry->control & TRB_ISP ? "ISP, " : "",
0418         __entry->control & TRB_FIFO_MODE ? "FIFO, " : "",
0419         __entry->control & TRB_CHAIN ? "CHAIN, " : "",
0420         __entry->control & TRB_IOC ? "IOC, " : "",
0421         TRB_FIELD_TO_TYPE(__entry->control) == TRB_NORMAL ? "Normal" : "LINK",
0422         TRB_FIELD_TO_STREAMID(__entry->control),
0423         __entry->last_stream_id
0424     )
0425 );
0426 
0427 DEFINE_EVENT(cdns3_log_trb, cdns3_prepare_trb,
0428     TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
0429     TP_ARGS(priv_ep, trb)
0430 );
0431 
0432 DEFINE_EVENT(cdns3_log_trb, cdns3_complete_trb,
0433     TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
0434     TP_ARGS(priv_ep, trb)
0435 );
0436 
0437 DECLARE_EVENT_CLASS(cdns3_log_ring,
0438     TP_PROTO(struct cdns3_endpoint *priv_ep),
0439     TP_ARGS(priv_ep),
0440     TP_STRUCT__entry(
0441         __dynamic_array(u8, ring, TRB_RING_SIZE)
0442         __dynamic_array(u8, priv_ep, sizeof(struct cdns3_endpoint))
0443         __dynamic_array(char, buffer,
0444                 (TRBS_PER_SEGMENT * 65) + CDNS3_MSG_MAX)
0445     ),
0446     TP_fast_assign(
0447         memcpy(__get_dynamic_array(priv_ep), priv_ep,
0448                sizeof(struct cdns3_endpoint));
0449         memcpy(__get_dynamic_array(ring), priv_ep->trb_pool,
0450                TRB_RING_SIZE);
0451     ),
0452 
0453     TP_printk("%s",
0454           cdns3_dbg_ring((struct cdns3_endpoint *)__get_str(priv_ep),
0455                  (struct cdns3_trb *)__get_str(ring),
0456                  __get_str(buffer)))
0457 );
0458 
0459 DEFINE_EVENT(cdns3_log_ring, cdns3_ring,
0460     TP_PROTO(struct cdns3_endpoint *priv_ep),
0461     TP_ARGS(priv_ep)
0462 );
0463 
0464 DECLARE_EVENT_CLASS(cdns3_log_ep,
0465     TP_PROTO(struct cdns3_endpoint *priv_ep),
0466     TP_ARGS(priv_ep),
0467     TP_STRUCT__entry(
0468         __string(name, priv_ep->name)
0469         __field(unsigned int, maxpacket)
0470         __field(unsigned int, maxpacket_limit)
0471         __field(unsigned int, max_streams)
0472         __field(unsigned int, use_streams)
0473         __field(unsigned int, maxburst)
0474         __field(unsigned int, flags)
0475         __field(unsigned int, dir)
0476         __field(u8, enqueue)
0477         __field(u8, dequeue)
0478     ),
0479     TP_fast_assign(
0480         __assign_str(name, priv_ep->name);
0481         __entry->maxpacket = priv_ep->endpoint.maxpacket;
0482         __entry->maxpacket_limit = priv_ep->endpoint.maxpacket_limit;
0483         __entry->max_streams = priv_ep->endpoint.max_streams;
0484         __entry->use_streams = priv_ep->use_streams;
0485         __entry->maxburst = priv_ep->endpoint.maxburst;
0486         __entry->flags = priv_ep->flags;
0487         __entry->dir = priv_ep->dir;
0488         __entry->enqueue = priv_ep->enqueue;
0489         __entry->dequeue = priv_ep->dequeue;
0490     ),
0491     TP_printk("%s: mps: %d/%d. streams: %d, stream enable: %d, burst: %d, "
0492           "enq idx: %d, deq idx: %d, flags %s%s%s%s%s%s%s%s, dir: %s",
0493         __get_str(name), __entry->maxpacket,
0494         __entry->maxpacket_limit, __entry->max_streams,
0495         __entry->use_streams,
0496         __entry->maxburst, __entry->enqueue,
0497         __entry->dequeue,
0498         __entry->flags & EP_ENABLED ? "EN | " : "",
0499         __entry->flags & EP_STALLED ? "STALLED | " : "",
0500         __entry->flags & EP_WEDGE ? "WEDGE | " : "",
0501         __entry->flags & EP_TRANSFER_STARTED ? "STARTED | " : "",
0502         __entry->flags & EP_UPDATE_EP_TRBADDR ? "UPD TRB | " : "",
0503         __entry->flags & EP_PENDING_REQUEST ? "REQ PEN | " : "",
0504         __entry->flags & EP_RING_FULL ? "RING FULL |" : "",
0505         __entry->flags & EP_CLAIMED ?  "CLAIMED " : "",
0506         __entry->dir ? "IN" : "OUT"
0507     )
0508 );
0509 
0510 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_enable,
0511     TP_PROTO(struct cdns3_endpoint *priv_ep),
0512     TP_ARGS(priv_ep)
0513 );
0514 
0515 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_disable,
0516     TP_PROTO(struct cdns3_endpoint *priv_ep),
0517     TP_ARGS(priv_ep)
0518 );
0519 
0520 DECLARE_EVENT_CLASS(cdns3_log_request_handled,
0521     TP_PROTO(struct cdns3_request *priv_req, int current_index,
0522          int handled),
0523     TP_ARGS(priv_req, current_index, handled),
0524     TP_STRUCT__entry(
0525         __field(struct cdns3_request *, priv_req)
0526         __field(unsigned int, dma_position)
0527         __field(unsigned int, handled)
0528         __field(unsigned int, dequeue_idx)
0529         __field(unsigned int, enqueue_idx)
0530         __field(unsigned int, start_trb)
0531         __field(unsigned int, end_trb)
0532     ),
0533     TP_fast_assign(
0534         __entry->priv_req = priv_req;
0535         __entry->dma_position = current_index;
0536         __entry->handled = handled;
0537         __entry->dequeue_idx = priv_req->priv_ep->dequeue;
0538         __entry->enqueue_idx = priv_req->priv_ep->enqueue;
0539         __entry->start_trb = priv_req->start_trb;
0540         __entry->end_trb = priv_req->end_trb;
0541     ),
0542     TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
0543           " start trb: %d, end trb: %d",
0544         __entry->priv_req,
0545         __entry->handled ? "handled" : "not handled",
0546         __entry->dma_position, __entry->dequeue_idx,
0547         __entry->enqueue_idx, __entry->start_trb,
0548         __entry->end_trb
0549     )
0550 );
0551 
0552 DEFINE_EVENT(cdns3_log_request_handled, cdns3_request_handled,
0553     TP_PROTO(struct cdns3_request *priv_req, int current_index,
0554          int handled),
0555     TP_ARGS(priv_req, current_index, handled)
0556 );
0557 #endif /* __LINUX_CDNS3_TRACE */
0558 
0559 /* this part must be outside header guard */
0560 
0561 #undef TRACE_INCLUDE_PATH
0562 #define TRACE_INCLUDE_PATH .
0563 
0564 #undef TRACE_INCLUDE_FILE
0565 #define TRACE_INCLUDE_FILE cdns3-trace
0566 
0567 #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!