1 // SPDX-License-Identifier: GPL-2.0
3 * xhci-debugfs.c - xHCI debugfs interface
5 * Copyright (C) 2017 Intel Corporation
7 * Author: Lu Baolu <baolu.lu@linux.intel.com>
10 #include <linux/slab.h>
11 #include <linux/uaccess.h>
14 #include "xhci-debugfs.h"
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),
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),
33 dump_register(DCBAAP_LOW),
34 dump_register(DCBAAP_HIGH),
35 dump_register(CONFIG),
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),
49 static const struct debugfs_reg32 xhci_extcap_legsup[] = {
50 dump_register(EXTCAP_USBLEGSUP),
51 dump_register(EXTCAP_USBLEGCTLSTS),
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),
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),
84 static struct dentry *xhci_debugfs_root;
86 static struct xhci_regset *xhci_debugfs_alloc_regset(struct xhci_hcd *xhci)
88 struct xhci_regset *regset;
90 regset = kzalloc(sizeof(*regset), GFP_KERNEL);
95 * The allocation and free of regset are executed in order.
96 * We needn't a lock here.
98 INIT_LIST_HEAD(®set->list);
99 list_add_tail(®set->list, &xhci->regset_list);
104 static void xhci_debugfs_free_regset(struct xhci_regset *regset)
109 list_del(®set->list);
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, ...)
119 struct xhci_regset *rgs;
121 struct debugfs_regset32 *regset;
122 struct usb_hcd *hcd = xhci_to_hcd(xhci);
124 rgs = xhci_debugfs_alloc_regset(xhci);
129 vsnprintf(rgs->name, sizeof(rgs->name), fmt, args);
132 regset = &rgs->regset;
134 regset->nregs = nregs;
135 regset->base = hcd->regs + base;
137 debugfs_create_regset32((const char *)rgs->name, 0444, parent, regset);
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)
146 size_t psic, nregs = n;
147 void __iomem *base = &xhci->cap_regs->hc_capbase;
149 offset = xhci_find_next_ext_cap(base, 0, cap_id);
151 if (cap_id == XHCI_EXT_CAPS_PROTOCOL) {
152 psic = XHCI_EXT_PORT_PSIC(readl(base + offset + 8));
153 nregs = min(4 + psic, n);
156 xhci_debugfs_regset(xhci, offset, regs, nregs,
157 xhci->debugfs_root, "%s:%02d",
159 offset = xhci_find_next_ext_cap(base, offset, cap_id);
164 static int xhci_ring_enqueue_show(struct seq_file *s, void *unused)
167 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
169 dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
170 seq_printf(s, "%pad\n", &dma);
175 static int xhci_ring_dequeue_show(struct seq_file *s, void *unused)
178 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
180 dma = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
181 seq_printf(s, "%pad\n", &dma);
186 static int xhci_ring_cycle_show(struct seq_file *s, void *unused)
188 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
190 seq_printf(s, "%d\n", ring->cycle_state);
195 static void xhci_ring_dump_segment(struct seq_file *s,
196 struct xhci_segment *seg)
201 char str[XHCI_MSG_MAX];
203 for (i = 0; i < TRBS_PER_SEGMENT; i++) {
205 dma = seg->dma + i * sizeof(*trb);
206 seq_printf(s, "%pad: %s\n", &dma,
207 xhci_decode_trb(str, XHCI_MSG_MAX, le32_to_cpu(trb->generic.field[0]),
208 le32_to_cpu(trb->generic.field[1]),
209 le32_to_cpu(trb->generic.field[2]),
210 le32_to_cpu(trb->generic.field[3])));
214 static int xhci_ring_trb_show(struct seq_file *s, void *unused)
217 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
218 struct xhci_segment *seg = ring->first_seg;
220 for (i = 0; i < ring->num_segs; i++) {
221 xhci_ring_dump_segment(s, seg);
228 static struct xhci_file_map ring_files[] = {
229 {"enqueue", xhci_ring_enqueue_show, },
230 {"dequeue", xhci_ring_dequeue_show, },
231 {"cycle", xhci_ring_cycle_show, },
232 {"trbs", xhci_ring_trb_show, },
235 static int xhci_ring_open(struct inode *inode, struct file *file)
238 struct xhci_file_map *f_map;
239 const char *file_name = file_dentry(file)->d_iname;
241 for (i = 0; i < ARRAY_SIZE(ring_files); i++) {
242 f_map = &ring_files[i];
244 if (strcmp(f_map->name, file_name) == 0)
248 return single_open(file, f_map->show, inode->i_private);
251 static const struct file_operations xhci_ring_fops = {
252 .open = xhci_ring_open,
255 .release = single_release,
258 static int xhci_slot_context_show(struct seq_file *s, void *unused)
260 struct xhci_hcd *xhci;
261 struct xhci_slot_ctx *slot_ctx;
262 struct xhci_slot_priv *priv = s->private;
263 struct xhci_virt_device *dev = priv->dev;
265 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus));
266 slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
267 seq_printf(s, "%pad: %s\n", &dev->out_ctx->dma,
268 xhci_decode_slot_context(le32_to_cpu(slot_ctx->dev_info),
269 le32_to_cpu(slot_ctx->dev_info2),
270 le32_to_cpu(slot_ctx->tt_info),
271 le32_to_cpu(slot_ctx->dev_state)));
276 static int xhci_endpoint_context_show(struct seq_file *s, void *unused)
280 struct xhci_hcd *xhci;
281 struct xhci_ep_ctx *ep_ctx;
282 struct xhci_slot_priv *priv = s->private;
283 struct xhci_virt_device *dev = priv->dev;
285 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus));
287 for (ep_index = 0; ep_index < 31; ep_index++) {
288 ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
289 dma = dev->out_ctx->dma + (ep_index + 1) * CTX_SIZE(xhci->hcc_params);
290 seq_printf(s, "%pad: %s\n", &dma,
291 xhci_decode_ep_context(le32_to_cpu(ep_ctx->ep_info),
292 le32_to_cpu(ep_ctx->ep_info2),
293 le64_to_cpu(ep_ctx->deq),
294 le32_to_cpu(ep_ctx->tx_info)));
300 static int xhci_device_name_show(struct seq_file *s, void *unused)
302 struct xhci_slot_priv *priv = s->private;
303 struct xhci_virt_device *dev = priv->dev;
305 seq_printf(s, "%s\n", dev_name(&dev->udev->dev));
310 static struct xhci_file_map context_files[] = {
311 {"name", xhci_device_name_show, },
312 {"slot-context", xhci_slot_context_show, },
313 {"ep-context", xhci_endpoint_context_show, },
316 static int xhci_context_open(struct inode *inode, struct file *file)
319 struct xhci_file_map *f_map;
320 const char *file_name = file_dentry(file)->d_iname;
322 for (i = 0; i < ARRAY_SIZE(context_files); i++) {
323 f_map = &context_files[i];
325 if (strcmp(f_map->name, file_name) == 0)
329 return single_open(file, f_map->show, inode->i_private);
332 static const struct file_operations xhci_context_fops = {
333 .open = xhci_context_open,
336 .release = single_release,
341 static int xhci_portsc_show(struct seq_file *s, void *unused)
343 struct xhci_port *port = s->private;
345 char str[XHCI_MSG_MAX];
347 portsc = readl(port->addr);
348 seq_printf(s, "%s\n", xhci_decode_portsc(str, portsc));
353 static int xhci_port_open(struct inode *inode, struct file *file)
355 return single_open(file, xhci_portsc_show, inode->i_private);
358 static ssize_t xhci_port_write(struct file *file, const char __user *ubuf,
359 size_t count, loff_t *ppos)
361 struct seq_file *s = file->private_data;
362 struct xhci_port *port = s->private;
363 struct xhci_hcd *xhci = hcd_to_xhci(port->rhub->hcd);
368 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
371 if (!strncmp(buf, "compliance", 10)) {
372 /* If CTC is clear, compliance is enabled by default */
373 if (!HCC2_CTC(xhci->hcc_params2))
375 spin_lock_irqsave(&xhci->lock, flags);
376 /* compliance mode can only be enabled on ports in RxDetect */
377 portsc = readl(port->addr);
378 if ((portsc & PORT_PLS_MASK) != XDEV_RXDETECT) {
379 spin_unlock_irqrestore(&xhci->lock, flags);
382 portsc = xhci_port_state_to_neutral(portsc);
383 portsc &= ~PORT_PLS_MASK;
384 portsc |= PORT_LINK_STROBE | XDEV_COMP_MODE;
385 writel(portsc, port->addr);
386 spin_unlock_irqrestore(&xhci->lock, flags);
393 static const struct file_operations port_fops = {
394 .open = xhci_port_open,
395 .write = xhci_port_write,
398 .release = single_release,
401 static void xhci_debugfs_create_files(struct xhci_hcd *xhci,
402 struct xhci_file_map *files,
403 size_t nentries, void *data,
404 struct dentry *parent,
405 const struct file_operations *fops)
409 for (i = 0; i < nentries; i++)
410 debugfs_create_file(files[i].name, 0444, parent, data, fops);
413 static struct dentry *xhci_debugfs_create_ring_dir(struct xhci_hcd *xhci,
414 struct xhci_ring **ring,
416 struct dentry *parent)
420 dir = debugfs_create_dir(name, parent);
421 xhci_debugfs_create_files(xhci, ring_files, ARRAY_SIZE(ring_files),
422 ring, dir, &xhci_ring_fops);
427 static void xhci_debugfs_create_context_files(struct xhci_hcd *xhci,
428 struct dentry *parent,
431 struct xhci_virt_device *dev = xhci->devs[slot_id];
433 xhci_debugfs_create_files(xhci, context_files,
434 ARRAY_SIZE(context_files),
435 dev->debugfs_private,
436 parent, &xhci_context_fops);
439 void xhci_debugfs_create_endpoint(struct xhci_hcd *xhci,
440 struct xhci_virt_device *dev,
443 struct xhci_ep_priv *epriv;
444 struct xhci_slot_priv *spriv = dev->debugfs_private;
449 if (spriv->eps[ep_index])
452 epriv = kzalloc(sizeof(*epriv), GFP_KERNEL);
456 epriv->show_ring = dev->eps[ep_index].ring;
458 snprintf(epriv->name, sizeof(epriv->name), "ep%02d", ep_index);
459 epriv->root = xhci_debugfs_create_ring_dir(xhci,
463 spriv->eps[ep_index] = epriv;
466 void xhci_debugfs_remove_endpoint(struct xhci_hcd *xhci,
467 struct xhci_virt_device *dev,
470 struct xhci_ep_priv *epriv;
471 struct xhci_slot_priv *spriv = dev->debugfs_private;
473 if (!spriv || !spriv->eps[ep_index])
476 epriv = spriv->eps[ep_index];
477 debugfs_remove_recursive(epriv->root);
478 spriv->eps[ep_index] = NULL;
482 static int xhci_stream_id_show(struct seq_file *s, void *unused)
484 struct xhci_ep_priv *epriv = s->private;
486 if (!epriv->stream_info)
489 seq_printf(s, "Show stream ID %d trb ring, supported [1 - %d]\n",
490 epriv->stream_id, epriv->stream_info->num_streams - 1);
495 static int xhci_stream_id_open(struct inode *inode, struct file *file)
497 return single_open(file, xhci_stream_id_show, inode->i_private);
500 static ssize_t xhci_stream_id_write(struct file *file, const char __user *ubuf,
501 size_t count, loff_t *ppos)
503 struct seq_file *s = file->private_data;
504 struct xhci_ep_priv *epriv = s->private;
506 u16 stream_id; /* MaxPStreams + 1 <= 16 */
508 if (!epriv->stream_info)
512 ret = kstrtou16_from_user(ubuf, count, 10, &stream_id);
516 if (stream_id == 0 || stream_id >= epriv->stream_info->num_streams)
519 epriv->stream_id = stream_id;
520 epriv->show_ring = epriv->stream_info->stream_rings[stream_id];
525 static const struct file_operations stream_id_fops = {
526 .open = xhci_stream_id_open,
527 .write = xhci_stream_id_write,
530 .release = single_release,
533 static int xhci_stream_context_array_show(struct seq_file *s, void *unused)
535 struct xhci_ep_priv *epriv = s->private;
536 struct xhci_stream_ctx *stream_ctx;
540 if (!epriv->stream_info)
543 seq_printf(s, "Allocated %d streams and %d stream context array entries\n",
544 epriv->stream_info->num_streams,
545 epriv->stream_info->num_stream_ctxs);
547 for (id = 0; id < epriv->stream_info->num_stream_ctxs; id++) {
548 stream_ctx = epriv->stream_info->stream_ctx_array + id;
549 dma = epriv->stream_info->ctx_array_dma + id * 16;
550 if (id < epriv->stream_info->num_streams)
551 seq_printf(s, "%pad stream id %d deq %016llx\n", &dma,
552 id, le64_to_cpu(stream_ctx->stream_ring));
554 seq_printf(s, "%pad stream context entry not used deq %016llx\n",
555 &dma, le64_to_cpu(stream_ctx->stream_ring));
560 DEFINE_SHOW_ATTRIBUTE(xhci_stream_context_array);
562 void xhci_debugfs_create_stream_files(struct xhci_hcd *xhci,
563 struct xhci_virt_device *dev,
566 struct xhci_slot_priv *spriv = dev->debugfs_private;
567 struct xhci_ep_priv *epriv;
569 if (!spriv || !spriv->eps[ep_index] ||
570 !dev->eps[ep_index].stream_info)
573 epriv = spriv->eps[ep_index];
574 epriv->stream_info = dev->eps[ep_index].stream_info;
576 /* Show trb ring of stream ID 1 by default */
577 epriv->stream_id = 1;
578 epriv->show_ring = epriv->stream_info->stream_rings[1];
579 debugfs_create_file("stream_id", 0644,
582 debugfs_create_file("stream_context_array", 0444,
584 &xhci_stream_context_array_fops);
587 void xhci_debugfs_create_slot(struct xhci_hcd *xhci, int slot_id)
589 struct xhci_slot_priv *priv;
590 struct xhci_virt_device *dev = xhci->devs[slot_id];
592 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
596 snprintf(priv->name, sizeof(priv->name), "%02d", slot_id);
597 priv->root = debugfs_create_dir(priv->name, xhci->debugfs_slots);
599 dev->debugfs_private = priv;
601 xhci_debugfs_create_ring_dir(xhci, &dev->eps[0].ring,
604 xhci_debugfs_create_context_files(xhci, priv->root, slot_id);
607 void xhci_debugfs_remove_slot(struct xhci_hcd *xhci, int slot_id)
610 struct xhci_slot_priv *priv;
611 struct xhci_virt_device *dev = xhci->devs[slot_id];
613 if (!dev || !dev->debugfs_private)
616 priv = dev->debugfs_private;
618 debugfs_remove_recursive(priv->root);
620 for (i = 0; i < 31; i++)
624 dev->debugfs_private = NULL;
627 static void xhci_debugfs_create_ports(struct xhci_hcd *xhci,
628 struct dentry *parent)
630 unsigned int num_ports;
632 struct xhci_port *port;
635 num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
637 parent = debugfs_create_dir("ports", parent);
639 while (num_ports--) {
640 scnprintf(port_name, sizeof(port_name), "port%02d",
642 dir = debugfs_create_dir(port_name, parent);
643 port = &xhci->hw_ports[num_ports];
644 debugfs_create_file("portsc", 0644, dir, port, &port_fops);
648 void xhci_debugfs_init(struct xhci_hcd *xhci)
650 struct device *dev = xhci_to_hcd(xhci)->self.controller;
652 xhci->debugfs_root = debugfs_create_dir(dev_name(dev),
655 INIT_LIST_HEAD(&xhci->regset_list);
657 xhci_debugfs_regset(xhci,
659 xhci_cap_regs, ARRAY_SIZE(xhci_cap_regs),
660 xhci->debugfs_root, "reg-cap");
662 xhci_debugfs_regset(xhci,
663 HC_LENGTH(readl(&xhci->cap_regs->hc_capbase)),
664 xhci_op_regs, ARRAY_SIZE(xhci_op_regs),
665 xhci->debugfs_root, "reg-op");
667 xhci_debugfs_regset(xhci,
668 readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK,
669 xhci_runtime_regs, ARRAY_SIZE(xhci_runtime_regs),
670 xhci->debugfs_root, "reg-runtime");
672 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_LEGACY,
674 ARRAY_SIZE(xhci_extcap_legsup),
677 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_PROTOCOL,
678 xhci_extcap_protocol,
679 ARRAY_SIZE(xhci_extcap_protocol),
682 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_DEBUG,
684 ARRAY_SIZE(xhci_extcap_dbc),
687 xhci_debugfs_create_ring_dir(xhci, &xhci->cmd_ring,
691 xhci_debugfs_create_ring_dir(xhci, &xhci->event_ring,
695 xhci->debugfs_slots = debugfs_create_dir("devices", xhci->debugfs_root);
697 xhci_debugfs_create_ports(xhci, xhci->debugfs_root);
700 void xhci_debugfs_exit(struct xhci_hcd *xhci)
702 struct xhci_regset *rgs, *tmp;
704 debugfs_remove_recursive(xhci->debugfs_root);
705 xhci->debugfs_root = NULL;
706 xhci->debugfs_slots = NULL;
708 list_for_each_entry_safe(rgs, tmp, &xhci->regset_list, list)
709 xhci_debugfs_free_regset(rgs);
712 void __init xhci_debugfs_create_root(void)
714 xhci_debugfs_root = debugfs_create_dir("xhci", usb_debug_root);
717 void __exit xhci_debugfs_remove_root(void)
719 debugfs_remove_recursive(xhci_debugfs_root);
720 xhci_debugfs_root = NULL;