cdns2-trace.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * USBHS-DEV device controller driver.
   4  * Trace support header file.
   5  *
   6  * Copyright (C) 2023 Cadence.
   7  *
   8  * Author: Pawel Laszczak <pawell@cadence.com>
   9  */
  10
  11 #undef TRACE_SYSTEM
  12 #define TRACE_SYSTEM cdns2-dev
  13
  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 cdns2_dev
  20
  21 #if !defined(__LINUX_CDNS2_TRACE) || defined(TRACE_HEADER_MULTI_READ)
  22 #define __LINUX_CDNS2_TRACE
  23
  24 #include <linux/types.h>
  25 #include <linux/tracepoint.h>
  26 #include <asm/byteorder.h>
  27 #include <linux/usb/ch9.h>
  28 #include "cdns2-gadget.h"
  29 #include "cdns2-debug.h"
  30
  31 #define CDNS2_MSG_MAX   500
  32
  33 DECLARE_EVENT_CLASS(cdns2_log_enable_disable,
  34         TP_PROTO(int set),
  35         TP_ARGS(set),
  36         TP_STRUCT__entry(
  37                 __field(int, set)
  38         ),
  39         TP_fast_assign(
  40                 __entry->set = set;
  41         ),
  42         TP_printk("%s", __entry->set ? "enabled" : "disabled")
  43 );
  44
  45 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_pullup,
  46         TP_PROTO(int set),
  47         TP_ARGS(set)
  48 );
  49
  50 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_lpm,
  51         TP_PROTO(int set),
  52         TP_ARGS(set)
  53 );
  54
  55 DEFINE_EVENT(cdns2_log_enable_disable, cdns2_may_wakeup,
  56         TP_PROTO(int set),
  57         TP_ARGS(set)
  58 );
  59
  60 DECLARE_EVENT_CLASS(cdns2_log_simple,
  61         TP_PROTO(char *msg),
  62         TP_ARGS(msg),
  63         TP_STRUCT__entry(
  64                 __string(text, msg)
  65         ),
  66         TP_fast_assign(
  67                 __assign_str(text, msg);
  68         ),
  69         TP_printk("%s", __get_str(text))
  70 );
  71
  72 DEFINE_EVENT(cdns2_log_simple, cdns2_no_room_on_ring,
  73         TP_PROTO(char *msg),
  74         TP_ARGS(msg)
  75 );
  76
  77 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_status_stage,
  78         TP_PROTO(char *msg),
  79         TP_ARGS(msg)
  80 );
  81
  82 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_set_config,
  83         TP_PROTO(char *msg),
  84         TP_ARGS(msg)
  85 );
  86
  87 DEFINE_EVENT(cdns2_log_simple, cdns2_ep0_setup,
  88         TP_PROTO(char *msg),
  89         TP_ARGS(msg)
  90 );
  91
  92 DEFINE_EVENT(cdns2_log_simple, cdns2_device_state,
  93         TP_PROTO(char *msg),
  94         TP_ARGS(msg)
  95 );
  96
  97 TRACE_EVENT(cdns2_ep_halt,
  98         TP_PROTO(struct cdns2_endpoint *ep_priv, u8 halt, u8 flush),
  99         TP_ARGS(ep_priv, halt, flush),
 100         TP_STRUCT__entry(
 101                 __string(name, ep_priv->name)
 102                 __field(u8, halt)
 103                 __field(u8, flush)
 104         ),
 105         TP_fast_assign(
 106                 __assign_str(name, ep_priv->name);
 107                 __entry->halt = halt;
 108                 __entry->flush = flush;
 109         ),
 110         TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "",
 111                   __get_str(name), __entry->halt ? "set" : "cleared")
 112 );
 113
 114 TRACE_EVENT(cdns2_wa1,
 115         TP_PROTO(struct cdns2_endpoint *ep_priv, char *msg),
 116         TP_ARGS(ep_priv, msg),
 117         TP_STRUCT__entry(
 118                 __string(ep_name, ep_priv->name)
 119                 __string(msg, msg)
 120         ),
 121         TP_fast_assign(
 122                 __assign_str(ep_name, ep_priv->name);
 123                 __assign_str(msg, msg);
 124         ),
 125         TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg))
 126 );
 127
 128 DECLARE_EVENT_CLASS(cdns2_log_doorbell,
 129         TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
 130         TP_ARGS(pep, ep_trbaddr),
 131         TP_STRUCT__entry(
 132                 __string(name, pep->num ? pep->name :
 133                                 (pep->dir ? "ep0in" : "ep0out"))
 134                 __field(u32, ep_trbaddr)
 135         ),
 136         TP_fast_assign(
 137                 __assign_str(name, pep->name);
 138                 __entry->ep_trbaddr = ep_trbaddr;
 139         ),
 140         TP_printk("%s, ep_trbaddr %08x", __get_str(name),
 141                   __entry->ep_trbaddr)
 142 );
 143
 144 DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_ep0,
 145         TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
 146         TP_ARGS(pep, ep_trbaddr)
 147 );
 148
 149 DEFINE_EVENT(cdns2_log_doorbell, cdns2_doorbell_epx,
 150         TP_PROTO(struct cdns2_endpoint *pep, u32 ep_trbaddr),
 151         TP_ARGS(pep, ep_trbaddr)
 152 );
 153
 154 DECLARE_EVENT_CLASS(cdns2_log_usb_irq,
 155         TP_PROTO(u32 usb_irq, u32 ext_irq),
 156         TP_ARGS(usb_irq, ext_irq),
 157         TP_STRUCT__entry(
 158                 __field(u32, usb_irq)
 159                 __field(u32, ext_irq)
 160         ),
 161         TP_fast_assign(
 162                 __entry->usb_irq = usb_irq;
 163                 __entry->ext_irq = ext_irq;
 164         ),
 165         TP_printk("%s", cdns2_decode_usb_irq(__get_buf(CDNS2_MSG_MAX),
 166                                              CDNS2_MSG_MAX,
 167                                              __entry->usb_irq,
 168                                              __entry->ext_irq))
 169 );
 170
 171 DEFINE_EVENT(cdns2_log_usb_irq, cdns2_usb_irq,
 172         TP_PROTO(u32 usb_irq, u32 ext_irq),
 173         TP_ARGS(usb_irq, ext_irq)
 174 );
 175
 176 TRACE_EVENT(cdns2_dma_ep_ists,
 177         TP_PROTO(u32 dma_ep_ists),
 178         TP_ARGS(dma_ep_ists),
 179         TP_STRUCT__entry(
 180                 __field(u32, dma_ep_ists)
 181         ),
 182         TP_fast_assign(
 183                 __entry->dma_ep_ists = dma_ep_ists;
 184         ),
 185         TP_printk("OUT: 0x%04x, IN: 0x%04x", (u16)__entry->dma_ep_ists,
 186                   __entry->dma_ep_ists >> 16)
 187 );
 188
 189 DECLARE_EVENT_CLASS(cdns2_log_epx_irq,
 190         TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
 191         TP_ARGS(pdev, pep),
 192         TP_STRUCT__entry(
 193                 __string(ep_name, pep->name)
 194                 __field(u32, ep_sts)
 195                 __field(u32, ep_ists)
 196                 __field(u32, ep_traddr)
 197         ),
 198         TP_fast_assign(
 199                 __assign_str(ep_name, pep->name);
 200                 __entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
 201                 __entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
 202                 __entry->ep_traddr = readl(&pdev->adma_regs->ep_traddr);
 203         ),
 204         TP_printk("%s, ep_traddr: %08x",
 205                   cdns2_decode_epx_irq(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
 206                                        __get_str(ep_name),
 207                                        __entry->ep_ists, __entry->ep_sts),
 208                   __entry->ep_traddr)
 209 );
 210
 211 DEFINE_EVENT(cdns2_log_epx_irq, cdns2_epx_irq,
 212         TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
 213         TP_ARGS(pdev, pep)
 214 );
 215
 216 DECLARE_EVENT_CLASS(cdns2_log_ep0_irq,
 217         TP_PROTO(struct cdns2_device *pdev),
 218         TP_ARGS(pdev),
 219         TP_STRUCT__entry(
 220                 __field(int, ep_dir)
 221                 __field(u32, ep_ists)
 222                 __field(u32, ep_sts)
 223         ),
 224         TP_fast_assign(
 225                 __entry->ep_dir = pdev->selected_ep;
 226                 __entry->ep_ists = readl(&pdev->adma_regs->ep_ists);
 227                 __entry->ep_sts = readl(&pdev->adma_regs->ep_sts);
 228         ),
 229         TP_printk("%s", cdns2_decode_ep0_irq(__get_buf(CDNS2_MSG_MAX),
 230                                              CDNS2_MSG_MAX,
 231                                              __entry->ep_ists, __entry->ep_sts,
 232                                              __entry->ep_dir))
 233 );
 234
 235 DEFINE_EVENT(cdns2_log_ep0_irq, cdns2_ep0_irq,
 236         TP_PROTO(struct cdns2_device *pdev),
 237         TP_ARGS(pdev)
 238 );
 239
 240 DECLARE_EVENT_CLASS(cdns2_log_ctrl,
 241         TP_PROTO(struct usb_ctrlrequest *ctrl),
 242         TP_ARGS(ctrl),
 243         TP_STRUCT__entry(
 244                 __field(u8, bRequestType)
 245                 __field(u8, bRequest)
 246                 __field(u16, wValue)
 247                 __field(u16, wIndex)
 248                 __field(u16, wLength)
 249         ),
 250         TP_fast_assign(
 251                 __entry->bRequestType = ctrl->bRequestType;
 252                 __entry->bRequest = ctrl->bRequest;
 253                 __entry->wValue = le16_to_cpu(ctrl->wValue);
 254                 __entry->wIndex = le16_to_cpu(ctrl->wIndex);
 255                 __entry->wLength = le16_to_cpu(ctrl->wLength);
 256         ),
 257         TP_printk("%s", usb_decode_ctrl(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
 258                                         __entry->bRequestType,
 259                                         __entry->bRequest, __entry->wValue,
 260                                         __entry->wIndex, __entry->wLength)
 261         )
 262 );
 263
 264 DEFINE_EVENT(cdns2_log_ctrl, cdns2_ctrl_req,
 265         TP_PROTO(struct usb_ctrlrequest *ctrl),
 266         TP_ARGS(ctrl)
 267 );
 268
 269 DECLARE_EVENT_CLASS(cdns2_log_request,
 270         TP_PROTO(struct cdns2_request *preq),
 271         TP_ARGS(preq),
 272         TP_STRUCT__entry(
 273                 __string(name, preq->pep->name)
 274                 __field(struct usb_request *, request)
 275                 __field(struct cdns2_request *, preq)
 276                 __field(void *, buf)
 277                 __field(unsigned int, actual)
 278                 __field(unsigned int, length)
 279                 __field(int, status)
 280                 __field(dma_addr_t, dma)
 281                 __field(int, zero)
 282                 __field(int, short_not_ok)
 283                 __field(int, no_interrupt)
 284                 __field(struct scatterlist*, sg)
 285                 __field(unsigned int, num_sgs)
 286                 __field(unsigned int, num_mapped_sgs)
 287                 __field(int, start_trb)
 288                 __field(int, end_trb)
 289         ),
 290         TP_fast_assign(
 291                 __assign_str(name, preq->pep->name);
 292                 __entry->request = &preq->request;
 293                 __entry->preq = preq;
 294                 __entry->buf = preq->request.buf;
 295                 __entry->actual = preq->request.actual;
 296                 __entry->length = preq->request.length;
 297                 __entry->status = preq->request.status;
 298                 __entry->dma = preq->request.dma;
 299                 __entry->zero = preq->request.zero;
 300                 __entry->short_not_ok = preq->request.short_not_ok;
 301                 __entry->no_interrupt = preq->request.no_interrupt;
 302                 __entry->sg = preq->request.sg;
 303                 __entry->num_sgs = preq->request.num_sgs;
 304                 __entry->num_mapped_sgs = preq->request.num_mapped_sgs;
 305                 __entry->start_trb = preq->start_trb;
 306                 __entry->end_trb = preq->end_trb;
 307         ),
 308         TP_printk("%s: req: %p, preq: %p, req buf: %p, length: %u/%u, status: %d,"
 309                   "buf dma: (%pad), %s%s%s, sg: %p, num_sgs: %d, num_m_sgs: %d,"
 310                   "trb: [start: %d, end: %d]",
 311                   __get_str(name), __entry->request, __entry->preq,
 312                   __entry->buf, __entry->actual, __entry->length,
 313                   __entry->status, &__entry->dma,
 314                   __entry->zero ? "Z" : "z",
 315                   __entry->short_not_ok ? "S" : "s",
 316                   __entry->no_interrupt ? "I" : "i",
 317                   __entry->sg, __entry->num_sgs, __entry->num_mapped_sgs,
 318                   __entry->start_trb,
 319                   __entry->end_trb
 320         )
 321 );
 322
 323 DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue,
 324         TP_PROTO(struct cdns2_request *preq),
 325         TP_ARGS(preq)
 326 );
 327
 328 DEFINE_EVENT(cdns2_log_request, cdns2_request_enqueue_error,
 329         TP_PROTO(struct cdns2_request *preq),
 330         TP_ARGS(preq)
 331 );
 332
 333 DEFINE_EVENT(cdns2_log_request, cdns2_alloc_request,
 334         TP_PROTO(struct cdns2_request *preq),
 335         TP_ARGS(preq)
 336 );
 337
 338 DEFINE_EVENT(cdns2_log_request, cdns2_free_request,
 339         TP_PROTO(struct cdns2_request *preq),
 340         TP_ARGS(preq)
 341 );
 342
 343 DEFINE_EVENT(cdns2_log_request, cdns2_ep_queue,
 344         TP_PROTO(struct cdns2_request *preq),
 345         TP_ARGS(preq)
 346 );
 347
 348 DEFINE_EVENT(cdns2_log_request, cdns2_request_dequeue,
 349         TP_PROTO(struct cdns2_request *preq),
 350         TP_ARGS(preq)
 351 );
 352
 353 DEFINE_EVENT(cdns2_log_request, cdns2_request_giveback,
 354         TP_PROTO(struct cdns2_request *preq),
 355         TP_ARGS(preq)
 356 );
 357
 358 TRACE_EVENT(cdns2_ep0_enqueue,
 359         TP_PROTO(struct cdns2_device *dev_priv, struct usb_request *request),
 360         TP_ARGS(dev_priv, request),
 361         TP_STRUCT__entry(
 362                 __field(int, dir)
 363                 __field(int, length)
 364         ),
 365         TP_fast_assign(
 366                 __entry->dir = dev_priv->eps[0].dir;
 367                 __entry->length = request->length;
 368         ),
 369         TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out",
 370                   __entry->length)
 371 );
 372
 373 DECLARE_EVENT_CLASS(cdns2_log_map_request,
 374         TP_PROTO(struct cdns2_request *priv_req),
 375         TP_ARGS(priv_req),
 376         TP_STRUCT__entry(
 377                 __string(name, priv_req->pep->name)
 378                 __field(struct usb_request *, req)
 379                 __field(void *, buf)
 380                 __field(dma_addr_t, dma)
 381         ),
 382         TP_fast_assign(
 383                 __assign_str(name, priv_req->pep->name);
 384                 __entry->req = &priv_req->request;
 385                 __entry->buf = priv_req->request.buf;
 386                 __entry->dma = priv_req->request.dma;
 387         ),
 388         TP_printk("%s: req: %p, req buf %p, dma %p",
 389                   __get_str(name), __entry->req, __entry->buf, &__entry->dma
 390         )
 391 );
 392
 393 DEFINE_EVENT(cdns2_log_map_request, cdns2_map_request,
 394              TP_PROTO(struct cdns2_request *req),
 395              TP_ARGS(req)
 396 );
 397 DEFINE_EVENT(cdns2_log_map_request, cdns2_mapped_request,
 398              TP_PROTO(struct cdns2_request *req),
 399              TP_ARGS(req)
 400 );
 401
 402 DECLARE_EVENT_CLASS(cdns2_log_trb,
 403         TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
 404         TP_ARGS(pep, trb),
 405         TP_STRUCT__entry(
 406                 __string(name, pep->name)
 407                 __field(struct cdns2_trb *, trb)
 408                 __field(u32, buffer)
 409                 __field(u32, length)
 410                 __field(u32, control)
 411                 __field(u32, type)
 412         ),
 413         TP_fast_assign(
 414                 __assign_str(name, pep->name);
 415                 __entry->trb = trb;
 416                 __entry->buffer = le32_to_cpu(trb->buffer);
 417                 __entry->length = le32_to_cpu(trb->length);
 418                 __entry->control = le32_to_cpu(trb->control);
 419                 __entry->type = usb_endpoint_type(pep->endpoint.desc);
 420         ),
 421         TP_printk("%s: trb V: %p, dma buf: P: 0x%08x, %s",
 422                  __get_str(name), __entry->trb, __entry->buffer,
 423                  cdns2_decode_trb(__get_buf(CDNS2_MSG_MAX), CDNS2_MSG_MAX,
 424                                   __entry->control, __entry->length,
 425                                   __entry->buffer))
 426 );
 427
 428 DEFINE_EVENT(cdns2_log_trb, cdns2_queue_trb,
 429         TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
 430         TP_ARGS(pep, trb)
 431 );
 432
 433 DEFINE_EVENT(cdns2_log_trb, cdns2_complete_trb,
 434         TP_PROTO(struct cdns2_endpoint *pep, struct cdns2_trb *trb),
 435         TP_ARGS(pep, trb)
 436 );
 437
 438 DECLARE_EVENT_CLASS(cdns2_log_ring,
 439         TP_PROTO(struct cdns2_endpoint *pep),
 440         TP_ARGS(pep),
 441         TP_STRUCT__entry(
 442                 __dynamic_array(u8, tr_seg, TR_SEG_SIZE)
 443                 __dynamic_array(u8, pep, sizeof(struct cdns2_endpoint))
 444                 __dynamic_array(char, buffer,
 445                                 (TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX)
 446         ),
 447         TP_fast_assign(
 448                 memcpy(__get_dynamic_array(pep), pep,
 449                        sizeof(struct cdns2_endpoint));
 450                 memcpy(__get_dynamic_array(tr_seg), pep->ring.trbs,
 451                        TR_SEG_SIZE);
 452         ),
 453
 454         TP_printk("%s",
 455                   cdns2_raw_ring((struct cdns2_endpoint *)__get_str(pep),
 456                                     (struct cdns2_trb *)__get_str(tr_seg),
 457                                     __get_str(buffer),
 458                                     (TRBS_PER_SEGMENT * 65) + CDNS2_MSG_MAX))
 459 );
 460
 461 DEFINE_EVENT(cdns2_log_ring, cdns2_ring,
 462         TP_PROTO(struct cdns2_endpoint *pep),
 463         TP_ARGS(pep)
 464 );
 465
 466 DECLARE_EVENT_CLASS(cdns2_log_ep,
 467         TP_PROTO(struct cdns2_endpoint *pep),
 468         TP_ARGS(pep),
 469         TP_STRUCT__entry(
 470                 __string(name, pep->name)
 471                 __field(unsigned int, maxpacket)
 472                 __field(unsigned int, maxpacket_limit)
 473                 __field(unsigned int, flags)
 474                 __field(unsigned int, dir)
 475                 __field(u8, enqueue)
 476                 __field(u8, dequeue)
 477         ),
 478         TP_fast_assign(
 479                 __assign_str(name, pep->name);
 480                 __entry->maxpacket = pep->endpoint.maxpacket;
 481                 __entry->maxpacket_limit = pep->endpoint.maxpacket_limit;
 482                 __entry->flags = pep->ep_state;
 483                 __entry->dir = pep->dir;
 484                 __entry->enqueue = pep->ring.enqueue;
 485                 __entry->dequeue = pep->ring.dequeue;
 486         ),
 487         TP_printk("%s: mps: %d/%d, enq idx: %d, deq idx: %d, "
 488                   "flags: %s%s%s%s, dir: %s",
 489                 __get_str(name), __entry->maxpacket,
 490                 __entry->maxpacket_limit, __entry->enqueue,
 491                 __entry->dequeue,
 492                 __entry->flags & EP_ENABLED ? "EN | " : "",
 493                 __entry->flags & EP_STALLED ? "STALLED | " : "",
 494                 __entry->flags & EP_WEDGE ? "WEDGE | " : "",
 495                 __entry->flags & EP_RING_FULL ? "RING FULL |" : "",
 496                 __entry->dir ? "IN" : "OUT"
 497         )
 498 );
 499
 500 DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_enable,
 501         TP_PROTO(struct cdns2_endpoint *pep),
 502         TP_ARGS(pep)
 503 );
 504
 505 DEFINE_EVENT(cdns2_log_ep, cdns2_gadget_ep_disable,
 506         TP_PROTO(struct cdns2_endpoint *pep),
 507         TP_ARGS(pep)
 508 );
 509
 510 DEFINE_EVENT(cdns2_log_ep, cdns2_iso_out_ep_disable,
 511         TP_PROTO(struct cdns2_endpoint *pep),
 512         TP_ARGS(pep)
 513 );
 514
 515 DEFINE_EVENT(cdns2_log_ep, cdns2_ep_busy_try_halt_again,
 516         TP_PROTO(struct cdns2_endpoint *pep),
 517         TP_ARGS(pep)
 518 );
 519
 520 DECLARE_EVENT_CLASS(cdns2_log_request_handled,
 521         TP_PROTO(struct cdns2_request *priv_req, int current_index,
 522                  int handled),
 523         TP_ARGS(priv_req, current_index, handled),
 524         TP_STRUCT__entry(
 525                 __field(struct cdns2_request *, priv_req)
 526                 __field(unsigned int, dma_position)
 527                 __field(unsigned int, handled)
 528                 __field(unsigned int, dequeue_idx)
 529                 __field(unsigned int, enqueue_idx)
 530                 __field(unsigned int, start_trb)
 531                 __field(unsigned int, end_trb)
 532         ),
 533         TP_fast_assign(
 534                 __entry->priv_req = priv_req;
 535                 __entry->dma_position = current_index;
 536                 __entry->handled = handled;
 537                 __entry->dequeue_idx = priv_req->pep->ring.dequeue;
 538                 __entry->enqueue_idx = priv_req->pep->ring.enqueue;
 539                 __entry->start_trb = priv_req->start_trb;
 540                 __entry->end_trb = priv_req->end_trb;
 541         ),
 542         TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d,"
 543                   " start trb: %d, end trb: %d",
 544                 __entry->priv_req,
 545                 __entry->handled ? "handled" : "not handled",
 546                 __entry->dma_position, __entry->dequeue_idx,
 547                 __entry->enqueue_idx, __entry->start_trb,
 548                 __entry->end_trb
 549         )
 550 );
 551
 552 DEFINE_EVENT(cdns2_log_request_handled, cdns2_request_handled,
 553         TP_PROTO(struct cdns2_request *priv_req, int current_index,
 554                  int handled),
 555         TP_ARGS(priv_req, current_index, handled)
 556 );
 557
 558 DECLARE_EVENT_CLASS(cdns2_log_epx_reg_config,
 559         TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
 560         TP_ARGS(pdev, pep),
 561         TP_STRUCT__entry(
 562                 __string(ep_name, pep->name)
 563                 __field(u8, burst_size)
 564                 __field(__le16, maxpack_reg)
 565                 __field(__u8, con_reg)
 566                 __field(u32, ep_sel_reg)
 567                 __field(u32, ep_sts_en_reg)
 568                 __field(u32, ep_cfg_reg)
 569         ),
 570         TP_fast_assign(
 571                 __assign_str(ep_name, pep->name);
 572                 __entry->burst_size = pep->trb_burst_size;
 573                 __entry->maxpack_reg = pep->dir ? readw(&pdev->epx_regs->txmaxpack[pep->num - 1]) :
 574                                                   readw(&pdev->epx_regs->rxmaxpack[pep->num - 1]);
 575                 __entry->con_reg = pep->dir ? readb(&pdev->epx_regs->ep[pep->num - 1].txcon) :
 576                                               readb(&pdev->epx_regs->ep[pep->num - 1].rxcon);
 577                 __entry->ep_sel_reg = readl(&pdev->adma_regs->ep_sel);
 578                 __entry->ep_sts_en_reg = readl(&pdev->adma_regs->ep_sts_en);
 579                 __entry->ep_cfg_reg = readl(&pdev->adma_regs->ep_cfg);
 580         ),
 581
 582         TP_printk("%s, maxpack: %d, con: %02x, dma_ep_sel: %08x, dma_ep_sts_en: %08x"
 583                   " dma_ep_cfg %08x",
 584                   __get_str(ep_name), __entry->maxpack_reg, __entry->con_reg,
 585                   __entry->ep_sel_reg, __entry->ep_sts_en_reg,
 586                   __entry->ep_cfg_reg
 587         )
 588 );
 589
 590 DEFINE_EVENT(cdns2_log_epx_reg_config, cdns2_epx_hw_cfg,
 591         TP_PROTO(struct cdns2_device *pdev, struct cdns2_endpoint *pep),
 592         TP_ARGS(pdev, pep)
 593 );
 594
 595 #endif /* __LINUX_CDNS2_TRACE */
 596
 597 /* This part must be outside header guard. */
 598
 599 #undef TRACE_INCLUDE_PATH
 600 #define TRACE_INCLUDE_PATH .
 601
 602 #undef TRACE_INCLUDE_FILE
 603 #define TRACE_INCLUDE_FILE cdns2-trace
 604
 605 #include <trace/define_trace.h>