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
  16 #define PORT_CAP_PCIE_LEN       1
  17 #define PORT_CAP_POWER_LEN      2
  18 #define PORT_CAP_LANE_LEN       3
  19 #define PORT_CAP_USB3_LEN       5
  20 #define PORT_CAP_DP_LEN         8
  21 #define PORT_CAP_TMU_LEN        8
  22 #define PORT_CAP_BASIC_LEN      9
  23 #define PORT_CAP_USB4_LEN       20
  24
  25 #define SWITCH_CAP_TMU_LEN      26
  26 #define SWITCH_CAP_BASIC_LEN    27
  27
  28 #define PATH_LEN                2
  29
  30 #define COUNTER_SET_LEN         3
  31
  32 #define DEBUGFS_ATTR(__space, __write)                                  \
  33 static int __space ## _open(struct inode *inode, struct file *file)     \
  34 {                                                                       \
  35         return single_open(file, __space ## _show, inode->i_private);   \
  36 }                                                                       \
  37                                                                         \
  38 static const struct file_operations __space ## _fops = {                \
  39         .owner = THIS_MODULE,                                           \
  40         .open = __space ## _open,                                       \
  41         .release = single_release,                                      \
  42         .read  = seq_read,                                              \
  43         .write = __write,                                               \
  44         .llseek = seq_lseek,                                            \
  45 }
  46
  47 #define DEBUGFS_ATTR_RO(__space)                                        \
  48         DEBUGFS_ATTR(__space, NULL)
  49
  50 #define DEBUGFS_ATTR_RW(__space)                                        \
  51         DEBUGFS_ATTR(__space, __space ## _write)
  52
  53 static struct dentry *tb_debugfs_root;
  54
  55 static void *validate_and_copy_from_user(const void __user *user_buf,
  56                                          size_t *count)
  57 {
  58         size_t nbytes;
  59         void *buf;
  60
  61         if (!*count)
  62                 return ERR_PTR(-EINVAL);
  63
  64         if (!access_ok(user_buf, *count))
  65                 return ERR_PTR(-EFAULT);
  66
  67         buf = (void *)get_zeroed_page(GFP_KERNEL);
  68         if (!buf)
  69                 return ERR_PTR(-ENOMEM);
  70
  71         nbytes = min_t(size_t, *count, PAGE_SIZE);
  72         if (copy_from_user(buf, user_buf, nbytes)) {
  73                 free_page((unsigned long)buf);
  74                 return ERR_PTR(-EFAULT);
  75         }
  76
  77         *count = nbytes;
  78         return buf;
  79 }
  80
  81 static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len,
  82                        int long_fmt_len)
  83 {
  84         char *token;
  85         u32 v[5];
  86         int ret;
  87
  88         token = strsep(line, "\n");
  89         if (!token)
  90                 return false;
  91
  92         /*
  93          * For Adapter/Router configuration space:
  94          * Short format is: offset value\n
  95          *                  v[0]   v[1]
  96          * Long format as produced from the read side:
  97          * offset relative_offset cap_id vs_cap_id value\n
  98          * v[0]   v[1]            v[2]   v[3]      v[4]
  99          *
 100          * For Counter configuration space:
 101          * Short format is: offset\n
 102          *                  v[0]
 103          * Long format as produced from the read side:
 104          * offset relative_offset counter_id value\n
 105          * v[0]   v[1]            v[2]       v[3]
 106          */
 107         ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]);
 108         /* In case of Counters, clear counter, "val" content is NA */
 109         if (ret == short_fmt_len) {
 110                 *offs = v[0];
 111                 *val = v[short_fmt_len - 1];
 112                 return true;
 113         } else if (ret == long_fmt_len) {
 114                 *offs = v[0];
 115                 *val = v[long_fmt_len - 1];
 116                 return true;
 117         }
 118
 119         return false;
 120 }
 121
 122 #if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)
 123 static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port,
 124                           const char __user *user_buf, size_t count,
 125                           loff_t *ppos)
 126 {
 127         struct tb *tb = sw->tb;
 128         char *line, *buf;
 129         u32 val, offset;
 130         int ret = 0;
 131
 132         buf = validate_and_copy_from_user(user_buf, &count);
 133         if (IS_ERR(buf))
 134                 return PTR_ERR(buf);
 135
 136         pm_runtime_get_sync(&sw->dev);
 137
 138         if (mutex_lock_interruptible(&tb->lock)) {
 139                 ret = -ERESTARTSYS;
 140                 goto out;
 141         }
 142
 143         /* User did hardware changes behind the driver's back */
 144         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 145
 146         line = buf;
 147         while (parse_line(&line, &offset, &val, 2, 5)) {
 148                 if (port)
 149                         ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1);
 150                 else
 151                         ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1);
 152                 if (ret)
 153                         break;
 154         }
 155
 156         mutex_unlock(&tb->lock);
 157
 158 out:
 159         pm_runtime_mark_last_busy(&sw->dev);
 160         pm_runtime_put_autosuspend(&sw->dev);
 161         free_page((unsigned long)buf);
 162
 163         return ret < 0 ? ret : count;
 164 }
 165
 166 static ssize_t port_regs_write(struct file *file, const char __user *user_buf,
 167                                size_t count, loff_t *ppos)
 168 {
 169         struct seq_file *s = file->private_data;
 170         struct tb_port *port = s->private;
 171
 172         return regs_write(port->sw, port, user_buf, count, ppos);
 173 }
 174
 175 static ssize_t switch_regs_write(struct file *file, const char __user *user_buf,
 176                                  size_t count, loff_t *ppos)
 177 {
 178         struct seq_file *s = file->private_data;
 179         struct tb_switch *sw = s->private;
 180
 181         return regs_write(sw, NULL, user_buf, count, ppos);
 182 }
 183 #define DEBUGFS_MODE            0600
 184 #else
 185 #define port_regs_write         NULL
 186 #define switch_regs_write       NULL
 187 #define DEBUGFS_MODE            0400
 188 #endif
 189
 190 static int port_clear_all_counters(struct tb_port *port)
 191 {
 192         u32 *buf;
 193         int ret;
 194
 195         buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32),
 196                       GFP_KERNEL);
 197         if (!buf)
 198                 return -ENOMEM;
 199
 200         ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0,
 201                             COUNTER_SET_LEN * port->config.max_counters);
 202         kfree(buf);
 203
 204         return ret;
 205 }
 206
 207 static ssize_t counters_write(struct file *file, const char __user *user_buf,
 208                               size_t count, loff_t *ppos)
 209 {
 210         struct seq_file *s = file->private_data;
 211         struct tb_port *port = s->private;
 212         struct tb_switch *sw = port->sw;
 213         struct tb *tb = port->sw->tb;
 214         char *buf;
 215         int ret;
 216
 217         buf = validate_and_copy_from_user(user_buf, &count);
 218         if (IS_ERR(buf))
 219                 return PTR_ERR(buf);
 220
 221         pm_runtime_get_sync(&sw->dev);
 222
 223         if (mutex_lock_interruptible(&tb->lock)) {
 224                 ret = -ERESTARTSYS;
 225                 goto out;
 226         }
 227
 228         /* If written delimiter only, clear all counters in one shot */
 229         if (buf[0] == '\n') {
 230                 ret = port_clear_all_counters(port);
 231         } else  {
 232                 char *line = buf;
 233                 u32 val, offset;
 234
 235                 ret = -EINVAL;
 236                 while (parse_line(&line, &offset, &val, 1, 4)) {
 237                         ret = tb_port_write(port, &val, TB_CFG_COUNTERS,
 238                                             offset, 1);
 239                         if (ret)
 240                                 break;
 241                 }
 242         }
 243
 244         mutex_unlock(&tb->lock);
 245
 246 out:
 247         pm_runtime_mark_last_busy(&sw->dev);
 248         pm_runtime_put_autosuspend(&sw->dev);
 249         free_page((unsigned long)buf);
 250
 251         return ret < 0 ? ret : count;
 252 }
 253
 254 static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw,
 255                            struct tb_port *port, unsigned int cap,
 256                            unsigned int offset, u8 cap_id, u8 vsec_id,
 257                            int dwords)
 258 {
 259         int i, ret;
 260         u32 data;
 261
 262         for (i = 0; i < dwords; i++) {
 263                 if (port)
 264                         ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1);
 265                 else
 266                         ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1);
 267                 if (ret) {
 268                         seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i);
 269                         continue;
 270                 }
 271
 272                 seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i,
 273                            offset + i, cap_id, vsec_id, data);
 274         }
 275 }
 276
 277 static void cap_show(struct seq_file *s, struct tb_switch *sw,
 278                      struct tb_port *port, unsigned int cap, u8 cap_id,
 279                      u8 vsec_id, int length)
 280 {
 281         int ret, offset = 0;
 282
 283         while (length > 0) {
 284                 int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH);
 285                 u32 data[TB_MAX_CONFIG_RW_LENGTH];
 286
 287                 if (port)
 288                         ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset,
 289                                            dwords);
 290                 else
 291                         ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords);
 292                 if (ret) {
 293                         cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length);
 294                         return;
 295                 }
 296
 297                 for (i = 0; i < dwords; i++) {
 298                         seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n",
 299                                    cap + offset + i, offset + i,
 300                                    cap_id, vsec_id, data[i]);
 301                 }
 302
 303                 length -= dwords;
 304                 offset += dwords;
 305         }
 306 }
 307
 308 static void port_cap_show(struct tb_port *port, struct seq_file *s,
 309                           unsigned int cap)
 310 {
 311         struct tb_cap_any header;
 312         u8 vsec_id = 0;
 313         size_t length;
 314         int ret;
 315
 316         ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1);
 317         if (ret) {
 318                 seq_printf(s, "0x%04x <capability read failed>\n", cap);
 319                 return;
 320         }
 321
 322         switch (header.basic.cap) {
 323         case TB_PORT_CAP_PHY:
 324                 length = PORT_CAP_LANE_LEN;
 325                 break;
 326
 327         case TB_PORT_CAP_TIME1:
 328                 length = PORT_CAP_TMU_LEN;
 329                 break;
 330
 331         case TB_PORT_CAP_POWER:
 332                 length = PORT_CAP_POWER_LEN;
 333                 break;
 334
 335         case TB_PORT_CAP_ADAP:
 336                 if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) {
 337                         length = PORT_CAP_PCIE_LEN;
 338                 } else if (tb_port_is_dpin(port) || tb_port_is_dpout(port)) {
 339                         length = PORT_CAP_DP_LEN;
 340                 } else if (tb_port_is_usb3_down(port) ||
 341                            tb_port_is_usb3_up(port)) {
 342                         length = PORT_CAP_USB3_LEN;
 343                 } else {
 344                         seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
 345                                    cap, header.basic.cap);
 346                         return;
 347                 }
 348                 break;
 349
 350         case TB_PORT_CAP_VSE:
 351                 if (!header.extended_short.length) {
 352                         ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT,
 353                                            cap + 1, 1);
 354                         if (ret) {
 355                                 seq_printf(s, "0x%04x <capability read failed>\n",
 356                                            cap + 1);
 357                                 return;
 358                         }
 359                         length = header.extended_long.length;
 360                         vsec_id = header.extended_short.vsec_id;
 361                 } else {
 362                         length = header.extended_short.length;
 363                         vsec_id = header.extended_short.vsec_id;
 364                 }
 365                 break;
 366
 367         case TB_PORT_CAP_USB4:
 368                 length = PORT_CAP_USB4_LEN;
 369                 break;
 370
 371         default:
 372                 seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n",
 373                            cap, header.basic.cap);
 374                 return;
 375         }
 376
 377         cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);
 378 }
 379
 380 static void port_caps_show(struct tb_port *port, struct seq_file *s)
 381 {
 382         int cap;
 383
 384         cap = tb_port_next_cap(port, 0);
 385         while (cap > 0) {
 386                 port_cap_show(port, s, cap);
 387                 cap = tb_port_next_cap(port, cap);
 388         }
 389 }
 390
 391 static int port_basic_regs_show(struct tb_port *port, struct seq_file *s)
 392 {
 393         u32 data[PORT_CAP_BASIC_LEN];
 394         int ret, i;
 395
 396         ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data));
 397         if (ret)
 398                 return ret;
 399
 400         for (i = 0; i < ARRAY_SIZE(data); i++)
 401                 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
 402
 403         return 0;
 404 }
 405
 406 static int port_regs_show(struct seq_file *s, void *not_used)
 407 {
 408         struct tb_port *port = s->private;
 409         struct tb_switch *sw = port->sw;
 410         struct tb *tb = sw->tb;
 411         int ret;
 412
 413         pm_runtime_get_sync(&sw->dev);
 414
 415         if (mutex_lock_interruptible(&tb->lock)) {
 416                 ret = -ERESTARTSYS;
 417                 goto out_rpm_put;
 418         }
 419
 420         seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
 421
 422         ret = port_basic_regs_show(port, s);
 423         if (ret)
 424                 goto out_unlock;
 425
 426         port_caps_show(port, s);
 427
 428 out_unlock:
 429         mutex_unlock(&tb->lock);
 430 out_rpm_put:
 431         pm_runtime_mark_last_busy(&sw->dev);
 432         pm_runtime_put_autosuspend(&sw->dev);
 433
 434         return ret;
 435 }
 436 DEBUGFS_ATTR_RW(port_regs);
 437
 438 static void switch_cap_show(struct tb_switch *sw, struct seq_file *s,
 439                             unsigned int cap)
 440 {
 441         struct tb_cap_any header;
 442         int ret, length;
 443         u8 vsec_id = 0;
 444
 445         ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1);
 446         if (ret) {
 447                 seq_printf(s, "0x%04x <capability read failed>\n", cap);
 448                 return;
 449         }
 450
 451         if (header.basic.cap == TB_SWITCH_CAP_VSE) {
 452                 if (!header.extended_short.length) {
 453                         ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH,
 454                                          cap + 1, 1);
 455                         if (ret) {
 456                                 seq_printf(s, "0x%04x <capability read failed>\n",
 457                                            cap + 1);
 458                                 return;
 459                         }
 460                         length = header.extended_long.length;
 461                 } else {
 462                         length = header.extended_short.length;
 463                 }
 464                 vsec_id = header.extended_short.vsec_id;
 465         } else {
 466                 if (header.basic.cap == TB_SWITCH_CAP_TMU) {
 467                         length = SWITCH_CAP_TMU_LEN;
 468                 } else  {
 469                         seq_printf(s, "0x%04x <unknown capability 0x%02x>\n",
 470                                    cap, header.basic.cap);
 471                         return;
 472                 }
 473         }
 474
 475         cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);
 476 }
 477
 478 static void switch_caps_show(struct tb_switch *sw, struct seq_file *s)
 479 {
 480         int cap;
 481
 482         cap = tb_switch_next_cap(sw, 0);
 483         while (cap > 0) {
 484                 switch_cap_show(sw, s, cap);
 485                 cap = tb_switch_next_cap(sw, cap);
 486         }
 487 }
 488
 489 static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s)
 490 {
 491         u32 data[SWITCH_CAP_BASIC_LEN];
 492         size_t dwords;
 493         int ret, i;
 494
 495         /* Only USB4 has the additional registers */
 496         if (tb_switch_is_usb4(sw))
 497                 dwords = ARRAY_SIZE(data);
 498         else
 499                 dwords = 7;
 500
 501         ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords);
 502         if (ret)
 503                 return ret;
 504
 505         for (i = 0; i < dwords; i++)
 506                 seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
 507
 508         return 0;
 509 }
 510
 511 static int switch_regs_show(struct seq_file *s, void *not_used)
 512 {
 513         struct tb_switch *sw = s->private;
 514         struct tb *tb = sw->tb;
 515         int ret;
 516
 517         pm_runtime_get_sync(&sw->dev);
 518
 519         if (mutex_lock_interruptible(&tb->lock)) {
 520                 ret = -ERESTARTSYS;
 521                 goto out_rpm_put;
 522         }
 523
 524         seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
 525
 526         ret = switch_basic_regs_show(sw, s);
 527         if (ret)
 528                 goto out_unlock;
 529
 530         switch_caps_show(sw, s);
 531
 532 out_unlock:
 533         mutex_unlock(&tb->lock);
 534 out_rpm_put:
 535         pm_runtime_mark_last_busy(&sw->dev);
 536         pm_runtime_put_autosuspend(&sw->dev);
 537
 538         return ret;
 539 }
 540 DEBUGFS_ATTR_RW(switch_regs);
 541
 542 static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid)
 543 {
 544         u32 data[PATH_LEN];
 545         int ret, i;
 546
 547         ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN,
 548                            ARRAY_SIZE(data));
 549         if (ret) {
 550                 seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN);
 551                 return ret;
 552         }
 553
 554         for (i = 0; i < ARRAY_SIZE(data); i++) {
 555                 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
 556                            hopid * PATH_LEN + i, i, hopid, data[i]);
 557         }
 558
 559         return 0;
 560 }
 561
 562 static int path_show(struct seq_file *s, void *not_used)
 563 {
 564         struct tb_port *port = s->private;
 565         struct tb_switch *sw = port->sw;
 566         struct tb *tb = sw->tb;
 567         int start, i, ret = 0;
 568
 569         pm_runtime_get_sync(&sw->dev);
 570
 571         if (mutex_lock_interruptible(&tb->lock)) {
 572                 ret = -ERESTARTSYS;
 573                 goto out_rpm_put;
 574         }
 575
 576         seq_puts(s, "# offset relative_offset in_hop_id value\n");
 577
 578         /* NHI and lane adapters have entry for path 0 */
 579         if (tb_port_is_null(port) || tb_port_is_nhi(port)) {
 580                 ret = path_show_one(port, s, 0);
 581                 if (ret)
 582                         goto out_unlock;
 583         }
 584
 585         start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
 586
 587         for (i = start; i <= port->config.max_in_hop_id; i++) {
 588                 ret = path_show_one(port, s, i);
 589                 if (ret)
 590                         break;
 591         }
 592
 593 out_unlock:
 594         mutex_unlock(&tb->lock);
 595 out_rpm_put:
 596         pm_runtime_mark_last_busy(&sw->dev);
 597         pm_runtime_put_autosuspend(&sw->dev);
 598
 599         return ret;
 600 }
 601 DEBUGFS_ATTR_RO(path);
 602
 603 static int counter_set_regs_show(struct tb_port *port, struct seq_file *s,
 604                                  int counter)
 605 {
 606         u32 data[COUNTER_SET_LEN];
 607         int ret, i;
 608
 609         ret = tb_port_read(port, data, TB_CFG_COUNTERS,
 610                            counter * COUNTER_SET_LEN, ARRAY_SIZE(data));
 611         if (ret) {
 612                 seq_printf(s, "0x%04x <not accessible>\n",
 613                            counter * COUNTER_SET_LEN);
 614                 return ret;
 615         }
 616
 617         for (i = 0; i < ARRAY_SIZE(data); i++) {
 618                 seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
 619                            counter * COUNTER_SET_LEN + i, i, counter, data[i]);
 620         }
 621
 622         return 0;
 623 }
 624
 625 static int counters_show(struct seq_file *s, void *not_used)
 626 {
 627         struct tb_port *port = s->private;
 628         struct tb_switch *sw = port->sw;
 629         struct tb *tb = sw->tb;
 630         int i, ret = 0;
 631
 632         pm_runtime_get_sync(&sw->dev);
 633
 634         if (mutex_lock_interruptible(&tb->lock)) {
 635                 ret = -ERESTARTSYS;
 636                 goto out;
 637         }
 638
 639         seq_puts(s, "# offset relative_offset counter_id value\n");
 640
 641         for (i = 0; i < port->config.max_counters; i++) {
 642                 ret = counter_set_regs_show(port, s, i);
 643                 if (ret)
 644                         break;
 645         }
 646
 647         mutex_unlock(&tb->lock);
 648
 649 out:
 650         pm_runtime_mark_last_busy(&sw->dev);
 651         pm_runtime_put_autosuspend(&sw->dev);
 652
 653         return ret;
 654 }
 655 DEBUGFS_ATTR_RW(counters);
 656
 657 /**
 658  * tb_switch_debugfs_init() - Add debugfs entries for router
 659  * @sw: Pointer to the router
 660  *
 661  * Adds debugfs directories and files for given router.
 662  */
 663 void tb_switch_debugfs_init(struct tb_switch *sw)
 664 {
 665         struct dentry *debugfs_dir;
 666         struct tb_port *port;
 667
 668         debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root);
 669         sw->debugfs_dir = debugfs_dir;
 670         debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw,
 671                             &switch_regs_fops);
 672
 673         tb_switch_for_each_port(sw, port) {
 674                 struct dentry *debugfs_dir;
 675                 char dir_name[10];
 676
 677                 if (port->disabled)
 678                         continue;
 679                 if (port->config.type == TB_TYPE_INACTIVE)
 680                         continue;
 681
 682                 snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
 683                 debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir);
 684                 debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir,
 685                                     port, &port_regs_fops);
 686                 debugfs_create_file("path", 0400, debugfs_dir, port,
 687                                     &path_fops);
 688                 if (port->config.counters_support)
 689                         debugfs_create_file("counters", 0600, debugfs_dir, port,
 690                                             &counters_fops);
 691         }
 692 }
 693
 694 /**
 695  * tb_switch_debugfs_remove() - Remove all router debugfs entries
 696  * @sw: Pointer to the router
 697  *
 698  * Removes all previously added debugfs entries under this router.
 699  */
 700 void tb_switch_debugfs_remove(struct tb_switch *sw)
 701 {
 702         debugfs_remove_recursive(sw->debugfs_dir);
 703 }
 704
 705 /**
 706  * tb_service_debugfs_init() - Add debugfs directory for service
 707  * @svc: Thunderbolt service pointer
 708  *
 709  * Adds debugfs directory for service.
 710  */
 711 void tb_service_debugfs_init(struct tb_service *svc)
 712 {
 713         svc->debugfs_dir = debugfs_create_dir(dev_name(&svc->dev),
 714                                               tb_debugfs_root);
 715 }
 716
 717 /**
 718  * tb_service_debugfs_remove() - Remove service debugfs directory
 719  * @svc: Thunderbolt service pointer
 720  *
 721  * Removes the previously created debugfs directory for @svc.
 722  */
 723 void tb_service_debugfs_remove(struct tb_service *svc)
 724 {
 725         debugfs_remove_recursive(svc->debugfs_dir);
 726         svc->debugfs_dir = NULL;
 727 }
 728
 729 void tb_debugfs_init(void)
 730 {
 731         tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);
 732 }
 733
 734 void tb_debugfs_exit(void)
 735 {
 736         debugfs_remove_recursive(tb_debugfs_root);
 737 }