projects/linux·blob master · refs

584 lines · 15.0 KiB

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
13static 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
79static 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
139static 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
161static 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
177static 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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(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 = scnprintf(str, size,
330 "%s: ep%d%s(%d) ctx %08x%08x slot %ld flags %c %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 field3 & TRB_ESP ? 'P' : 'p');
337 break;
338 case TRB_STOP_RING:
339 ret = scnprintf(str, size,
340 "%s: ep%d%s(%d) slot %ld sp %d flags %c",
341 cdnsp_trb_type_string(type),
342 ep_num, ep_id % 2 ? "out" : "in",
343 TRB_TO_EP_INDEX(field3),
344 TRB_TO_SLOT_ID(field3),
345 TRB_TO_SUSPEND_PORT(field3),
346 field3 & TRB_CYCLE ? 'C' : 'c');
347 break;
348 case TRB_SET_DEQ:
349 ret = scnprintf(str, size,
350 "%s: ep%d%s(%d) deq %08x%08x stream %ld slot %ld flags %c",
351 cdnsp_trb_type_string(type),
352 ep_num, ep_id % 2 ? "out" : "in",
353 TRB_TO_EP_INDEX(field3), field1, field0,
354 TRB_TO_STREAM_ID(field2),
355 TRB_TO_SLOT_ID(field3),
356 field3 & TRB_CYCLE ? 'C' : 'c');
357 break;
358 case TRB_RESET_DEV:
359 ret = scnprintf(str, size, "%s: slot %ld flags %c",
360 cdnsp_trb_type_string(type),
361 TRB_TO_SLOT_ID(field3),
362 field3 & TRB_CYCLE ? 'C' : 'c');
363 break;
364 case TRB_ENDPOINT_NRDY:
365 temp = TRB_TO_HOST_STREAM(field2);
366
367 ret = scnprintf(str, size,
368 "%s: ep%d%s(%d) H_SID %x%s%s D_SID %lx flags %c:%c",
369 cdnsp_trb_type_string(type),
370 ep_num, ep_id % 2 ? "out" : "in",
371 TRB_TO_EP_INDEX(field3), temp,
372 temp == STREAM_PRIME_ACK ? "(PRIME)" : "",
373 temp == STREAM_REJECTED ? "(REJECTED)" : "",
374 TRB_TO_DEV_STREAM(field0),
375 field3 & TRB_STAT ? 'S' : 's',
376 field3 & TRB_CYCLE ? 'C' : 'c');
377 break;
378 default:
379 ret = scnprintf(str, size,
380 "type '%s' -> raw %08x %08x %08x %08x",
381 cdnsp_trb_type_string(type),
382 field0, field1, field2, field3);
383 }
384
385 if (ret == size - 1)
386 pr_info("CDNSP: buffer may be truncated.\n");
387
388 return str;
389}
390
391static inline const char *cdnsp_decode_slot_context(u32 info, u32 info2,
392 u32 int_target, u32 state)
393{
394 static char str[1024];
395 int ret = 0;
396 u32 speed;
397 char *s;
398
399 speed = info & DEV_SPEED;
400
401 switch (speed) {
402 case SLOT_SPEED_FS:
403 s = "full-speed";
404 break;
405 case SLOT_SPEED_HS:
406 s = "high-speed";
407 break;
408 case SLOT_SPEED_SS:
409 s = "super-speed";
410 break;
411 case SLOT_SPEED_SSP:
412 s = "super-speed plus";
413 break;
414 default:
415 s = "UNKNOWN speed";
416 }
417
418 ret = sprintf(str, "%s Ctx Entries %d",
419 s, (info & LAST_CTX_MASK) >> 27);
420
421 ret += sprintf(str + ret, " [Intr %ld] Addr %ld State %s",
422 GET_INTR_TARGET(int_target), state & DEV_ADDR_MASK,
423 cdnsp_slot_state_string(GET_SLOT_STATE(state)));
424
425 return str;
426}
427
428static inline const char *cdnsp_portsc_link_state_string(u32 portsc)
429{
430 switch (portsc & PORT_PLS_MASK) {
431 case XDEV_U0:
432 return "U0";
433 case XDEV_U1:
434 return "U1";
435 case XDEV_U2:
436 return "U2";
437 case XDEV_U3:
438 return "U3";
439 case XDEV_DISABLED:
440 return "Disabled";
441 case XDEV_RXDETECT:
442 return "RxDetect";
443 case XDEV_INACTIVE:
444 return "Inactive";
445 case XDEV_POLLING:
446 return "Polling";
447 case XDEV_RECOVERY:
448 return "Recovery";
449 case XDEV_HOT_RESET:
450 return "Hot Reset";
451 case XDEV_COMP_MODE:
452 return "Compliance mode";
453 case XDEV_TEST_MODE:
454 return "Test mode";
455 case XDEV_RESUME:
456 return "Resume";
457 default:
458 break;
459 }
460
461 return "Unknown";
462}
463
464static inline const char *cdnsp_decode_portsc(char *str, size_t size,
465 u32 portsc)
466{
467 int ret;
468
469 ret = scnprintf(str, size, "%s %s %s Link:%s PortSpeed:%d ",
470 portsc & PORT_POWER ? "Powered" : "Powered-off",
471 portsc & PORT_CONNECT ? "Connected" : "Not-connected",
472 portsc & PORT_PED ? "Enabled" : "Disabled",
473 cdnsp_portsc_link_state_string(portsc),
474 DEV_PORT_SPEED(portsc));
475
476 if (portsc & PORT_RESET)
477 ret += scnprintf(str + ret, size - ret, "In-Reset ");
478
479 ret += scnprintf(str + ret, size - ret, "Change: ");
480 if (portsc & PORT_CSC)
481 ret += scnprintf(str + ret, size - ret, "CSC ");
482 if (portsc & PORT_WRC)
483 ret += scnprintf(str + ret, size - ret, "WRC ");
484 if (portsc & PORT_RC)
485 ret += scnprintf(str + ret, size - ret, "PRC ");
486 if (portsc & PORT_PLC)
487 ret += scnprintf(str + ret, size - ret, "PLC ");
488 if (portsc & PORT_CEC)
489 ret += scnprintf(str + ret, size - ret, "CEC ");
490 ret += scnprintf(str + ret, size - ret, "Wake: ");
491 if (portsc & PORT_WKCONN_E)
492 ret += scnprintf(str + ret, size - ret, "WCE ");
493 if (portsc & PORT_WKDISC_E)
494 ret += scnprintf(str + ret, size - ret, "WDE ");
495
496 return str;
497}
498
499static inline const char *cdnsp_ep_state_string(u8 state)
500{
501 switch (state) {
502 case EP_STATE_DISABLED:
503 return "disabled";
504 case EP_STATE_RUNNING:
505 return "running";
506 case EP_STATE_HALTED:
507 return "halted";
508 case EP_STATE_STOPPED:
509 return "stopped";
510 case EP_STATE_ERROR:
511 return "error";
512 default:
513 return "INVALID";
514 }
515}
516
517static inline const char *cdnsp_ep_type_string(u8 type)
518{
519 switch (type) {
520 case ISOC_OUT_EP:
521 return "Isoc OUT";
522 case BULK_OUT_EP:
523 return "Bulk OUT";
524 case INT_OUT_EP:
525 return "Int OUT";
526 case CTRL_EP:
527 return "Ctrl";
528 case ISOC_IN_EP:
529 return "Isoc IN";
530 case BULK_IN_EP:
531 return "Bulk IN";
532 case INT_IN_EP:
533 return "Int IN";
534 default:
535 return "INVALID";
536 }
537}
538
539static inline const char *cdnsp_decode_ep_context(char *str, size_t size,
540 u32 info, u32 info2,
541 u64 deq, u32 tx_info)
542{
543 u8 max_pstr, ep_state, interval, ep_type, burst, cerr, mult;
544 bool lsa, hid;
545 u16 maxp, avg;
546 u32 esit;
547 int ret;
548
549 esit = CTX_TO_MAX_ESIT_PAYLOAD_HI(info) << 16 |
550 CTX_TO_MAX_ESIT_PAYLOAD_LO(tx_info);
551
552 ep_state = info & EP_STATE_MASK;
553 max_pstr = CTX_TO_EP_MAXPSTREAMS(info);
554 interval = CTX_TO_EP_INTERVAL(info);
555 mult = CTX_TO_EP_MULT(info) + 1;
556 lsa = !!(info & EP_HAS_LSA);
557
558 cerr = (info2 & (3 << 1)) >> 1;
559 ep_type = CTX_TO_EP_TYPE(info2);
560 hid = !!(info2 & (1 << 7));
561 burst = CTX_TO_MAX_BURST(info2);
562 maxp = MAX_PACKET_DECODED(info2);
563
564 avg = EP_AVG_TRB_LENGTH(tx_info);
565
566 ret = scnprintf(str, size, "State %s mult %d max P. Streams %d %s",
567 cdnsp_ep_state_string(ep_state), mult,
568 max_pstr, lsa ? "LSA " : "");
569
570 ret += scnprintf(str + ret, size - ret,
571 "interval %d us max ESIT payload %d CErr %d ",
572 (1 << interval) * 125, esit, cerr);
573
574 ret += scnprintf(str + ret, size - ret,
575 "Type %s %sburst %d maxp %d deq %016llx ",
576 cdnsp_ep_type_string(ep_type), hid ? "HID" : "",
577 burst, maxp, deq);
578
579 ret += scnprintf(str + ret, size - ret, "avg trb len %d", avg);
580
581 return str;
582}
583
584#endif /*__LINUX_CDNSP_DEBUG*/