drivers/usb/cdns3/trace.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * USBSS device controller driver.
   4  * Trace support header file.
   5  *
   6  * Copyright (C) 2018-2019 Cadence.
   7  *
   8  * Author: Pawel Laszczak <pawell@cadence.com>
   9  */
  10
  11 #undef TRACE_SYSTEM
  12 #define TRACE_SYSTEM cdns3
  13
  14 #if !defined(__LINUX_CDNS3_TRACE) || defined(TRACE_HEADER_MULTI_READ)
  15 #define __LINUX_CDNS3_TRACE
  16
  17 #include <linux/types.h>
  18 #include <linux/tracepoint.h>
  19 #include <asm/byteorder.h>
  20 #include <linux/usb/ch9.h>
  21 #include "core.h"
  22 #include "gadget.h"
  23 #include "debug.h"
  24
  25 #define CDNS3_MSG_MAX   500
  26
  27 TRACE_EVENT(cdns3_halt,
  28         TP_PROTO(struct cdns3_endpoint *ep_priv, u8 halt, u8 flush),
  29         TP_ARGS(ep_priv, halt, flush),
  30         TP_STRUCT__entry(
  31                 __string(name, ep_priv->name)
  32                 __field(u8, halt)
  33                 __field(u8, flush)
  34         ),
  35         TP_fast_assign(
  36                 __assign_str(name, ep_priv->name);
  37                 __entry->halt = halt;
  38                 __entry->flush = flush;
  39         ),
  40         TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
  41                   __get_str(name), __entry->halt ? "set" : "cleared")
  42 );
  43
  44 TRACE_EVENT(cdns3_wa1,
  45         TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
  46         TP_ARGS(ep_priv, msg),
  47         TP_STRUCT__entry(
  48                 __string(ep_name, ep_priv->name)
  49                 __string(msg, msg)
  50         ),
  51         TP_fast_assign(
  52                 __assign_str(ep_name, ep_priv->name);
  53                 __assign_str(msg, msg);
  54         ),
  55         TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
  56 );
  57
  58 TRACE_EVENT(cdns3_wa2,
  59         TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg),
  60         TP_ARGS(ep_priv, msg),
  61         TP_STRUCT__entry(
  62                 __string(ep_name, ep_priv->name)
  63                 __string(msg, msg)
  64         ),
  65         TP_fast_assign(
  66                 __assign_str(ep_name, ep_priv->name);
  67                 __assign_str(msg, msg);
  68         ),
  69         TP_printk("WA2: %s %s", __get_str(ep_name), __get_str(msg))
  70 );
  71
  72 DECLARE_EVENT_CLASS(cdns3_log_doorbell,
  73         TP_PROTO(const char *ep_name, u32 ep_trbaddr),
  74         TP_ARGS(ep_name, ep_trbaddr),
  75         TP_STRUCT__entry(
  76                 __string(name, ep_name)
  77                 __field(u32, ep_trbaddr)
  78         ),
  79         TP_fast_assign(
  80                 __assign_str(name, ep_name);
  81                 __entry->ep_trbaddr = ep_trbaddr;
  82         ),
  83         TP_printk("%s, ep_trbaddr %08x", __get_str(name),
  84                   __entry->ep_trbaddr)
  85 );
  86
  87 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_ep0,
  88         TP_PROTO(const char *ep_name, u32 ep_trbaddr),
  89         TP_ARGS(ep_name, ep_trbaddr)
  90 );
  91
  92 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_epx,
  93         TP_PROTO(const char *ep_name, u32 ep_trbaddr),
  94         TP_ARGS(ep_name, ep_trbaddr)
  95 );
  96
  97 DECLARE_EVENT_CLASS(cdns3_log_usb_irq,
  98         TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
  99         TP_ARGS(priv_dev, usb_ists),
 100         TP_STRUCT__entry(
 101                 __field(enum usb_device_speed, speed)
 102                 __field(u32, usb_ists)
 103                 __dynamic_array(char, str, CDNS3_MSG_MAX)
 104         ),
 105         TP_fast_assign(
 106                 __entry->speed = cdns3_get_speed(priv_dev);
 107                 __entry->usb_ists = usb_ists;
 108         ),
 109         TP_printk("%s", cdns3_decode_usb_irq(__get_str(str), __entry->speed,
 110                                              __entry->usb_ists))
 111 );
 112
 113 DEFINE_EVENT(cdns3_log_usb_irq, cdns3_usb_irq,
 114         TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists),
 115         TP_ARGS(priv_dev, usb_ists)
 116 );
 117
 118 DECLARE_EVENT_CLASS(cdns3_log_epx_irq,
 119         TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
 120         TP_ARGS(priv_dev, priv_ep),
 121         TP_STRUCT__entry(
 122                 __string(ep_name, priv_ep->name)
 123                 __field(u32, ep_sts)
 124                 __field(u32, ep_traddr)
 125                 __field(u32, ep_last_sid)
 126                 __field(u32, use_streams)
 127                 __dynamic_array(char, str, CDNS3_MSG_MAX)
 128         ),
 129         TP_fast_assign(
 130                 __assign_str(ep_name, priv_ep->name);
 131                 __entry->ep_sts = readl(&priv_dev->regs->ep_sts);
 132                 __entry->ep_traddr = readl(&priv_dev->regs->ep_traddr);
 133                 __entry->ep_last_sid = priv_ep->last_stream_id;
 134                 __entry->use_streams = priv_ep->use_streams;
 135         ),
 136         TP_printk("%s, ep_traddr: %08x ep_last_sid: %08x use_streams: %d",
 137                   cdns3_decode_epx_irq(__get_str(str),
 138                                        __get_str(ep_name),
 139                                        __entry->ep_sts),
 140                   __entry->ep_traddr,
 141                   __entry->ep_last_sid,
 142                   __entry->use_streams)
 143 );
 144
 145 DEFINE_EVENT(cdns3_log_epx_irq, cdns3_epx_irq,
 146         TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep),
 147         TP_ARGS(priv_dev, priv_ep)
 148 );
 149
 150 DECLARE_EVENT_CLASS(cdns3_log_ep0_irq,
 151         TP_PROTO(struct cdns3_device *priv_dev,  u32 ep_sts),
 152         TP_ARGS(priv_dev, ep_sts),
 153         TP_STRUCT__entry(
 154                 __field(int, ep_dir)
 155                 __field(u32, ep_sts)
 156                 __dynamic_array(char, str, CDNS3_MSG_MAX)
 157         ),
 158         TP_fast_assign(
 159                 __entry->ep_dir = priv_dev->ep0_data_dir;
 160                 __entry->ep_sts = ep_sts;
 161         ),
 162         TP_printk("%s", cdns3_decode_ep0_irq(__get_str(str),
 163                                              __entry->ep_dir,
 164                                              __entry->ep_sts))
 165 );
 166
 167 DEFINE_EVENT(cdns3_log_ep0_irq, cdns3_ep0_irq,
 168         TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts),
 169         TP_ARGS(priv_dev, ep_sts)
 170 );
 171
 172 DECLARE_EVENT_CLASS(cdns3_log_ctrl,
 173         TP_PROTO(struct usb_ctrlrequest *ctrl),
 174         TP_ARGS(ctrl),
 175         TP_STRUCT__entry(
 176                 __field(u8, bRequestType)
 177                 __field(u8, bRequest)
 178                 __field(u16, wValue)
 179                 __field(u16, wIndex)
 180                 __field(u16, wLength)
 181                 __dynamic_array(char, str, CDNS3_MSG_MAX)
 182         ),
 183         TP_fast_assign(
 184                 __entry->bRequestType = ctrl->bRequestType;
 185                 __entry->bRequest = ctrl->bRequest;
 186                 __entry->wValue = le16_to_cpu(ctrl->wValue);
 187                 __entry->wIndex = le16_to_cpu(ctrl->wIndex);
 188                 __entry->wLength = le16_to_cpu(ctrl->wLength);
 189         ),
 190         TP_printk("%s", usb_decode_ctrl(__get_str(str), CDNS3_MSG_MAX,
 191                                         __entry->bRequestType,
 192                                         __entry->bRequest, __entry->wValue,
 193                                         __entry->wIndex, __entry->wLength)
 194         )
 195 );
 196
 197 DEFINE_EVENT(cdns3_log_ctrl, cdns3_ctrl_req,
 198         TP_PROTO(struct usb_ctrlrequest *ctrl),
 199         TP_ARGS(ctrl)
 200 );
 201
 202 DECLARE_EVENT_CLASS(cdns3_log_request,
 203         TP_PROTO(struct cdns3_request *req),
 204         TP_ARGS(req),
 205         TP_STRUCT__entry(
 206                 __string(name, req->priv_ep->name)
 207                 __field(struct cdns3_request *, req)
 208                 __field(void *, buf)
 209                 __field(unsigned int, actual)
 210                 __field(unsigned int, length)
 211                 __field(int, status)
 212                 __field(int, zero)
 213                 __field(int, short_not_ok)
 214                 __field(int, no_interrupt)
 215                 __field(int, start_trb)
 216                 __field(int, end_trb)
 217                 __field(struct cdns3_trb *, start_trb_addr)
 218                 __field(int, flags)
 219                 __field(unsigned int, stream_id)
 220         ),
 221         TP_fast_assign(
 222                 __assign_str(name, req->priv_ep->name);
 223                 __entry->req = req;
 224                 __entry->buf = req->request.buf;
 225                 __entry->actual = req->request.actual;
 226                 __entry->length = req->request.length;
 227                 __entry->status = req->request.status;
 228                 __entry->zero = req->request.zero;
 229                 __entry->short_not_ok = req->request.short_not_ok;
 230                 __entry->no_interrupt = req->request.no_interrupt;
 231                 __entry->start_trb = req->start_trb;
 232                 __entry->end_trb = req->end_trb;
 233                 __entry->start_trb_addr = req->trb;
 234                 __entry->flags = req->flags;
 235                 __entry->stream_id = req->request.stream_id;
 236         ),
 237         TP_printk("%s: req: %p, req buff %p, length: %u/%u %s%s%s, status: %d,"
 238                   " trb: [start:%d, end:%d: virt addr %pa], flags:%x SID: %u",
 239                 __get_str(name), __entry->req, __entry->buf, __entry->actual,
 240                 __entry->length,
 241                 __entry->zero ? "Z" : "z",
 242                 __entry->short_not_ok ? "S" : "s",
 243                 __entry->no_interrupt ? "I" : "i",
 244                 __entry->status,
 245                 __entry->start_trb,
 246                 __entry->end_trb,
 247                 __entry->start_trb_addr,
 248                 __entry->flags,
 249                 __entry->stream_id
 250         )
 251 );
 252
 253 DEFINE_EVENT(cdns3_log_request, cdns3_alloc_request,
 254         TP_PROTO(struct cdns3_request *req),
 255         TP_ARGS(req)
 256 );
 257
 258 DEFINE_EVENT(cdns3_log_request, cdns3_free_request,
 259         TP_PROTO(struct cdns3_request *req),
 260         TP_ARGS(req)
 261 );
 262
 263 DEFINE_EVENT(cdns3_log_request, cdns3_ep_queue,
 264         TP_PROTO(struct cdns3_request *req),
 265         TP_ARGS(req)
 266 );
 267
 268 DEFINE_EVENT(cdns3_log_request, cdns3_ep_dequeue,
 269         TP_PROTO(struct cdns3_request *req),
 270         TP_ARGS(req)
 271 );
 272
 273 DEFINE_EVENT(cdns3_log_request, cdns3_gadget_giveback,
 274         TP_PROTO(struct cdns3_request *req),
 275         TP_ARGS(req)
 276 );
 277
 278 TRACE_EVENT(cdns3_ep0_queue,
 279         TP_PROTO(struct cdns3_device *dev_priv, struct usb_request *request),
 280         TP_ARGS(dev_priv, request),
 281         TP_STRUCT__entry(
 282                 __field(int, dir)
 283                 __field(int, length)
 284         ),
 285         TP_fast_assign(
 286                 __entry->dir = dev_priv->ep0_data_dir;
 287                 __entry->length = request->length;
 288         ),
 289         TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
 290                   __entry->length)
 291 );
 292
 293 DECLARE_EVENT_CLASS(cdns3_stream_split_transfer_len,
 294         TP_PROTO(struct cdns3_request *req),
 295         TP_ARGS(req),
 296         TP_STRUCT__entry(
 297                 __string(name, req->priv_ep->name)
 298                 __field(struct cdns3_request *, req)
 299                 __field(unsigned int, length)
 300                 __field(unsigned int, actual)
 301                 __field(unsigned int, stream_id)
 302         ),
 303         TP_fast_assign(
 304                 __assign_str(name, req->priv_ep->name);
 305                 __entry->req = req;
 306                 __entry->actual = req->request.length;
 307                 __entry->length = req->request.actual;
 308                 __entry->stream_id = req->request.stream_id;
 309         ),
 310         TP_printk("%s: req: %p,request length: %u actual length: %u  SID: %u",
 311                   __get_str(name), __entry->req, __entry->length,
 312                   __entry->actual, __entry->stream_id)
 313 );
 314
 315 DEFINE_EVENT(cdns3_stream_split_transfer_len, cdns3_stream_transfer_split,
 316              TP_PROTO(struct cdns3_request *req),
 317              TP_ARGS(req)
 318 );
 319
 320 DEFINE_EVENT(cdns3_stream_split_transfer_len,
 321              cdns3_stream_transfer_split_next_part,
 322              TP_PROTO(struct cdns3_request *req),
 323              TP_ARGS(req)
 324 );
 325
 326 DECLARE_EVENT_CLASS(cdns3_log_aligned_request,
 327         TP_PROTO(struct cdns3_request *priv_req),
 328         TP_ARGS(priv_req),
 329         TP_STRUCT__entry(
 330                 __string(name, priv_req->priv_ep->name)
 331                 __field(struct usb_request *, req)
 332                 __field(void *, buf)
 333                 __field(dma_addr_t, dma)
 334                 __field(void *, aligned_buf)
 335                 __field(dma_addr_t, aligned_dma)
 336                 __field(u32, aligned_buf_size)
 337         ),
 338         TP_fast_assign(
 339                 __assign_str(name, priv_req->priv_ep->name);
 340                 __entry->req = &priv_req->request;
 341                 __entry->buf = priv_req->request.buf;
 342                 __entry->dma = priv_req->request.dma;
 343                 __entry->aligned_buf = priv_req->aligned_buf->buf;
 344                 __entry->aligned_dma = priv_req->aligned_buf->dma;
 345                 __entry->aligned_buf_size = priv_req->aligned_buf->size;
 346         ),
 347         TP_printk("%s: req: %p, req buf %p, dma %pad a_buf %p a_dma %pad, size %d",
 348                 __get_str(name), __entry->req, __entry->buf, &__entry->dma,
 349                 __entry->aligned_buf, &__entry->aligned_dma,
 350                 __entry->aligned_buf_size
 351         )
 352 );
 353
 354 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_free_aligned_request,
 355         TP_PROTO(struct cdns3_request *req),
 356         TP_ARGS(req)
 357 );
 358
 359 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_prepare_aligned_request,
 360         TP_PROTO(struct cdns3_request *req),
 361         TP_ARGS(req)
 362 );
 363
 364 DECLARE_EVENT_CLASS(cdns3_log_map_request,
 365         TP_PROTO(struct cdns3_request *priv_req),
 366         TP_ARGS(priv_req),
 367         TP_STRUCT__entry(
 368                 __string(name, priv_req->priv_ep->name)
 369                 __field(struct usb_request *, req)
 370                 __field(void *, buf)
 371                 __field(dma_addr_t, dma)
 372         ),
 373         TP_fast_assign(
 374                 __assign_str(name, priv_req->priv_ep->name);
 375                 __entry->req = &priv_req->request;
 376                 __entry->buf = priv_req->request.buf;
 377                 __entry->dma = priv_req->request.dma;
 378         ),
 379         TP_printk("%s: req: %p, req buf %p, dma %p",
 380                   __get_str(name), __entry->req, __entry->buf, &__entry->dma
 381         )
 382 );
 383 DEFINE_EVENT(cdns3_log_map_request, cdns3_map_request,
 384              TP_PROTO(struct cdns3_request *req),
 385              TP_ARGS(req)
 386 );
 387 DEFINE_EVENT(cdns3_log_map_request, cdns3_mapped_request,
 388              TP_PROTO(struct cdns3_request *req),
 389              TP_ARGS(req)
 390 );
 391
 392 DECLARE_EVENT_CLASS(cdns3_log_trb,
 393         TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
 394         TP_ARGS(priv_ep, trb),
 395         TP_STRUCT__entry(
 396                 __string(name, priv_ep->name)
 397                 __field(struct cdns3_trb *, trb)
 398                 __field(u32, buffer)
 399                 __field(u32, length)
 400                 __field(u32, control)
 401                 __field(u32, type)
 402                 __field(unsigned int, last_stream_id)
 403         ),
 404         TP_fast_assign(
 405                 __assign_str(name, priv_ep->name);
 406                 __entry->trb = trb;
 407                 __entry->buffer = trb->buffer;
 408                 __entry->length = trb->length;
 409                 __entry->control = trb->control;
 410                 __entry->type = usb_endpoint_type(priv_ep->endpoint.desc);
 411                 __entry->last_stream_id = priv_ep->last_stream_id;
 412         ),
 413         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",
 414                 __get_str(name), __entry->trb, __entry->buffer,
 415                 TRB_LEN(__entry->length),
 416                 (u8)TRB_BURST_LEN_GET(__entry->length),
 417                 __entry->control,
 418                 __entry->control & TRB_CYCLE ? "C=1, " : "C=0, ",
 419                 __entry->control & TRB_TOGGLE ? "T=1, " : "T=0, ",
 420                 __entry->control & TRB_ISP ? "ISP, " : "",
 421                 __entry->control & TRB_FIFO_MODE ? "FIFO, " : "",
 422                 __entry->control & TRB_CHAIN ? "CHAIN, " : "",
 423                 __entry->control & TRB_IOC ? "IOC, " : "",
 424                 TRB_FIELD_TO_TYPE(__entry->control) == TRB_NORMAL ? "Normal" : "LINK",
 425                 TRB_FIELD_TO_STREAMID(__entry->control),
 426                 __entry->last_stream_id
 427         )
 428 );
 429
 430 DEFINE_EVENT(cdns3_log_trb, cdns3_prepare_trb,
 431         TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
 432         TP_ARGS(priv_ep, trb)
 433 );
 434
 435 DEFINE_EVENT(cdns3_log_trb, cdns3_complete_trb,
 436         TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb),
 437         TP_ARGS(priv_ep, trb)
 438 );
 439
 440 DECLARE_EVENT_CLASS(cdns3_log_ring,
 441         TP_PROTO(struct cdns3_endpoint *priv_ep),
 442         TP_ARGS(priv_ep),
 443         TP_STRUCT__entry(
 444                 __dynamic_array(u8, ring, TRB_RING_SIZE)
 445                 __dynamic_array(u8, priv_ep, sizeof(struct cdns3_endpoint))
 446                 __dynamic_array(char, buffer,
 447                                 (TRBS_PER_SEGMENT * 65) + CDNS3_MSG_MAX)
 448         ),
 449         TP_fast_assign(
 450                 memcpy(__get_dynamic_array(priv_ep), priv_ep,
 451                        sizeof(struct cdns3_endpoint));
 452                 memcpy(__get_dynamic_array(ring), priv_ep->trb_pool,
 453                        TRB_RING_SIZE);
 454         ),
 455
 456         TP_printk("%s",
 457                   cdns3_dbg_ring((struct cdns3_endpoint *)__get_str(priv_ep),
 458                                  (struct cdns3_trb *)__get_str(ring),
 459                                  __get_str(buffer)))
 460 );
 461
 462 DEFINE_EVENT(cdns3_log_ring, cdns3_ring,
 463         TP_PROTO(struct cdns3_endpoint *priv_ep),
 464         TP_ARGS(priv_ep)
 465 );
 466
 467 DECLARE_EVENT_CLASS(cdns3_log_ep,
 468         TP_PROTO(struct cdns3_endpoint *priv_ep),
 469         TP_ARGS(priv_ep),
 470         TP_STRUCT__entry(
 471                 __string(name, priv_ep->name)
 472                 __field(unsigned int, maxpacket)
 473                 __field(unsigned int, maxpacket_limit)
 474                 __field(unsigned int, max_streams)
 475                 __field(unsigned int, use_streams)
 476                 __field(unsigned int, maxburst)
 477                 __field(unsigned int, flags)
 478                 __field(unsigned int, dir)
 479                 __field(u8, enqueue)
 480                 __field(u8, dequeue)
 481         ),
 482         TP_fast_assign(
 483                 __assign_str(name, priv_ep->name);
 484                 __entry->maxpacket = priv_ep->endpoint.maxpacket;
 485                 __entry->maxpacket_limit = priv_ep->endpoint.maxpacket_limit;
 486                 __entry->max_streams = priv_ep->endpoint.max_streams;
 487                 __entry->use_streams = priv_ep->use_streams;
 488                 __entry->maxburst = priv_ep->endpoint.maxburst;
 489                 __entry->flags = priv_ep->flags;
 490                 __entry->dir = priv_ep->dir;
 491                 __entry->enqueue = priv_ep->enqueue;
 492                 __entry->dequeue = priv_ep->dequeue;
 493         ),
 494         TP_printk("%s: mps: %d/%d. streams: %d, stream enable: %d, burst: %d, "
 495                   "enq idx: %d, deq idx: %d, flags %s%s%s%s%s%s%s%s, dir: %s",
 496                 __get_str(name), __entry->maxpacket,
 497                 __entry->maxpacket_limit, __entry->max_streams,
 498                 __entry->use_streams,
 499                 __entry->maxburst, __entry->enqueue,
 500                 __entry->dequeue,
 501                 __entry->flags & EP_ENABLED ? "EN | " : "",
 502                 __entry->flags & EP_STALLED ? "STALLED | " : "",
 503                 __entry->flags & EP_WEDGE ? "WEDGE | " : "",
 504                 __entry->flags & EP_TRANSFER_STARTED ? "STARTED | " : "",
 505                 __entry->flags & EP_UPDATE_EP_TRBADDR ? "UPD TRB | " : "",
 506                 __entry->flags & EP_PENDING_REQUEST ? "REQ PEN | " : "",
 507                 __entry->flags & EP_RING_FULL ? "RING FULL |" : "",
 508                 __entry->flags & EP_CLAIMED ?  "CLAIMED " : "",
 509                 __entry->dir ? "IN" : "OUT"
 510         )
 511 );
 512
 513 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_enable,
 514         TP_PROTO(struct cdns3_endpoint *priv_ep),
 515         TP_ARGS(priv_ep)
 516 );
 517
 518 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_disable,
 519         TP_PROTO(struct cdns3_endpoint *priv_ep),
 520         TP_ARGS(priv_ep)
 521 );
 522
 523 DECLARE_EVENT_CLASS(cdns3_log_request_handled,
 524         TP_PROTO(struct cdns3_request *priv_req, int current_index,
 525                  int handled),
 526         TP_ARGS(priv_req, current_index, handled),
 527         TP_STRUCT__entry(
 528                 __field(struct cdns3_request *, priv_req)
 529                 __field(unsigned int, dma_position)
 530                 __field(unsigned int, handled)
 531                 __field(unsigned int, dequeue_idx)
 532                 __field(unsigned int, enqueue_idx)
 533                 __field(unsigned int, start_trb)
 534                 __field(unsigned int, end_trb)
 535         ),
 536         TP_fast_assign(
 537                 __entry->priv_req = priv_req;
 538                 __entry->dma_position = current_index;
 539                 __entry->handled = handled;
 540                 __entry->dequeue_idx = priv_req->priv_ep->dequeue;
 541                 __entry->enqueue_idx = priv_req->priv_ep->enqueue;
 542                 __entry->start_trb = priv_req->start_trb;
 543                 __entry->end_trb = priv_req->end_trb;
 544         ),
 545         TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
 546                   " start trb: %d, end trb: %d",
 547                 __entry->priv_req,
 548                 __entry->handled ? "handled" : "not handled",
 549                 __entry->dma_position, __entry->dequeue_idx,
 550                 __entry->enqueue_idx, __entry->start_trb,
 551                 __entry->end_trb
 552         )
 553 );
 554
 555 DEFINE_EVENT(cdns3_log_request_handled, cdns3_request_handled,
 556         TP_PROTO(struct cdns3_request *priv_req, int current_index,
 557                  int handled),
 558         TP_ARGS(priv_req, current_index, handled)
 559 );
 560 #endif /* __LINUX_CDNS3_TRACE */
 561
 562 /* this part must be outside header guard */
 563
 564 #undef TRACE_INCLUDE_PATH
 565 #define TRACE_INCLUDE_PATH .
 566
 567 #undef TRACE_INCLUDE_FILE
 568 #define TRACE_INCLUDE_FILE trace
 569
 570 #include <trace/define_trace.h>