drivers/usb/cdns3/cdnsp-debug.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Cadence CDNSP DRD Driver.
   4  *
   5  * Copyright (C) 2020 Cadence.
   6  *
   7  * Author: Pawel Laszczak <[email protected]>
   8  *
   9  */
  10 #ifndef __LINUX_CDNSP_DEBUG
  11 #define __LINUX_CDNSP_DEBUG
  12
  13 static inline const char *cdnsp_trb_comp_code_string(u8 status)
  14 {
  15         switch (status) {
  16         case COMP_INVALID:
  17                 return "Invalid";
  18         case COMP_SUCCESS:
  19                 return "Success";
  20         case COMP_DATA_BUFFER_ERROR:
  21                 return "Data Buffer Error";
  22         case COMP_BABBLE_DETECTED_ERROR:
  23                 return "Babble Detected";
  24         case COMP_TRB_ERROR:
  25                 return "TRB Error";
  26         case COMP_RESOURCE_ERROR:
  27                 return "Resource Error";
  28         case COMP_NO_SLOTS_AVAILABLE_ERROR:
  29                 return "No Slots Available Error";
  30         case COMP_INVALID_STREAM_TYPE_ERROR:
  31                 return "Invalid Stream Type Error";
  32         case COMP_SLOT_NOT_ENABLED_ERROR:
  33                 return "Slot Not Enabled Error";
  34         case COMP_ENDPOINT_NOT_ENABLED_ERROR:
  35                 return "Endpoint Not Enabled Error";
  36         case COMP_SHORT_PACKET:
  37                 return "Short Packet";
  38         case COMP_RING_UNDERRUN:
  39                 return "Ring Underrun";
  40         case COMP_RING_OVERRUN:
  41                 return "Ring Overrun";
  42         case COMP_VF_EVENT_RING_FULL_ERROR:
  43                 return "VF Event Ring Full Error";
  44         case COMP_PARAMETER_ERROR:
  45                 return "Parameter Error";
  46         case COMP_CONTEXT_STATE_ERROR:
  47                 return "Context State Error";
  48         case COMP_EVENT_RING_FULL_ERROR:
  49                 return "Event Ring Full Error";
  50         case COMP_INCOMPATIBLE_DEVICE_ERROR:
  51                 return "Incompatible Device Error";
  52         case COMP_MISSED_SERVICE_ERROR:
  53                 return "Missed Service Error";
  54         case COMP_COMMAND_RING_STOPPED:
  55                 return "Command Ring Stopped";
  56         case COMP_COMMAND_ABORTED:
  57                 return "Command Aborted";
  58         case COMP_STOPPED:
  59                 return "Stopped";
  60         case COMP_STOPPED_LENGTH_INVALID:
  61                 return "Stopped - Length Invalid";
  62         case COMP_STOPPED_SHORT_PACKET:
  63                 return "Stopped - Short Packet";
  64         case COMP_MAX_EXIT_LATENCY_TOO_LARGE_ERROR:
  65                 return "Max Exit Latency Too Large Error";
  66         case COMP_ISOCH_BUFFER_OVERRUN:
  67                 return "Isoch Buffer Overrun";
  68         case COMP_EVENT_LOST_ERROR:
  69                 return "Event Lost Error";
  70         case COMP_UNDEFINED_ERROR:
  71                 return "Undefined Error";
  72         case COMP_INVALID_STREAM_ID_ERROR:
  73                 return "Invalid Stream ID Error";
  74         default:
  75                 return "Unknown!!";
  76         }
  77 }
  78
  79 static inline const char *cdnsp_trb_type_string(u8 type)
  80 {
  81         switch (type) {
  82         case TRB_NORMAL:
  83                 return "Normal";
  84         case TRB_SETUP:
  85                 return "Setup Stage";
  86         case TRB_DATA:
  87                 return "Data Stage";
  88         case TRB_STATUS:
  89                 return "Status Stage";
  90         case TRB_ISOC:
  91                 return "Isoch";
  92         case TRB_LINK:
  93                 return "Link";
  94         case TRB_EVENT_DATA:
  95                 return "Event Data";
  96         case TRB_TR_NOOP:
  97                 return "No-Op";
  98         case TRB_ENABLE_SLOT:
  99                 return "Enable Slot Command";
 100         case TRB_DISABLE_SLOT:
 101                 return "Disable Slot Command";
 102         case TRB_ADDR_DEV:
 103                 return "Address Device Command";
 104         case TRB_CONFIG_EP:
 105                 return "Configure Endpoint Command";
 106         case TRB_EVAL_CONTEXT:
 107                 return "Evaluate Context Command";
 108         case TRB_RESET_EP:
 109                 return "Reset Endpoint Command";
 110         case TRB_STOP_RING:
 111                 return "Stop Ring Command";
 112         case TRB_SET_DEQ:
 113                 return "Set TR Dequeue Pointer Command";
 114         case TRB_RESET_DEV:
 115                 return "Reset Device Command";
 116         case TRB_FORCE_HEADER:
 117                 return "Force Header Command";
 118         case TRB_CMD_NOOP:
 119                 return "No-Op Command";
 120         case TRB_TRANSFER:
 121                 return "Transfer Event";
 122         case TRB_COMPLETION:
 123                 return "Command Completion Event";
 124         case TRB_PORT_STATUS:
 125                 return "Port Status Change Event";
 126         case TRB_HC_EVENT:
 127                 return "Device Controller Event";
 128         case TRB_MFINDEX_WRAP:
 129                 return "MFINDEX Wrap Event";
 130         case TRB_ENDPOINT_NRDY:
 131                 return "Endpoint Not ready";
 132         case TRB_HALT_ENDPOINT:
 133                 return "Halt Endpoint";
 134         default:
 135                 return "UNKNOWN";
 136         }
 137 }
 138
 139 static inline const char *cdnsp_ring_type_string(enum cdnsp_ring_type type)
 140 {
 141         switch (type) {
 142         case TYPE_CTRL:
 143                 return "CTRL";
 144         case TYPE_ISOC:
 145                 return "ISOC";
 146         case TYPE_BULK:
 147                 return "BULK";
 148         case TYPE_INTR:
 149                 return "INTR";
 150         case TYPE_STREAM:
 151                 return "STREAM";
 152         case TYPE_COMMAND:
 153                 return "CMD";
 154         case TYPE_EVENT:
 155                 return "EVENT";
 156         }
 157
 158         return "UNKNOWN";
 159 }
 160
 161 static inline char *cdnsp_slot_state_string(u32 state)
 162 {
 163         switch (state) {
 164         case SLOT_STATE_ENABLED:
 165                 return "enabled/disabled";
 166         case SLOT_STATE_DEFAULT:
 167                 return "default";
 168         case SLOT_STATE_ADDRESSED:
 169                 return "addressed";
 170         case SLOT_STATE_CONFIGURED:
 171                 return "configured";
 172         default:
 173                 return "reserved";
 174         }
 175 }
 176
 177 static inline const char *cdnsp_decode_trb(char *str, size_t size, u32 field0,
 178                                            u32 field1, u32 field2, u32 field3)
 179 {
 180         int ep_id = TRB_TO_EP_INDEX(field3) - 1;
 181         int type = TRB_FIELD_TO_TYPE(field3);
 182         unsigned int ep_num;
 183         int ret;
 184         u32 temp;
 185
 186         ep_num = DIV_ROUND_UP(ep_id, 2);
 187
 188         switch (type) {
 189         case TRB_LINK:
 190                 ret = snprintf(str, size,
 191                                "LINK %08x%08x intr %ld type '%s' flags %c:%c:%c:%c",
 192                                field1, field0, GET_INTR_TARGET(field2),
 193                                cdnsp_trb_type_string(type),
 194                                field3 & TRB_IOC ? 'I' : 'i',
 195                                field3 & TRB_CHAIN ? 'C' : 'c',
 196                                field3 & TRB_TC ? 'T' : 't',
 197                                field3 & TRB_CYCLE ? 'C' : 'c');
 198                 break;
 199         case TRB_TRANSFER:
 200         case TRB_COMPLETION:
 201         case TRB_PORT_STATUS:
 202         case TRB_HC_EVENT:
 203                 ret = snprintf(str, size,
 204                                "ep%d%s(%d) type '%s' TRB %08x%08x status '%s'"
 205                                " len %ld slot %ld flags %c:%c",
 206                                ep_num, ep_id % 2 ? "out" : "in",
 207                                TRB_TO_EP_INDEX(field3),
 208                                cdnsp_trb_type_string(type), field1, field0,
 209                                cdnsp_trb_comp_code_string(GET_COMP_CODE(field2)),
 210                                EVENT_TRB_LEN(field2), TRB_TO_SLOT_ID(field3),
 211                                field3 & EVENT_DATA ? 'E' : 'e',
 212                                field3 & TRB_CYCLE ? 'C' : 'c');
 213                 break;
 214         case TRB_MFINDEX_WRAP:
 215                 ret = snprintf(str, size, "%s: flags %c",
 216                                cdnsp_trb_type_string(type),
 217                                field3 & TRB_CYCLE ? 'C' : 'c');
 218                 break;
 219         case TRB_SETUP:
 220                 ret = snprintf(str, size,
 221                                "type '%s' bRequestType %02x bRequest %02x "
 222                                "wValue %02x%02x wIndex %02x%02x wLength %d "
 223                                "length %ld TD size %ld intr %ld Setup ID %ld "
 224                                "flags %c:%c:%c",
 225                                cdnsp_trb_type_string(type),
 226                                field0 & 0xff,
 227                                (field0 & 0xff00) >> 8,
 228                                (field0 & 0xff000000) >> 24,
 229                                (field0 & 0xff0000) >> 16,
 230                                (field1 & 0xff00) >> 8,
 231                                field1 & 0xff,
 232                                (field1 & 0xff000000) >> 16 |
 233                                (field1 & 0xff0000) >> 16,
 234                                TRB_LEN(field2), GET_TD_SIZE(field2),
 235                                GET_INTR_TARGET(field2),
 236                                TRB_SETUPID_TO_TYPE(field3),
 237                                field3 & TRB_IDT ? 'D' : 'd',
 238                                field3 & TRB_IOC ? 'I' : 'i',
 239                                field3 & TRB_CYCLE ? 'C' : 'c');
 240                 break;
 241         case TRB_DATA:
 242                 ret = snprintf(str, size,
 243                                "type '%s' Buffer %08x%08x length %ld TD size %ld "
 244                                "intr %ld flags %c:%c:%c:%c:%c:%c:%c",
 245                                cdnsp_trb_type_string(type),
 246                                field1, field0, TRB_LEN(field2),
 247                                GET_TD_SIZE(field2),
 248                                GET_INTR_TARGET(field2),
 249                                field3 & TRB_IDT ? 'D' : 'i',
 250                                field3 & TRB_IOC ? 'I' : 'i',
 251                                field3 & TRB_CHAIN ? 'C' : 'c',
 252                                field3 & TRB_NO_SNOOP ? 'S' : 's',
 253                                field3 & TRB_ISP ? 'I' : 'i',
 254                                field3 & TRB_ENT ? 'E' : 'e',
 255                                field3 & TRB_CYCLE ? 'C' : 'c');
 256                 break;
 257         case TRB_STATUS:
 258                 ret = snprintf(str, size,
 259                                "Buffer %08x%08x length %ld TD size %ld intr"
 260                                "%ld type '%s' flags %c:%c:%c:%c",
 261                                field1, field0, TRB_LEN(field2),
 262                                GET_TD_SIZE(field2),
 263                                GET_INTR_TARGET(field2),
 264                                cdnsp_trb_type_string(type),
 265                                field3 & TRB_IOC ? 'I' : 'i',
 266                                field3 & TRB_CHAIN ? 'C' : 'c',
 267                                field3 & TRB_ENT ? 'E' : 'e',
 268                                field3 & TRB_CYCLE ? 'C' : 'c');
 269                 break;
 270         case TRB_NORMAL:
 271         case TRB_ISOC:
 272         case TRB_EVENT_DATA:
 273         case TRB_TR_NOOP:
 274                 ret = snprintf(str, size,
 275                                "type '%s' Buffer %08x%08x length %ld "
 276                                "TD size %ld intr %ld "
 277                                "flags %c:%c:%c:%c:%c:%c:%c:%c:%c",
 278                                cdnsp_trb_type_string(type),
 279                                field1, field0, TRB_LEN(field2),
 280                                GET_TD_SIZE(field2),
 281                                GET_INTR_TARGET(field2),
 282                                field3 & TRB_BEI ? 'B' : 'b',
 283                                field3 & TRB_IDT ? 'T' : 't',
 284                                field3 & TRB_IOC ? 'I' : 'i',
 285                                field3 & TRB_CHAIN ? 'C' : 'c',
 286                                field3 & TRB_NO_SNOOP ? 'S' : 's',
 287                                field3 & TRB_ISP ? 'I' : 'i',
 288                                field3 & TRB_ENT ? 'E' : 'e',
 289                                field3 & TRB_CYCLE ? 'C' : 'c',
 290                                !(field3 & TRB_EVENT_INVALIDATE) ? 'V' : 'v');
 291                 break;
 292         case TRB_CMD_NOOP:
 293         case TRB_ENABLE_SLOT:
 294                 ret = snprintf(str, size, "%s: flags %c",
 295                                cdnsp_trb_type_string(type),
 296                                field3 & TRB_CYCLE ? 'C' : 'c');
 297                 break;
 298         case TRB_DISABLE_SLOT:
 299                 ret = snprintf(str, size, "%s: slot %ld flags %c",
 300                                cdnsp_trb_type_string(type),
 301                                TRB_TO_SLOT_ID(field3),
 302                                field3 & TRB_CYCLE ? 'C' : 'c');
 303                 break;
 304         case TRB_ADDR_DEV:
 305                 ret = snprintf(str, size,
 306                                "%s: ctx %08x%08x slot %ld flags %c:%c",
 307                                cdnsp_trb_type_string(type), field1, field0,
 308                                TRB_TO_SLOT_ID(field3),
 309                                field3 & TRB_BSR ? 'B' : 'b',
 310                                field3 & TRB_CYCLE ? 'C' : 'c');
 311                 break;
 312         case TRB_CONFIG_EP:
 313                 ret = snprintf(str, size,
 314                                "%s: ctx %08x%08x slot %ld flags %c:%c",
 315                                cdnsp_trb_type_string(type), field1, field0,
 316                                TRB_TO_SLOT_ID(field3),
 317                                field3 & TRB_DC ? 'D' : 'd',
 318                                field3 & TRB_CYCLE ? 'C' : 'c');
 319                 break;
 320         case TRB_EVAL_CONTEXT:
 321                 ret = snprintf(str, size,
 322                                "%s: ctx %08x%08x slot %ld flags %c",
 323                                cdnsp_trb_type_string(type), field1, field0,
 324                                TRB_TO_SLOT_ID(field3),
 325                                field3 & TRB_CYCLE ? 'C' : 'c');
 326                 break;
 327         case TRB_RESET_EP:
 328         case TRB_HALT_ENDPOINT:
 329                 ret = snprintf(str, size,
 330                                "%s: ep%d%s(%d) ctx %08x%08x slot %ld flags %c",
 331                                cdnsp_trb_type_string(type),
 332                                ep_num, ep_id % 2 ? "out" : "in",
 333                                TRB_TO_EP_INDEX(field3), field1, field0,
 334                                TRB_TO_SLOT_ID(field3),
 335                                field3 & TRB_CYCLE ? 'C' : 'c');
 336                 break;
 337         case TRB_STOP_RING:
 338                 ret = snprintf(str, size,
 339                                "%s: ep%d%s(%d) slot %ld sp %d flags %c",
 340                                cdnsp_trb_type_string(type),
 341                                ep_num, ep_id % 2 ? "out" : "in",
 342                                TRB_TO_EP_INDEX(field3),
 343                                TRB_TO_SLOT_ID(field3),
 344                                TRB_TO_SUSPEND_PORT(field3),
 345                                field3 & TRB_CYCLE ? 'C' : 'c');
 346                 break;
 347         case TRB_SET_DEQ:
 348                 ret = snprintf(str, size,
 349                                "%s: ep%d%s(%d) deq %08x%08x stream %ld slot %ld  flags %c",
 350                                cdnsp_trb_type_string(type),
 351                                ep_num, ep_id % 2 ? "out" : "in",
 352                                TRB_TO_EP_INDEX(field3), field1, field0,
 353                                TRB_TO_STREAM_ID(field2),
 354                                TRB_TO_SLOT_ID(field3),
 355                                field3 & TRB_CYCLE ? 'C' : 'c');
 356                 break;
 357         case TRB_RESET_DEV:
 358                 ret = snprintf(str, size, "%s: slot %ld flags %c",
 359                                cdnsp_trb_type_string(type),
 360                                TRB_TO_SLOT_ID(field3),
 361                                field3 & TRB_CYCLE ? 'C' : 'c');
 362                 break;
 363         case TRB_ENDPOINT_NRDY:
 364                 temp = TRB_TO_HOST_STREAM(field2);
 365
 366                 ret = snprintf(str, size,
 367                                "%s: ep%d%s(%d) H_SID %x%s%s D_SID %lx flags %c:%c",
 368                                cdnsp_trb_type_string(type),
 369                                ep_num, ep_id % 2 ? "out" : "in",
 370                                TRB_TO_EP_INDEX(field3), temp,
 371                                temp == STREAM_PRIME_ACK ? "(PRIME)" : "",
 372                                temp == STREAM_REJECTED ? "(REJECTED)" : "",
 373                                TRB_TO_DEV_STREAM(field0),
 374                                field3 & TRB_STAT ? 'S' : 's',
 375                                field3 & TRB_CYCLE ? 'C' : 'c');
 376                 break;
 377         default:
 378                 ret = snprintf(str, size,
 379                                "type '%s' -> raw %08x %08x %08x %08x",
 380                                cdnsp_trb_type_string(type),
 381                                field0, field1, field2, field3);
 382         }
 383
 384         if (ret >= size)
 385                 pr_info("CDNSP: buffer overflowed.\n");
 386
 387         return str;
 388 }
 389
 390 static inline const char *cdnsp_decode_slot_context(u32 info, u32 info2,
 391                                                     u32 int_target, u32 state)
 392 {
 393         static char str[1024];
 394         int ret = 0;
 395         u32 speed;
 396         char *s;
 397
 398         speed = info & DEV_SPEED;
 399
 400         switch (speed) {
 401         case SLOT_SPEED_FS:
 402                 s = "full-speed";
 403                 break;
 404         case SLOT_SPEED_HS:
 405                 s = "high-speed";
 406                 break;
 407         case SLOT_SPEED_SS:
 408                 s = "super-speed";
 409                 break;
 410         case SLOT_SPEED_SSP:
 411                 s = "super-speed plus";
 412                 break;
 413         default:
 414                 s = "UNKNOWN speed";
 415         }
 416
 417         ret = sprintf(str, "%s Ctx Entries %d",
 418                       s, (info & LAST_CTX_MASK) >> 27);
 419
 420         ret += sprintf(str + ret, " [Intr %ld] Addr %ld State %s",
 421                        GET_INTR_TARGET(int_target), state & DEV_ADDR_MASK,
 422                        cdnsp_slot_state_string(GET_SLOT_STATE(state)));
 423
 424         return str;
 425 }
 426
 427 static inline const char *cdnsp_portsc_link_state_string(u32 portsc)
 428 {
 429         switch (portsc & PORT_PLS_MASK) {
 430         case XDEV_U0:
 431                 return "U0";
 432         case XDEV_U1:
 433                 return "U1";
 434         case XDEV_U2:
 435                 return "U2";
 436         case XDEV_U3:
 437                 return "U3";
 438         case XDEV_DISABLED:
 439                 return "Disabled";
 440         case XDEV_RXDETECT:
 441                 return "RxDetect";
 442         case XDEV_INACTIVE:
 443                 return "Inactive";
 444         case XDEV_POLLING:
 445                 return "Polling";
 446         case XDEV_RECOVERY:
 447                 return "Recovery";
 448         case XDEV_HOT_RESET:
 449                 return "Hot Reset";
 450         case XDEV_COMP_MODE:
 451                 return "Compliance mode";
 452         case XDEV_TEST_MODE:
 453                 return "Test mode";
 454         case XDEV_RESUME:
 455                 return "Resume";
 456         default:
 457                 break;
 458         }
 459
 460         return "Unknown";
 461 }
 462
 463 static inline const char *cdnsp_decode_portsc(char *str, size_t size,
 464                                               u32 portsc)
 465 {
 466         int ret;
 467
 468         ret = snprintf(str, size, "%s %s %s Link:%s PortSpeed:%d ",
 469                        portsc & PORT_POWER ? "Powered" : "Powered-off",
 470                        portsc & PORT_CONNECT ? "Connected" : "Not-connected",
 471                        portsc & PORT_PED ? "Enabled" : "Disabled",
 472                        cdnsp_portsc_link_state_string(portsc),
 473                        DEV_PORT_SPEED(portsc));
 474
 475         if (portsc & PORT_RESET)
 476                 ret += snprintf(str + ret, size - ret, "In-Reset ");
 477
 478         ret += snprintf(str + ret, size - ret, "Change: ");
 479         if (portsc & PORT_CSC)
 480                 ret += snprintf(str + ret, size - ret, "CSC ");
 481         if (portsc & PORT_WRC)
 482                 ret += snprintf(str + ret, size - ret, "WRC ");
 483         if (portsc & PORT_RC)
 484                 ret += snprintf(str + ret, size - ret, "PRC ");
 485         if (portsc & PORT_PLC)
 486                 ret += snprintf(str + ret, size - ret, "PLC ");
 487         if (portsc & PORT_CEC)
 488                 ret += snprintf(str + ret, size - ret, "CEC ");
 489         ret += snprintf(str + ret, size - ret, "Wake: ");
 490         if (portsc & PORT_WKCONN_E)
 491                 ret += snprintf(str + ret, size - ret, "WCE ");
 492         if (portsc & PORT_WKDISC_E)
 493                 ret += snprintf(str + ret, size - ret, "WDE ");
 494
 495         return str;
 496 }
 497
 498 static inline const char *cdnsp_ep_state_string(u8 state)
 499 {
 500         switch (state) {
 501         case EP_STATE_DISABLED:
 502                 return "disabled";
 503         case EP_STATE_RUNNING:
 504                 return "running";
 505         case EP_STATE_HALTED:
 506                 return "halted";
 507         case EP_STATE_STOPPED:
 508                 return "stopped";
 509         case EP_STATE_ERROR:
 510                 return "error";
 511         default:
 512                 return "INVALID";
 513         }
 514 }
 515
 516 static inline const char *cdnsp_ep_type_string(u8 type)
 517 {
 518         switch (type) {
 519         case ISOC_OUT_EP:
 520                 return "Isoc OUT";
 521         case BULK_OUT_EP:
 522                 return "Bulk OUT";
 523         case INT_OUT_EP:
 524                 return "Int OUT";
 525         case CTRL_EP:
 526                 return "Ctrl";
 527         case ISOC_IN_EP:
 528                 return "Isoc IN";
 529         case BULK_IN_EP:
 530                 return "Bulk IN";
 531         case INT_IN_EP:
 532                 return "Int IN";
 533         default:
 534                 return "INVALID";
 535         }
 536 }
 537
 538 static inline const char *cdnsp_decode_ep_context(char *str, size_t size,
 539                                                   u32 info, u32 info2,
 540                                                   u64 deq, u32 tx_info)
 541 {
 542         u8 max_pstr, ep_state, interval, ep_type, burst, cerr, mult;
 543         bool lsa, hid;
 544         u16 maxp, avg;
 545         u32 esit;
 546         int ret;
 547
 548         esit = CTX_TO_MAX_ESIT_PAYLOAD_HI(info) << 16 |
 549                CTX_TO_MAX_ESIT_PAYLOAD_LO(tx_info);
 550
 551         ep_state = info & EP_STATE_MASK;
 552         max_pstr = CTX_TO_EP_MAXPSTREAMS(info);
 553         interval = CTX_TO_EP_INTERVAL(info);
 554         mult = CTX_TO_EP_MULT(info) + 1;
 555         lsa = !!(info & EP_HAS_LSA);
 556
 557         cerr = (info2 & (3 << 1)) >> 1;
 558         ep_type = CTX_TO_EP_TYPE(info2);
 559         hid = !!(info2 & (1 << 7));
 560         burst = CTX_TO_MAX_BURST(info2);
 561         maxp = MAX_PACKET_DECODED(info2);
 562
 563         avg = EP_AVG_TRB_LENGTH(tx_info);
 564
 565         ret = snprintf(str, size, "State %s mult %d max P. Streams %d %s",
 566                        cdnsp_ep_state_string(ep_state), mult,
 567                        max_pstr, lsa ? "LSA " : "");
 568
 569         ret += snprintf(str + ret, size - ret,
 570                         "interval %d us max ESIT payload %d CErr %d ",
 571                         (1 << interval) * 125, esit, cerr);
 572
 573         ret += snprintf(str + ret, size - ret,
 574                         "Type %s %sburst %d maxp %d deq %016llx ",
 575                         cdnsp_ep_type_string(ep_type), hid ? "HID" : "",
 576                         burst, maxp, deq);
 577
 578         ret += snprintf(str + ret, size - ret, "avg trb len %d", avg);
 579
 580         return str;
 581 }
 582
 583 #endif /*__LINUX_CDNSP_DEBUG*/