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