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