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, ®, 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 ¶ms, &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, ¶ms); 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, ¶ms, 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 } 2274