1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Debugfs interface
4 *
5 * Copyright (C) 2020, Intel Corporation
6 * Authors: Gil Fine <gil.fine@intel.com>
7 * Mika Westerberg <mika.westerberg@linux.intel.com>
8 */
9
10 #include <linux/debugfs.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/uaccess.h>
13
14 #include "tb.h"
15 #include "sb_regs.h"
16
17 #define PORT_CAP_V1_PCIE_LEN 1
18 #define PORT_CAP_V2_PCIE_LEN 2
19 #define PORT_CAP_POWER_LEN 2
20 #define PORT_CAP_LANE_LEN 3
21 #define PORT_CAP_USB3_LEN 5
22 #define PORT_CAP_DP_V1_LEN 9
23 #define PORT_CAP_DP_V2_LEN 14
24 #define PORT_CAP_TMU_V1_LEN 8
25 #define PORT_CAP_TMU_V2_LEN 10
26 #define PORT_CAP_BASIC_LEN 9
27 #define PORT_CAP_USB4_LEN 20
28
29 #define SWITCH_CAP_TMU_LEN 26
30 #define SWITCH_CAP_BASIC_LEN 27
31
32 #define PATH_LEN 2
33
34 #define COUNTER_SET_LEN 3
35
36 #define DEBUGFS_ATTR(__space, __write) \
37 static int __space ## _open(struct inode *inode, struct file *file) \
38 { \
39 return single_open(file, __space ## _show, inode->i_private); \
40 } \
41 \
42 static const struct file_operations __space ## _fops = { \
43 .owner = THIS_MODULE, \
44 .open = __space ## _open, \
45 .release = single_release, \
46 .read = seq_read, \
47 .write = __write, \
48 .llseek = seq_lseek, \
49 }
50
51 #define DEBUGFS_ATTR_RO(__space) \
52 DEBUGFS_ATTR(__space, NULL)
53
54 #define DEBUGFS_ATTR_RW(__space) \
55 DEBUGFS_ATTR(__space, __space ## _write)
56
57 static struct dentry *tb_debugfs_root;
58
validate_and_copy_from_user(const void __user * user_buf,size_t * count)59 static void *validate_and_copy_from_user(const void __user *user_buf,
60 size_t *count)
61 {
62 size_t nbytes;
63 void *buf;
64
65 if (!*count)
66 return ERR_PTR(-EINVAL);
67
68 if (!access_ok(user_buf, *count))
69 return ERR_PTR(-EFAULT);
70
71 buf = (void *)get_zeroed_page(GFP_KERNEL);
72 if (!buf)
73 return ERR_PTR(-ENOMEM);
74
75 nbytes = min_t(size_t, *count, PAGE_SIZE);
76 if (copy_from_user(buf, user_buf, nbytes)) {
77 free_page((unsigned long)buf);
78 return ERR_PTR(-EFAULT);
79 }
80
81 *count = nbytes;
82 return buf;
83 }
84
parse_line(char ** line,u32 * offs,u32 * val,int short_fmt_len,int long_fmt_len)85 static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len,
86 int long_fmt_len)
87 {
88 char *token;
89 u32 v[5];
90 int ret;
91
92 token = strsep(line, "\n");
93 if (!token)
94 return false;
95
96 /*
97 * For Adapter/Router configuration space:
98 * Short format is: offset value\n
99 * v[0] v[1]
100 * Long format as produced from the read side:
101 * offset relative_offset cap_id vs_cap_id value\n
102 * v[0] v[1] v[2] v[3] v[4]
103 *
104 * For Counter configuration space:
105 * Short format is: offset\n
106 * v[0]
107 * Long format as produced from the read side:
108 * offset relative_offset counter_id value\n
109 * v[0] v[1] v[2] v[3]
110 */
111 ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]);
112 /* In case of Counters, clear counter, "val" content is NA */
113 if (ret == short_fmt_len) {
114 *offs = v[0];
115 *val = v[short_fmt_len - 1];
116 return true;
117 } else if (ret == long_fmt_len) {
118 *offs = v[0];
119 *val = v[long_fmt_len - 1];
120 return true;
121 }
122
123 return false;
124 }
125
126 #if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)
regs_write(struct tb_switch * sw,struct tb_port * port,const char __user * user_buf,size_t count,loff_t * ppos)127 static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port,
128 const char __user *user_buf, size_t count,
129 loff_t *ppos)
130 {
131 struct tb *tb = sw->tb;
132 char *line, *buf;
133 u32 val, offset;
134 int ret = 0;
135
136 buf = validate_and_copy_from_user(user_buf, &count);
137 if (IS_ERR(buf))
138 return PTR_ERR(buf);
139
140 pm_runtime_get_sync(&sw->dev);
141
142 if (mutex_lock_interruptible(&tb->lock)) {
143 ret = -ERESTARTSYS;
144 goto out;
145 }
146
147 /* User did hardware changes behind the driver's back */
148 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
149
150 line = buf;
151 while (parse_line(&line, &offset, &val, 2, 5)) {
152 if (port)
153 ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1);
154 else
155 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1);
156 if (ret)
157 break;
158 }
159
160 mutex_unlock(&tb->lock);
161
162 out:
163 pm_runtime_mark_last_busy(&sw->dev);
164 pm_runtime_put_autosuspend(&sw->dev);
165 free_page((unsigned long)buf);
166
167 return ret < 0 ? ret : count;
168 }
169
port_regs_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)170 static ssize_t port_regs_write(struct file *file, const char __user *user_buf,
171 size_t count, loff_t *ppos)
172 {
173 struct seq_file *s = file->private_data;
174 struct tb_port *port = s->private;
175
176 return regs_write(port->sw, port, user_buf, count, ppos);
177 }
178
switch_regs_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)179 static ssize_t switch_regs_write(struct file *file, const char __user *user_buf,
180 size_t count, loff_t *ppos)
181 {
182 struct seq_file *s = file->private_data;
183 struct tb_switch *sw = s->private;
184
185 return regs_write(sw, NULL, user_buf, count, ppos);
186 }
187 #define DEBUGFS_MODE 0600
188 #else
189 #define port_regs_write NULL
190 #define switch_regs_write NULL
191 #define DEBUGFS_MODE 0400
192 #endif
193
194 #if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING)
195 /**
196 * struct tb_margining - Lane margining support
197 * @caps: Port lane margining capabilities
198 * @results: Last lane margining results
199 * @lanes: %0, %1 or %7 (all)
200 * @min_ber_level: Minimum supported BER level contour value
201 * @max_ber_level: Maximum supported BER level contour value
202 * @ber_level: Current BER level contour value
203 * @voltage_steps: Number of mandatory voltage steps
204 * @max_voltage_offset: Maximum mandatory voltage offset (in mV)
205 * @time_steps: Number of time margin steps
206 * @max_time_offset: Maximum time margin offset (in mUI)
207 * @software: %true if software margining is used instead of hardware
208 * @time: %true if time margining is used instead of voltage
209 * @right_high: %false if left/low margin test is performed, %true if
210 * right/high
211 */
212 struct tb_margining {
213 u32 caps[2];
214 u32 results[2];
215 unsigned int lanes;
216 unsigned int min_ber_level;
217 unsigned int max_ber_level;
218 unsigned int ber_level;
219 unsigned int voltage_steps;
220 unsigned int max_voltage_offset;
221 unsigned int time_steps;
222 unsigned int max_time_offset;
223 bool software;
224 bool time;
225 bool right_high;
226 };
227
supports_software(const struct usb4_port * usb4)228 static bool supports_software(const struct usb4_port *usb4)
229 {
230 return usb4->margining->caps[0] & USB4_MARGIN_CAP_0_MODES_SW;
231 }
232
supports_hardware(const struct usb4_port * usb4)233 static bool supports_hardware(const struct usb4_port *usb4)
234 {
235 return usb4->margining->caps[0] & USB4_MARGIN_CAP_0_MODES_HW;
236 }
237
both_lanes(const struct usb4_port * usb4)238 static bool both_lanes(const struct usb4_port *usb4)
239 {
240 return usb4->margining->caps[0] & USB4_MARGIN_CAP_0_2_LANES;
241 }
242
independent_voltage_margins(const struct usb4_port * usb4)243 static unsigned int independent_voltage_margins(const struct usb4_port *usb4)
244 {
245 return (usb4->margining->caps[0] & USB4_MARGIN_CAP_0_VOLTAGE_INDP_MASK) >>
246 USB4_MARGIN_CAP_0_VOLTAGE_INDP_SHIFT;
247 }
248
supports_time(const struct usb4_port * usb4)249 static bool supports_time(const struct usb4_port *usb4)
250 {
251 return usb4->margining->caps[0] & USB4_MARGIN_CAP_0_TIME;
252 }
253
254 /* Only applicable if supports_time() returns true */
independent_time_margins(const struct usb4_port * usb4)255 static unsigned int independent_time_margins(const struct usb4_port *usb4)
256 {
257 return (usb4->margining->caps[1] & USB4_MARGIN_CAP_1_TIME_INDP_MASK) >>
258 USB4_MARGIN_CAP_1_TIME_INDP_SHIFT;
259 }
260
261 static ssize_t
margining_ber_level_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)262 margining_ber_level_write(struct file *file, const char __user *user_buf,
263 size_t count, loff_t *ppos)
264 {
265 struct seq_file *s = file->private_data;
266 struct tb_port *port = s->private;
267 struct usb4_port *usb4 = port->usb4;
268 struct tb *tb = port->sw->tb;
269 unsigned int val;
270 int ret = 0;
271 char *buf;
272
273 if (mutex_lock_interruptible(&tb->lock))
274 return -ERESTARTSYS;
275
276 if (usb4->margining->software) {
277 ret = -EINVAL;
278 goto out_unlock;
279 }
280
281 buf = validate_and_copy_from_user(user_buf, &count);
282 if (IS_ERR(buf)) {
283 ret = PTR_ERR(buf);
284 goto out_unlock;
285 }
286
287 buf[count - 1] = '\0';
288
289 ret = kstrtouint(buf, 10, &val);
290 if (ret)
291 goto out_free;
292
293 if (val < usb4->margining->min_ber_level ||
294 val > usb4->margining->max_ber_level) {
295 ret = -EINVAL;
296 goto out_free;
297 }
298
299 usb4->margining->ber_level = val;
300
301 out_free:
302 free_page((unsigned long)buf);
303 out_unlock:
304 mutex_unlock(&tb->lock);
305
306 return ret < 0 ? ret : count;
307 }
308
ber_level_show(struct seq_file * s,unsigned int val)309 static void ber_level_show(struct seq_file *s, unsigned int val)
310 {
311 if (val % 2)
312 seq_printf(s, "3 * 1e%d (%u)\n", -12 + (val + 1) / 2, val);
313 else
314 seq_printf(s, "1e%d (%u)\n", -12 + val / 2, val);
315 }
316
margining_ber_level_show(struct seq_file * s,void * not_used)317 static int margining_ber_level_show(struct seq_file *s, void *not_used)
318 {
319 struct tb_port *port = s->private;
320 struct usb4_port *usb4 = port->usb4;
321
322 if (usb4->margining->software)
323 return -EINVAL;
324 ber_level_show(s, usb4->margining->ber_level);
325 return 0;
326 }
327 DEBUGFS_ATTR_RW(margining_ber_level);
328
margining_caps_show(struct seq_file * s,void * not_used)329 static int margining_caps_show(struct seq_file *s, void *not_used)
330 {
331 struct tb_port *port = s->private;
332 struct usb4_port *usb4 = port->usb4;
333 struct tb *tb = port->sw->tb;
334 u32 cap0, cap1;
335
336 if (mutex_lock_interruptible(&tb->lock))
337 return -ERESTARTSYS;
338
339 /* Dump the raw caps first */
340 cap0 = usb4->margining->caps[0];
341 seq_printf(s, "0x%08x\n", cap0);
342 cap1 = usb4->margining->caps[1];
343 seq_printf(s, "0x%08x\n", cap1);
344
345 seq_printf(s, "# software margining: %s\n",
346 supports_software(usb4) ? "yes" : "no");
347 if (supports_hardware(usb4)) {
348 seq_puts(s, "# hardware margining: yes\n");
349 seq_puts(s, "# minimum BER level contour: ");
350 ber_level_show(s, usb4->margining->min_ber_level);
351 seq_puts(s, "# maximum BER level contour: ");
352 ber_level_show(s, usb4->margining->max_ber_level);
353 } else {
354 seq_puts(s, "# hardware margining: no\n");
355 }
356
357 seq_printf(s, "# both lanes simultaneously: %s\n",
358 both_lanes(usb4) ? "yes" : "no");
359 seq_printf(s, "# voltage margin steps: %u\n",
360 usb4->margining->voltage_steps);
361 seq_printf(s, "# maximum voltage offset: %u mV\n",
362 usb4->margining->max_voltage_offset);
363
364 switch (independent_voltage_margins(usb4)) {
365 case USB4_MARGIN_CAP_0_VOLTAGE_MIN:
366 seq_puts(s, "# returns minimum between high and low voltage margins\n");
367 break;
368 case USB4_MARGIN_CAP_0_VOLTAGE_HL:
369 seq_puts(s, "# returns high or low voltage margin\n");
370 break;
371 case USB4_MARGIN_CAP_0_VOLTAGE_BOTH:
372 seq_puts(s, "# returns both high and low margins\n");
373 break;
374 }
375
376 if (supports_time(usb4)) {
377 seq_puts(s, "# time margining: yes\n");
378 seq_printf(s, "# time margining is destructive: %s\n",
379 cap1 & USB4_MARGIN_CAP_1_TIME_DESTR ? "yes" : "no");
380
381 switch (independent_time_margins(usb4)) {
382 case USB4_MARGIN_CAP_1_TIME_MIN:
383 seq_puts(s, "# returns minimum between left and right time margins\n");
384 break;
385 case USB4_MARGIN_CAP_1_TIME_LR:
386 seq_puts(s, "# returns left or right margin\n");
387 break;
388 case USB4_MARGIN_CAP_1_TIME_BOTH:
389 seq_puts(s, "# returns both left and right margins\n");
390 break;
391 }
392
393 seq_printf(s, "# time margin steps: %u\n",
394 usb4->margining->time_steps);
395 seq_printf(s, "# maximum time offset: %u mUI\n",
396 usb4->margining->max_time_offset);
397 } else {
398 seq_puts(s, "# time margining: no\n");
399 }
400
401 mutex_unlock(&tb->lock);
402 return 0;
403 }
404 DEBUGFS_ATTR_RO(margining_caps);
405
406 static ssize_t
margining_lanes_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)407 margining_lanes_write(struct file *file, const char __user *user_buf,
408 size_t count, loff_t *ppos)
409 {
410 struct seq_file *s = file->private_data;
411 struct tb_port *port = s->private;
412 struct usb4_port *usb4 = port->usb4;
413 struct tb *tb = port->sw->tb;
414 int ret = 0;
415 char *buf;
416
417 buf = validate_and_copy_from_user(user_buf, &count);
418 if (IS_ERR(buf))
419 return PTR_ERR(buf);
420
421 buf[count - 1] = '\0';
422
423 if (mutex_lock_interruptible(&tb->lock)) {
424 ret = -ERESTARTSYS;
425 goto out_free;
426 }
427
428 if (!strcmp(buf, "0")) {
429 usb4->margining->lanes = 0;
430 } else if (!strcmp(buf, "1")) {
431 usb4->margining->lanes = 1;
432 } else if (!strcmp(buf, "all")) {
433 /* Needs to be supported */
434 if (both_lanes(usb4))
435 usb4->margining->lanes = 7;
436 else
437 ret = -EINVAL;
438 } else {
439 ret = -EINVAL;
440 }
441
442 mutex_unlock(&tb->lock);
443
444 out_free:
445 free_page((unsigned long)buf);
446 return ret < 0 ? ret : count;
447 }
448
margining_lanes_show(struct seq_file * s,void * not_used)449 static int margining_lanes_show(struct seq_file *s, void *not_used)
450 {
451 struct tb_port *port = s->private;
452 struct usb4_port *usb4 = port->usb4;
453 struct tb *tb = port->sw->tb;
454 unsigned int lanes;
455
456 if (mutex_lock_interruptible(&tb->lock))
457 return -ERESTARTSYS;
458
459 lanes = usb4->margining->lanes;
460 if (both_lanes(usb4)) {
461 if (!lanes)
462 seq_puts(s, "[0] 1 all\n");
463 else if (lanes == 1)
464 seq_puts(s, "0 [1] all\n");
465 else
466 seq_puts(s, "0 1 [all]\n");
467 } else {
468 if (!lanes)
469 seq_puts(s, "[0] 1\n");
470 else
471 seq_puts(s, "0 [1]\n");
472 }
473
474 mutex_unlock(&tb->lock);
475 return 0;
476 }
477 DEBUGFS_ATTR_RW(margining_lanes);
478
margining_mode_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)479 static ssize_t margining_mode_write(struct file *file,
480 const char __user *user_buf,
481 size_t count, loff_t *ppos)
482 {
483 struct seq_file *s = file->private_data;
484 struct tb_port *port = s->private;
485 struct usb4_port *usb4 = port->usb4;
486 struct tb *tb = port->sw->tb;
487 int ret = 0;
488 char *buf;
489
490 buf = validate_and_copy_from_user(user_buf, &count);
491 if (IS_ERR(buf))
492 return PTR_ERR(buf);
493
494 buf[count - 1] = '\0';
495
496 if (mutex_lock_interruptible(&tb->lock)) {
497 ret = -ERESTARTSYS;
498 goto out_free;
499 }
500
501 if (!strcmp(buf, "software")) {
502 if (supports_software(usb4))
503 usb4->margining->software = true;
504 else
505 ret = -EINVAL;
506 } else if (!strcmp(buf, "hardware")) {
507 if (supports_hardware(usb4))
508 usb4->margining->software = false;
509 else
510 ret = -EINVAL;
511 } else {
512 ret = -EINVAL;
513 }
514
515 mutex_unlock(&tb->lock);
516
517 out_free:
518 free_page((unsigned long)buf);
519 return ret ? ret : count;
520 }
521
margining_mode_show(struct seq_file * s,void * not_used)522 static int margining_mode_show(struct seq_file *s, void *not_used)
523 {
524 const struct tb_port *port = s->private;
525 const struct usb4_port *usb4 = port->usb4;
526 struct tb *tb = port->sw->tb;
527 const char *space = "";
528
529 if (mutex_lock_interruptible(&tb->lock))
530 return -ERESTARTSYS;
531
532 if (supports_software(usb4)) {
533 if (usb4->margining->software)
534 seq_puts(s, "[software]");
535 else
536 seq_puts(s, "software");
537 space = " ";
538 }
539 if (supports_hardware(usb4)) {
540 if (usb4->margining->software)
541 seq_printf(s, "%shardware", space);
542 else
543 seq_printf(s, "%s[hardware]", space);
544 }
545
546 mutex_unlock(&tb->lock);
547
548 seq_puts(s, "\n");
549 return 0;
550 }
551 DEBUGFS_ATTR_RW(margining_mode);
552
margining_run_write(void * data,u64 val)553 static int margining_run_write(void *data, u64 val)
554 {
555 struct tb_port *port = data;
556 struct usb4_port *usb4 = port->usb4;
557 struct tb_switch *sw = port->sw;
558 struct tb_margining *margining;
559 struct tb_switch *down_sw;
560 struct tb *tb = sw->tb;
561 int ret, clx;
562
563 if (val != 1)
564 return -EINVAL;
565
566 pm_runtime_get_sync(&sw->dev);
567
568 if (mutex_lock_interruptible(&tb->lock)) {
569 ret = -ERESTARTSYS;
570 goto out_rpm_put;
571 }
572
573 if (tb_is_upstream_port(port))
574 down_sw = sw;
575 else if (port->remote)
576 down_sw = port->remote->sw;
577 else
578 down_sw = NULL;
579
580 if (down_sw) {
581 /*
582 * CL states may interfere with lane margining so
583 * disable them temporarily now.
584 */
585 ret = tb_switch_clx_disable(down_sw);
586 if (ret < 0) {
587 tb_sw_warn(down_sw, "failed to disable CL states\n");
588 goto out_unlock;
589 }
590 clx = ret;
591 }
592
593 margining = usb4->margining;
594
595 if (margining->software) {
596 tb_port_dbg(port, "running software %s lane margining for lanes %u\n",
597 margining->time ? "time" : "voltage", margining->lanes);
598 ret = usb4_port_sw_margin(port, margining->lanes, margining->time,
599 margining->right_high,
600 USB4_MARGIN_SW_COUNTER_CLEAR);
601 if (ret)
602 goto out_clx;
603
604 ret = usb4_port_sw_margin_errors(port, &margining->results[0]);
605 } else {
606 tb_port_dbg(port, "running hardware %s lane margining for lanes %u\n",
607 margining->time ? "time" : "voltage", margining->lanes);
608 /* Clear the results */
609 margining->results[0] = 0;
610 margining->results[1] = 0;
611 ret = usb4_port_hw_margin(port, margining->lanes,
612 margining->ber_level, margining->time,
613 margining->right_high, margining->results);
614 }
615
616 out_clx:
617 if (down_sw)
618 tb_switch_clx_enable(down_sw, clx);
619 out_unlock:
620 mutex_unlock(&tb->lock);
621 out_rpm_put:
622 pm_runtime_mark_last_busy(&sw->dev);
623 pm_runtime_put_autosuspend(&sw->dev);
624
625 return ret;
626 }
627 DEFINE_DEBUGFS_ATTRIBUTE(margining_run_fops, NULL, margining_run_write,
628 "%llu\n");
629
margining_results_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)630 static ssize_t margining_results_write(struct file *file,
631 const char __user *user_buf,
632 size_t count, loff_t *ppos)
633 {
634 struct seq_file *s = file->private_data;
635 struct tb_port *port = s->private;
636 struct usb4_port *usb4 = port->usb4;
637 struct tb *tb = port->sw->tb;
638
639 if (mutex_lock_interruptible(&tb->lock))
640 return -ERESTARTSYS;
641
642 /* Just clear the results */
643 usb4->margining->results[0] = 0;
644 usb4->margining->results[1] = 0;
645
646 mutex_unlock(&tb->lock);
647 return count;
648 }
649
voltage_margin_show(struct seq_file * s,const struct tb_margining * margining,u8 val)650 static void voltage_margin_show(struct seq_file *s,
651 const struct tb_margining *margining, u8 val)
652 {
653 unsigned int tmp, voltage;
654
655 tmp = val & USB4_MARGIN_HW_RES_1_MARGIN_MASK;
656 voltage = tmp * margining->max_voltage_offset / margining->voltage_steps;
657 seq_printf(s, "%u mV (%u)", voltage, tmp);
658 if (val & USB4_MARGIN_HW_RES_1_EXCEEDS)
659 seq_puts(s, " exceeds maximum");
660 seq_puts(s, "\n");
661 }
662
time_margin_show(struct seq_file * s,const struct tb_margining * margining,u8 val)663 static void time_margin_show(struct seq_file *s,
664 const struct tb_margining *margining, u8 val)
665 {
666 unsigned int tmp, interval;
667
668 tmp = val & USB4_MARGIN_HW_RES_1_MARGIN_MASK;
669 interval = tmp * margining->max_time_offset / margining->time_steps;
670 seq_printf(s, "%u mUI (%u)", interval, tmp);
671 if (val & USB4_MARGIN_HW_RES_1_EXCEEDS)
672 seq_puts(s, " exceeds maximum");
673 seq_puts(s, "\n");
674 }
675
margining_results_show(struct seq_file * s,void * not_used)676 static int margining_results_show(struct seq_file *s, void *not_used)
677 {
678 struct tb_port *port = s->private;
679 struct usb4_port *usb4 = port->usb4;
680 struct tb_margining *margining;
681 struct tb *tb = port->sw->tb;
682
683 if (mutex_lock_interruptible(&tb->lock))
684 return -ERESTARTSYS;
685
686 margining = usb4->margining;
687 /* Dump the raw results first */
688 seq_printf(s, "0x%08x\n", margining->results[0]);
689 /* Only the hardware margining has two result dwords */
690 if (!margining->software) {
691 unsigned int val;
692
693 seq_printf(s, "0x%08x\n", margining->results[1]);
694
695 if (margining->time) {
696 if (!margining->lanes || margining->lanes == 7) {
697 val = margining->results[1];
698 seq_puts(s, "# lane 0 right time margin: ");
699 time_margin_show(s, margining, val);
700 val = margining->results[1] >>
701 USB4_MARGIN_HW_RES_1_L0_LL_MARGIN_SHIFT;
702 seq_puts(s, "# lane 0 left time margin: ");
703 time_margin_show(s, margining, val);
704 }
705 if (margining->lanes == 1 || margining->lanes == 7) {
706 val = margining->results[1] >>
707 USB4_MARGIN_HW_RES_1_L1_RH_MARGIN_SHIFT;
708 seq_puts(s, "# lane 1 right time margin: ");
709 time_margin_show(s, margining, val);
710 val = margining->results[1] >>
711 USB4_MARGIN_HW_RES_1_L1_LL_MARGIN_SHIFT;
712 seq_puts(s, "# lane 1 left time margin: ");
713 time_margin_show(s, margining, val);
714 }
715 } else {
716 if (!margining->lanes || margining->lanes == 7) {
717 val = margining->results[1];
718 seq_puts(s, "# lane 0 high voltage margin: ");
719 voltage_margin_show(s, margining, val);
720 val = margining->results[1] >>
721 USB4_MARGIN_HW_RES_1_L0_LL_MARGIN_SHIFT;
722 seq_puts(s, "# lane 0 low voltage margin: ");
723 voltage_margin_show(s, margining, val);
724 }
725 if (margining->lanes == 1 || margining->lanes == 7) {
726 val = margining->results[1] >>
727 USB4_MARGIN_HW_RES_1_L1_RH_MARGIN_SHIFT;
728 seq_puts(s, "# lane 1 high voltage margin: ");
729 voltage_margin_show(s, margining, val);
730 val = margining->results[1] >>
731 USB4_MARGIN_HW_RES_1_L1_LL_MARGIN_SHIFT;
732 seq_puts(s, "# lane 1 low voltage margin: ");
733 voltage_margin_show(s, margining, val);
734 }
735 }
736 }
737
738 mutex_unlock(&tb->lock);
739 return 0;
740 }
741 DEBUGFS_ATTR_RW(margining_results);
742
margining_test_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)743 static ssize_t margining_test_write(struct file *file,
744 const char __user *user_buf,
745 size_t count, loff_t *ppos)
746 {
747 struct seq_file *s = file->private_data;
748 struct tb_port *port = s->private;
749 struct usb4_port *usb4 = port->usb4;
750 struct tb *tb = port->sw->tb;
751 int ret = 0;
752 char *buf;
753
754 buf = validate_and_copy_from_user(user_buf, &count);
755 if (IS_ERR(buf))
756 return PTR_ERR(buf);
757
758 buf[count - 1] = '\0';
759
760 if (mutex_lock_interruptible(&tb->lock)) {
761 ret = -ERESTARTSYS;
762 goto out_free;
763 }
764
765 if (!strcmp(buf, "time") && supports_time(usb4))
766 usb4->margining->time = true;
767 else if (!strcmp(buf, "voltage"))
768 usb4->margining->time = false;
769 else
770 ret = -EINVAL;
771
772 mutex_unlock(&tb->lock);
773
774 out_free:
775 free_page((unsigned long)buf);
776 return ret ? ret : count;
777 }
778
margining_test_show(struct seq_file * s,void * not_used)779 static int margining_test_show(struct seq_file *s, void *not_used)
780 {
781 struct tb_port *port = s->private;
782 struct usb4_port *usb4 = port->usb4;
783 struct tb *tb = port->sw->tb;
784
785 if (mutex_lock_interruptible(&tb->lock))
786 return -ERESTARTSYS;
787
788 if (supports_time(usb4)) {
789 if (usb4->margining->time)
790 seq_puts(s, "voltage [time]\n");
791 else
792 seq_puts(s, "[voltage] time\n");
793 } else {
794 seq_puts(s, "[voltage]\n");
795 }
796
797 mutex_unlock(&tb->lock);
798 return 0;
799 }
800 DEBUGFS_ATTR_RW(margining_test);
801
margining_margin_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)802 static ssize_t margining_margin_write(struct file *file,
803 const char __user *user_buf,
804 size_t count, loff_t *ppos)
805 {
806 struct seq_file *s = file->private_data;
807 struct tb_port *port = s->private;
808 struct usb4_port *usb4 = port->usb4;
809 struct tb *tb = port->sw->tb;
810 int ret = 0;
811 char *buf;
812
813 buf = validate_and_copy_from_user(user_buf, &count);
814 if (IS_ERR(buf))
815 return PTR_ERR(buf);
816
817 buf[count - 1] = '\0';
818
819 if (mutex_lock_interruptible(&tb->lock)) {
820 ret = -ERESTARTSYS;
821 goto out_free;
822 }
823
824 if (usb4->margining->time) {
825 if (!strcmp(buf, "left"))
826 usb4->margining->right_high = false;
827 else if (!strcmp(buf, "right"))
828 usb4->margining->right_high = true;
829 else
830 ret = -EINVAL;
831 } else {
832 if (!strcmp(buf, "low"))
833 usb4->margining->right_high = false;
834 else if (!strcmp(buf, "high"))
835 usb4->margining->right_high = true;
836 else
837 ret = -EINVAL;
838 }
839
840 mutex_unlock(&tb->lock);
841
842 out_free:
843 free_page((unsigned long)buf);
844 return ret ? ret : count;
845 }
846
margining_margin_show(struct seq_file * s,void * not_used)847 static int margining_margin_show(struct seq_file *s, void *not_used)
848 {
849 struct tb_port *port = s->private;
850 struct usb4_port *usb4 = port->usb4;
851 struct tb *tb = port->sw->tb;
852
853 if (mutex_lock_interruptible(&tb->lock))
854 return -ERESTARTSYS;
855
856 if (usb4->margining->time) {
857 if (usb4->margining->right_high)
858 seq_puts(s, "left [right]\n");
859 else
860 seq_puts(s, "[left] right\n");
861 } else {
862 if (usb4->margining->right_high)
863 seq_puts(s, "low [high]\n");
864 else
865 seq_puts(s, "[low] high\n");
866 }
867
868 mutex_unlock(&tb->lock);
869 return 0;
870 }
871 DEBUGFS_ATTR_RW(margining_margin);
872
margining_port_init(struct tb_port * port)873 static void margining_port_init(struct tb_port *port)
874 {
875 struct tb_margining *margining;
876 struct dentry *dir, *parent;
877 struct usb4_port *usb4;
878 char dir_name[10];
879 unsigned int val;
880 int ret;
881
882 usb4 = port->usb4;
883 if (!usb4)
884 return;
885
886 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
887 parent = debugfs_lookup(dir_name, port->sw->debugfs_dir);
888
889 margining = kzalloc(sizeof(*margining), GFP_KERNEL);
890 if (!margining)
891 return;
892
893 ret = usb4_port_margining_caps(port, margining->caps);
894 if (ret) {
895 kfree(margining);
896 return;
897 }
898
899 usb4->margining = margining;
900
901 /* Set the initial mode */
902 if (supports_software(usb4))
903 margining->software = true;
904
905 val = (margining->caps[0] & USB4_MARGIN_CAP_0_VOLTAGE_STEPS_MASK) >>
906 USB4_MARGIN_CAP_0_VOLTAGE_STEPS_SHIFT;
907 margining->voltage_steps = val;
908 val = (margining->caps[0] & USB4_MARGIN_CAP_0_MAX_VOLTAGE_OFFSET_MASK) >>
909 USB4_MARGIN_CAP_0_MAX_VOLTAGE_OFFSET_SHIFT;
910 margining->max_voltage_offset = 74 + val * 2;
911
912 if (supports_time(usb4)) {
913 val = (margining->caps[1] & USB4_MARGIN_CAP_1_TIME_STEPS_MASK) >>
914 USB4_MARGIN_CAP_1_TIME_STEPS_SHIFT;
915 margining->time_steps = val;
916 val = (margining->caps[1] & USB4_MARGIN_CAP_1_TIME_OFFSET_MASK) >>
917 USB4_MARGIN_CAP_1_TIME_OFFSET_SHIFT;
918 /*
919 * Store it as mUI (milli Unit Interval) because we want
920 * to keep it as integer.
921 */
922 margining->max_time_offset = 200 + 10 * val;
923 }
924
925 dir = debugfs_create_dir("margining", parent);
926 if (supports_hardware(usb4)) {
927 val = (margining->caps[1] & USB4_MARGIN_CAP_1_MIN_BER_MASK) >>
928 USB4_MARGIN_CAP_1_MIN_BER_SHIFT;
929 margining->min_ber_level = val;
930 val = (margining->caps[1] & USB4_MARGIN_CAP_1_MAX_BER_MASK) >>
931 USB4_MARGIN_CAP_1_MAX_BER_SHIFT;
932 margining->max_ber_level = val;
933
934 /* Set the default to minimum */
935 margining->ber_level = margining->min_ber_level;
936
937 debugfs_create_file("ber_level_contour", 0400, dir, port,
938 &margining_ber_level_fops);
939 }
940 debugfs_create_file("caps", 0400, dir, port, &margining_caps_fops);
941 debugfs_create_file("lanes", 0600, dir, port, &margining_lanes_fops);
942 debugfs_create_file("mode", 0600, dir, port, &margining_mode_fops);
943 debugfs_create_file("run", 0600, dir, port, &margining_run_fops);
944 debugfs_create_file("results", 0600, dir, port, &margining_results_fops);
945 debugfs_create_file("test", 0600, dir, port, &margining_test_fops);
946 if (independent_voltage_margins(usb4) == USB4_MARGIN_CAP_0_VOLTAGE_HL ||
947 (supports_time(usb4) &&
948 independent_time_margins(usb4) == USB4_MARGIN_CAP_1_TIME_LR))
949 debugfs_create_file("margin", 0600, dir, port, &margining_margin_fops);
950 }
951
margining_port_remove(struct tb_port * port)952 static void margining_port_remove(struct tb_port *port)
953 {
954 struct dentry *parent;
955 char dir_name[10];
956
957 if (!port->usb4)
958 return;
959
960 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
961 parent = debugfs_lookup(dir_name, port->sw->debugfs_dir);
962 if (parent)
963 debugfs_lookup_and_remove("margining", parent);
964
965 kfree(port->usb4->margining);
966 port->usb4->margining = NULL;
967 }
968
margining_switch_init(struct tb_switch * sw)969 static void margining_switch_init(struct tb_switch *sw)
970 {
971 struct tb_port *upstream, *downstream;
972 struct tb_switch *parent_sw;
973 u64 route = tb_route(sw);
974
975 if (!route)
976 return;
977
978 upstream = tb_upstream_port(sw);
979 parent_sw = tb_switch_parent(sw);
980 downstream = tb_port_at(route, parent_sw);
981
982 margining_port_init(downstream);
983 margining_port_init(upstream);
984 }
985
margining_switch_remove(struct tb_switch * sw)986 static void margining_switch_remove(struct tb_switch *sw)
987 {
988 struct tb_port *upstream, *downstream;
989 struct tb_switch *parent_sw;
990 u64 route = tb_route(sw);
991
992 if (!route)
993 return;
994
995 upstream = tb_upstream_port(sw);
996 parent_sw = tb_switch_parent(sw);
997 downstream = tb_port_at(route, parent_sw);
998
999 margining_port_remove(upstream);
1000 margining_port_remove(downstream);
1001 }
1002
margining_xdomain_init(struct tb_xdomain * xd)1003 static void margining_xdomain_init(struct tb_xdomain *xd)
1004 {
1005 struct tb_switch *parent_sw;
1006 struct tb_port *downstream;
1007
1008 parent_sw = tb_xdomain_parent(xd);
1009 downstream = tb_port_at(xd->route, parent_sw);
1010
1011 margining_port_init(downstream);
1012 }
1013
margining_xdomain_remove(struct tb_xdomain * xd)1014 static void margining_xdomain_remove(struct tb_xdomain *xd)
1015 {
1016 struct tb_switch *parent_sw;
1017 struct tb_port *downstream;
1018
1019 parent_sw = tb_xdomain_parent(xd);
1020 downstream = tb_port_at(xd->route, parent_sw);
1021 margining_port_remove(downstream);
1022 }
1023 #else
margining_switch_init(struct tb_switch * sw)1024 static inline void margining_switch_init(struct tb_switch *sw) { }
margining_switch_remove(struct tb_switch * sw)1025 static inline void margining_switch_remove(struct tb_switch *sw) { }
margining_xdomain_init(struct tb_xdomain * xd)1026 static inline void margining_xdomain_init(struct tb_xdomain *xd) { }
margining_xdomain_remove(struct tb_xdomain * xd)1027 static inline void margining_xdomain_remove(struct tb_xdomain *xd) { }
1028 #endif
1029
port_clear_all_counters(struct tb_port * port)1030 static int port_clear_all_counters(struct tb_port *port)
1031 {
1032 u32 *buf;
1033 int ret;
1034
1035 buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32),
1036 GFP_KERNEL);
1037 if (!buf)
1038 return -ENOMEM;
1039
1040 ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0,
1041 COUNTER_SET_LEN * port->config.max_counters);
1042 kfree(buf);
1043
1044 return ret;
1045 }
1046
counters_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)1047 static ssize_t counters_write(struct file *file, const char __user *user_buf,
1048 size_t count, loff_t *ppos)
1049 {
1050 struct seq_file *s = file->private_data;
1051 struct tb_port *port = s->private;
1052 struct tb_switch *sw = port->sw;
1053 struct tb *tb = port->sw->tb;
1054 char *buf;
1055 int ret;
1056
1057 buf = validate_and_copy_from_user(user_buf, &count);
1058 if (IS_ERR(buf))
1059 return PTR_ERR(buf);
1060
1061 pm_runtime_get_sync(&sw->dev);
1062
1063 if (mutex_lock_interruptible(&tb->lock)) {
1064 ret = -ERESTARTSYS;
1065 goto out;
1066 }
1067
1068 /* If written delimiter only, clear all counters in one shot */
1069 if (buf[0] == '\n') {
1070 ret = port_clear_all_counters(port);
1071 } else {
1072 char *line = buf;
1073 u32 val, offset;
1074
1075 ret = -EINVAL;
1076 while (parse_line(&line, &offset, &val, 1, 4)) {
1077 ret = tb_port_write(port, &val, TB_CFG_COUNTERS,
1078 offset, 1);
1079 if (ret)
1080 break;
1081 }
1082 }
1083
1084 mutex_unlock(&tb->lock);
1085
1086 out:
1087 pm_runtime_mark_last_busy(&sw->dev);
1088 pm_runtime_put_autosuspend(&sw->dev);
1089 free_page((unsigned long)buf);
1090
1091 return ret < 0 ? ret : count;
1092 }
1093
cap_show_by_dw(struct seq_file * s,struct tb_switch * sw,struct tb_port * port,unsigned int cap,unsigned int offset,u8 cap_id,u8 vsec_id,int dwords)1094 static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw,
1095 struct tb_port *port, unsigned int cap,
1096 unsigned int offset, u8 cap_id, u8 vsec_id,
1097 int dwords)
1098 {
1099 int i, ret;
1100 u32 data;
1101
1102 for (i = 0; i < dwords; i++) {
1103 if (port)
1104 ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1);
1105 else
1106 ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1);
1107 if (ret) {
1108 seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i);
1109 continue;
1110 }
1111
1112 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i,
1113 offset + i, cap_id, vsec_id, data);
1114 }
1115 }
1116
cap_show(struct seq_file * s,struct tb_switch * sw,struct tb_port * port,unsigned int cap,u8 cap_id,u8 vsec_id,int length)1117 static void cap_show(struct seq_file *s, struct tb_switch *sw,
1118 struct tb_port *port, unsigned int cap, u8 cap_id,
1119 u8 vsec_id, int length)
1120 {
1121 int ret, offset = 0;
1122
1123 while (length > 0) {
1124 int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH);
1125 u32 data[TB_MAX_CONFIG_RW_LENGTH];
1126
1127 if (port)
1128 ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset,
1129 dwords);
1130 else
1131 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords);
1132 if (ret) {
1133 cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length);
1134 return;
1135 }
1136
1137 for (i = 0; i < dwords; i++) {
1138 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n",
1139 cap + offset + i, offset + i,
1140 cap_id, vsec_id, data[i]);
1141 }
1142
1143 length -= dwords;
1144 offset += dwords;
1145 }
1146 }
1147
port_cap_show(struct tb_port * port,struct seq_file * s,unsigned int cap)1148 static void port_cap_show(struct tb_port *port, struct seq_file *s,
1149 unsigned int cap)
1150 {
1151 struct tb_cap_any header;
1152 u8 vsec_id = 0;
1153 size_t length;
1154 int ret;
1155
1156 ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1);
1157 if (ret) {
1158 seq_printf(s, "0x%04x <capability read failed>\n", cap);
1159 return;
1160 }
1161
1162 switch (header.basic.cap) {
1163 case TB_PORT_CAP_PHY:
1164 length = PORT_CAP_LANE_LEN;
1165 break;
1166
1167 case TB_PORT_CAP_TIME1:
1168 if (usb4_switch_version(port->sw) < 2)
1169 length = PORT_CAP_TMU_V1_LEN;
1170 else
1171 length = PORT_CAP_TMU_V2_LEN;
1172 break;
1173
1174 case TB_PORT_CAP_POWER:
1175 length = PORT_CAP_POWER_LEN;
1176 break;
1177
1178 case TB_PORT_CAP_ADAP:
1179 if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) {
1180 if (usb4_switch_version(port->sw) < 2)
1181 length = PORT_CAP_V1_PCIE_LEN;
1182 else
1183 length = PORT_CAP_V2_PCIE_LEN;
1184 } else if (tb_port_is_dpin(port)) {
1185 if (usb4_switch_version(port->sw) < 2)
1186 length = PORT_CAP_DP_V1_LEN;
1187 else
1188 length = PORT_CAP_DP_V2_LEN;
1189 } else if (tb_port_is_dpout(port)) {
1190 length = PORT_CAP_DP_V1_LEN;
1191 } else if (tb_port_is_usb3_down(port) ||
1192 tb_port_is_usb3_up(port)) {
1193 length = PORT_CAP_USB3_LEN;
1194 } else {
1195 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
1196 cap, header.basic.cap);
1197 return;
1198 }
1199 break;
1200
1201 case TB_PORT_CAP_VSE:
1202 if (!header.extended_short.length) {
1203 ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT,
1204 cap + 1, 1);
1205 if (ret) {
1206 seq_printf(s, "0x%04x <capability read failed>\n",
1207 cap + 1);
1208 return;
1209 }
1210 length = header.extended_long.length;
1211 vsec_id = header.extended_short.vsec_id;
1212 } else {
1213 length = header.extended_short.length;
1214 vsec_id = header.extended_short.vsec_id;
1215 }
1216 break;
1217
1218 case TB_PORT_CAP_USB4:
1219 length = PORT_CAP_USB4_LEN;
1220 break;
1221
1222 default:
1223 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
1224 cap, header.basic.cap);
1225 return;
1226 }
1227
1228 cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);
1229 }
1230
port_caps_show(struct tb_port * port,struct seq_file * s)1231 static void port_caps_show(struct tb_port *port, struct seq_file *s)
1232 {
1233 int cap;
1234
1235 cap = tb_port_next_cap(port, 0);
1236 while (cap > 0) {
1237 port_cap_show(port, s, cap);
1238 cap = tb_port_next_cap(port, cap);
1239 }
1240 }
1241
port_basic_regs_show(struct tb_port * port,struct seq_file * s)1242 static int port_basic_regs_show(struct tb_port *port, struct seq_file *s)
1243 {
1244 u32 data[PORT_CAP_BASIC_LEN];
1245 int ret, i;
1246
1247 ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data));
1248 if (ret)
1249 return ret;
1250
1251 for (i = 0; i < ARRAY_SIZE(data); i++)
1252 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
1253
1254 return 0;
1255 }
1256
port_regs_show(struct seq_file * s,void * not_used)1257 static int port_regs_show(struct seq_file *s, void *not_used)
1258 {
1259 struct tb_port *port = s->private;
1260 struct tb_switch *sw = port->sw;
1261 struct tb *tb = sw->tb;
1262 int ret;
1263
1264 pm_runtime_get_sync(&sw->dev);
1265
1266 if (mutex_lock_interruptible(&tb->lock)) {
1267 ret = -ERESTARTSYS;
1268 goto out_rpm_put;
1269 }
1270
1271 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
1272
1273 ret = port_basic_regs_show(port, s);
1274 if (ret)
1275 goto out_unlock;
1276
1277 port_caps_show(port, s);
1278
1279 out_unlock:
1280 mutex_unlock(&tb->lock);
1281 out_rpm_put:
1282 pm_runtime_mark_last_busy(&sw->dev);
1283 pm_runtime_put_autosuspend(&sw->dev);
1284
1285 return ret;
1286 }
1287 DEBUGFS_ATTR_RW(port_regs);
1288
switch_cap_show(struct tb_switch * sw,struct seq_file * s,unsigned int cap)1289 static void switch_cap_show(struct tb_switch *sw, struct seq_file *s,
1290 unsigned int cap)
1291 {
1292 struct tb_cap_any header;
1293 int ret, length;
1294 u8 vsec_id = 0;
1295
1296 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1);
1297 if (ret) {
1298 seq_printf(s, "0x%04x <capability read failed>\n", cap);
1299 return;
1300 }
1301
1302 if (header.basic.cap == TB_SWITCH_CAP_VSE) {
1303 if (!header.extended_short.length) {
1304 ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH,
1305 cap + 1, 1);
1306 if (ret) {
1307 seq_printf(s, "0x%04x <capability read failed>\n",
1308 cap + 1);
1309 return;
1310 }
1311 length = header.extended_long.length;
1312 } else {
1313 length = header.extended_short.length;
1314 }
1315 vsec_id = header.extended_short.vsec_id;
1316 } else {
1317 if (header.basic.cap == TB_SWITCH_CAP_TMU) {
1318 length = SWITCH_CAP_TMU_LEN;
1319 } else {
1320 seq_printf(s, "0x%04x <unknown capability 0x%02x>\n",
1321 cap, header.basic.cap);
1322 return;
1323 }
1324 }
1325
1326 cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);
1327 }
1328
switch_caps_show(struct tb_switch * sw,struct seq_file * s)1329 static void switch_caps_show(struct tb_switch *sw, struct seq_file *s)
1330 {
1331 int cap;
1332
1333 cap = tb_switch_next_cap(sw, 0);
1334 while (cap > 0) {
1335 switch_cap_show(sw, s, cap);
1336 cap = tb_switch_next_cap(sw, cap);
1337 }
1338 }
1339
switch_basic_regs_show(struct tb_switch * sw,struct seq_file * s)1340 static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s)
1341 {
1342 u32 data[SWITCH_CAP_BASIC_LEN];
1343 size_t dwords;
1344 int ret, i;
1345
1346 /* Only USB4 has the additional registers */
1347 if (tb_switch_is_usb4(sw))
1348 dwords = ARRAY_SIZE(data);
1349 else
1350 dwords = 7;
1351
1352 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords);
1353 if (ret)
1354 return ret;
1355
1356 for (i = 0; i < dwords; i++)
1357 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
1358
1359 return 0;
1360 }
1361
switch_regs_show(struct seq_file * s,void * not_used)1362 static int switch_regs_show(struct seq_file *s, void *not_used)
1363 {
1364 struct tb_switch *sw = s->private;
1365 struct tb *tb = sw->tb;
1366 int ret;
1367
1368 pm_runtime_get_sync(&sw->dev);
1369
1370 if (mutex_lock_interruptible(&tb->lock)) {
1371 ret = -ERESTARTSYS;
1372 goto out_rpm_put;
1373 }
1374
1375 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
1376
1377 ret = switch_basic_regs_show(sw, s);
1378 if (ret)
1379 goto out_unlock;
1380
1381 switch_caps_show(sw, s);
1382
1383 out_unlock:
1384 mutex_unlock(&tb->lock);
1385 out_rpm_put:
1386 pm_runtime_mark_last_busy(&sw->dev);
1387 pm_runtime_put_autosuspend(&sw->dev);
1388
1389 return ret;
1390 }
1391 DEBUGFS_ATTR_RW(switch_regs);
1392
path_show_one(struct tb_port * port,struct seq_file * s,int hopid)1393 static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid)
1394 {
1395 u32 data[PATH_LEN];
1396 int ret, i;
1397
1398 ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN,
1399 ARRAY_SIZE(data));
1400 if (ret) {
1401 seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN);
1402 return ret;
1403 }
1404
1405 for (i = 0; i < ARRAY_SIZE(data); i++) {
1406 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
1407 hopid * PATH_LEN + i, i, hopid, data[i]);
1408 }
1409
1410 return 0;
1411 }
1412
path_show(struct seq_file * s,void * not_used)1413 static int path_show(struct seq_file *s, void *not_used)
1414 {
1415 struct tb_port *port = s->private;
1416 struct tb_switch *sw = port->sw;
1417 struct tb *tb = sw->tb;
1418 int start, i, ret = 0;
1419
1420 pm_runtime_get_sync(&sw->dev);
1421
1422 if (mutex_lock_interruptible(&tb->lock)) {
1423 ret = -ERESTARTSYS;
1424 goto out_rpm_put;
1425 }
1426
1427 seq_puts(s, "# offset relative_offset in_hop_id value\n");
1428
1429 /* NHI and lane adapters have entry for path 0 */
1430 if (tb_port_is_null(port) || tb_port_is_nhi(port)) {
1431 ret = path_show_one(port, s, 0);
1432 if (ret)
1433 goto out_unlock;
1434 }
1435
1436 start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
1437
1438 for (i = start; i <= port->config.max_in_hop_id; i++) {
1439 ret = path_show_one(port, s, i);
1440 if (ret)
1441 break;
1442 }
1443
1444 out_unlock:
1445 mutex_unlock(&tb->lock);
1446 out_rpm_put:
1447 pm_runtime_mark_last_busy(&sw->dev);
1448 pm_runtime_put_autosuspend(&sw->dev);
1449
1450 return ret;
1451 }
1452 DEBUGFS_ATTR_RO(path);
1453
counter_set_regs_show(struct tb_port * port,struct seq_file * s,int counter)1454 static int counter_set_regs_show(struct tb_port *port, struct seq_file *s,
1455 int counter)
1456 {
1457 u32 data[COUNTER_SET_LEN];
1458 int ret, i;
1459
1460 ret = tb_port_read(port, data, TB_CFG_COUNTERS,
1461 counter * COUNTER_SET_LEN, ARRAY_SIZE(data));
1462 if (ret) {
1463 seq_printf(s, "0x%04x <not accessible>\n",
1464 counter * COUNTER_SET_LEN);
1465 return ret;
1466 }
1467
1468 for (i = 0; i < ARRAY_SIZE(data); i++) {
1469 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
1470 counter * COUNTER_SET_LEN + i, i, counter, data[i]);
1471 }
1472
1473 return 0;
1474 }
1475
counters_show(struct seq_file * s,void * not_used)1476 static int counters_show(struct seq_file *s, void *not_used)
1477 {
1478 struct tb_port *port = s->private;
1479 struct tb_switch *sw = port->sw;
1480 struct tb *tb = sw->tb;
1481 int i, ret = 0;
1482
1483 pm_runtime_get_sync(&sw->dev);
1484
1485 if (mutex_lock_interruptible(&tb->lock)) {
1486 ret = -ERESTARTSYS;
1487 goto out;
1488 }
1489
1490 seq_puts(s, "# offset relative_offset counter_id value\n");
1491
1492 for (i = 0; i < port->config.max_counters; i++) {
1493 ret = counter_set_regs_show(port, s, i);
1494 if (ret)
1495 break;
1496 }
1497
1498 mutex_unlock(&tb->lock);
1499
1500 out:
1501 pm_runtime_mark_last_busy(&sw->dev);
1502 pm_runtime_put_autosuspend(&sw->dev);
1503
1504 return ret;
1505 }
1506 DEBUGFS_ATTR_RW(counters);
1507
1508 /**
1509 * tb_switch_debugfs_init() - Add debugfs entries for router
1510 * @sw: Pointer to the router
1511 *
1512 * Adds debugfs directories and files for given router.
1513 */
tb_switch_debugfs_init(struct tb_switch * sw)1514 void tb_switch_debugfs_init(struct tb_switch *sw)
1515 {
1516 struct dentry *debugfs_dir;
1517 struct tb_port *port;
1518
1519 debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root);
1520 sw->debugfs_dir = debugfs_dir;
1521 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw,
1522 &switch_regs_fops);
1523
1524 tb_switch_for_each_port(sw, port) {
1525 struct dentry *debugfs_dir;
1526 char dir_name[10];
1527
1528 if (port->disabled)
1529 continue;
1530 if (port->config.type == TB_TYPE_INACTIVE)
1531 continue;
1532
1533 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
1534 debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir);
1535 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir,
1536 port, &port_regs_fops);
1537 debugfs_create_file("path", 0400, debugfs_dir, port,
1538 &path_fops);
1539 if (port->config.counters_support)
1540 debugfs_create_file("counters", 0600, debugfs_dir, port,
1541 &counters_fops);
1542 }
1543
1544 margining_switch_init(sw);
1545 }
1546
1547 /**
1548 * tb_switch_debugfs_remove() - Remove all router debugfs entries
1549 * @sw: Pointer to the router
1550 *
1551 * Removes all previously added debugfs entries under this router.
1552 */
tb_switch_debugfs_remove(struct tb_switch * sw)1553 void tb_switch_debugfs_remove(struct tb_switch *sw)
1554 {
1555 margining_switch_remove(sw);
1556 debugfs_remove_recursive(sw->debugfs_dir);
1557 }
1558
tb_xdomain_debugfs_init(struct tb_xdomain * xd)1559 void tb_xdomain_debugfs_init(struct tb_xdomain *xd)
1560 {
1561 margining_xdomain_init(xd);
1562 }
1563
tb_xdomain_debugfs_remove(struct tb_xdomain * xd)1564 void tb_xdomain_debugfs_remove(struct tb_xdomain *xd)
1565 {
1566 margining_xdomain_remove(xd);
1567 }
1568
1569 /**
1570 * tb_service_debugfs_init() - Add debugfs directory for service
1571 * @svc: Thunderbolt service pointer
1572 *
1573 * Adds debugfs directory for service.
1574 */
tb_service_debugfs_init(struct tb_service * svc)1575 void tb_service_debugfs_init(struct tb_service *svc)
1576 {
1577 svc->debugfs_dir = debugfs_create_dir(dev_name(&svc->dev),
1578 tb_debugfs_root);
1579 }
1580
1581 /**
1582 * tb_service_debugfs_remove() - Remove service debugfs directory
1583 * @svc: Thunderbolt service pointer
1584 *
1585 * Removes the previously created debugfs directory for @svc.
1586 */
tb_service_debugfs_remove(struct tb_service * svc)1587 void tb_service_debugfs_remove(struct tb_service *svc)
1588 {
1589 debugfs_remove_recursive(svc->debugfs_dir);
1590 svc->debugfs_dir = NULL;
1591 }
1592
tb_debugfs_init(void)1593 void tb_debugfs_init(void)
1594 {
1595 tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);
1596 }
1597
tb_debugfs_exit(void)1598 void tb_debugfs_exit(void)
1599 {
1600 debugfs_remove_recursive(tb_debugfs_root);
1601 }
1602