1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * xhci-debugfs.c - xHCI debugfs interface 4 * 5 * Copyright (C) 2017 Intel Corporation 6 * 7 * Author: Lu Baolu <baolu.lu@linux.intel.com> 8 */ 9 10 #include <linux/slab.h> 11 #include <linux/uaccess.h> 12 13 #include "xhci.h" 14 #include "xhci-debugfs.h" 15 16 static const struct debugfs_reg32 xhci_cap_regs[] = { 17 dump_register(CAPLENGTH), 18 dump_register(HCSPARAMS1), 19 dump_register(HCSPARAMS2), 20 dump_register(HCSPARAMS3), 21 dump_register(HCCPARAMS1), 22 dump_register(DOORBELLOFF), 23 dump_register(RUNTIMEOFF), 24 dump_register(HCCPARAMS2), 25 }; 26 27 static const struct debugfs_reg32 xhci_op_regs[] = { 28 dump_register(USBCMD), 29 dump_register(USBSTS), 30 dump_register(PAGESIZE), 31 dump_register(DNCTRL), 32 dump_register(CRCR), 33 dump_register(DCBAAP_LOW), 34 dump_register(DCBAAP_HIGH), 35 dump_register(CONFIG), 36 }; 37 38 static const struct debugfs_reg32 xhci_runtime_regs[] = { 39 dump_register(MFINDEX), 40 dump_register(IR0_IMAN), 41 dump_register(IR0_IMOD), 42 dump_register(IR0_ERSTSZ), 43 dump_register(IR0_ERSTBA_LOW), 44 dump_register(IR0_ERSTBA_HIGH), 45 dump_register(IR0_ERDP_LOW), 46 dump_register(IR0_ERDP_HIGH), 47 }; 48 49 static const struct debugfs_reg32 xhci_extcap_legsup[] = { 50 dump_register(EXTCAP_USBLEGSUP), 51 dump_register(EXTCAP_USBLEGCTLSTS), 52 }; 53 54 static const struct debugfs_reg32 xhci_extcap_protocol[] = { 55 dump_register(EXTCAP_REVISION), 56 dump_register(EXTCAP_NAME), 57 dump_register(EXTCAP_PORTINFO), 58 dump_register(EXTCAP_PORTTYPE), 59 dump_register(EXTCAP_MANTISSA1), 60 dump_register(EXTCAP_MANTISSA2), 61 dump_register(EXTCAP_MANTISSA3), 62 dump_register(EXTCAP_MANTISSA4), 63 dump_register(EXTCAP_MANTISSA5), 64 dump_register(EXTCAP_MANTISSA6), 65 }; 66 67 static const struct debugfs_reg32 xhci_extcap_dbc[] = { 68 dump_register(EXTCAP_DBC_CAPABILITY), 69 dump_register(EXTCAP_DBC_DOORBELL), 70 dump_register(EXTCAP_DBC_ERSTSIZE), 71 dump_register(EXTCAP_DBC_ERST_LOW), 72 dump_register(EXTCAP_DBC_ERST_HIGH), 73 dump_register(EXTCAP_DBC_ERDP_LOW), 74 dump_register(EXTCAP_DBC_ERDP_HIGH), 75 dump_register(EXTCAP_DBC_CONTROL), 76 dump_register(EXTCAP_DBC_STATUS), 77 dump_register(EXTCAP_DBC_PORTSC), 78 dump_register(EXTCAP_DBC_CONT_LOW), 79 dump_register(EXTCAP_DBC_CONT_HIGH), 80 dump_register(EXTCAP_DBC_DEVINFO1), 81 dump_register(EXTCAP_DBC_DEVINFO2), 82 }; 83 84 static struct dentry *xhci_debugfs_root; 85 86 static struct xhci_regset *xhci_debugfs_alloc_regset(struct xhci_hcd *xhci) 87 { 88 struct xhci_regset *regset; 89 90 regset = kzalloc(sizeof(*regset), GFP_KERNEL); 91 if (!regset) 92 return NULL; 93 94 /* 95 * The allocation and free of regset are executed in order. 96 * We needn't a lock here. 97 */ 98 INIT_LIST_HEAD(®set->list); 99 list_add_tail(®set->list, &xhci->regset_list); 100 101 return regset; 102 } 103 104 static void xhci_debugfs_free_regset(struct xhci_regset *regset) 105 { 106 if (!regset) 107 return; 108 109 list_del(®set->list); 110 kfree(regset); 111 } 112 113 __printf(6, 7) 114 static void xhci_debugfs_regset(struct xhci_hcd *xhci, u32 base, 115 const struct debugfs_reg32 *regs, 116 size_t nregs, struct dentry *parent, 117 const char *fmt, ...) 118 { 119 struct xhci_regset *rgs; 120 va_list args; 121 struct debugfs_regset32 *regset; 122 struct usb_hcd *hcd = xhci_to_hcd(xhci); 123 124 rgs = xhci_debugfs_alloc_regset(xhci); 125 if (!rgs) 126 return; 127 128 va_start(args, fmt); 129 vsnprintf(rgs->name, sizeof(rgs->name), fmt, args); 130 va_end(args); 131 132 regset = &rgs->regset; 133 regset->regs = regs; 134 regset->nregs = nregs; 135 regset->base = hcd->regs + base; 136 regset->dev = hcd->self.controller; 137 138 debugfs_create_regset32((const char *)rgs->name, 0444, parent, regset); 139 } 140 141 static void xhci_debugfs_extcap_regset(struct xhci_hcd *xhci, int cap_id, 142 const struct debugfs_reg32 *regs, 143 size_t n, const char *cap_name) 144 { 145 u32 offset; 146 int index = 0; 147 size_t psic, nregs = n; 148 void __iomem *base = &xhci->cap_regs->hc_capbase; 149 150 offset = xhci_find_next_ext_cap(base, 0, cap_id); 151 while (offset) { 152 if (cap_id == XHCI_EXT_CAPS_PROTOCOL) { 153 psic = XHCI_EXT_PORT_PSIC(readl(base + offset + 8)); 154 nregs = min(4 + psic, n); 155 } 156 157 xhci_debugfs_regset(xhci, offset, regs, nregs, 158 xhci->debugfs_root, "%s:%02d", 159 cap_name, index); 160 offset = xhci_find_next_ext_cap(base, offset, cap_id); 161 index++; 162 } 163 } 164 165 static int xhci_ring_enqueue_show(struct seq_file *s, void *unused) 166 { 167 dma_addr_t dma; 168 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 169 170 dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue); 171 seq_printf(s, "%pad\n", &dma); 172 173 return 0; 174 } 175 176 static int xhci_ring_dequeue_show(struct seq_file *s, void *unused) 177 { 178 dma_addr_t dma; 179 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 180 181 dma = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue); 182 seq_printf(s, "%pad\n", &dma); 183 184 return 0; 185 } 186 187 static int xhci_ring_cycle_show(struct seq_file *s, void *unused) 188 { 189 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 190 191 seq_printf(s, "%d\n", ring->cycle_state); 192 193 return 0; 194 } 195 196 static void xhci_ring_dump_segment(struct seq_file *s, 197 struct xhci_segment *seg) 198 { 199 int i; 200 dma_addr_t dma; 201 union xhci_trb *trb; 202 char str[XHCI_MSG_MAX]; 203 204 for (i = 0; i < TRBS_PER_SEGMENT; i++) { 205 trb = &seg->trbs[i]; 206 dma = seg->dma + i * sizeof(*trb); 207 seq_printf(s, "%pad: %s\n", &dma, 208 xhci_decode_trb(str, XHCI_MSG_MAX, le32_to_cpu(trb->generic.field[0]), 209 le32_to_cpu(trb->generic.field[1]), 210 le32_to_cpu(trb->generic.field[2]), 211 le32_to_cpu(trb->generic.field[3]))); 212 } 213 } 214 215 static int xhci_ring_trb_show(struct seq_file *s, void *unused) 216 { 217 int i; 218 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 219 struct xhci_segment *seg = ring->first_seg; 220 221 for (i = 0; i < ring->num_segs; i++) { 222 xhci_ring_dump_segment(s, seg); 223 seg = seg->next; 224 } 225 226 return 0; 227 } 228 229 static struct xhci_file_map ring_files[] = { 230 {"enqueue", xhci_ring_enqueue_show, }, 231 {"dequeue", xhci_ring_dequeue_show, }, 232 {"cycle", xhci_ring_cycle_show, }, 233 {"trbs", xhci_ring_trb_show, }, 234 }; 235 236 static int xhci_ring_open(struct inode *inode, struct file *file) 237 { 238 int i; 239 struct xhci_file_map *f_map; 240 const char *file_name = file_dentry(file)->d_iname; 241 242 for (i = 0; i < ARRAY_SIZE(ring_files); i++) { 243 f_map = &ring_files[i]; 244 245 if (strcmp(f_map->name, file_name) == 0) 246 break; 247 } 248 249 return single_open(file, f_map->show, inode->i_private); 250 } 251 252 static const struct file_operations xhci_ring_fops = { 253 .open = xhci_ring_open, 254 .read = seq_read, 255 .llseek = seq_lseek, 256 .release = single_release, 257 }; 258 259 static int xhci_slot_context_show(struct seq_file *s, void *unused) 260 { 261 struct xhci_hcd *xhci; 262 struct xhci_slot_ctx *slot_ctx; 263 struct xhci_slot_priv *priv = s->private; 264 struct xhci_virt_device *dev = priv->dev; 265 char str[XHCI_MSG_MAX]; 266 267 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus)); 268 slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx); 269 seq_printf(s, "%pad: %s\n", &dev->out_ctx->dma, 270 xhci_decode_slot_context(str, 271 le32_to_cpu(slot_ctx->dev_info), 272 le32_to_cpu(slot_ctx->dev_info2), 273 le32_to_cpu(slot_ctx->tt_info), 274 le32_to_cpu(slot_ctx->dev_state))); 275 276 return 0; 277 } 278 279 static int xhci_endpoint_context_show(struct seq_file *s, void *unused) 280 { 281 int ep_index; 282 dma_addr_t dma; 283 struct xhci_hcd *xhci; 284 struct xhci_ep_ctx *ep_ctx; 285 struct xhci_slot_priv *priv = s->private; 286 struct xhci_virt_device *dev = priv->dev; 287 char str[XHCI_MSG_MAX]; 288 289 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus)); 290 291 for (ep_index = 0; ep_index < 31; ep_index++) { 292 ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index); 293 dma = dev->out_ctx->dma + (ep_index + 1) * CTX_SIZE(xhci->hcc_params); 294 seq_printf(s, "%pad: %s\n", &dma, 295 xhci_decode_ep_context(str, 296 le32_to_cpu(ep_ctx->ep_info), 297 le32_to_cpu(ep_ctx->ep_info2), 298 le64_to_cpu(ep_ctx->deq), 299 le32_to_cpu(ep_ctx->tx_info))); 300 } 301 302 return 0; 303 } 304 305 static int xhci_device_name_show(struct seq_file *s, void *unused) 306 { 307 struct xhci_slot_priv *priv = s->private; 308 struct xhci_virt_device *dev = priv->dev; 309 310 seq_printf(s, "%s\n", dev_name(&dev->udev->dev)); 311 312 return 0; 313 } 314 315 static struct xhci_file_map context_files[] = { 316 {"name", xhci_device_name_show, }, 317 {"slot-context", xhci_slot_context_show, }, 318 {"ep-context", xhci_endpoint_context_show, }, 319 }; 320 321 static int xhci_context_open(struct inode *inode, struct file *file) 322 { 323 int i; 324 struct xhci_file_map *f_map; 325 const char *file_name = file_dentry(file)->d_iname; 326 327 for (i = 0; i < ARRAY_SIZE(context_files); i++) { 328 f_map = &context_files[i]; 329 330 if (strcmp(f_map->name, file_name) == 0) 331 break; 332 } 333 334 return single_open(file, f_map->show, inode->i_private); 335 } 336 337 static const struct file_operations xhci_context_fops = { 338 .open = xhci_context_open, 339 .read = seq_read, 340 .llseek = seq_lseek, 341 .release = single_release, 342 }; 343 344 345 346 static int xhci_portsc_show(struct seq_file *s, void *unused) 347 { 348 struct xhci_port *port = s->private; 349 u32 portsc; 350 char str[XHCI_MSG_MAX]; 351 352 portsc = readl(port->addr); 353 seq_printf(s, "%s\n", xhci_decode_portsc(str, portsc)); 354 355 return 0; 356 } 357 358 static int xhci_port_open(struct inode *inode, struct file *file) 359 { 360 return single_open(file, xhci_portsc_show, inode->i_private); 361 } 362 363 static ssize_t xhci_port_write(struct file *file, const char __user *ubuf, 364 size_t count, loff_t *ppos) 365 { 366 struct seq_file *s = file->private_data; 367 struct xhci_port *port = s->private; 368 struct xhci_hcd *xhci = hcd_to_xhci(port->rhub->hcd); 369 char buf[32]; 370 u32 portsc; 371 unsigned long flags; 372 373 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 374 return -EFAULT; 375 376 if (!strncmp(buf, "compliance", 10)) { 377 /* If CTC is clear, compliance is enabled by default */ 378 if (!HCC2_CTC(xhci->hcc_params2)) 379 return count; 380 spin_lock_irqsave(&xhci->lock, flags); 381 /* compliance mode can only be enabled on ports in RxDetect */ 382 portsc = readl(port->addr); 383 if ((portsc & PORT_PLS_MASK) != XDEV_RXDETECT) { 384 spin_unlock_irqrestore(&xhci->lock, flags); 385 return -EPERM; 386 } 387 portsc = xhci_port_state_to_neutral(portsc); 388 portsc &= ~PORT_PLS_MASK; 389 portsc |= PORT_LINK_STROBE | XDEV_COMP_MODE; 390 writel(portsc, port->addr); 391 spin_unlock_irqrestore(&xhci->lock, flags); 392 } else { 393 return -EINVAL; 394 } 395 return count; 396 } 397 398 static const struct file_operations port_fops = { 399 .open = xhci_port_open, 400 .write = xhci_port_write, 401 .read = seq_read, 402 .llseek = seq_lseek, 403 .release = single_release, 404 }; 405 406 static void xhci_debugfs_create_files(struct xhci_hcd *xhci, 407 struct xhci_file_map *files, 408 size_t nentries, void *data, 409 struct dentry *parent, 410 const struct file_operations *fops) 411 { 412 int i; 413 414 for (i = 0; i < nentries; i++) 415 debugfs_create_file(files[i].name, 0444, parent, data, fops); 416 } 417 418 static struct dentry *xhci_debugfs_create_ring_dir(struct xhci_hcd *xhci, 419 struct xhci_ring **ring, 420 const char *name, 421 struct dentry *parent) 422 { 423 struct dentry *dir; 424 425 dir = debugfs_create_dir(name, parent); 426 xhci_debugfs_create_files(xhci, ring_files, ARRAY_SIZE(ring_files), 427 ring, dir, &xhci_ring_fops); 428 429 return dir; 430 } 431 432 static void xhci_debugfs_create_context_files(struct xhci_hcd *xhci, 433 struct dentry *parent, 434 int slot_id) 435 { 436 struct xhci_virt_device *dev = xhci->devs[slot_id]; 437 438 xhci_debugfs_create_files(xhci, context_files, 439 ARRAY_SIZE(context_files), 440 dev->debugfs_private, 441 parent, &xhci_context_fops); 442 } 443 444 void xhci_debugfs_create_endpoint(struct xhci_hcd *xhci, 445 struct xhci_virt_device *dev, 446 int ep_index) 447 { 448 struct xhci_ep_priv *epriv; 449 struct xhci_slot_priv *spriv = dev->debugfs_private; 450 451 if (!spriv) 452 return; 453 454 if (spriv->eps[ep_index]) 455 return; 456 457 epriv = kzalloc(sizeof(*epriv), GFP_KERNEL); 458 if (!epriv) 459 return; 460 461 epriv->show_ring = dev->eps[ep_index].ring; 462 463 snprintf(epriv->name, sizeof(epriv->name), "ep%02d", ep_index); 464 epriv->root = xhci_debugfs_create_ring_dir(xhci, 465 &epriv->show_ring, 466 epriv->name, 467 spriv->root); 468 spriv->eps[ep_index] = epriv; 469 } 470 471 void xhci_debugfs_remove_endpoint(struct xhci_hcd *xhci, 472 struct xhci_virt_device *dev, 473 int ep_index) 474 { 475 struct xhci_ep_priv *epriv; 476 struct xhci_slot_priv *spriv = dev->debugfs_private; 477 478 if (!spriv || !spriv->eps[ep_index]) 479 return; 480 481 epriv = spriv->eps[ep_index]; 482 debugfs_remove_recursive(epriv->root); 483 spriv->eps[ep_index] = NULL; 484 kfree(epriv); 485 } 486 487 static int xhci_stream_id_show(struct seq_file *s, void *unused) 488 { 489 struct xhci_ep_priv *epriv = s->private; 490 491 if (!epriv->stream_info) 492 return -EPERM; 493 494 seq_printf(s, "Show stream ID %d trb ring, supported [1 - %d]\n", 495 epriv->stream_id, epriv->stream_info->num_streams - 1); 496 497 return 0; 498 } 499 500 static int xhci_stream_id_open(struct inode *inode, struct file *file) 501 { 502 return single_open(file, xhci_stream_id_show, inode->i_private); 503 } 504 505 static ssize_t xhci_stream_id_write(struct file *file, const char __user *ubuf, 506 size_t count, loff_t *ppos) 507 { 508 struct seq_file *s = file->private_data; 509 struct xhci_ep_priv *epriv = s->private; 510 int ret; 511 u16 stream_id; /* MaxPStreams + 1 <= 16 */ 512 513 if (!epriv->stream_info) 514 return -EPERM; 515 516 /* Decimal number */ 517 ret = kstrtou16_from_user(ubuf, count, 10, &stream_id); 518 if (ret) 519 return ret; 520 521 if (stream_id == 0 || stream_id >= epriv->stream_info->num_streams) 522 return -EINVAL; 523 524 epriv->stream_id = stream_id; 525 epriv->show_ring = epriv->stream_info->stream_rings[stream_id]; 526 527 return count; 528 } 529 530 static const struct file_operations stream_id_fops = { 531 .open = xhci_stream_id_open, 532 .write = xhci_stream_id_write, 533 .read = seq_read, 534 .llseek = seq_lseek, 535 .release = single_release, 536 }; 537 538 static int xhci_stream_context_array_show(struct seq_file *s, void *unused) 539 { 540 struct xhci_ep_priv *epriv = s->private; 541 struct xhci_stream_ctx *stream_ctx; 542 dma_addr_t dma; 543 int id; 544 545 if (!epriv->stream_info) 546 return -EPERM; 547 548 seq_printf(s, "Allocated %d streams and %d stream context array entries\n", 549 epriv->stream_info->num_streams, 550 epriv->stream_info->num_stream_ctxs); 551 552 for (id = 0; id < epriv->stream_info->num_stream_ctxs; id++) { 553 stream_ctx = epriv->stream_info->stream_ctx_array + id; 554 dma = epriv->stream_info->ctx_array_dma + id * 16; 555 if (id < epriv->stream_info->num_streams) 556 seq_printf(s, "%pad stream id %d deq %016llx\n", &dma, 557 id, le64_to_cpu(stream_ctx->stream_ring)); 558 else 559 seq_printf(s, "%pad stream context entry not used deq %016llx\n", 560 &dma, le64_to_cpu(stream_ctx->stream_ring)); 561 } 562 563 return 0; 564 } 565 DEFINE_SHOW_ATTRIBUTE(xhci_stream_context_array); 566 567 void xhci_debugfs_create_stream_files(struct xhci_hcd *xhci, 568 struct xhci_virt_device *dev, 569 int ep_index) 570 { 571 struct xhci_slot_priv *spriv = dev->debugfs_private; 572 struct xhci_ep_priv *epriv; 573 574 if (!spriv || !spriv->eps[ep_index] || 575 !dev->eps[ep_index].stream_info) 576 return; 577 578 epriv = spriv->eps[ep_index]; 579 epriv->stream_info = dev->eps[ep_index].stream_info; 580 581 /* Show trb ring of stream ID 1 by default */ 582 epriv->stream_id = 1; 583 epriv->show_ring = epriv->stream_info->stream_rings[1]; 584 debugfs_create_file("stream_id", 0644, 585 epriv->root, epriv, 586 &stream_id_fops); 587 debugfs_create_file("stream_context_array", 0444, 588 epriv->root, epriv, 589 &xhci_stream_context_array_fops); 590 } 591 592 void xhci_debugfs_create_slot(struct xhci_hcd *xhci, int slot_id) 593 { 594 struct xhci_slot_priv *priv; 595 struct xhci_virt_device *dev = xhci->devs[slot_id]; 596 597 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 598 if (!priv) 599 return; 600 601 snprintf(priv->name, sizeof(priv->name), "%02d", slot_id); 602 priv->root = debugfs_create_dir(priv->name, xhci->debugfs_slots); 603 priv->dev = dev; 604 dev->debugfs_private = priv; 605 606 xhci_debugfs_create_ring_dir(xhci, &dev->eps[0].ring, 607 "ep00", priv->root); 608 609 xhci_debugfs_create_context_files(xhci, priv->root, slot_id); 610 } 611 612 void xhci_debugfs_remove_slot(struct xhci_hcd *xhci, int slot_id) 613 { 614 int i; 615 struct xhci_slot_priv *priv; 616 struct xhci_virt_device *dev = xhci->devs[slot_id]; 617 618 if (!dev || !dev->debugfs_private) 619 return; 620 621 priv = dev->debugfs_private; 622 623 debugfs_remove_recursive(priv->root); 624 625 for (i = 0; i < 31; i++) 626 kfree(priv->eps[i]); 627 628 kfree(priv); 629 dev->debugfs_private = NULL; 630 } 631 632 static void xhci_debugfs_create_ports(struct xhci_hcd *xhci, 633 struct dentry *parent) 634 { 635 unsigned int num_ports; 636 char port_name[8]; 637 struct xhci_port *port; 638 struct dentry *dir; 639 640 num_ports = HCS_MAX_PORTS(xhci->hcs_params1); 641 642 parent = debugfs_create_dir("ports", parent); 643 644 while (num_ports--) { 645 scnprintf(port_name, sizeof(port_name), "port%02d", 646 num_ports + 1); 647 dir = debugfs_create_dir(port_name, parent); 648 port = &xhci->hw_ports[num_ports]; 649 debugfs_create_file("portsc", 0644, dir, port, &port_fops); 650 } 651 } 652 653 void xhci_debugfs_init(struct xhci_hcd *xhci) 654 { 655 struct device *dev = xhci_to_hcd(xhci)->self.controller; 656 657 xhci->debugfs_root = debugfs_create_dir(dev_name(dev), 658 xhci_debugfs_root); 659 660 INIT_LIST_HEAD(&xhci->regset_list); 661 662 xhci_debugfs_regset(xhci, 663 0, 664 xhci_cap_regs, ARRAY_SIZE(xhci_cap_regs), 665 xhci->debugfs_root, "reg-cap"); 666 667 xhci_debugfs_regset(xhci, 668 HC_LENGTH(readl(&xhci->cap_regs->hc_capbase)), 669 xhci_op_regs, ARRAY_SIZE(xhci_op_regs), 670 xhci->debugfs_root, "reg-op"); 671 672 xhci_debugfs_regset(xhci, 673 readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK, 674 xhci_runtime_regs, ARRAY_SIZE(xhci_runtime_regs), 675 xhci->debugfs_root, "reg-runtime"); 676 677 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_LEGACY, 678 xhci_extcap_legsup, 679 ARRAY_SIZE(xhci_extcap_legsup), 680 "reg-ext-legsup"); 681 682 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_PROTOCOL, 683 xhci_extcap_protocol, 684 ARRAY_SIZE(xhci_extcap_protocol), 685 "reg-ext-protocol"); 686 687 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_DEBUG, 688 xhci_extcap_dbc, 689 ARRAY_SIZE(xhci_extcap_dbc), 690 "reg-ext-dbc"); 691 692 xhci_debugfs_create_ring_dir(xhci, &xhci->cmd_ring, 693 "command-ring", 694 xhci->debugfs_root); 695 696 xhci_debugfs_create_ring_dir(xhci, &xhci->interrupter->event_ring, 697 "event-ring", 698 xhci->debugfs_root); 699 700 xhci->debugfs_slots = debugfs_create_dir("devices", xhci->debugfs_root); 701 702 xhci_debugfs_create_ports(xhci, xhci->debugfs_root); 703 } 704 705 void xhci_debugfs_exit(struct xhci_hcd *xhci) 706 { 707 struct xhci_regset *rgs, *tmp; 708 709 debugfs_remove_recursive(xhci->debugfs_root); 710 xhci->debugfs_root = NULL; 711 xhci->debugfs_slots = NULL; 712 713 list_for_each_entry_safe(rgs, tmp, &xhci->regset_list, list) 714 xhci_debugfs_free_regset(rgs); 715 } 716 717 void __init xhci_debugfs_create_root(void) 718 { 719 xhci_debugfs_root = debugfs_create_dir("xhci", usb_debug_root); 720 } 721 722 void __exit xhci_debugfs_remove_root(void) 723 { 724 debugfs_remove_recursive(xhci_debugfs_root); 725 xhci_debugfs_root = NULL; 726 } 727