Loading...
Note: File does not exist in v3.1.
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
12#include "xhci.h"
13#include "xhci-debugfs.h"
14
15static const struct debugfs_reg32 xhci_cap_regs[] = {
16 dump_register(CAPLENGTH),
17 dump_register(HCSPARAMS1),
18 dump_register(HCSPARAMS2),
19 dump_register(HCSPARAMS3),
20 dump_register(HCCPARAMS1),
21 dump_register(DOORBELLOFF),
22 dump_register(RUNTIMEOFF),
23 dump_register(HCCPARAMS2),
24};
25
26static const struct debugfs_reg32 xhci_op_regs[] = {
27 dump_register(USBCMD),
28 dump_register(USBSTS),
29 dump_register(PAGESIZE),
30 dump_register(DNCTRL),
31 dump_register(CRCR),
32 dump_register(DCBAAP_LOW),
33 dump_register(DCBAAP_HIGH),
34 dump_register(CONFIG),
35};
36
37static const struct debugfs_reg32 xhci_runtime_regs[] = {
38 dump_register(MFINDEX),
39 dump_register(IR0_IMAN),
40 dump_register(IR0_IMOD),
41 dump_register(IR0_ERSTSZ),
42 dump_register(IR0_ERSTBA_LOW),
43 dump_register(IR0_ERSTBA_HIGH),
44 dump_register(IR0_ERDP_LOW),
45 dump_register(IR0_ERDP_HIGH),
46};
47
48static const struct debugfs_reg32 xhci_extcap_legsup[] = {
49 dump_register(EXTCAP_USBLEGSUP),
50 dump_register(EXTCAP_USBLEGCTLSTS),
51};
52
53static const struct debugfs_reg32 xhci_extcap_protocol[] = {
54 dump_register(EXTCAP_REVISION),
55 dump_register(EXTCAP_NAME),
56 dump_register(EXTCAP_PORTINFO),
57 dump_register(EXTCAP_PORTTYPE),
58 dump_register(EXTCAP_MANTISSA1),
59 dump_register(EXTCAP_MANTISSA2),
60 dump_register(EXTCAP_MANTISSA3),
61 dump_register(EXTCAP_MANTISSA4),
62 dump_register(EXTCAP_MANTISSA5),
63 dump_register(EXTCAP_MANTISSA6),
64};
65
66static const struct debugfs_reg32 xhci_extcap_dbc[] = {
67 dump_register(EXTCAP_DBC_CAPABILITY),
68 dump_register(EXTCAP_DBC_DOORBELL),
69 dump_register(EXTCAP_DBC_ERSTSIZE),
70 dump_register(EXTCAP_DBC_ERST_LOW),
71 dump_register(EXTCAP_DBC_ERST_HIGH),
72 dump_register(EXTCAP_DBC_ERDP_LOW),
73 dump_register(EXTCAP_DBC_ERDP_HIGH),
74 dump_register(EXTCAP_DBC_CONTROL),
75 dump_register(EXTCAP_DBC_STATUS),
76 dump_register(EXTCAP_DBC_PORTSC),
77 dump_register(EXTCAP_DBC_CONT_LOW),
78 dump_register(EXTCAP_DBC_CONT_HIGH),
79 dump_register(EXTCAP_DBC_DEVINFO1),
80 dump_register(EXTCAP_DBC_DEVINFO2),
81};
82
83static struct dentry *xhci_debugfs_root;
84
85static struct xhci_regset *xhci_debugfs_alloc_regset(struct xhci_hcd *xhci)
86{
87 struct xhci_regset *regset;
88
89 regset = kzalloc(sizeof(*regset), GFP_KERNEL);
90 if (!regset)
91 return NULL;
92
93 /*
94 * The allocation and free of regset are executed in order.
95 * We needn't a lock here.
96 */
97 INIT_LIST_HEAD(®set->list);
98 list_add_tail(®set->list, &xhci->regset_list);
99
100 return regset;
101}
102
103static void xhci_debugfs_free_regset(struct xhci_regset *regset)
104{
105 if (!regset)
106 return;
107
108 list_del(®set->list);
109 kfree(regset);
110}
111
112static void xhci_debugfs_regset(struct xhci_hcd *xhci, u32 base,
113 const struct debugfs_reg32 *regs,
114 size_t nregs, struct dentry *parent,
115 const char *fmt, ...)
116{
117 struct xhci_regset *rgs;
118 va_list args;
119 struct debugfs_regset32 *regset;
120 struct usb_hcd *hcd = xhci_to_hcd(xhci);
121
122 rgs = xhci_debugfs_alloc_regset(xhci);
123 if (!rgs)
124 return;
125
126 va_start(args, fmt);
127 vsnprintf(rgs->name, sizeof(rgs->name), fmt, args);
128 va_end(args);
129
130 regset = &rgs->regset;
131 regset->regs = regs;
132 regset->nregs = nregs;
133 regset->base = hcd->regs + base;
134
135 debugfs_create_regset32((const char *)rgs->name, 0444, parent, regset);
136}
137
138static void xhci_debugfs_extcap_regset(struct xhci_hcd *xhci, int cap_id,
139 const struct debugfs_reg32 *regs,
140 size_t n, const char *cap_name)
141{
142 u32 offset;
143 int index = 0;
144 size_t psic, nregs = n;
145 void __iomem *base = &xhci->cap_regs->hc_capbase;
146
147 offset = xhci_find_next_ext_cap(base, 0, cap_id);
148 while (offset) {
149 if (cap_id == XHCI_EXT_CAPS_PROTOCOL) {
150 psic = XHCI_EXT_PORT_PSIC(readl(base + offset + 8));
151 nregs = min(4 + psic, n);
152 }
153
154 xhci_debugfs_regset(xhci, offset, regs, nregs,
155 xhci->debugfs_root, "%s:%02d",
156 cap_name, index);
157 offset = xhci_find_next_ext_cap(base, offset, cap_id);
158 index++;
159 }
160}
161
162static int xhci_ring_enqueue_show(struct seq_file *s, void *unused)
163{
164 dma_addr_t dma;
165 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
166
167 dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
168 seq_printf(s, "%pad\n", &dma);
169
170 return 0;
171}
172
173static int xhci_ring_dequeue_show(struct seq_file *s, void *unused)
174{
175 dma_addr_t dma;
176 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
177
178 dma = xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
179 seq_printf(s, "%pad\n", &dma);
180
181 return 0;
182}
183
184static int xhci_ring_cycle_show(struct seq_file *s, void *unused)
185{
186 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
187
188 seq_printf(s, "%d\n", ring->cycle_state);
189
190 return 0;
191}
192
193static void xhci_ring_dump_segment(struct seq_file *s,
194 struct xhci_segment *seg)
195{
196 int i;
197 dma_addr_t dma;
198 union xhci_trb *trb;
199
200 for (i = 0; i < TRBS_PER_SEGMENT; i++) {
201 trb = &seg->trbs[i];
202 dma = seg->dma + i * sizeof(*trb);
203 seq_printf(s, "%pad: %s\n", &dma,
204 xhci_decode_trb(trb->generic.field[0],
205 trb->generic.field[1],
206 trb->generic.field[2],
207 trb->generic.field[3]));
208 }
209}
210
211static int xhci_ring_trb_show(struct seq_file *s, void *unused)
212{
213 int i;
214 struct xhci_ring *ring = *(struct xhci_ring **)s->private;
215 struct xhci_segment *seg = ring->first_seg;
216
217 for (i = 0; i < ring->num_segs; i++) {
218 xhci_ring_dump_segment(s, seg);
219 seg = seg->next;
220 }
221
222 return 0;
223}
224
225static struct xhci_file_map ring_files[] = {
226 {"enqueue", xhci_ring_enqueue_show, },
227 {"dequeue", xhci_ring_dequeue_show, },
228 {"cycle", xhci_ring_cycle_show, },
229 {"trbs", xhci_ring_trb_show, },
230};
231
232static int xhci_ring_open(struct inode *inode, struct file *file)
233{
234 int i;
235 struct xhci_file_map *f_map;
236 const char *file_name = file_dentry(file)->d_iname;
237
238 for (i = 0; i < ARRAY_SIZE(ring_files); i++) {
239 f_map = &ring_files[i];
240
241 if (strcmp(f_map->name, file_name) == 0)
242 break;
243 }
244
245 return single_open(file, f_map->show, inode->i_private);
246}
247
248static const struct file_operations xhci_ring_fops = {
249 .open = xhci_ring_open,
250 .read = seq_read,
251 .llseek = seq_lseek,
252 .release = single_release,
253};
254
255static int xhci_slot_context_show(struct seq_file *s, void *unused)
256{
257 struct xhci_hcd *xhci;
258 struct xhci_slot_ctx *slot_ctx;
259 struct xhci_slot_priv *priv = s->private;
260 struct xhci_virt_device *dev = priv->dev;
261
262 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus));
263 slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
264 seq_printf(s, "%pad: %s\n", &dev->out_ctx->dma,
265 xhci_decode_slot_context(slot_ctx->dev_info,
266 slot_ctx->dev_info2,
267 slot_ctx->tt_info,
268 slot_ctx->dev_state));
269
270 return 0;
271}
272
273static int xhci_endpoint_context_show(struct seq_file *s, void *unused)
274{
275 int dci;
276 dma_addr_t dma;
277 struct xhci_hcd *xhci;
278 struct xhci_ep_ctx *ep_ctx;
279 struct xhci_slot_priv *priv = s->private;
280 struct xhci_virt_device *dev = priv->dev;
281
282 xhci = hcd_to_xhci(bus_to_hcd(dev->udev->bus));
283
284 for (dci = 1; dci < 32; dci++) {
285 ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, dci);
286 dma = dev->out_ctx->dma + dci * CTX_SIZE(xhci->hcc_params);
287 seq_printf(s, "%pad: %s\n", &dma,
288 xhci_decode_ep_context(ep_ctx->ep_info,
289 ep_ctx->ep_info2,
290 ep_ctx->deq,
291 ep_ctx->tx_info));
292 }
293
294 return 0;
295}
296
297static int xhci_device_name_show(struct seq_file *s, void *unused)
298{
299 struct xhci_slot_priv *priv = s->private;
300 struct xhci_virt_device *dev = priv->dev;
301
302 seq_printf(s, "%s\n", dev_name(&dev->udev->dev));
303
304 return 0;
305}
306
307static struct xhci_file_map context_files[] = {
308 {"name", xhci_device_name_show, },
309 {"slot-context", xhci_slot_context_show, },
310 {"ep-context", xhci_endpoint_context_show, },
311};
312
313static int xhci_context_open(struct inode *inode, struct file *file)
314{
315 int i;
316 struct xhci_file_map *f_map;
317 const char *file_name = file_dentry(file)->d_iname;
318
319 for (i = 0; i < ARRAY_SIZE(context_files); i++) {
320 f_map = &context_files[i];
321
322 if (strcmp(f_map->name, file_name) == 0)
323 break;
324 }
325
326 return single_open(file, f_map->show, inode->i_private);
327}
328
329static const struct file_operations xhci_context_fops = {
330 .open = xhci_context_open,
331 .read = seq_read,
332 .llseek = seq_lseek,
333 .release = single_release,
334};
335
336static void xhci_debugfs_create_files(struct xhci_hcd *xhci,
337 struct xhci_file_map *files,
338 size_t nentries, void *data,
339 struct dentry *parent,
340 const struct file_operations *fops)
341{
342 int i;
343
344 for (i = 0; i < nentries; i++)
345 debugfs_create_file(files[i].name, 0444, parent, data, fops);
346}
347
348static struct dentry *xhci_debugfs_create_ring_dir(struct xhci_hcd *xhci,
349 struct xhci_ring **ring,
350 const char *name,
351 struct dentry *parent)
352{
353 struct dentry *dir;
354
355 dir = debugfs_create_dir(name, parent);
356 xhci_debugfs_create_files(xhci, ring_files, ARRAY_SIZE(ring_files),
357 ring, dir, &xhci_ring_fops);
358
359 return dir;
360}
361
362static void xhci_debugfs_create_context_files(struct xhci_hcd *xhci,
363 struct dentry *parent,
364 int slot_id)
365{
366 struct xhci_virt_device *dev = xhci->devs[slot_id];
367
368 xhci_debugfs_create_files(xhci, context_files,
369 ARRAY_SIZE(context_files),
370 dev->debugfs_private,
371 parent, &xhci_context_fops);
372}
373
374void xhci_debugfs_create_endpoint(struct xhci_hcd *xhci,
375 struct xhci_virt_device *dev,
376 int ep_index)
377{
378 struct xhci_ep_priv *epriv;
379 struct xhci_slot_priv *spriv = dev->debugfs_private;
380
381 if (spriv->eps[ep_index])
382 return;
383
384 epriv = kzalloc(sizeof(*epriv), GFP_KERNEL);
385 if (!epriv)
386 return;
387
388 snprintf(epriv->name, sizeof(epriv->name), "ep%02d", ep_index);
389 epriv->root = xhci_debugfs_create_ring_dir(xhci,
390 &dev->eps[ep_index].ring,
391 epriv->name,
392 spriv->root);
393 spriv->eps[ep_index] = epriv;
394}
395
396void xhci_debugfs_remove_endpoint(struct xhci_hcd *xhci,
397 struct xhci_virt_device *dev,
398 int ep_index)
399{
400 struct xhci_ep_priv *epriv;
401 struct xhci_slot_priv *spriv = dev->debugfs_private;
402
403 if (!spriv || !spriv->eps[ep_index])
404 return;
405
406 epriv = spriv->eps[ep_index];
407 debugfs_remove_recursive(epriv->root);
408 spriv->eps[ep_index] = NULL;
409 kfree(epriv);
410}
411
412void xhci_debugfs_create_slot(struct xhci_hcd *xhci, int slot_id)
413{
414 struct xhci_slot_priv *priv;
415 struct xhci_virt_device *dev = xhci->devs[slot_id];
416
417 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
418 if (!priv)
419 return;
420
421 snprintf(priv->name, sizeof(priv->name), "%02d", slot_id);
422 priv->root = debugfs_create_dir(priv->name, xhci->debugfs_slots);
423 priv->dev = dev;
424 dev->debugfs_private = priv;
425
426 xhci_debugfs_create_ring_dir(xhci, &dev->eps[0].ring,
427 "ep00", priv->root);
428
429 xhci_debugfs_create_context_files(xhci, priv->root, slot_id);
430}
431
432void xhci_debugfs_remove_slot(struct xhci_hcd *xhci, int slot_id)
433{
434 int i;
435 struct xhci_slot_priv *priv;
436 struct xhci_virt_device *dev = xhci->devs[slot_id];
437
438 if (!dev || !dev->debugfs_private)
439 return;
440
441 priv = dev->debugfs_private;
442
443 debugfs_remove_recursive(priv->root);
444
445 for (i = 0; i < 31; i++)
446 kfree(priv->eps[i]);
447
448 kfree(priv);
449 dev->debugfs_private = NULL;
450}
451
452void xhci_debugfs_init(struct xhci_hcd *xhci)
453{
454 struct device *dev = xhci_to_hcd(xhci)->self.controller;
455
456 xhci->debugfs_root = debugfs_create_dir(dev_name(dev),
457 xhci_debugfs_root);
458
459 INIT_LIST_HEAD(&xhci->regset_list);
460
461 xhci_debugfs_regset(xhci,
462 0,
463 xhci_cap_regs, ARRAY_SIZE(xhci_cap_regs),
464 xhci->debugfs_root, "reg-cap");
465
466 xhci_debugfs_regset(xhci,
467 HC_LENGTH(readl(&xhci->cap_regs->hc_capbase)),
468 xhci_op_regs, ARRAY_SIZE(xhci_op_regs),
469 xhci->debugfs_root, "reg-op");
470
471 xhci_debugfs_regset(xhci,
472 readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK,
473 xhci_runtime_regs, ARRAY_SIZE(xhci_runtime_regs),
474 xhci->debugfs_root, "reg-runtime");
475
476 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_LEGACY,
477 xhci_extcap_legsup,
478 ARRAY_SIZE(xhci_extcap_legsup),
479 "reg-ext-legsup");
480
481 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_PROTOCOL,
482 xhci_extcap_protocol,
483 ARRAY_SIZE(xhci_extcap_protocol),
484 "reg-ext-protocol");
485
486 xhci_debugfs_extcap_regset(xhci, XHCI_EXT_CAPS_DEBUG,
487 xhci_extcap_dbc,
488 ARRAY_SIZE(xhci_extcap_dbc),
489 "reg-ext-dbc");
490
491 xhci_debugfs_create_ring_dir(xhci, &xhci->cmd_ring,
492 "command-ring",
493 xhci->debugfs_root);
494
495 xhci_debugfs_create_ring_dir(xhci, &xhci->event_ring,
496 "event-ring",
497 xhci->debugfs_root);
498
499 xhci->debugfs_slots = debugfs_create_dir("devices", xhci->debugfs_root);
500}
501
502void xhci_debugfs_exit(struct xhci_hcd *xhci)
503{
504 struct xhci_regset *rgs, *tmp;
505
506 debugfs_remove_recursive(xhci->debugfs_root);
507 xhci->debugfs_root = NULL;
508 xhci->debugfs_slots = NULL;
509
510 list_for_each_entry_safe(rgs, tmp, &xhci->regset_list, list)
511 xhci_debugfs_free_regset(rgs);
512}
513
514void __init xhci_debugfs_create_root(void)
515{
516 xhci_debugfs_root = debugfs_create_dir("xhci", usb_debug_root);
517}
518
519void __exit xhci_debugfs_remove_root(void)
520{
521 debugfs_remove_recursive(xhci_debugfs_root);
522 xhci_debugfs_root = NULL;
523}