drivers/thunderbolt/debugfs.c

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