1
2
3
4
5
6
7
8
9
10#include <linux/debugfs.h>
11#include <linux/pm_runtime.h>
12#include <linux/uaccess.h>
13
14#include "tb.h"
15
16#define PORT_CAP_PCIE_LEN 1
17#define PORT_CAP_POWER_LEN 2
18#define PORT_CAP_LANE_LEN 3
19#define PORT_CAP_USB3_LEN 5
20#define PORT_CAP_DP_LEN 8
21#define PORT_CAP_TMU_LEN 8
22#define PORT_CAP_BASIC_LEN 9
23#define PORT_CAP_USB4_LEN 20
24
25#define SWITCH_CAP_TMU_LEN 26
26#define SWITCH_CAP_BASIC_LEN 27
27
28#define PATH_LEN 2
29
30#define COUNTER_SET_LEN 3
31
32#define DEBUGFS_ATTR(__space, __write) \
33static int __space ## _open(struct inode *inode, struct file *file) \
34{ \
35 return single_open(file, __space ## _show, inode->i_private); \
36} \
37 \
38static const struct file_operations __space ## _fops = { \
39 .owner = THIS_MODULE, \
40 .open = __space ## _open, \
41 .release = single_release, \
42 .read = seq_read, \
43 .write = __write, \
44 .llseek = seq_lseek, \
45}
46
47#define DEBUGFS_ATTR_RO(__space) \
48 DEBUGFS_ATTR(__space, NULL)
49
50#define DEBUGFS_ATTR_RW(__space) \
51 DEBUGFS_ATTR(__space, __space ## _write)
52
53static struct dentry *tb_debugfs_root;
54
55static void *validate_and_copy_from_user(const void __user *user_buf,
56 size_t *count)
57{
58 size_t nbytes;
59 void *buf;
60
61 if (!*count)
62 return ERR_PTR(-EINVAL);
63
64 if (!access_ok(user_buf, *count))
65 return ERR_PTR(-EFAULT);
66
67 buf = (void *)get_zeroed_page(GFP_KERNEL);
68 if (!buf)
69 return ERR_PTR(-ENOMEM);
70
71 nbytes = min_t(size_t, *count, PAGE_SIZE);
72 if (copy_from_user(buf, user_buf, nbytes)) {
73 free_page((unsigned long)buf);
74 return ERR_PTR(-EFAULT);
75 }
76
77 *count = nbytes;
78 return buf;
79}
80
81static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len,
82 int long_fmt_len)
83{
84 char *token;
85 u32 v[5];
86 int ret;
87
88 token = strsep(line, "\n");
89 if (!token)
90 return false;
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107 ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]);
108
109 if (ret == short_fmt_len) {
110 *offs = v[0];
111 *val = v[short_fmt_len - 1];
112 return true;
113 } else if (ret == long_fmt_len) {
114 *offs = v[0];
115 *val = v[long_fmt_len - 1];
116 return true;
117 }
118
119 return false;
120}
121
122#if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)
123static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port,
124 const char __user *user_buf, size_t count,
125 loff_t *ppos)
126{
127 struct tb *tb = sw->tb;
128 char *line, *buf;
129 u32 val, offset;
130 int ret = 0;
131
132 buf = validate_and_copy_from_user(user_buf, &count);
133 if (IS_ERR(buf))
134 return PTR_ERR(buf);
135
136 pm_runtime_get_sync(&sw->dev);
137
138 if (mutex_lock_interruptible(&tb->lock)) {
139 ret = -ERESTARTSYS;
140 goto out;
141 }
142
143
144 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
145
146 line = buf;
147 while (parse_line(&line, &offset, &val, 2, 5)) {
148 if (port)
149 ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1);
150 else
151 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1);
152 if (ret)
153 break;
154 }
155
156 mutex_unlock(&tb->lock);
157
158out:
159 pm_runtime_mark_last_busy(&sw->dev);
160 pm_runtime_put_autosuspend(&sw->dev);
161 free_page((unsigned long)buf);
162
163 return ret < 0 ? ret : count;
164}
165
166static ssize_t port_regs_write(struct file *file, const char __user *user_buf,
167 size_t count, loff_t *ppos)
168{
169 struct seq_file *s = file->private_data;
170 struct tb_port *port = s->private;
171
172 return regs_write(port->sw, port, user_buf, count, ppos);
173}
174
175static ssize_t switch_regs_write(struct file *file, const char __user *user_buf,
176 size_t count, loff_t *ppos)
177{
178 struct seq_file *s = file->private_data;
179 struct tb_switch *sw = s->private;
180
181 return regs_write(sw, NULL, user_buf, count, ppos);
182}
183#define DEBUGFS_MODE 0600
184#else
185#define port_regs_write NULL
186#define switch_regs_write NULL
187#define DEBUGFS_MODE 0400
188#endif
189
190static int port_clear_all_counters(struct tb_port *port)
191{
192 u32 *buf;
193 int ret;
194
195 buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32),
196 GFP_KERNEL);
197 if (!buf)
198 return -ENOMEM;
199
200 ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0,
201 COUNTER_SET_LEN * port->config.max_counters);
202 kfree(buf);
203
204 return ret;
205}
206
207static ssize_t counters_write(struct file *file, const char __user *user_buf,
208 size_t count, loff_t *ppos)
209{
210 struct seq_file *s = file->private_data;
211 struct tb_port *port = s->private;
212 struct tb_switch *sw = port->sw;
213 struct tb *tb = port->sw->tb;
214 char *buf;
215 int ret;
216
217 buf = validate_and_copy_from_user(user_buf, &count);
218 if (IS_ERR(buf))
219 return PTR_ERR(buf);
220
221 pm_runtime_get_sync(&sw->dev);
222
223 if (mutex_lock_interruptible(&tb->lock)) {
224 ret = -ERESTARTSYS;
225 goto out;
226 }
227
228
229 if (buf[0] == '\n') {
230 ret = port_clear_all_counters(port);
231 } else {
232 char *line = buf;
233 u32 val, offset;
234
235 ret = -EINVAL;
236 while (parse_line(&line, &offset, &val, 1, 4)) {
237 ret = tb_port_write(port, &val, TB_CFG_COUNTERS,
238 offset, 1);
239 if (ret)
240 break;
241 }
242 }
243
244 mutex_unlock(&tb->lock);
245
246out:
247 pm_runtime_mark_last_busy(&sw->dev);
248 pm_runtime_put_autosuspend(&sw->dev);
249 free_page((unsigned long)buf);
250
251 return ret < 0 ? ret : count;
252}
253
254static void cap_show(struct seq_file *s, struct tb_switch *sw,
255 struct tb_port *port, unsigned int cap, u8 cap_id,
256 u8 vsec_id, int length)
257{
258 int ret, offset = 0;
259
260 while (length > 0) {
261 int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH);
262 u32 data[TB_MAX_CONFIG_RW_LENGTH];
263
264 if (port)
265 ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset,
266 dwords);
267 else
268 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords);
269 if (ret) {
270 seq_printf(s, "0x%04x <not accessible>\n",
271 cap + offset);
272 if (dwords > 1)
273 seq_printf(s, "0x%04x ...\n", cap + offset + 1);
274 return;
275 }
276
277 for (i = 0; i < dwords; i++) {
278 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n",
279 cap + offset + i, offset + i,
280 cap_id, vsec_id, data[i]);
281 }
282
283 length -= dwords;
284 offset += dwords;
285 }
286}
287
288static void port_cap_show(struct tb_port *port, struct seq_file *s,
289 unsigned int cap)
290{
291 struct tb_cap_any header;
292 u8 vsec_id = 0;
293 size_t length;
294 int ret;
295
296 ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1);
297 if (ret) {
298 seq_printf(s, "0x%04x <capability read failed>\n", cap);
299 return;
300 }
301
302 switch (header.basic.cap) {
303 case TB_PORT_CAP_PHY:
304 length = PORT_CAP_LANE_LEN;
305 break;
306
307 case TB_PORT_CAP_TIME1:
308 length = PORT_CAP_TMU_LEN;
309 break;
310
311 case TB_PORT_CAP_POWER:
312 length = PORT_CAP_POWER_LEN;
313 break;
314
315 case TB_PORT_CAP_ADAP:
316 if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) {
317 length = PORT_CAP_PCIE_LEN;
318 } else if (tb_port_is_dpin(port) || tb_port_is_dpout(port)) {
319 length = PORT_CAP_DP_LEN;
320 } else if (tb_port_is_usb3_down(port) ||
321 tb_port_is_usb3_up(port)) {
322 length = PORT_CAP_USB3_LEN;
323 } else {
324 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
325 cap, header.basic.cap);
326 return;
327 }
328 break;
329
330 case TB_PORT_CAP_VSE:
331 if (!header.extended_short.length) {
332 ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT,
333 cap + 1, 1);
334 if (ret) {
335 seq_printf(s, "0x%04x <capability read failed>\n",
336 cap + 1);
337 return;
338 }
339 length = header.extended_long.length;
340 vsec_id = header.extended_short.vsec_id;
341 } else {
342 length = header.extended_short.length;
343 vsec_id = header.extended_short.vsec_id;
344
345
346
347
348
349 if (!vsec_id &&
350 (tb_switch_is_ice_lake(port->sw) ||
351 tb_switch_is_tiger_lake(port->sw)))
352 length = 32;
353 }
354 break;
355
356 case TB_PORT_CAP_USB4:
357 length = PORT_CAP_USB4_LEN;
358 break;
359
360 default:
361 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
362 cap, header.basic.cap);
363 return;
364 }
365
366 cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);
367}
368
369static void port_caps_show(struct tb_port *port, struct seq_file *s)
370{
371 int cap;
372
373 cap = tb_port_next_cap(port, 0);
374 while (cap > 0) {
375 port_cap_show(port, s, cap);
376 cap = tb_port_next_cap(port, cap);
377 }
378}
379
380static int port_basic_regs_show(struct tb_port *port, struct seq_file *s)
381{
382 u32 data[PORT_CAP_BASIC_LEN];
383 int ret, i;
384
385 ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data));
386 if (ret)
387 return ret;
388
389 for (i = 0; i < ARRAY_SIZE(data); i++)
390 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
391
392 return 0;
393}
394
395static int port_regs_show(struct seq_file *s, void *not_used)
396{
397 struct tb_port *port = s->private;
398 struct tb_switch *sw = port->sw;
399 struct tb *tb = sw->tb;
400 int ret;
401
402 pm_runtime_get_sync(&sw->dev);
403
404 if (mutex_lock_interruptible(&tb->lock)) {
405 ret = -ERESTARTSYS;
406 goto out_rpm_put;
407 }
408
409 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
410
411 ret = port_basic_regs_show(port, s);
412 if (ret)
413 goto out_unlock;
414
415 port_caps_show(port, s);
416
417out_unlock:
418 mutex_unlock(&tb->lock);
419out_rpm_put:
420 pm_runtime_mark_last_busy(&sw->dev);
421 pm_runtime_put_autosuspend(&sw->dev);
422
423 return ret;
424}
425DEBUGFS_ATTR_RW(port_regs);
426
427static void switch_cap_show(struct tb_switch *sw, struct seq_file *s,
428 unsigned int cap)
429{
430 struct tb_cap_any header;
431 int ret, length;
432 u8 vsec_id = 0;
433
434 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1);
435 if (ret) {
436 seq_printf(s, "0x%04x <capability read failed>\n", cap);
437 return;
438 }
439
440 if (header.basic.cap == TB_SWITCH_CAP_VSE) {
441 if (!header.extended_short.length) {
442 ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH,
443 cap + 1, 1);
444 if (ret) {
445 seq_printf(s, "0x%04x <capability read failed>\n",
446 cap + 1);
447 return;
448 }
449 length = header.extended_long.length;
450 } else {
451 length = header.extended_short.length;
452 }
453 vsec_id = header.extended_short.vsec_id;
454 } else {
455 if (header.basic.cap == TB_SWITCH_CAP_TMU) {
456 length = SWITCH_CAP_TMU_LEN;
457 } else {
458 seq_printf(s, "0x%04x <unknown capability 0x%02x>\n",
459 cap, header.basic.cap);
460 return;
461 }
462 }
463
464 cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);
465}
466
467static void switch_caps_show(struct tb_switch *sw, struct seq_file *s)
468{
469 int cap;
470
471 cap = tb_switch_next_cap(sw, 0);
472 while (cap > 0) {
473 switch_cap_show(sw, s, cap);
474 cap = tb_switch_next_cap(sw, cap);
475 }
476}
477
478static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s)
479{
480 u32 data[SWITCH_CAP_BASIC_LEN];
481 size_t dwords;
482 int ret, i;
483
484
485 if (tb_switch_is_usb4(sw))
486 dwords = ARRAY_SIZE(data);
487 else
488 dwords = 7;
489
490 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords);
491 if (ret)
492 return ret;
493
494 for (i = 0; i < dwords; i++)
495 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
496
497 return 0;
498}
499
500static int switch_regs_show(struct seq_file *s, void *not_used)
501{
502 struct tb_switch *sw = s->private;
503 struct tb *tb = sw->tb;
504 int ret;
505
506 pm_runtime_get_sync(&sw->dev);
507
508 if (mutex_lock_interruptible(&tb->lock)) {
509 ret = -ERESTARTSYS;
510 goto out_rpm_put;
511 }
512
513 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
514
515 ret = switch_basic_regs_show(sw, s);
516 if (ret)
517 goto out_unlock;
518
519 switch_caps_show(sw, s);
520
521out_unlock:
522 mutex_unlock(&tb->lock);
523out_rpm_put:
524 pm_runtime_mark_last_busy(&sw->dev);
525 pm_runtime_put_autosuspend(&sw->dev);
526
527 return ret;
528}
529DEBUGFS_ATTR_RW(switch_regs);
530
531static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid)
532{
533 u32 data[PATH_LEN];
534 int ret, i;
535
536 ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN,
537 ARRAY_SIZE(data));
538 if (ret) {
539 seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN);
540 return ret;
541 }
542
543 for (i = 0; i < ARRAY_SIZE(data); i++) {
544 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
545 hopid * PATH_LEN + i, i, hopid, data[i]);
546 }
547
548 return 0;
549}
550
551static int path_show(struct seq_file *s, void *not_used)
552{
553 struct tb_port *port = s->private;
554 struct tb_switch *sw = port->sw;
555 struct tb *tb = sw->tb;
556 int start, i, ret = 0;
557
558 pm_runtime_get_sync(&sw->dev);
559
560 if (mutex_lock_interruptible(&tb->lock)) {
561 ret = -ERESTARTSYS;
562 goto out_rpm_put;
563 }
564
565 seq_puts(s, "# offset relative_offset in_hop_id value\n");
566
567
568 if (tb_port_is_null(port) || tb_port_is_nhi(port)) {
569 ret = path_show_one(port, s, 0);
570 if (ret)
571 goto out_unlock;
572 }
573
574 start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
575
576 for (i = start; i <= port->config.max_in_hop_id; i++) {
577 ret = path_show_one(port, s, i);
578 if (ret)
579 break;
580 }
581
582out_unlock:
583 mutex_unlock(&tb->lock);
584out_rpm_put:
585 pm_runtime_mark_last_busy(&sw->dev);
586 pm_runtime_put_autosuspend(&sw->dev);
587
588 return ret;
589}
590DEBUGFS_ATTR_RO(path);
591
592static int counter_set_regs_show(struct tb_port *port, struct seq_file *s,
593 int counter)
594{
595 u32 data[COUNTER_SET_LEN];
596 int ret, i;
597
598 ret = tb_port_read(port, data, TB_CFG_COUNTERS,
599 counter * COUNTER_SET_LEN, ARRAY_SIZE(data));
600 if (ret) {
601 seq_printf(s, "0x%04x <not accessible>\n",
602 counter * COUNTER_SET_LEN);
603 return ret;
604 }
605
606 for (i = 0; i < ARRAY_SIZE(data); i++) {
607 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
608 counter * COUNTER_SET_LEN + i, i, counter, data[i]);
609 }
610
611 return 0;
612}
613
614static int counters_show(struct seq_file *s, void *not_used)
615{
616 struct tb_port *port = s->private;
617 struct tb_switch *sw = port->sw;
618 struct tb *tb = sw->tb;
619 int i, ret = 0;
620
621 pm_runtime_get_sync(&sw->dev);
622
623 if (mutex_lock_interruptible(&tb->lock)) {
624 ret = -ERESTARTSYS;
625 goto out;
626 }
627
628 seq_puts(s, "# offset relative_offset counter_id value\n");
629
630 for (i = 0; i < port->config.max_counters; i++) {
631 ret = counter_set_regs_show(port, s, i);
632 if (ret)
633 break;
634 }
635
636 mutex_unlock(&tb->lock);
637
638out:
639 pm_runtime_mark_last_busy(&sw->dev);
640 pm_runtime_put_autosuspend(&sw->dev);
641
642 return ret;
643}
644DEBUGFS_ATTR_RW(counters);
645
646
647
648
649
650
651
652void tb_switch_debugfs_init(struct tb_switch *sw)
653{
654 struct dentry *debugfs_dir;
655 struct tb_port *port;
656
657 debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root);
658 sw->debugfs_dir = debugfs_dir;
659 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw,
660 &switch_regs_fops);
661
662 tb_switch_for_each_port(sw, port) {
663 struct dentry *debugfs_dir;
664 char dir_name[10];
665
666 if (port->disabled)
667 continue;
668 if (port->config.type == TB_TYPE_INACTIVE)
669 continue;
670
671 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
672 debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir);
673 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir,
674 port, &port_regs_fops);
675 debugfs_create_file("path", 0400, debugfs_dir, port,
676 &path_fops);
677 if (port->config.counters_support)
678 debugfs_create_file("counters", 0600, debugfs_dir, port,
679 &counters_fops);
680 }
681}
682
683
684
685
686
687
688
689void tb_switch_debugfs_remove(struct tb_switch *sw)
690{
691 debugfs_remove_recursive(sw->debugfs_dir);
692}
693
694void tb_debugfs_init(void)
695{
696 tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);
697}
698
699void tb_debugfs_exit(void)
700{
701 debugfs_remove_recursive(tb_debugfs_root);
702}
703
