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