?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf: Remove unused 'bprintf'
[drm/drm-misc.git] / drivers / thunderbolt / debugfs.c
blob350310bd0feea70656f6c18f28906c59c5acfea7
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/bitfield.h>
11 #include <linux/debugfs.h>
12 #include <linux/delay.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/uaccess.h>
15
16 #include "tb.h"
17 #include "sb_regs.h"
18
19 #define PORT_CAP_V1_PCIE_LEN 1
20 #define PORT_CAP_V2_PCIE_LEN 2
21 #define PORT_CAP_POWER_LEN 2
22 #define PORT_CAP_LANE_LEN 3
23 #define PORT_CAP_USB3_LEN 5
24 #define PORT_CAP_DP_V1_LEN 9
25 #define PORT_CAP_DP_V2_LEN 14
26 #define PORT_CAP_TMU_V1_LEN 8
27 #define PORT_CAP_TMU_V2_LEN 10
28 #define PORT_CAP_BASIC_LEN 9
29 #define PORT_CAP_USB4_LEN 20
30
31 #define SWITCH_CAP_TMU_LEN 26
32 #define SWITCH_CAP_BASIC_LEN 27
33
34 #define PATH_LEN 2
35
36 #define COUNTER_SET_LEN 3
37
38 /*
39 * USB4 spec doesn't specify dwell range, the range of 100 ms to 500 ms
40 * probed to give good results.
41 */
42 #define MIN_DWELL_TIME 100 /* ms */
43 #define MAX_DWELL_TIME 500 /* ms */
44 #define DWELL_SAMPLE_INTERVAL 10
45
46 /* Sideband registers and their sizes as defined in the USB4 spec */
47 struct sb_reg {
48 unsigned int reg;
49 unsigned int size;
50 };
51
52 #define SB_MAX_SIZE 64
53
54 /* Sideband registers for router */
55 static const struct sb_reg port_sb_regs[] = {
56 { USB4_SB_VENDOR_ID, 4 },
57 { USB4_SB_PRODUCT_ID, 4 },
58 { USB4_SB_DEBUG_CONF, 4 },
59 { USB4_SB_DEBUG, 54 },
60 { USB4_SB_LRD_TUNING, 4 },
61 { USB4_SB_OPCODE, 4 },
62 { USB4_SB_METADATA, 4 },
63 { USB4_SB_LINK_CONF, 3 },
64 { USB4_SB_GEN23_TXFFE, 4 },
65 { USB4_SB_GEN4_TXFFE, 4 },
66 { USB4_SB_VERSION, 4 },
67 { USB4_SB_DATA, 64 },
68 };
69
70 /* Sideband registers for retimer */
71 static const struct sb_reg retimer_sb_regs[] = {
72 { USB4_SB_VENDOR_ID, 4 },
73 { USB4_SB_PRODUCT_ID, 4 },
74 { USB4_SB_FW_VERSION, 4 },
75 { USB4_SB_LRD_TUNING, 4 },
76 { USB4_SB_OPCODE, 4 },
77 { USB4_SB_METADATA, 4 },
78 { USB4_SB_GEN23_TXFFE, 4 },
79 { USB4_SB_GEN4_TXFFE, 4 },
80 { USB4_SB_VERSION, 4 },
81 { USB4_SB_DATA, 64 },
82 };
83
84 #define DEBUGFS_ATTR(__space, __write) \
85 static int __space ## _open(struct inode *inode, struct file *file) \
86 { \
87 return single_open(file, __space ## _show, inode->i_private); \
88 } \
89 \
90 static const struct file_operations __space ## _fops = { \
91 .owner = THIS_MODULE, \
92 .open = __space ## _open, \
93 .release = single_release, \
94 .read = seq_read, \
95 .write = __write, \
96 .llseek = seq_lseek, \
97 }
98
99 #define DEBUGFS_ATTR_RO(__space) \
100 DEBUGFS_ATTR(__space, NULL)
101
102 #define DEBUGFS_ATTR_RW(__space) \
103 DEBUGFS_ATTR(__space, __space ## _write)
104
105 static struct dentry *tb_debugfs_root;
106
107 static void *validate_and_copy_from_user(const void __user *user_buf,
108 size_t *count)
109 {
110 size_t nbytes;
111 void *buf;
112
113 if (!*count)
114 return ERR_PTR(-EINVAL);
115
116 if (!access_ok(user_buf, *count))
117 return ERR_PTR(-EFAULT);
118
119 buf = (void *)get_zeroed_page(GFP_KERNEL);
120 if (!buf)
121 return ERR_PTR(-ENOMEM);
122
123 nbytes = min_t(size_t, *count, PAGE_SIZE);
124 if (copy_from_user(buf, user_buf, nbytes)) {
125 free_page((unsigned long)buf);
126 return ERR_PTR(-EFAULT);
127 }
128
129 *count = nbytes;
130 return buf;
131 }
132
133 static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len,
134 int long_fmt_len)
135 {
136 char *token;
137 u32 v[5];
138 int ret;
139
140 token = strsep(line, "\n");
141 if (!token)
142 return false;
143
144 /*
145 * For Adapter/Router configuration space:
146 * Short format is: offset value\n
147 * v[0] v[1]
148 * Long format as produced from the read side:
149 * offset relative_offset cap_id vs_cap_id value\n
150 * v[0] v[1] v[2] v[3] v[4]
151 *
152 * For Counter configuration space:
153 * Short format is: offset\n
154 * v[0]
155 * Long format as produced from the read side:
156 * offset relative_offset counter_id value\n
157 * v[0] v[1] v[2] v[3]
158 */
159 ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]);
160 /* In case of Counters, clear counter, "val" content is NA */
161 if (ret == short_fmt_len) {
162 *offs = v[0];
163 *val = v[short_fmt_len - 1];
164 return true;
165 } else if (ret == long_fmt_len) {
166 *offs = v[0];
167 *val = v[long_fmt_len - 1];
168 return true;
169 }
170
171 return false;
172 }
173
174 #if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)
175 static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port,
176 const char __user *user_buf, size_t count,
177 loff_t *ppos)
178 {
179 struct tb *tb = sw->tb;
180 char *line, *buf;
181 u32 val, offset;
182 int ret = 0;
183
184 buf = validate_and_copy_from_user(user_buf, &count);
185 if (IS_ERR(buf))
186 return PTR_ERR(buf);
187
188 pm_runtime_get_sync(&sw->dev);
189
190 if (mutex_lock_interruptible(&tb->lock)) {
191 ret = -ERESTARTSYS;
192 goto out;
193 }
194
195 /* User did hardware changes behind the driver's back */
196 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
197
198 line = buf;
199 while (parse_line(&line, &offset, &val, 2, 5)) {
200 if (port)
201 ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1);
202 else
203 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1);
204 if (ret)
205 break;
206 }
207
208 mutex_unlock(&tb->lock);
209
210 out:
211 pm_runtime_mark_last_busy(&sw->dev);
212 pm_runtime_put_autosuspend(&sw->dev);
213 free_page((unsigned long)buf);
214
215 return ret < 0 ? ret : count;
216 }
217
218 static ssize_t port_regs_write(struct file *file, const char __user *user_buf,
219 size_t count, loff_t *ppos)
220 {
221 struct seq_file *s = file->private_data;
222 struct tb_port *port = s->private;
223
224 return regs_write(port->sw, port, user_buf, count, ppos);
225 }
226
227 static ssize_t switch_regs_write(struct file *file, const char __user *user_buf,
228 size_t count, loff_t *ppos)
229 {
230 struct seq_file *s = file->private_data;
231 struct tb_switch *sw = s->private;
232
233 return regs_write(sw, NULL, user_buf, count, ppos);
234 }
235
236 static bool parse_sb_line(char **line, u8 *reg, u8 *data, size_t data_size,
237 size_t *bytes_read)
238 {
239 char *field, *token;
240 int i;
241
242 token = strsep(line, "\n");
243 if (!token)
244 return false;
245
246 /* Parse the register first */
247 field = strsep(&token, " ");
248 if (!field)
249 return false;
250 if (kstrtou8(field, 0, reg))
251 return false;
252
253 /* Then the values for the register, up to data_size */
254 for (i = 0; i < data_size; i++) {
255 field = strsep(&token, " ");
256 if (!field)
257 break;
258 if (kstrtou8(field, 0, &data[i]))
259 return false;
260 }
261
262 *bytes_read = i;
263 return true;
264 }
265
266 static ssize_t sb_regs_write(struct tb_port *port, const struct sb_reg *sb_regs,
267 size_t size, enum usb4_sb_target target, u8 index,
268 char *buf, size_t count, loff_t *ppos)
269 {
270 u8 reg, data[SB_MAX_SIZE];
271 size_t bytes_read;
272 char *line = buf;
273
274 /* User did hardware changes behind the driver's back */
275 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
276
277 /*
278 * For sideband registers we accept:
279 * reg b0 b1 b2...\n
280 *
281 * Here "reg" is the byte offset of the sideband register and "b0"..
282 * are the byte values. There can be less byte values than the register
283 * size. The leftovers will not be overwritten.
284 */
285 while (parse_sb_line(&line, &reg, data, ARRAY_SIZE(data), &bytes_read)) {
286 const struct sb_reg *sb_reg;
287 int ret;
288
289 /* At least one byte must be passed */
290 if (bytes_read < 1)
291 return -EINVAL;
292
293 /* Find the register */
294 sb_reg = NULL;
295 for (int i = 0; i < size; i++) {
296 if (sb_regs[i].reg == reg) {
297 sb_reg = &sb_regs[i];
298 break;
299 }
300 }
301
302 if (!sb_reg)
303 return -EINVAL;
304
305 if (bytes_read > sb_regs->size)
306 return -E2BIG;
307
308 ret = usb4_port_sb_write(port, target, index, sb_reg->reg, data,
309 bytes_read);
310 if (ret)
311 return ret;
312 }
313
314 return 0;
315 }
316
317 static ssize_t port_sb_regs_write(struct file *file, const char __user *user_buf,
318 size_t count, loff_t *ppos)
319 {
320 struct seq_file *s = file->private_data;
321 struct tb_port *port = s->private;
322 struct tb_switch *sw = port->sw;
323 struct tb *tb = sw->tb;
324 char *buf;
325 int ret;
326
327 buf = validate_and_copy_from_user(user_buf, &count);
328 if (IS_ERR(buf))
329 return PTR_ERR(buf);
330
331 pm_runtime_get_sync(&sw->dev);
332
333 if (mutex_lock_interruptible(&tb->lock)) {
334 ret = -ERESTARTSYS;
335 goto out;
336 }
337
338 ret = sb_regs_write(port, port_sb_regs, ARRAY_SIZE(port_sb_regs),
339 USB4_SB_TARGET_ROUTER, 0, buf, count, ppos);
340
341 mutex_unlock(&tb->lock);
342 out:
343 pm_runtime_mark_last_busy(&sw->dev);
344 pm_runtime_put_autosuspend(&sw->dev);
345 free_page((unsigned long)buf);
346
347 return ret < 0 ? ret : count;
348 }
349
350 static ssize_t retimer_sb_regs_write(struct file *file,
351 const char __user *user_buf,
352 size_t count, loff_t *ppos)
353 {
354 struct seq_file *s = file->private_data;
355 struct tb_retimer *rt = s->private;
356 struct tb *tb = rt->tb;
357 char *buf;
358 int ret;
359
360 buf = validate_and_copy_from_user(user_buf, &count);
361 if (IS_ERR(buf))
362 return PTR_ERR(buf);
363
364 pm_runtime_get_sync(&rt->dev);
365
366 if (mutex_lock_interruptible(&tb->lock)) {
367 ret = -ERESTARTSYS;
368 goto out;
369 }
370
371 ret = sb_regs_write(rt->port, retimer_sb_regs, ARRAY_SIZE(retimer_sb_regs),
372 USB4_SB_TARGET_RETIMER, rt->index, buf, count, ppos);
373
374 mutex_unlock(&tb->lock);
375 out:
376 pm_runtime_mark_last_busy(&rt->dev);
377 pm_runtime_put_autosuspend(&rt->dev);
378 free_page((unsigned long)buf);
379
380 return ret < 0 ? ret : count;
381 }
382 #define DEBUGFS_MODE 0600
383 #else
384 #define port_regs_write NULL
385 #define switch_regs_write NULL
386 #define port_sb_regs_write NULL
387 #define retimer_sb_regs_write NULL
388 #define DEBUGFS_MODE 0400
389 #endif
390
391 #if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING)
392 /**
393 * struct tb_margining - Lane margining support
394 * @port: USB4 port through which the margining operations are run
395 * @target: Sideband target
396 * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER
397 * @dev: Pointer to the device that is the target (USB4 port or retimer)
398 * @caps: Port lane margining capabilities
399 * @results: Last lane margining results
400 * @lanes: %0, %1 or %7 (all)
401 * @min_ber_level: Minimum supported BER level contour value
402 * @max_ber_level: Maximum supported BER level contour value
403 * @ber_level: Current BER level contour value
404 * @voltage_steps: Number of mandatory voltage steps
405 * @max_voltage_offset: Maximum mandatory voltage offset (in mV)
406 * @voltage_steps_optional_range: Number of voltage steps for optional range
407 * @max_voltage_offset_optional_range: Maximum voltage offset for the optional
408 * range (in mV).
409 * @time_steps: Number of time margin steps
410 * @max_time_offset: Maximum time margin offset (in mUI)
411 * @voltage_time_offset: Offset for voltage / time for software margining
412 * @dwell_time: Dwell time for software margining (in ms)
413 * @error_counter: Error counter operation for software margining
414 * @optional_voltage_offset_range: Enable optional extended voltage range
415 * @software: %true if software margining is used instead of hardware
416 * @time: %true if time margining is used instead of voltage
417 * @right_high: %false if left/low margin test is performed, %true if
418 * right/high
419 */
420 struct tb_margining {
421 struct tb_port *port;
422 enum usb4_sb_target target;
423 u8 index;
424 struct device *dev;
425 u32 caps[2];
426 u32 results[2];
427 unsigned int lanes;
428 unsigned int min_ber_level;
429 unsigned int max_ber_level;
430 unsigned int ber_level;
431 unsigned int voltage_steps;
432 unsigned int max_voltage_offset;
433 unsigned int voltage_steps_optional_range;
434 unsigned int max_voltage_offset_optional_range;
435 unsigned int time_steps;
436 unsigned int max_time_offset;
437 unsigned int voltage_time_offset;
438 unsigned int dwell_time;
439 enum usb4_margin_sw_error_counter error_counter;
440 bool optional_voltage_offset_range;
441 bool software;
442 bool time;
443 bool right_high;
444 };
445
446 static int margining_modify_error_counter(struct tb_margining *margining,
447 u32 lanes, enum usb4_margin_sw_error_counter error_counter)
448 {
449 struct usb4_port_margining_params params = { 0 };
450 struct tb_port *port = margining->port;
451 u32 result;
452
453 if (error_counter != USB4_MARGIN_SW_ERROR_COUNTER_CLEAR &&
454 error_counter != USB4_MARGIN_SW_ERROR_COUNTER_STOP)
455 return -EOPNOTSUPP;
456
457 params.error_counter = error_counter;
458 params.lanes = lanes;
459
460 return usb4_port_sw_margin(port, margining->target, margining->index,
461 &params, &result);
462 }
463
464 static bool supports_software(const struct tb_margining *margining)
465 {
466 return margining->caps[0] & USB4_MARGIN_CAP_0_MODES_SW;
467 }
468
469 static bool supports_hardware(const struct tb_margining *margining)
470 {
471 return margining->caps[0] & USB4_MARGIN_CAP_0_MODES_HW;
472 }
473
474 static bool both_lanes(const struct tb_margining *margining)
475 {
476 return margining->caps[0] & USB4_MARGIN_CAP_0_2_LANES;
477 }
478
479 static unsigned int
480 independent_voltage_margins(const struct tb_margining *margining)
481 {
482 return FIELD_GET(USB4_MARGIN_CAP_0_VOLTAGE_INDP_MASK, margining->caps[0]);
483 }
484
485 static bool supports_time(const struct tb_margining *margining)
486 {
487 return margining->caps[0] & USB4_MARGIN_CAP_0_TIME;
488 }
489
490 /* Only applicable if supports_time() returns true */
491 static unsigned int
492 independent_time_margins(const struct tb_margining *margining)
493 {
494 return FIELD_GET(USB4_MARGIN_CAP_1_TIME_INDP_MASK, margining->caps[1]);
495 }
496
497 static bool
498 supports_optional_voltage_offset_range(const struct tb_margining *margining)
499 {
500 return margining->caps[0] & USB4_MARGIN_CAP_0_OPT_VOLTAGE_SUPPORT;
501 }
502
503 static ssize_t
504 margining_ber_level_write(struct file *file, const char __user *user_buf,
505 size_t count, loff_t *ppos)
506 {
507 struct seq_file *s = file->private_data;
508 struct tb_margining *margining = s->private;
509 struct tb *tb = margining->port->sw->tb;
510 unsigned int val;
511 int ret = 0;
512 char *buf;
513
514 if (mutex_lock_interruptible(&tb->lock))
515 return -ERESTARTSYS;
516
517 if (margining->software) {
518 ret = -EINVAL;
519 goto out_unlock;
520 }
521
522 buf = validate_and_copy_from_user(user_buf, &count);
523 if (IS_ERR(buf)) {
524 ret = PTR_ERR(buf);
525 goto out_unlock;
526 }
527
528 buf[count - 1] = '\0';
529
530 ret = kstrtouint(buf, 10, &val);
531 if (ret)
532 goto out_free;
533
534 if (val < margining->min_ber_level ||
535 val > margining->max_ber_level) {
536 ret = -EINVAL;
537 goto out_free;
538 }
539
540 margining->ber_level = val;
541
542 out_free:
543 free_page((unsigned long)buf);
544 out_unlock:
545 mutex_unlock(&tb->lock);
546
547 return ret < 0 ? ret : count;
548 }
549
550 static void ber_level_show(struct seq_file *s, unsigned int val)
551 {
552 if (val % 2)
553 seq_printf(s, "3 * 1e%d (%u)\n", -12 + (val + 1) / 2, val);
554 else
555 seq_printf(s, "1e%d (%u)\n", -12 + val / 2, val);
556 }
557
558 static int margining_ber_level_show(struct seq_file *s, void *not_used)
559 {
560 const struct tb_margining *margining = s->private;
561
562 if (margining->software)
563 return -EINVAL;
564 ber_level_show(s, margining->ber_level);
565 return 0;
566 }
567 DEBUGFS_ATTR_RW(margining_ber_level);
568
569 static int margining_caps_show(struct seq_file *s, void *not_used)
570 {
571 struct tb_margining *margining = s->private;
572 struct tb *tb = margining->port->sw->tb;
573 u32 cap0, cap1;
574
575 if (mutex_lock_interruptible(&tb->lock))
576 return -ERESTARTSYS;
577
578 /* Dump the raw caps first */
579 cap0 = margining->caps[0];
580 seq_printf(s, "0x%08x\n", cap0);
581 cap1 = margining->caps[1];
582 seq_printf(s, "0x%08x\n", cap1);
583
584 seq_printf(s, "# software margining: %s\n",
585 supports_software(margining) ? "yes" : "no");
586 if (supports_hardware(margining)) {
587 seq_puts(s, "# hardware margining: yes\n");
588 seq_puts(s, "# minimum BER level contour: ");
589 ber_level_show(s, margining->min_ber_level);
590 seq_puts(s, "# maximum BER level contour: ");
591 ber_level_show(s, margining->max_ber_level);
592 } else {
593 seq_puts(s, "# hardware margining: no\n");
594 }
595
596 seq_printf(s, "# both lanes simultaneously: %s\n",
597 both_lanes(margining) ? "yes" : "no");
598 seq_printf(s, "# voltage margin steps: %u\n",
599 margining->voltage_steps);
600 seq_printf(s, "# maximum voltage offset: %u mV\n",
601 margining->max_voltage_offset);
602 seq_printf(s, "# optional voltage offset range support: %s\n",
603 str_yes_no(supports_optional_voltage_offset_range(margining)));
604 if (supports_optional_voltage_offset_range(margining)) {
605 seq_printf(s, "# voltage margin steps, optional range: %u\n",
606 margining->voltage_steps_optional_range);
607 seq_printf(s, "# maximum voltage offset, optional range: %u mV\n",
608 margining->max_voltage_offset_optional_range);
609 }
610
611 switch (independent_voltage_margins(margining)) {
612 case USB4_MARGIN_CAP_0_VOLTAGE_MIN:
613 seq_puts(s, "# returns minimum between high and low voltage margins\n");
614 break;
615 case USB4_MARGIN_CAP_0_VOLTAGE_HL:
616 seq_puts(s, "# returns high or low voltage margin\n");
617 break;
618 case USB4_MARGIN_CAP_0_VOLTAGE_BOTH:
619 seq_puts(s, "# returns both high and low margins\n");
620 break;
621 }
622
623 if (supports_time(margining)) {
624 seq_puts(s, "# time margining: yes\n");
625 seq_printf(s, "# time margining is destructive: %s\n",
626 cap1 & USB4_MARGIN_CAP_1_TIME_DESTR ? "yes" : "no");
627
628 switch (independent_time_margins(margining)) {
629 case USB4_MARGIN_CAP_1_TIME_MIN:
630 seq_puts(s, "# returns minimum between left and right time margins\n");
631 break;
632 case USB4_MARGIN_CAP_1_TIME_LR:
633 seq_puts(s, "# returns left or right margin\n");
634 break;
635 case USB4_MARGIN_CAP_1_TIME_BOTH:
636 seq_puts(s, "# returns both left and right margins\n");
637 break;
638 }
639
640 seq_printf(s, "# time margin steps: %u\n",
641 margining->time_steps);
642 seq_printf(s, "# maximum time offset: %u mUI\n",
643 margining->max_time_offset);
644 } else {
645 seq_puts(s, "# time margining: no\n");
646 }
647
648 mutex_unlock(&tb->lock);
649 return 0;
650 }
651 DEBUGFS_ATTR_RO(margining_caps);
652
653 static ssize_t
654 margining_lanes_write(struct file *file, const char __user *user_buf,
655 size_t count, loff_t *ppos)
656 {
657 struct seq_file *s = file->private_data;
658 struct tb_margining *margining = s->private;
659 struct tb *tb = margining->port->sw->tb;
660 int ret = 0;
661 char *buf;
662
663 buf = validate_and_copy_from_user(user_buf, &count);
664 if (IS_ERR(buf))
665 return PTR_ERR(buf);
666
667 buf[count - 1] = '\0';
668
669 if (mutex_lock_interruptible(&tb->lock)) {
670 ret = -ERESTARTSYS;
671 goto out_free;
672 }
673
674 if (!strcmp(buf, "0")) {
675 margining->lanes = 0;
676 } else if (!strcmp(buf, "1")) {
677 margining->lanes = 1;
678 } else if (!strcmp(buf, "all")) {
679 /* Needs to be supported */
680 if (both_lanes(margining))
681 margining->lanes = 7;
682 else
683 ret = -EINVAL;
684 } else {
685 ret = -EINVAL;
686 }
687
688 mutex_unlock(&tb->lock);
689
690 out_free:
691 free_page((unsigned long)buf);
692 return ret < 0 ? ret : count;
693 }
694
695 static int margining_lanes_show(struct seq_file *s, void *not_used)
696 {
697 struct tb_margining *margining = s->private;
698 struct tb *tb = margining->port->sw->tb;
699 unsigned int lanes;
700
701 if (mutex_lock_interruptible(&tb->lock))
702 return -ERESTARTSYS;
703
704 lanes = margining->lanes;
705 if (both_lanes(margining)) {
706 if (!lanes)
707 seq_puts(s, "[0] 1 all\n");
708 else if (lanes == 1)
709 seq_puts(s, "0 [1] all\n");
710 else
711 seq_puts(s, "0 1 [all]\n");
712 } else {
713 if (!lanes)
714 seq_puts(s, "[0] 1\n");
715 else
716 seq_puts(s, "0 [1]\n");
717 }
718
719 mutex_unlock(&tb->lock);
720 return 0;
721 }
722 DEBUGFS_ATTR_RW(margining_lanes);
723
724 static ssize_t
725 margining_voltage_time_offset_write(struct file *file,
726 const char __user *user_buf,
727 size_t count, loff_t *ppos)
728 {
729 struct seq_file *s = file->private_data;
730 struct tb_margining *margining = s->private;
731 struct tb *tb = margining->port->sw->tb;
732 unsigned int max_margin;
733 unsigned int val;
734 int ret;
735
736 ret = kstrtouint_from_user(user_buf, count, 10, &val);
737 if (ret)
738 return ret;
739
740 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
741 if (!margining->software)
742 return -EOPNOTSUPP;
743
744 if (margining->time)
745 max_margin = margining->time_steps;
746 else
747 if (margining->optional_voltage_offset_range)
748 max_margin = margining->voltage_steps_optional_range;
749 else
750 max_margin = margining->voltage_steps;
751
752 margining->voltage_time_offset = clamp(val, 0, max_margin);
753 }
754
755 return count;
756 }
757
758 static int margining_voltage_time_offset_show(struct seq_file *s,
759 void *not_used)
760 {
761 const struct tb_margining *margining = s->private;
762 struct tb *tb = margining->port->sw->tb;
763
764 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
765 if (!margining->software)
766 return -EOPNOTSUPP;
767
768 seq_printf(s, "%d\n", margining->voltage_time_offset);
769 }
770
771 return 0;
772 }
773 DEBUGFS_ATTR_RW(margining_voltage_time_offset);
774
775 static ssize_t
776 margining_error_counter_write(struct file *file, const char __user *user_buf,
777 size_t count, loff_t *ppos)
778 {
779 enum usb4_margin_sw_error_counter error_counter;
780 struct seq_file *s = file->private_data;
781 struct tb_margining *margining = s->private;
782 struct tb *tb = margining->port->sw->tb;
783 char *buf;
784
785 buf = validate_and_copy_from_user(user_buf, &count);
786 if (IS_ERR(buf))
787 return PTR_ERR(buf);
788
789 buf[count - 1] = '\0';
790
791 if (!strcmp(buf, "nop"))
792 error_counter = USB4_MARGIN_SW_ERROR_COUNTER_NOP;
793 else if (!strcmp(buf, "clear"))
794 error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR;
795 else if (!strcmp(buf, "start"))
796 error_counter = USB4_MARGIN_SW_ERROR_COUNTER_START;
797 else if (!strcmp(buf, "stop"))
798 error_counter = USB4_MARGIN_SW_ERROR_COUNTER_STOP;
799 else
800 return -EINVAL;
801
802 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
803 if (!margining->software)
804 return -EOPNOTSUPP;
805
806 margining->error_counter = error_counter;
807 }
808
809 return count;
810 }
811
812 static int margining_error_counter_show(struct seq_file *s, void *not_used)
813 {
814 const struct tb_margining *margining = s->private;
815 struct tb *tb = margining->port->sw->tb;
816
817 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
818 if (!margining->software)
819 return -EOPNOTSUPP;
820
821 switch (margining->error_counter) {
822 case USB4_MARGIN_SW_ERROR_COUNTER_NOP:
823 seq_puts(s, "[nop] clear start stop\n");
824 break;
825 case USB4_MARGIN_SW_ERROR_COUNTER_CLEAR:
826 seq_puts(s, "nop [clear] start stop\n");
827 break;
828 case USB4_MARGIN_SW_ERROR_COUNTER_START:
829 seq_puts(s, "nop clear [start] stop\n");
830 break;
831 case USB4_MARGIN_SW_ERROR_COUNTER_STOP:
832 seq_puts(s, "nop clear start [stop]\n");
833 break;
834 }
835 }
836
837 return 0;
838 }
839 DEBUGFS_ATTR_RW(margining_error_counter);
840
841 static ssize_t
842 margining_dwell_time_write(struct file *file, const char __user *user_buf,
843 size_t count, loff_t *ppos)
844 {
845 struct seq_file *s = file->private_data;
846 struct tb_margining *margining = s->private;
847 struct tb *tb = margining->port->sw->tb;
848 unsigned int val;
849 int ret;
850
851 ret = kstrtouint_from_user(user_buf, count, 10, &val);
852 if (ret)
853 return ret;
854
855 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
856 if (!margining->software)
857 return -EOPNOTSUPP;
858
859 margining->dwell_time = clamp(val, MIN_DWELL_TIME, MAX_DWELL_TIME);
860 }
861
862 return count;
863 }
864
865 static int margining_dwell_time_show(struct seq_file *s, void *not_used)
866 {
867 struct tb_margining *margining = s->private;
868 struct tb *tb = margining->port->sw->tb;
869
870 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
871 if (!margining->software)
872 return -EOPNOTSUPP;
873
874 seq_printf(s, "%d\n", margining->dwell_time);
875 }
876
877 return 0;
878 }
879 DEBUGFS_ATTR_RW(margining_dwell_time);
880
881 static ssize_t
882 margining_optional_voltage_offset_write(struct file *file, const char __user *user_buf,
883 size_t count, loff_t *ppos)
884 {
885 struct seq_file *s = file->private_data;
886 struct tb_margining *margining = s->private;
887 struct tb *tb = margining->port->sw->tb;
888 bool val;
889 int ret;
890
891 ret = kstrtobool_from_user(user_buf, count, &val);
892 if (ret)
893 return ret;
894
895 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
896 margining->optional_voltage_offset_range = val;
897 }
898
899 return count;
900 }
901
902 static int margining_optional_voltage_offset_show(struct seq_file *s,
903 void *not_used)
904 {
905 struct tb_margining *margining = s->private;
906 struct tb *tb = margining->port->sw->tb;
907
908 scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) {
909 seq_printf(s, "%u\n", margining->optional_voltage_offset_range);
910 }
911
912 return 0;
913 }
914 DEBUGFS_ATTR_RW(margining_optional_voltage_offset);
915
916 static ssize_t margining_mode_write(struct file *file,
917 const char __user *user_buf,
918 size_t count, loff_t *ppos)
919 {
920 struct seq_file *s = file->private_data;
921 struct tb_margining *margining = s->private;
922 struct tb *tb = margining->port->sw->tb;
923 int ret = 0;
924 char *buf;
925
926 buf = validate_and_copy_from_user(user_buf, &count);
927 if (IS_ERR(buf))
928 return PTR_ERR(buf);
929
930 buf[count - 1] = '\0';
931
932 if (mutex_lock_interruptible(&tb->lock)) {
933 ret = -ERESTARTSYS;
934 goto out_free;
935 }
936
937 if (!strcmp(buf, "software")) {
938 if (supports_software(margining))
939 margining->software = true;
940 else
941 ret = -EINVAL;
942 } else if (!strcmp(buf, "hardware")) {
943 if (supports_hardware(margining))
944 margining->software = false;
945 else
946 ret = -EINVAL;
947 } else {
948 ret = -EINVAL;
949 }
950
951 mutex_unlock(&tb->lock);
952
953 out_free:
954 free_page((unsigned long)buf);
955 return ret ? ret : count;
956 }
957
958 static int margining_mode_show(struct seq_file *s, void *not_used)
959 {
960 struct tb_margining *margining = s->private;
961 struct tb *tb = margining->port->sw->tb;
962 const char *space = "";
963
964 if (mutex_lock_interruptible(&tb->lock))
965 return -ERESTARTSYS;
966
967 if (supports_software(margining)) {
968 if (margining->software)
969 seq_puts(s, "[software]");
970 else
971 seq_puts(s, "software");
972 space = " ";
973 }
974 if (supports_hardware(margining)) {
975 if (margining->software)
976 seq_printf(s, "%shardware", space);
977 else
978 seq_printf(s, "%s[hardware]", space);
979 }
980
981 mutex_unlock(&tb->lock);
982
983 seq_puts(s, "\n");
984 return 0;
985 }
986 DEBUGFS_ATTR_RW(margining_mode);
987
988 static int margining_run_sw(struct tb_margining *margining,
989 struct usb4_port_margining_params *params)
990 {
991 u32 nsamples = margining->dwell_time / DWELL_SAMPLE_INTERVAL;
992 int ret, i;
993
994 ret = usb4_port_sw_margin(margining->port, margining->target, margining->index,
995 params, margining->results);
996 if (ret)
997 goto out_stop;
998
999 for (i = 0; i <= nsamples; i++) {
1000 u32 errors = 0;
1001
1002 ret = usb4_port_sw_margin_errors(margining->port, margining->target,
1003 margining->index, &margining->results[1]);
1004 if (ret)
1005 break;
1006
1007 if (margining->lanes == USB4_MARGIN_SW_LANE_0)
1008 errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_0_MASK,
1009 margining->results[1]);
1010 else if (margining->lanes == USB4_MARGIN_SW_LANE_1)
1011 errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_1_MASK,
1012 margining->results[1]);
1013 else if (margining->lanes == USB4_MARGIN_SW_ALL_LANES)
1014 errors = margining->results[1];
1015
1016 /* Any errors stop the test */
1017 if (errors)
1018 break;
1019
1020 fsleep(DWELL_SAMPLE_INTERVAL * USEC_PER_MSEC);
1021 }
1022
1023 out_stop:
1024 /*
1025 * Stop the counters but don't clear them to allow the
1026 * different error counter configurations.
1027 */
1028 margining_modify_error_counter(margining, margining->lanes,
1029 USB4_MARGIN_SW_ERROR_COUNTER_STOP);
1030 return ret;
1031 }
1032
1033 static int margining_run_write(void *data, u64 val)
1034 {
1035 struct tb_margining *margining = data;
1036 struct tb_port *port = margining->port;
1037 struct device *dev = margining->dev;
1038 struct tb_switch *sw = port->sw;
1039 struct tb_switch *down_sw;
1040 struct tb *tb = sw->tb;
1041 int ret, clx;
1042
1043 if (val != 1)
1044 return -EINVAL;
1045
1046 pm_runtime_get_sync(dev);
1047
1048 if (mutex_lock_interruptible(&tb->lock)) {
1049 ret = -ERESTARTSYS;
1050 goto out_rpm_put;
1051 }
1052
1053 if (tb_is_upstream_port(port))
1054 down_sw = sw;
1055 else if (port->remote)
1056 down_sw = port->remote->sw;
1057 else
1058 down_sw = NULL;
1059
1060 if (down_sw) {
1061 /*
1062 * CL states may interfere with lane margining so
1063 * disable them temporarily now.
1064 */
1065 ret = tb_switch_clx_disable(down_sw);
1066 if (ret < 0) {
1067 tb_sw_warn(down_sw, "failed to disable CL states\n");
1068 goto out_unlock;
1069 }
1070 clx = ret;
1071 }
1072
1073 /* Clear the results */
1074 memset(margining->results, 0, sizeof(margining->results));
1075
1076 if (margining->software) {
1077 struct usb4_port_margining_params params = {
1078 .error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR,
1079 .lanes = margining->lanes,
1080 .time = margining->time,
1081 .voltage_time_offset = margining->voltage_time_offset,
1082 .right_high = margining->right_high,
1083 .optional_voltage_offset_range = margining->optional_voltage_offset_range,
1084 };
1085
1086 tb_port_dbg(port,
1087 "running software %s lane margining for %s lanes %u\n",
1088 margining->time ? "time" : "voltage", dev_name(dev),
1089 margining->lanes);
1090
1091 ret = margining_run_sw(margining, &params);
1092 } else {
1093 struct usb4_port_margining_params params = {
1094 .ber_level = margining->ber_level,
1095 .lanes = margining->lanes,
1096 .time = margining->time,
1097 .right_high = margining->right_high,
1098 .optional_voltage_offset_range = margining->optional_voltage_offset_range,
1099 };
1100
1101 tb_port_dbg(port,
1102 "running hardware %s lane margining for %s lanes %u\n",
1103 margining->time ? "time" : "voltage", dev_name(dev),
1104 margining->lanes);
1105
1106 ret = usb4_port_hw_margin(port, margining->target, margining->index, &params,
1107 margining->results);
1108 }
1109
1110 if (down_sw)
1111 tb_switch_clx_enable(down_sw, clx);
1112 out_unlock:
1113 mutex_unlock(&tb->lock);
1114 out_rpm_put:
1115 pm_runtime_mark_last_busy(dev);
1116 pm_runtime_put_autosuspend(dev);
1117
1118 return ret;
1119 }
1120 DEFINE_DEBUGFS_ATTRIBUTE(margining_run_fops, NULL, margining_run_write,
1121 "%llu\n");
1122
1123 static ssize_t margining_results_write(struct file *file,
1124 const char __user *user_buf,
1125 size_t count, loff_t *ppos)
1126 {
1127 struct seq_file *s = file->private_data;
1128 struct tb_margining *margining = s->private;
1129 struct tb *tb = margining->port->sw->tb;
1130
1131 if (mutex_lock_interruptible(&tb->lock))
1132 return -ERESTARTSYS;
1133
1134 /* Just clear the results */
1135 margining->results[0] = 0;
1136 margining->results[1] = 0;
1137
1138 if (margining->software) {
1139 /* Clear the error counters */
1140 margining_modify_error_counter(margining,
1141 USB4_MARGIN_SW_ALL_LANES,
1142 USB4_MARGIN_SW_ERROR_COUNTER_CLEAR);
1143 }
1144
1145 mutex_unlock(&tb->lock);
1146 return count;
1147 }
1148
1149 static void voltage_margin_show(struct seq_file *s,
1150 const struct tb_margining *margining, u8 val)
1151 {
1152 unsigned int tmp, voltage;
1153
1154 tmp = FIELD_GET(USB4_MARGIN_HW_RES_1_MARGIN_MASK, val);
1155 voltage = tmp * margining->max_voltage_offset / margining->voltage_steps;
1156 seq_printf(s, "%u mV (%u)", voltage, tmp);
1157 if (val & USB4_MARGIN_HW_RES_1_EXCEEDS)
1158 seq_puts(s, " exceeds maximum");
1159 seq_puts(s, "\n");
1160 if (margining->optional_voltage_offset_range)
1161 seq_puts(s, " optional voltage offset range enabled\n");
1162 }
1163
1164 static void time_margin_show(struct seq_file *s,
1165 const struct tb_margining *margining, u8 val)
1166 {
1167 unsigned int tmp, interval;
1168
1169 tmp = FIELD_GET(USB4_MARGIN_HW_RES_1_MARGIN_MASK, val);
1170 interval = tmp * margining->max_time_offset / margining->time_steps;
1171 seq_printf(s, "%u mUI (%u)", interval, tmp);
1172 if (val & USB4_MARGIN_HW_RES_1_EXCEEDS)
1173 seq_puts(s, " exceeds maximum");
1174 seq_puts(s, "\n");
1175 }
1176
1177 static int margining_results_show(struct seq_file *s, void *not_used)
1178 {
1179 struct tb_margining *margining = s->private;
1180 struct tb *tb = margining->port->sw->tb;
1181
1182 if (mutex_lock_interruptible(&tb->lock))
1183 return -ERESTARTSYS;
1184
1185 /* Dump the raw results first */
1186 seq_printf(s, "0x%08x\n", margining->results[0]);
1187 /* Only the hardware margining has two result dwords */
1188 if (!margining->software) {
1189 unsigned int val;
1190
1191 seq_printf(s, "0x%08x\n", margining->results[1]);
1192
1193 if (margining->time) {
1194 if (!margining->lanes || margining->lanes == 7) {
1195 val = margining->results[1];
1196 seq_puts(s, "# lane 0 right time margin: ");
1197 time_margin_show(s, margining, val);
1198 val = margining->results[1] >>
1199 USB4_MARGIN_HW_RES_1_L0_LL_MARGIN_SHIFT;
1200 seq_puts(s, "# lane 0 left time margin: ");
1201 time_margin_show(s, margining, val);
1202 }
1203 if (margining->lanes == 1 || margining->lanes == 7) {
1204 val = margining->results[1] >>
1205 USB4_MARGIN_HW_RES_1_L1_RH_MARGIN_SHIFT;
1206 seq_puts(s, "# lane 1 right time margin: ");
1207 time_margin_show(s, margining, val);
1208 val = margining->results[1] >>
1209 USB4_MARGIN_HW_RES_1_L1_LL_MARGIN_SHIFT;
1210 seq_puts(s, "# lane 1 left time margin: ");
1211 time_margin_show(s, margining, val);
1212 }
1213 } else {
1214 if (!margining->lanes || margining->lanes == 7) {
1215 val = margining->results[1];
1216 seq_puts(s, "# lane 0 high voltage margin: ");
1217 voltage_margin_show(s, margining, val);
1218 val = margining->results[1] >>
1219 USB4_MARGIN_HW_RES_1_L0_LL_MARGIN_SHIFT;
1220 seq_puts(s, "# lane 0 low voltage margin: ");
1221 voltage_margin_show(s, margining, val);
1222 }
1223 if (margining->lanes == 1 || margining->lanes == 7) {
1224 val = margining->results[1] >>
1225 USB4_MARGIN_HW_RES_1_L1_RH_MARGIN_SHIFT;
1226 seq_puts(s, "# lane 1 high voltage margin: ");
1227 voltage_margin_show(s, margining, val);
1228 val = margining->results[1] >>
1229 USB4_MARGIN_HW_RES_1_L1_LL_MARGIN_SHIFT;
1230 seq_puts(s, "# lane 1 low voltage margin: ");
1231 voltage_margin_show(s, margining, val);
1232 }
1233 }
1234 } else {
1235 u32 lane_errors, result;
1236
1237 seq_printf(s, "0x%08x\n", margining->results[1]);
1238 result = FIELD_GET(USB4_MARGIN_SW_LANES_MASK, margining->results[0]);
1239
1240 if (result == USB4_MARGIN_SW_LANE_0 ||
1241 result == USB4_MARGIN_SW_ALL_LANES) {
1242 lane_errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_0_MASK,
1243 margining->results[1]);
1244 seq_printf(s, "# lane 0 errors: %u\n", lane_errors);
1245 }
1246 if (result == USB4_MARGIN_SW_LANE_1 ||
1247 result == USB4_MARGIN_SW_ALL_LANES) {
1248 lane_errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_1_MASK,
1249 margining->results[1]);
1250 seq_printf(s, "# lane 1 errors: %u\n", lane_errors);
1251 }
1252 }
1253
1254 mutex_unlock(&tb->lock);
1255 return 0;
1256 }
1257 DEBUGFS_ATTR_RW(margining_results);
1258
1259 static ssize_t margining_test_write(struct file *file,
1260 const char __user *user_buf,
1261 size_t count, loff_t *ppos)
1262 {
1263 struct seq_file *s = file->private_data;
1264 struct tb_margining *margining = s->private;
1265 struct tb *tb = margining->port->sw->tb;
1266 int ret = 0;
1267 char *buf;
1268
1269 buf = validate_and_copy_from_user(user_buf, &count);
1270 if (IS_ERR(buf))
1271 return PTR_ERR(buf);
1272
1273 buf[count - 1] = '\0';
1274
1275 if (mutex_lock_interruptible(&tb->lock)) {
1276 ret = -ERESTARTSYS;
1277 goto out_free;
1278 }
1279
1280 if (!strcmp(buf, "time") && supports_time(margining))
1281 margining->time = true;
1282 else if (!strcmp(buf, "voltage"))
1283 margining->time = false;
1284 else
1285 ret = -EINVAL;
1286
1287 mutex_unlock(&tb->lock);
1288
1289 out_free:
1290 free_page((unsigned long)buf);
1291 return ret ? ret : count;
1292 }
1293
1294 static int margining_test_show(struct seq_file *s, void *not_used)
1295 {
1296 struct tb_margining *margining = s->private;
1297 struct tb *tb = margining->port->sw->tb;
1298
1299 if (mutex_lock_interruptible(&tb->lock))
1300 return -ERESTARTSYS;
1301
1302 if (supports_time(margining)) {
1303 if (margining->time)
1304 seq_puts(s, "voltage [time]\n");
1305 else
1306 seq_puts(s, "[voltage] time\n");
1307 } else {
1308 seq_puts(s, "[voltage]\n");
1309 }
1310
1311 mutex_unlock(&tb->lock);
1312 return 0;
1313 }
1314 DEBUGFS_ATTR_RW(margining_test);
1315
1316 static ssize_t margining_margin_write(struct file *file,
1317 const char __user *user_buf,
1318 size_t count, loff_t *ppos)
1319 {
1320 struct seq_file *s = file->private_data;
1321 struct tb_margining *margining = s->private;
1322 struct tb *tb = margining->port->sw->tb;
1323 int ret = 0;
1324 char *buf;
1325
1326 buf = validate_and_copy_from_user(user_buf, &count);
1327 if (IS_ERR(buf))
1328 return PTR_ERR(buf);
1329
1330 buf[count - 1] = '\0';
1331
1332 if (mutex_lock_interruptible(&tb->lock)) {
1333 ret = -ERESTARTSYS;
1334 goto out_free;
1335 }
1336
1337 if (margining->time) {
1338 if (!strcmp(buf, "left"))
1339 margining->right_high = false;
1340 else if (!strcmp(buf, "right"))
1341 margining->right_high = true;
1342 else
1343 ret = -EINVAL;
1344 } else {
1345 if (!strcmp(buf, "low"))
1346 margining->right_high = false;
1347 else if (!strcmp(buf, "high"))
1348 margining->right_high = true;
1349 else
1350 ret = -EINVAL;
1351 }
1352
1353 mutex_unlock(&tb->lock);
1354
1355 out_free:
1356 free_page((unsigned long)buf);
1357 return ret ? ret : count;
1358 }
1359
1360 static int margining_margin_show(struct seq_file *s, void *not_used)
1361 {
1362 struct tb_margining *margining = s->private;
1363 struct tb *tb = margining->port->sw->tb;
1364
1365 if (mutex_lock_interruptible(&tb->lock))
1366 return -ERESTARTSYS;
1367
1368 if (margining->time) {
1369 if (margining->right_high)
1370 seq_puts(s, "left [right]\n");
1371 else
1372 seq_puts(s, "[left] right\n");
1373 } else {
1374 if (margining->right_high)
1375 seq_puts(s, "low [high]\n");
1376 else
1377 seq_puts(s, "[low] high\n");
1378 }
1379
1380 mutex_unlock(&tb->lock);
1381 return 0;
1382 }
1383 DEBUGFS_ATTR_RW(margining_margin);
1384
1385 static struct tb_margining *margining_alloc(struct tb_port *port,
1386 struct device *dev,
1387 enum usb4_sb_target target,
1388 u8 index, struct dentry *parent)
1389 {
1390 struct tb_margining *margining;
1391 struct dentry *dir;
1392 unsigned int val;
1393 int ret;
1394
1395 margining = kzalloc(sizeof(*margining), GFP_KERNEL);
1396 if (!margining)
1397 return NULL;
1398
1399 margining->port = port;
1400 margining->target = target;
1401 margining->index = index;
1402 margining->dev = dev;
1403
1404 ret = usb4_port_margining_caps(port, target, index, margining->caps);
1405 if (ret) {
1406 kfree(margining);
1407 return NULL;
1408 }
1409
1410 /* Set the initial mode */
1411 if (supports_software(margining))
1412 margining->software = true;
1413
1414 val = FIELD_GET(USB4_MARGIN_CAP_0_VOLTAGE_STEPS_MASK, margining->caps[0]);
1415 margining->voltage_steps = val;
1416 val = FIELD_GET(USB4_MARGIN_CAP_0_MAX_VOLTAGE_OFFSET_MASK, margining->caps[0]);
1417 margining->max_voltage_offset = 74 + val * 2;
1418
1419 if (supports_optional_voltage_offset_range(margining)) {
1420 val = FIELD_GET(USB4_MARGIN_CAP_0_VOLT_STEPS_OPT_MASK,
1421 margining->caps[0]);
1422 margining->voltage_steps_optional_range = val;
1423 val = FIELD_GET(USB4_MARGIN_CAP_1_MAX_VOLT_OFS_OPT_MASK,
1424 margining->caps[1]);
1425 margining->max_voltage_offset_optional_range = 74 + val * 2;
1426 }
1427
1428 if (supports_time(margining)) {
1429 val = FIELD_GET(USB4_MARGIN_CAP_1_TIME_STEPS_MASK, margining->caps[1]);
1430 margining->time_steps = val;
1431 val = FIELD_GET(USB4_MARGIN_CAP_1_TIME_OFFSET_MASK, margining->caps[1]);
1432 /*
1433 * Store it as mUI (milli Unit Interval) because we want
1434 * to keep it as integer.
1435 */
1436 margining->max_time_offset = 200 + 10 * val;
1437 }
1438
1439 dir = debugfs_create_dir("margining", parent);
1440 if (supports_hardware(margining)) {
1441 val = FIELD_GET(USB4_MARGIN_CAP_1_MIN_BER_MASK, margining->caps[1]);
1442 margining->min_ber_level = val;
1443 val = FIELD_GET(USB4_MARGIN_CAP_1_MAX_BER_MASK, margining->caps[1]);
1444 margining->max_ber_level = val;
1445
1446 /* Set the default to minimum */
1447 margining->ber_level = margining->min_ber_level;
1448
1449 debugfs_create_file("ber_level_contour", 0400, dir, margining,
1450 &margining_ber_level_fops);
1451 }
1452 debugfs_create_file("caps", 0400, dir, margining, &margining_caps_fops);
1453 debugfs_create_file("lanes", 0600, dir, margining, &margining_lanes_fops);
1454 debugfs_create_file("mode", 0600, dir, margining, &margining_mode_fops);
1455 debugfs_create_file("run", 0600, dir, margining, &margining_run_fops);
1456 debugfs_create_file("results", 0600, dir, margining,
1457 &margining_results_fops);
1458 debugfs_create_file("test", 0600, dir, margining, &margining_test_fops);
1459 if (independent_voltage_margins(margining) == USB4_MARGIN_CAP_0_VOLTAGE_HL ||
1460 (supports_time(margining) &&
1461 independent_time_margins(margining) == USB4_MARGIN_CAP_1_TIME_LR))
1462 debugfs_create_file("margin", 0600, dir, margining,
1463 &margining_margin_fops);
1464
1465 margining->error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR;
1466 margining->dwell_time = MIN_DWELL_TIME;
1467
1468 if (supports_optional_voltage_offset_range(margining))
1469 debugfs_create_file("optional_voltage_offset", DEBUGFS_MODE, dir, margining,
1470 &margining_optional_voltage_offset_fops);
1471
1472 if (supports_software(margining)) {
1473 debugfs_create_file("voltage_time_offset", DEBUGFS_MODE, dir, margining,
1474 &margining_voltage_time_offset_fops);
1475 debugfs_create_file("error_counter", DEBUGFS_MODE, dir, margining,
1476 &margining_error_counter_fops);
1477 debugfs_create_file("dwell_time", DEBUGFS_MODE, dir, margining,
1478 &margining_dwell_time_fops);
1479 }
1480 return margining;
1481 }
1482
1483 static void margining_port_init(struct tb_port *port)
1484 {
1485 struct dentry *parent;
1486 char dir_name[10];
1487
1488 if (!port->usb4)
1489 return;
1490
1491 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
1492 parent = debugfs_lookup(dir_name, port->sw->debugfs_dir);
1493 port->usb4->margining = margining_alloc(port, &port->usb4->dev,
1494 USB4_SB_TARGET_ROUTER, 0,
1495 parent);
1496 }
1497
1498 static void margining_port_remove(struct tb_port *port)
1499 {
1500 struct dentry *parent;
1501 char dir_name[10];
1502
1503 if (!port->usb4)
1504 return;
1505
1506 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
1507 parent = debugfs_lookup(dir_name, port->sw->debugfs_dir);
1508 if (parent)
1509 debugfs_lookup_and_remove("margining", parent);
1510
1511 kfree(port->usb4->margining);
1512 port->usb4->margining = NULL;
1513 }
1514
1515 static void margining_switch_init(struct tb_switch *sw)
1516 {
1517 struct tb_port *upstream, *downstream;
1518 struct tb_switch *parent_sw;
1519 u64 route = tb_route(sw);
1520
1521 if (!route)
1522 return;
1523
1524 upstream = tb_upstream_port(sw);
1525 parent_sw = tb_switch_parent(sw);
1526 downstream = tb_port_at(route, parent_sw);
1527
1528 margining_port_init(downstream);
1529 margining_port_init(upstream);
1530 }
1531
1532 static void margining_switch_remove(struct tb_switch *sw)
1533 {
1534 struct tb_port *upstream, *downstream;
1535 struct tb_switch *parent_sw;
1536 u64 route = tb_route(sw);
1537
1538 if (!route)
1539 return;
1540
1541 upstream = tb_upstream_port(sw);
1542 parent_sw = tb_switch_parent(sw);
1543 downstream = tb_port_at(route, parent_sw);
1544
1545 margining_port_remove(upstream);
1546 margining_port_remove(downstream);
1547 }
1548
1549 static void margining_xdomain_init(struct tb_xdomain *xd)
1550 {
1551 struct tb_switch *parent_sw;
1552 struct tb_port *downstream;
1553
1554 parent_sw = tb_xdomain_parent(xd);
1555 downstream = tb_port_at(xd->route, parent_sw);
1556
1557 margining_port_init(downstream);
1558 }
1559
1560 static void margining_xdomain_remove(struct tb_xdomain *xd)
1561 {
1562 struct tb_switch *parent_sw;
1563 struct tb_port *downstream;
1564
1565 parent_sw = tb_xdomain_parent(xd);
1566 downstream = tb_port_at(xd->route, parent_sw);
1567 margining_port_remove(downstream);
1568 }
1569
1570 static void margining_retimer_init(struct tb_retimer *rt, struct dentry *debugfs_dir)
1571 {
1572 rt->margining = margining_alloc(rt->port, &rt->dev,
1573 USB4_SB_TARGET_RETIMER, rt->index,
1574 debugfs_dir);
1575 }
1576
1577 static void margining_retimer_remove(struct tb_retimer *rt)
1578 {
1579 kfree(rt->margining);
1580 rt->margining = NULL;
1581 }
1582 #else
1583 static inline void margining_switch_init(struct tb_switch *sw) { }
1584 static inline void margining_switch_remove(struct tb_switch *sw) { }
1585 static inline void margining_xdomain_init(struct tb_xdomain *xd) { }
1586 static inline void margining_xdomain_remove(struct tb_xdomain *xd) { }
1587 static inline void margining_retimer_init(struct tb_retimer *rt,
1588 struct dentry *debugfs_dir) { }
1589 static inline void margining_retimer_remove(struct tb_retimer *rt) { }
1590 #endif
1591
1592 static int port_clear_all_counters(struct tb_port *port)
1593 {
1594 u32 *buf;
1595 int ret;
1596
1597 buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32),
1598 GFP_KERNEL);
1599 if (!buf)
1600 return -ENOMEM;
1601
1602 ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0,
1603 COUNTER_SET_LEN * port->config.max_counters);
1604 kfree(buf);
1605
1606 return ret;
1607 }
1608
1609 static ssize_t counters_write(struct file *file, const char __user *user_buf,
1610 size_t count, loff_t *ppos)
1611 {
1612 struct seq_file *s = file->private_data;
1613 struct tb_port *port = s->private;
1614 struct tb_switch *sw = port->sw;
1615 struct tb *tb = port->sw->tb;
1616 char *buf;
1617 int ret;
1618
1619 buf = validate_and_copy_from_user(user_buf, &count);
1620 if (IS_ERR(buf))
1621 return PTR_ERR(buf);
1622
1623 pm_runtime_get_sync(&sw->dev);
1624
1625 if (mutex_lock_interruptible(&tb->lock)) {
1626 ret = -ERESTARTSYS;
1627 goto out;
1628 }
1629
1630 /* If written delimiter only, clear all counters in one shot */
1631 if (buf[0] == '\n') {
1632 ret = port_clear_all_counters(port);
1633 } else {
1634 char *line = buf;
1635 u32 val, offset;
1636
1637 ret = -EINVAL;
1638 while (parse_line(&line, &offset, &val, 1, 4)) {
1639 ret = tb_port_write(port, &val, TB_CFG_COUNTERS,
1640 offset, 1);
1641 if (ret)
1642 break;
1643 }
1644 }
1645
1646 mutex_unlock(&tb->lock);
1647
1648 out:
1649 pm_runtime_mark_last_busy(&sw->dev);
1650 pm_runtime_put_autosuspend(&sw->dev);
1651 free_page((unsigned long)buf);
1652
1653 return ret < 0 ? ret : count;
1654 }
1655
1656 static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw,
1657 struct tb_port *port, unsigned int cap,
1658 unsigned int offset, u8 cap_id, u8 vsec_id,
1659 int dwords)
1660 {
1661 int i, ret;
1662 u32 data;
1663
1664 for (i = 0; i < dwords; i++) {
1665 if (port)
1666 ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1);
1667 else
1668 ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1);
1669 if (ret) {
1670 seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i);
1671 continue;
1672 }
1673
1674 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i,
1675 offset + i, cap_id, vsec_id, data);
1676 }
1677 }
1678
1679 static void cap_show(struct seq_file *s, struct tb_switch *sw,
1680 struct tb_port *port, unsigned int cap, u8 cap_id,
1681 u8 vsec_id, int length)
1682 {
1683 int ret, offset = 0;
1684
1685 while (length > 0) {
1686 int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH);
1687 u32 data[TB_MAX_CONFIG_RW_LENGTH];
1688
1689 if (port)
1690 ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset,
1691 dwords);
1692 else
1693 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords);
1694 if (ret) {
1695 cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length);
1696 return;
1697 }
1698
1699 for (i = 0; i < dwords; i++) {
1700 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n",
1701 cap + offset + i, offset + i,
1702 cap_id, vsec_id, data[i]);
1703 }
1704
1705 length -= dwords;
1706 offset += dwords;
1707 }
1708 }
1709
1710 static void port_cap_show(struct tb_port *port, struct seq_file *s,
1711 unsigned int cap)
1712 {
1713 struct tb_cap_any header;
1714 u8 vsec_id = 0;
1715 size_t length;
1716 int ret;
1717
1718 ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1);
1719 if (ret) {
1720 seq_printf(s, "0x%04x <capability read failed>\n", cap);
1721 return;
1722 }
1723
1724 switch (header.basic.cap) {
1725 case TB_PORT_CAP_PHY:
1726 length = PORT_CAP_LANE_LEN;
1727 break;
1728
1729 case TB_PORT_CAP_TIME1:
1730 if (usb4_switch_version(port->sw) < 2)
1731 length = PORT_CAP_TMU_V1_LEN;
1732 else
1733 length = PORT_CAP_TMU_V2_LEN;
1734 break;
1735
1736 case TB_PORT_CAP_POWER:
1737 length = PORT_CAP_POWER_LEN;
1738 break;
1739
1740 case TB_PORT_CAP_ADAP:
1741 if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) {
1742 if (usb4_switch_version(port->sw) < 2)
1743 length = PORT_CAP_V1_PCIE_LEN;
1744 else
1745 length = PORT_CAP_V2_PCIE_LEN;
1746 } else if (tb_port_is_dpin(port)) {
1747 if (usb4_switch_version(port->sw) < 2)
1748 length = PORT_CAP_DP_V1_LEN;
1749 else
1750 length = PORT_CAP_DP_V2_LEN;
1751 } else if (tb_port_is_dpout(port)) {
1752 length = PORT_CAP_DP_V1_LEN;
1753 } else if (tb_port_is_usb3_down(port) ||
1754 tb_port_is_usb3_up(port)) {
1755 length = PORT_CAP_USB3_LEN;
1756 } else {
1757 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
1758 cap, header.basic.cap);
1759 return;
1760 }
1761 break;
1762
1763 case TB_PORT_CAP_VSE:
1764 if (!header.extended_short.length) {
1765 ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT,
1766 cap + 1, 1);
1767 if (ret) {
1768 seq_printf(s, "0x%04x <capability read failed>\n",
1769 cap + 1);
1770 return;
1771 }
1772 length = header.extended_long.length;
1773 vsec_id = header.extended_short.vsec_id;
1774 } else {
1775 length = header.extended_short.length;
1776 vsec_id = header.extended_short.vsec_id;
1777 }
1778 break;
1779
1780 case TB_PORT_CAP_USB4:
1781 length = PORT_CAP_USB4_LEN;
1782 break;
1783
1784 default:
1785 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
1786 cap, header.basic.cap);
1787 return;
1788 }
1789
1790 cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);
1791 }
1792
1793 static void port_caps_show(struct tb_port *port, struct seq_file *s)
1794 {
1795 int cap;
1796
1797 cap = tb_port_next_cap(port, 0);
1798 while (cap > 0) {
1799 port_cap_show(port, s, cap);
1800 cap = tb_port_next_cap(port, cap);
1801 }
1802 }
1803
1804 static int port_basic_regs_show(struct tb_port *port, struct seq_file *s)
1805 {
1806 u32 data[PORT_CAP_BASIC_LEN];
1807 int ret, i;
1808
1809 ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data));
1810 if (ret)
1811 return ret;
1812
1813 for (i = 0; i < ARRAY_SIZE(data); i++)
1814 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
1815
1816 return 0;
1817 }
1818
1819 static int port_regs_show(struct seq_file *s, void *not_used)
1820 {
1821 struct tb_port *port = s->private;
1822 struct tb_switch *sw = port->sw;
1823 struct tb *tb = sw->tb;
1824 int ret;
1825
1826 pm_runtime_get_sync(&sw->dev);
1827
1828 if (mutex_lock_interruptible(&tb->lock)) {
1829 ret = -ERESTARTSYS;
1830 goto out_rpm_put;
1831 }
1832
1833 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
1834
1835 ret = port_basic_regs_show(port, s);
1836 if (ret)
1837 goto out_unlock;
1838
1839 port_caps_show(port, s);
1840
1841 out_unlock:
1842 mutex_unlock(&tb->lock);
1843 out_rpm_put:
1844 pm_runtime_mark_last_busy(&sw->dev);
1845 pm_runtime_put_autosuspend(&sw->dev);
1846
1847 return ret;
1848 }
1849 DEBUGFS_ATTR_RW(port_regs);
1850
1851 static void switch_cap_show(struct tb_switch *sw, struct seq_file *s,
1852 unsigned int cap)
1853 {
1854 struct tb_cap_any header;
1855 int ret, length;
1856 u8 vsec_id = 0;
1857
1858 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1);
1859 if (ret) {
1860 seq_printf(s, "0x%04x <capability read failed>\n", cap);
1861 return;
1862 }
1863
1864 if (header.basic.cap == TB_SWITCH_CAP_VSE) {
1865 if (!header.extended_short.length) {
1866 ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH,
1867 cap + 1, 1);
1868 if (ret) {
1869 seq_printf(s, "0x%04x <capability read failed>\n",
1870 cap + 1);
1871 return;
1872 }
1873 length = header.extended_long.length;
1874 } else {
1875 length = header.extended_short.length;
1876 }
1877 vsec_id = header.extended_short.vsec_id;
1878 } else {
1879 if (header.basic.cap == TB_SWITCH_CAP_TMU) {
1880 length = SWITCH_CAP_TMU_LEN;
1881 } else {
1882 seq_printf(s, "0x%04x <unknown capability 0x%02x>\n",
1883 cap, header.basic.cap);
1884 return;
1885 }
1886 }
1887
1888 cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);
1889 }
1890
1891 static void switch_caps_show(struct tb_switch *sw, struct seq_file *s)
1892 {
1893 int cap;
1894
1895 cap = tb_switch_next_cap(sw, 0);
1896 while (cap > 0) {
1897 switch_cap_show(sw, s, cap);
1898 cap = tb_switch_next_cap(sw, cap);
1899 }
1900 }
1901
1902 static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s)
1903 {
1904 u32 data[SWITCH_CAP_BASIC_LEN];
1905 size_t dwords;
1906 int ret, i;
1907
1908 /* Only USB4 has the additional registers */
1909 if (tb_switch_is_usb4(sw))
1910 dwords = ARRAY_SIZE(data);
1911 else
1912 dwords = 5;
1913
1914 ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords);
1915 if (ret)
1916 return ret;
1917
1918 for (i = 0; i < dwords; i++)
1919 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
1920
1921 return 0;
1922 }
1923
1924 static int switch_regs_show(struct seq_file *s, void *not_used)
1925 {
1926 struct tb_switch *sw = s->private;
1927 struct tb *tb = sw->tb;
1928 int ret;
1929
1930 pm_runtime_get_sync(&sw->dev);
1931
1932 if (mutex_lock_interruptible(&tb->lock)) {
1933 ret = -ERESTARTSYS;
1934 goto out_rpm_put;
1935 }
1936
1937 seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
1938
1939 ret = switch_basic_regs_show(sw, s);
1940 if (ret)
1941 goto out_unlock;
1942
1943 switch_caps_show(sw, s);
1944
1945 out_unlock:
1946 mutex_unlock(&tb->lock);
1947 out_rpm_put:
1948 pm_runtime_mark_last_busy(&sw->dev);
1949 pm_runtime_put_autosuspend(&sw->dev);
1950
1951 return ret;
1952 }
1953 DEBUGFS_ATTR_RW(switch_regs);
1954
1955 static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid)
1956 {
1957 u32 data[PATH_LEN];
1958 int ret, i;
1959
1960 ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN,
1961 ARRAY_SIZE(data));
1962 if (ret) {
1963 seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN);
1964 return ret;
1965 }
1966
1967 for (i = 0; i < ARRAY_SIZE(data); i++) {
1968 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
1969 hopid * PATH_LEN + i, i, hopid, data[i]);
1970 }
1971
1972 return 0;
1973 }
1974
1975 static int path_show(struct seq_file *s, void *not_used)
1976 {
1977 struct tb_port *port = s->private;
1978 struct tb_switch *sw = port->sw;
1979 struct tb *tb = sw->tb;
1980 int start, i, ret = 0;
1981
1982 pm_runtime_get_sync(&sw->dev);
1983
1984 if (mutex_lock_interruptible(&tb->lock)) {
1985 ret = -ERESTARTSYS;
1986 goto out_rpm_put;
1987 }
1988
1989 seq_puts(s, "# offset relative_offset in_hop_id value\n");
1990
1991 /* NHI and lane adapters have entry for path 0 */
1992 if (tb_port_is_null(port) || tb_port_is_nhi(port)) {
1993 ret = path_show_one(port, s, 0);
1994 if (ret)
1995 goto out_unlock;
1996 }
1997
1998 start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
1999
2000 for (i = start; i <= port->config.max_in_hop_id; i++) {
2001 ret = path_show_one(port, s, i);
2002 if (ret)
2003 break;
2004 }
2005
2006 out_unlock:
2007 mutex_unlock(&tb->lock);
2008 out_rpm_put:
2009 pm_runtime_mark_last_busy(&sw->dev);
2010 pm_runtime_put_autosuspend(&sw->dev);
2011
2012 return ret;
2013 }
2014 DEBUGFS_ATTR_RO(path);
2015
2016 static int counter_set_regs_show(struct tb_port *port, struct seq_file *s,
2017 int counter)
2018 {
2019 u32 data[COUNTER_SET_LEN];
2020 int ret, i;
2021
2022 ret = tb_port_read(port, data, TB_CFG_COUNTERS,
2023 counter * COUNTER_SET_LEN, ARRAY_SIZE(data));
2024 if (ret) {
2025 seq_printf(s, "0x%04x <not accessible>\n",
2026 counter * COUNTER_SET_LEN);
2027 return ret;
2028 }
2029
2030 for (i = 0; i < ARRAY_SIZE(data); i++) {
2031 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
2032 counter * COUNTER_SET_LEN + i, i, counter, data[i]);
2033 }
2034
2035 return 0;
2036 }
2037
2038 static int counters_show(struct seq_file *s, void *not_used)
2039 {
2040 struct tb_port *port = s->private;
2041 struct tb_switch *sw = port->sw;
2042 struct tb *tb = sw->tb;
2043 int i, ret = 0;
2044
2045 pm_runtime_get_sync(&sw->dev);
2046
2047 if (mutex_lock_interruptible(&tb->lock)) {
2048 ret = -ERESTARTSYS;
2049 goto out;
2050 }
2051
2052 seq_puts(s, "# offset relative_offset counter_id value\n");
2053
2054 for (i = 0; i < port->config.max_counters; i++) {
2055 ret = counter_set_regs_show(port, s, i);
2056 if (ret)
2057 break;
2058 }
2059
2060 mutex_unlock(&tb->lock);
2061
2062 out:
2063 pm_runtime_mark_last_busy(&sw->dev);
2064 pm_runtime_put_autosuspend(&sw->dev);
2065
2066 return ret;
2067 }
2068 DEBUGFS_ATTR_RW(counters);
2069
2070 static int sb_regs_show(struct tb_port *port, const struct sb_reg *sb_regs,
2071 size_t size, enum usb4_sb_target target, u8 index,
2072 struct seq_file *s)
2073 {
2074 int ret, i;
2075
2076 seq_puts(s, "# register value\n");
2077
2078 for (i = 0; i < size; i++) {
2079 const struct sb_reg *regs = &sb_regs[i];
2080 u8 data[64];
2081 int j;
2082
2083 memset(data, 0, sizeof(data));
2084 ret = usb4_port_sb_read(port, target, index, regs->reg, data,
2085 regs->size);
2086 if (ret)
2087 return ret;
2088
2089 seq_printf(s, "0x%02x", regs->reg);
2090 for (j = 0; j < regs->size; j++)
2091 seq_printf(s, " 0x%02x", data[j]);
2092 seq_puts(s, "\n");
2093 }
2094
2095 return 0;
2096 }
2097
2098 static int port_sb_regs_show(struct seq_file *s, void *not_used)
2099 {
2100 struct tb_port *port = s->private;
2101 struct tb_switch *sw = port->sw;
2102 struct tb *tb = sw->tb;
2103 int ret;
2104
2105 pm_runtime_get_sync(&sw->dev);
2106
2107 if (mutex_lock_interruptible(&tb->lock)) {
2108 ret = -ERESTARTSYS;
2109 goto out_rpm_put;
2110 }
2111
2112 ret = sb_regs_show(port, port_sb_regs, ARRAY_SIZE(port_sb_regs),
2113 USB4_SB_TARGET_ROUTER, 0, s);
2114
2115 mutex_unlock(&tb->lock);
2116 out_rpm_put:
2117 pm_runtime_mark_last_busy(&sw->dev);
2118 pm_runtime_put_autosuspend(&sw->dev);
2119
2120 return ret;
2121 }
2122 DEBUGFS_ATTR_RW(port_sb_regs);
2123
2124 /**
2125 * tb_switch_debugfs_init() - Add debugfs entries for router
2126 * @sw: Pointer to the router
2127 *
2128 * Adds debugfs directories and files for given router.
2129 */
2130 void tb_switch_debugfs_init(struct tb_switch *sw)
2131 {
2132 struct dentry *debugfs_dir;
2133 struct tb_port *port;
2134
2135 debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root);
2136 sw->debugfs_dir = debugfs_dir;
2137 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw,
2138 &switch_regs_fops);
2139
2140 tb_switch_for_each_port(sw, port) {
2141 struct dentry *debugfs_dir;
2142 char dir_name[10];
2143
2144 if (port->disabled)
2145 continue;
2146 if (port->config.type == TB_TYPE_INACTIVE)
2147 continue;
2148
2149 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
2150 debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir);
2151 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir,
2152 port, &port_regs_fops);
2153 debugfs_create_file("path", 0400, debugfs_dir, port,
2154 &path_fops);
2155 if (port->config.counters_support)
2156 debugfs_create_file("counters", 0600, debugfs_dir, port,
2157 &counters_fops);
2158 if (port->usb4)
2159 debugfs_create_file("sb_regs", DEBUGFS_MODE, debugfs_dir,
2160 port, &port_sb_regs_fops);
2161 }
2162
2163 margining_switch_init(sw);
2164 }
2165
2166 /**
2167 * tb_switch_debugfs_remove() - Remove all router debugfs entries
2168 * @sw: Pointer to the router
2169 *
2170 * Removes all previously added debugfs entries under this router.
2171 */
2172 void tb_switch_debugfs_remove(struct tb_switch *sw)
2173 {
2174 margining_switch_remove(sw);
2175 debugfs_remove_recursive(sw->debugfs_dir);
2176 }
2177
2178 void tb_xdomain_debugfs_init(struct tb_xdomain *xd)
2179 {
2180 margining_xdomain_init(xd);
2181 }
2182
2183 void tb_xdomain_debugfs_remove(struct tb_xdomain *xd)
2184 {
2185 margining_xdomain_remove(xd);
2186 }
2187
2188 /**
2189 * tb_service_debugfs_init() - Add debugfs directory for service
2190 * @svc: Thunderbolt service pointer
2191 *
2192 * Adds debugfs directory for service.
2193 */
2194 void tb_service_debugfs_init(struct tb_service *svc)
2195 {
2196 svc->debugfs_dir = debugfs_create_dir(dev_name(&svc->dev),
2197 tb_debugfs_root);
2198 }
2199
2200 /**
2201 * tb_service_debugfs_remove() - Remove service debugfs directory
2202 * @svc: Thunderbolt service pointer
2203 *
2204 * Removes the previously created debugfs directory for @svc.
2205 */
2206 void tb_service_debugfs_remove(struct tb_service *svc)
2207 {
2208 debugfs_remove_recursive(svc->debugfs_dir);
2209 svc->debugfs_dir = NULL;
2210 }
2211
2212 static int retimer_sb_regs_show(struct seq_file *s, void *not_used)
2213 {
2214 struct tb_retimer *rt = s->private;
2215 struct tb *tb = rt->tb;
2216 int ret;
2217
2218 pm_runtime_get_sync(&rt->dev);
2219
2220 if (mutex_lock_interruptible(&tb->lock)) {
2221 ret = -ERESTARTSYS;
2222 goto out_rpm_put;
2223 }
2224
2225 ret = sb_regs_show(rt->port, retimer_sb_regs, ARRAY_SIZE(retimer_sb_regs),
2226 USB4_SB_TARGET_RETIMER, rt->index, s);
2227
2228 mutex_unlock(&tb->lock);
2229 out_rpm_put:
2230 pm_runtime_mark_last_busy(&rt->dev);
2231 pm_runtime_put_autosuspend(&rt->dev);
2232
2233 return ret;
2234 }
2235 DEBUGFS_ATTR_RW(retimer_sb_regs);
2236
2237 /**
2238 * tb_retimer_debugfs_init() - Add debugfs directory for retimer
2239 * @rt: Pointer to retimer structure
2240 *
2241 * Adds and populates retimer debugfs directory.
2242 */
2243 void tb_retimer_debugfs_init(struct tb_retimer *rt)
2244 {
2245 struct dentry *debugfs_dir;
2246
2247 debugfs_dir = debugfs_create_dir(dev_name(&rt->dev), tb_debugfs_root);
2248 debugfs_create_file("sb_regs", DEBUGFS_MODE, debugfs_dir, rt,
2249 &retimer_sb_regs_fops);
2250 margining_retimer_init(rt, debugfs_dir);
2251 }
2252
2253 /**
2254 * tb_retimer_debugfs_remove() - Remove retimer debugfs directory
2255 * @rt: Pointer to retimer structure
2256 *
2257 * Removes the retimer debugfs directory along with its contents.
2258 */
2259 void tb_retimer_debugfs_remove(struct tb_retimer *rt)
2260 {
2261 debugfs_lookup_and_remove(dev_name(&rt->dev), tb_debugfs_root);
2262 margining_retimer_remove(rt);
2263 }
2264
2265 void tb_debugfs_init(void)
2266 {
2267 tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);
2268 }
2269
2270 void tb_debugfs_exit(void)
2271 {
2272 debugfs_remove_recursive(tb_debugfs_root);
2273 }
Kernel DRM miscellaneous fixes and cross-tree changes