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