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 137 debugfs_create_regset32((const char *)rgs->name, 0444, parent, regset); 138 } 139 140 static void xhci_debugfs_extcap_regset(struct xhci_hcd *xhci, int cap_id, 141 const struct debugfs_reg32 *regs, 142 size_t n, const char *cap_name) 143 { 144 u32 offset; 145 int index = 0; 146 size_t psic, nregs = n; 147 void __iomem *base = &xhci->cap_regs->hc_capbase; 148 149 offset = xhci_find_next_ext_cap(base, 0, cap_id); 150 while (offset) { 151 if (cap_id == XHCI_EXT_CAPS_PROTOCOL) { 152 psic = XHCI_EXT_PORT_PSIC(readl(base + offset + 8)); 153 nregs = min(4 + psic, n); 154 } 155 156 xhci_debugfs_regset(xhci, offset, regs, nregs, 157 xhci->debugfs_root, "%s:%02d", 158 cap_name, index); 159 offset = xhci_find_next_ext_cap(base, offset, cap_id); 160 index++; 161 } 162 } 163 164 static int xhci_ring_enqueue_show(struct seq_file *s, void *unused) 165 { 166 dma_addr_t dma; 167 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 168 169 dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue); 170 seq_printf(s, "%pad\n", &dma); 171 172 return 0; 173 } 174 175 static int xhci_ring_dequeue_show(struct seq_file *s, void *unused) 176 { 177 dma_addr_t dma; 178 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 179 180 dma = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue); 181 seq_printf(s, "%pad\n", &dma); 182 183 return 0; 184 } 185 186 static int xhci_ring_cycle_show(struct seq_file *s, void *unused) 187 { 188 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 189 190 seq_printf(s, "%d\n", ring->cycle_state); 191 192 return 0; 193 } 194 195 static void xhci_ring_dump_segment(struct seq_file *s, 196 struct xhci_segment *seg) 197 { 198 int i; 199 dma_addr_t dma; 200 union xhci_trb *trb; 201 202 for (i = 0; i < TRBS_PER_SEGMENT; i++) { 203 trb = &seg->trbs[i]; 204 dma = seg->dma + i * sizeof(*trb); 205 seq_printf(s, "%pad: %s\n", &dma, 206 xhci_decode_trb(le32_to_cpu(trb->generic.field[0]), 207 le32_to_cpu(trb->generic.field[1]), 208 le32_to_cpu(trb->generic.field[2]), 209 le32_to_cpu(trb->generic.field[3]))); 210 } 211 } 212 213 static int xhci_ring_trb_show(struct seq_file *s, void *unused) 214 { 215 int i; 216 struct xhci_ring *ring = *(struct xhci_ring **)s->private; 217 struct xhci_segment *seg = ring->first_seg; 218 219 for (i = 0; i < ring->num_segs; i++) { 220 xhci_ring_dump_segment(s, seg); 221 seg = seg->next; 222 } 223 224 return 0; 225 } 226 227 static struct xhci_file_map ring_files[] = { 228 {"enqueue", xhci_ring_enqueue_show, }, 229 {"dequeue", xhci_ring_dequeue_show, }, 230 {"cycle", xhci_ring_cycle_show, }, 231 {"trbs", xhci_ring_trb_show, }, 232 }; 233 234 static int xhci_ring_open(struct inode *inode, struct file *file) 235 { 236 int i; 237 struct xhci_file_map *f_map; 238 const char *file_name = file_dentry(file)->d_iname; 239 240 for (i = 0; i < ARRAY_SIZE(ring_files); i++) { 241 f_map = &ring_files[i]; 242 243 if (strcmp(f_map->name, file_name) == 0) 244 break; 245 } 246 247 return single_open(file, f_map->show, inode->i_private); 248 } 249 250 static const struct file_operations xhci_ring_fops = { 251 .open = xhci_ring_open, 252 .read = seq_read, 253 .llseek = seq_lseek, 254 .release = single_release, 255 }; 256 257 static int xhci_slot_context_show(struct seq_file *s, void *unused) 258 { 259 struct xhci_hcd *xhci; 260 struct xhci_slot_ctx *slot_ctx; 261 struct xhci_slot_priv *priv = s->private; 262 struct xhci_virt_device *dev = priv->dev; 263 264 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus)); 265 slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx); 266 seq_printf(s, "%pad: %s\n", &dev->out_ctx->dma, 267 xhci_decode_slot_context(le32_to_cpu(slot_ctx->dev_info), 268 le32_to_cpu(slot_ctx->dev_info2), 269 le32_to_cpu(slot_ctx->tt_info), 270 le32_to_cpu(slot_ctx->dev_state))); 271 272 return 0; 273 } 274 275 static int xhci_endpoint_context_show(struct seq_file *s, void *unused) 276 { 277 int dci; 278 dma_addr_t dma; 279 struct xhci_hcd *xhci; 280 struct xhci_ep_ctx *ep_ctx; 281 struct xhci_slot_priv *priv = s->private; 282 struct xhci_virt_device *dev = priv->dev; 283 284 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus)); 285 286 for (dci = 1; dci < 32; dci++) { 287 ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, dci); 288 dma = dev->out_ctx->dma + dci * CTX_SIZE(xhci->hcc_params); 289 seq_printf(s, "%pad: %s\n", &dma, 290 xhci_decode_ep_context(le32_to_cpu(ep_ctx->ep_info), 291 le32_to_cpu(ep_ctx->ep_info2), 292 le64_to_cpu(ep_ctx->deq), 293 le32_to_cpu(ep_ctx->tx_info))); 294 } 295 296 return 0; 297 } 298 299 static int xhci_device_name_show(struct seq_file *s, void *unused) 300 { 301 struct xhci_slot_priv *priv = s->private; 302 struct xhci_virt_device *dev = priv->dev; 303 304 seq_printf(s, "%s\n", dev_name(&dev->udev->dev)); 305 306 return 0; 307 } 308 309 static struct xhci_file_map context_files[] = { 310 {"name", xhci_device_name_show, }, 311 {"slot-context", xhci_slot_context_show, }, 312 {"ep-context", xhci_endpoint_context_show, }, 313 }; 314 315 static int xhci_context_open(struct inode *inode, struct file *file) 316 { 317 int i; 318 struct xhci_file_map *f_map; 319 const char *file_name = file_dentry(file)->d_iname; 320 321 for (i = 0; i < ARRAY_SIZE(context_files); i++) { 322 f_map = &context_files[i]; 323 324 if (strcmp(f_map->name, file_name) == 0) 325 break; 326 } 327 328 return single_open(file, f_map->show, inode->i_private); 329 } 330 331 static const struct file_operations xhci_context_fops = { 332 .open = xhci_context_open, 333 .read = seq_read, 334 .llseek = seq_lseek, 335 .release = single_release, 336 }; 337 338 339 340 static int xhci_portsc_show(struct seq_file *s, void *unused) 341 { 342 struct xhci_port *port = s->private; 343 u32 portsc; 344 345 portsc = readl(port->addr); 346 seq_printf(s, "%s\n", xhci_decode_portsc(portsc)); 347 348 return 0; 349 } 350 351 static int xhci_port_open(struct inode *inode, struct file *file) 352 { 353 return single_open(file, xhci_portsc_show, inode->i_private); 354 } 355 356 static ssize_t xhci_port_write(struct file *file, const char __user *ubuf, 357 size_t count, loff_t *ppos) 358 { 359 struct seq_file *s = file->private_data; 360 struct xhci_port *port = s->private; 361 struct xhci_hcd *xhci = hcd_to_xhci(port->rhub->hcd); 362 char buf[32]; 363 u32 portsc; 364 unsigned long flags; 365 366 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 367 return -EFAULT; 368 369 if (!strncmp(buf, "compliance", 10)) { 370 /* If CTC is clear, compliance is enabled by default */ 371 if (!HCC2_CTC(xhci->hcc_params2)) 372 return count; 373 spin_lock_irqsave(&xhci->lock, flags); 374 /* compliance mode can only be enabled on ports in RxDetect */ 375 portsc = readl(port->addr); 376 if ((portsc & PORT_PLS_MASK) != XDEV_RXDETECT) { 377 spin_unlock_irqrestore(&xhci->lock, flags); 378 return -EPERM; 379 } 380 portsc = xhci_port_state_to_neutral(portsc); 381 portsc &= ~PORT_PLS_MASK; 382 portsc |= PORT_LINK_STROBE | XDEV_COMP_MODE; 383 writel(portsc, port->addr); 384 spin_unlock_irqrestore(&xhci->lock, flags); 385 } else { 386 return -EINVAL; 387 } 388 return count; 389 } 390 391 static const struct file_operations port_fops = { 392 .open = xhci_port_open, 393 .write = xhci_port_write, 394 .read = seq_read, 395 .llseek = seq_lseek, 396 .release = single_release, 397 }; 398 399 static void xhci_debugfs_create_files(struct xhci_hcd *xhci, 400 struct xhci_file_map *files, 401 size_t nentries, void *data, 402 struct dentry *parent, 403 const struct file_operations *fops) 404 { 405 int i; 406 407 for (i = 0; i < nentries; i++) 408 debugfs_create_file(files[i].name, 0444, parent, data, fops); 409 } 410 411 static struct dentry *xhci_debugfs_create_ring_dir(struct xhci_hcd *xhci, 412 struct xhci_ring **ring, 413 const char *name, 414 struct dentry *parent) 415 { 416 struct dentry *dir; 417 418 dir = debugfs_create_dir(name, parent); 419 xhci_debugfs_create_files(xhci, ring_files, ARRAY_SIZE(ring_files), 420 ring, dir, &xhci_ring_fops); 421 422 return dir; 423 } 424 425 static void xhci_debugfs_create_context_files(struct xhci_hcd *xhci, 426 struct dentry *parent, 427 int slot_id) 428 { 429 struct xhci_virt_device *dev = xhci->devs[slot_id]; 430 431 xhci_debugfs_create_files(xhci, context_files, 432 ARRAY_SIZE(context_files), 433 dev->debugfs_private, 434 parent, &xhci_context_fops); 435 } 436 437 void xhci_debugfs_create_endpoint(struct xhci_hcd *xhci, 438 struct xhci_virt_device *dev, 439 int ep_index) 440 { 441 struct xhci_ep_priv *epriv; 442 struct xhci_slot_priv *spriv = dev->debugfs_private; 443 444 if (!spriv) 445 return; 446 447 if (spriv->eps[ep_index]) 448 return; 449 450 epriv = kzalloc(sizeof(*epriv), GFP_KERNEL); 451 if (!epriv) 452 return; 453 454 snprintf(epriv->name, sizeof(epriv->name), "ep%02d", ep_index); 455 epriv->root = xhci_debugfs_create_ring_dir(xhci, 456 &dev->eps[ep_index].ring, 457 epriv->name, 458 spriv->root); 459 spriv->eps[ep_index] = epriv; 460 } 461 462 void xhci_debugfs_remove_endpoint(struct xhci_hcd *xhci, 463 struct xhci_virt_device *dev, 464 int ep_index) 465 { 466 struct xhci_ep_priv *epriv; 467 struct xhci_slot_priv *spriv = dev->debugfs_private; 468 469 if (!spriv || !spriv->eps[ep_index]) 470 return; 471 472 epriv = spriv->eps[ep_index]; 473 debugfs_remove_recursive(epriv->root); 474 spriv->eps[ep_index] = NULL; 475 kfree(epriv); 476 } 477 478 void xhci_debugfs_create_slot(struct xhci_hcd *xhci, int slot_id) 479 { 480 struct xhci_slot_priv *priv; 481 struct xhci_virt_device *dev = xhci->devs[slot_id]; 482 483 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 484 if (!priv) 485 return; 486 487 snprintf(priv->name, sizeof(priv->name), "%02d", slot_id); 488 priv->root = debugfs_create_dir(priv->name, xhci->debugfs_slots); 489 priv->dev = dev; 490 dev->debugfs_private = priv; 491 492 xhci_debugfs_create_ring_dir(xhci, &dev->eps[0].ring, 493 "ep00", priv->root); 494 495 xhci_debugfs_create_context_files(xhci, priv->root, slot_id); 496 } 497 498 void xhci_debugfs_remove_slot(struct xhci_hcd *xhci, int slot_id) 499 { 500 int i; 501 struct xhci_slot_priv *priv; 502 struct xhci_virt_device *dev = xhci->devs[slot_id]; 503 504 if (!dev || !dev->debugfs_private) 505 return; 506 507 priv = dev->debugfs_private; 508 509 debugfs_remove_recursive(priv->root); 510 511 for (i = 0; i < 31; i++) 512 kfree(priv->eps[i]); 513 514 kfree(priv); 515 dev->debugfs_private = NULL; 516 } 517 518 static void xhci_debugfs_create_ports(struct xhci_hcd *xhci, 519 struct dentry *parent) 520 { 521 unsigned int num_ports; 522 char port_name[8]; 523 struct xhci_port *port; 524 struct dentry *dir; 525 526 num_ports = HCS_MAX_PORTS(xhci->hcs_params1); 527 528 parent = debugfs_create_dir("ports", parent); 529 530 while (num_ports--) { 531 scnprintf(port_name, sizeof(port_name), "port%02d", 532 num_ports + 1); 533 dir = debugfs_create_dir(port_name, parent); 534 port = &xhci->hw_ports[num_ports]; 535 debugfs_create_file("portsc", 0644, dir, port, &port_fops); 536 } 537 } 538 539 void xhci_debugfs_init(struct xhci_hcd *xhci) 540 { 541 struct device *dev = xhci_to_hcd(xhci)->self.controller; 542 543 xhci->debugfs_root = debugfs_create_dir(dev_name(dev), 544 xhci_debugfs_root); 545 546 INIT_LIST_HEAD(&xhci->regset_list); 547 548 xhci_debugfs_regset(xhci, 549 0, 550 xhci_cap_regs, ARRAY_SIZE(xhci_cap_regs), 551 xhci->debugfs_root, "reg-cap"); 552 553 xhci_debugfs_regset(xhci, 554 HC_LENGTH(readl(&xhci->cap_regs->hc_capbase)), 555 xhci_op_regs, ARRAY_SIZE(xhci_op_regs), 556 xhci->debugfs_root, "reg-op"); 557 558 xhci_debugfs_regset(xhci, 559 readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK, 560 xhci_runtime_regs, ARRAY_SIZE(xhci_runtime_regs), 561 xhci->debugfs_root, "reg-runtime"); 562 563 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_LEGACY, 564 xhci_extcap_legsup, 565 ARRAY_SIZE(xhci_extcap_legsup), 566 "reg-ext-legsup"); 567 568 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_PROTOCOL, 569 xhci_extcap_protocol, 570 ARRAY_SIZE(xhci_extcap_protocol), 571 "reg-ext-protocol"); 572 573 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_DEBUG, 574 xhci_extcap_dbc, 575 ARRAY_SIZE(xhci_extcap_dbc), 576 "reg-ext-dbc"); 577 578 xhci_debugfs_create_ring_dir(xhci, &xhci->cmd_ring, 579 "command-ring", 580 xhci->debugfs_root); 581 582 xhci_debugfs_create_ring_dir(xhci, &xhci->event_ring, 583 "event-ring", 584 xhci->debugfs_root); 585 586 xhci->debugfs_slots = debugfs_create_dir("devices", xhci->debugfs_root); 587 588 xhci_debugfs_create_ports(xhci, xhci->debugfs_root); 589 } 590 591 void xhci_debugfs_exit(struct xhci_hcd *xhci) 592 { 593 struct xhci_regset *rgs, *tmp; 594 595 debugfs_remove_recursive(xhci->debugfs_root); 596 xhci->debugfs_root = NULL; 597 xhci->debugfs_slots = NULL; 598 599 list_for_each_entry_safe(rgs, tmp, &xhci->regset_list, list) 600 xhci_debugfs_free_regset(rgs); 601 } 602 603 void __init xhci_debugfs_create_root(void) 604 { 605 xhci_debugfs_root = debugfs_create_dir("xhci", usb_debug_root); 606 } 607 608 void __exit xhci_debugfs_remove_root(void) 609 { 610 debugfs_remove_recursive(xhci_debugfs_root); 611 xhci_debugfs_root = NULL; 612 } 613