2 * debugfs.c - DesignWare USB3 DRD Controller DebugFS file
4 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
6 * Authors: Felipe Balbi <balbi@ti.com>,
7 * Sebastian Andrzej Siewior <bigeasy@linutronix.de>
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 of
11 * the License as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/slab.h>
22 #include <linux/ptrace.h>
23 #include <linux/types.h>
24 #include <linux/spinlock.h>
25 #include <linux/debugfs.h>
26 #include <linux/seq_file.h>
27 #include <linux/delay.h>
28 #include <linux/uaccess.h>
30 #include <linux/usb/ch9.h>
37 #define dump_register(nm) \
39 .name = __stringify(nm), \
40 .offset = DWC3_ ##nm - DWC3_GLOBALS_REGS_START, \
43 #define ep_event_rate(ev, c, p, dt) \
44 ((dt) ? ((c.ev - p.ev) * (MSEC_PER_SEC)) / (dt) : 0)
46 static const struct debugfs_reg32 dwc3_regs[] = {
47 dump_register(GSBUSCFG0),
48 dump_register(GSBUSCFG1),
49 dump_register(GTXTHRCFG),
50 dump_register(GRXTHRCFG),
52 dump_register(GEVTEN),
54 dump_register(GSNPSID),
58 dump_register(GBUSERRADDR0),
59 dump_register(GBUSERRADDR1),
60 dump_register(GPRTBIMAP0),
61 dump_register(GPRTBIMAP1),
62 dump_register(GHWPARAMS0),
63 dump_register(GHWPARAMS1),
64 dump_register(GHWPARAMS2),
65 dump_register(GHWPARAMS3),
66 dump_register(GHWPARAMS4),
67 dump_register(GHWPARAMS5),
68 dump_register(GHWPARAMS6),
69 dump_register(GHWPARAMS7),
70 dump_register(GDBGFIFOSPACE),
71 dump_register(GDBGLTSSM),
72 dump_register(GPRTBIMAP_HS0),
73 dump_register(GPRTBIMAP_HS1),
74 dump_register(GPRTBIMAP_FS0),
75 dump_register(GPRTBIMAP_FS1),
77 dump_register(GUSB2PHYCFG(0)),
78 dump_register(GUSB2PHYCFG(1)),
79 dump_register(GUSB2PHYCFG(2)),
80 dump_register(GUSB2PHYCFG(3)),
81 dump_register(GUSB2PHYCFG(4)),
82 dump_register(GUSB2PHYCFG(5)),
83 dump_register(GUSB2PHYCFG(6)),
84 dump_register(GUSB2PHYCFG(7)),
85 dump_register(GUSB2PHYCFG(8)),
86 dump_register(GUSB2PHYCFG(9)),
87 dump_register(GUSB2PHYCFG(10)),
88 dump_register(GUSB2PHYCFG(11)),
89 dump_register(GUSB2PHYCFG(12)),
90 dump_register(GUSB2PHYCFG(13)),
91 dump_register(GUSB2PHYCFG(14)),
92 dump_register(GUSB2PHYCFG(15)),
94 dump_register(GUSB2I2CCTL(0)),
95 dump_register(GUSB2I2CCTL(1)),
96 dump_register(GUSB2I2CCTL(2)),
97 dump_register(GUSB2I2CCTL(3)),
98 dump_register(GUSB2I2CCTL(4)),
99 dump_register(GUSB2I2CCTL(5)),
100 dump_register(GUSB2I2CCTL(6)),
101 dump_register(GUSB2I2CCTL(7)),
102 dump_register(GUSB2I2CCTL(8)),
103 dump_register(GUSB2I2CCTL(9)),
104 dump_register(GUSB2I2CCTL(10)),
105 dump_register(GUSB2I2CCTL(11)),
106 dump_register(GUSB2I2CCTL(12)),
107 dump_register(GUSB2I2CCTL(13)),
108 dump_register(GUSB2I2CCTL(14)),
109 dump_register(GUSB2I2CCTL(15)),
111 dump_register(GUSB2PHYACC(0)),
112 dump_register(GUSB2PHYACC(1)),
113 dump_register(GUSB2PHYACC(2)),
114 dump_register(GUSB2PHYACC(3)),
115 dump_register(GUSB2PHYACC(4)),
116 dump_register(GUSB2PHYACC(5)),
117 dump_register(GUSB2PHYACC(6)),
118 dump_register(GUSB2PHYACC(7)),
119 dump_register(GUSB2PHYACC(8)),
120 dump_register(GUSB2PHYACC(9)),
121 dump_register(GUSB2PHYACC(10)),
122 dump_register(GUSB2PHYACC(11)),
123 dump_register(GUSB2PHYACC(12)),
124 dump_register(GUSB2PHYACC(13)),
125 dump_register(GUSB2PHYACC(14)),
126 dump_register(GUSB2PHYACC(15)),
128 dump_register(GUSB3PIPECTL(0)),
129 dump_register(GUSB3PIPECTL(1)),
130 dump_register(GUSB3PIPECTL(2)),
131 dump_register(GUSB3PIPECTL(3)),
132 dump_register(GUSB3PIPECTL(4)),
133 dump_register(GUSB3PIPECTL(5)),
134 dump_register(GUSB3PIPECTL(6)),
135 dump_register(GUSB3PIPECTL(7)),
136 dump_register(GUSB3PIPECTL(8)),
137 dump_register(GUSB3PIPECTL(9)),
138 dump_register(GUSB3PIPECTL(10)),
139 dump_register(GUSB3PIPECTL(11)),
140 dump_register(GUSB3PIPECTL(12)),
141 dump_register(GUSB3PIPECTL(13)),
142 dump_register(GUSB3PIPECTL(14)),
143 dump_register(GUSB3PIPECTL(15)),
145 dump_register(GTXFIFOSIZ(0)),
146 dump_register(GTXFIFOSIZ(1)),
147 dump_register(GTXFIFOSIZ(2)),
148 dump_register(GTXFIFOSIZ(3)),
149 dump_register(GTXFIFOSIZ(4)),
150 dump_register(GTXFIFOSIZ(5)),
151 dump_register(GTXFIFOSIZ(6)),
152 dump_register(GTXFIFOSIZ(7)),
153 dump_register(GTXFIFOSIZ(8)),
154 dump_register(GTXFIFOSIZ(9)),
155 dump_register(GTXFIFOSIZ(10)),
156 dump_register(GTXFIFOSIZ(11)),
157 dump_register(GTXFIFOSIZ(12)),
158 dump_register(GTXFIFOSIZ(13)),
159 dump_register(GTXFIFOSIZ(14)),
160 dump_register(GTXFIFOSIZ(15)),
161 dump_register(GTXFIFOSIZ(16)),
162 dump_register(GTXFIFOSIZ(17)),
163 dump_register(GTXFIFOSIZ(18)),
164 dump_register(GTXFIFOSIZ(19)),
165 dump_register(GTXFIFOSIZ(20)),
166 dump_register(GTXFIFOSIZ(21)),
167 dump_register(GTXFIFOSIZ(22)),
168 dump_register(GTXFIFOSIZ(23)),
169 dump_register(GTXFIFOSIZ(24)),
170 dump_register(GTXFIFOSIZ(25)),
171 dump_register(GTXFIFOSIZ(26)),
172 dump_register(GTXFIFOSIZ(27)),
173 dump_register(GTXFIFOSIZ(28)),
174 dump_register(GTXFIFOSIZ(29)),
175 dump_register(GTXFIFOSIZ(30)),
176 dump_register(GTXFIFOSIZ(31)),
178 dump_register(GRXFIFOSIZ(0)),
179 dump_register(GRXFIFOSIZ(1)),
180 dump_register(GRXFIFOSIZ(2)),
181 dump_register(GRXFIFOSIZ(3)),
182 dump_register(GRXFIFOSIZ(4)),
183 dump_register(GRXFIFOSIZ(5)),
184 dump_register(GRXFIFOSIZ(6)),
185 dump_register(GRXFIFOSIZ(7)),
186 dump_register(GRXFIFOSIZ(8)),
187 dump_register(GRXFIFOSIZ(9)),
188 dump_register(GRXFIFOSIZ(10)),
189 dump_register(GRXFIFOSIZ(11)),
190 dump_register(GRXFIFOSIZ(12)),
191 dump_register(GRXFIFOSIZ(13)),
192 dump_register(GRXFIFOSIZ(14)),
193 dump_register(GRXFIFOSIZ(15)),
194 dump_register(GRXFIFOSIZ(16)),
195 dump_register(GRXFIFOSIZ(17)),
196 dump_register(GRXFIFOSIZ(18)),
197 dump_register(GRXFIFOSIZ(19)),
198 dump_register(GRXFIFOSIZ(20)),
199 dump_register(GRXFIFOSIZ(21)),
200 dump_register(GRXFIFOSIZ(22)),
201 dump_register(GRXFIFOSIZ(23)),
202 dump_register(GRXFIFOSIZ(24)),
203 dump_register(GRXFIFOSIZ(25)),
204 dump_register(GRXFIFOSIZ(26)),
205 dump_register(GRXFIFOSIZ(27)),
206 dump_register(GRXFIFOSIZ(28)),
207 dump_register(GRXFIFOSIZ(29)),
208 dump_register(GRXFIFOSIZ(30)),
209 dump_register(GRXFIFOSIZ(31)),
211 dump_register(GEVNTADRLO(0)),
212 dump_register(GEVNTADRHI(0)),
213 dump_register(GEVNTSIZ(0)),
214 dump_register(GEVNTCOUNT(0)),
216 dump_register(GHWPARAMS8),
217 dump_register(GFLADJ),
220 dump_register(DEVTEN),
222 dump_register(DGCMDPAR),
223 dump_register(DGCMD),
224 dump_register(DALEPENA),
226 dump_register(DEPCMDPAR2(0)),
227 dump_register(DEPCMDPAR2(1)),
228 dump_register(DEPCMDPAR2(2)),
229 dump_register(DEPCMDPAR2(3)),
230 dump_register(DEPCMDPAR2(4)),
231 dump_register(DEPCMDPAR2(5)),
232 dump_register(DEPCMDPAR2(6)),
233 dump_register(DEPCMDPAR2(7)),
234 dump_register(DEPCMDPAR2(8)),
235 dump_register(DEPCMDPAR2(9)),
236 dump_register(DEPCMDPAR2(10)),
237 dump_register(DEPCMDPAR2(11)),
238 dump_register(DEPCMDPAR2(12)),
239 dump_register(DEPCMDPAR2(13)),
240 dump_register(DEPCMDPAR2(14)),
241 dump_register(DEPCMDPAR2(15)),
242 dump_register(DEPCMDPAR2(16)),
243 dump_register(DEPCMDPAR2(17)),
244 dump_register(DEPCMDPAR2(18)),
245 dump_register(DEPCMDPAR2(19)),
246 dump_register(DEPCMDPAR2(20)),
247 dump_register(DEPCMDPAR2(21)),
248 dump_register(DEPCMDPAR2(22)),
249 dump_register(DEPCMDPAR2(23)),
250 dump_register(DEPCMDPAR2(24)),
251 dump_register(DEPCMDPAR2(25)),
252 dump_register(DEPCMDPAR2(26)),
253 dump_register(DEPCMDPAR2(27)),
254 dump_register(DEPCMDPAR2(28)),
255 dump_register(DEPCMDPAR2(29)),
256 dump_register(DEPCMDPAR2(30)),
257 dump_register(DEPCMDPAR2(31)),
259 dump_register(DEPCMDPAR1(0)),
260 dump_register(DEPCMDPAR1(1)),
261 dump_register(DEPCMDPAR1(2)),
262 dump_register(DEPCMDPAR1(3)),
263 dump_register(DEPCMDPAR1(4)),
264 dump_register(DEPCMDPAR1(5)),
265 dump_register(DEPCMDPAR1(6)),
266 dump_register(DEPCMDPAR1(7)),
267 dump_register(DEPCMDPAR1(8)),
268 dump_register(DEPCMDPAR1(9)),
269 dump_register(DEPCMDPAR1(10)),
270 dump_register(DEPCMDPAR1(11)),
271 dump_register(DEPCMDPAR1(12)),
272 dump_register(DEPCMDPAR1(13)),
273 dump_register(DEPCMDPAR1(14)),
274 dump_register(DEPCMDPAR1(15)),
275 dump_register(DEPCMDPAR1(16)),
276 dump_register(DEPCMDPAR1(17)),
277 dump_register(DEPCMDPAR1(18)),
278 dump_register(DEPCMDPAR1(19)),
279 dump_register(DEPCMDPAR1(20)),
280 dump_register(DEPCMDPAR1(21)),
281 dump_register(DEPCMDPAR1(22)),
282 dump_register(DEPCMDPAR1(23)),
283 dump_register(DEPCMDPAR1(24)),
284 dump_register(DEPCMDPAR1(25)),
285 dump_register(DEPCMDPAR1(26)),
286 dump_register(DEPCMDPAR1(27)),
287 dump_register(DEPCMDPAR1(28)),
288 dump_register(DEPCMDPAR1(29)),
289 dump_register(DEPCMDPAR1(30)),
290 dump_register(DEPCMDPAR1(31)),
292 dump_register(DEPCMDPAR0(0)),
293 dump_register(DEPCMDPAR0(1)),
294 dump_register(DEPCMDPAR0(2)),
295 dump_register(DEPCMDPAR0(3)),
296 dump_register(DEPCMDPAR0(4)),
297 dump_register(DEPCMDPAR0(5)),
298 dump_register(DEPCMDPAR0(6)),
299 dump_register(DEPCMDPAR0(7)),
300 dump_register(DEPCMDPAR0(8)),
301 dump_register(DEPCMDPAR0(9)),
302 dump_register(DEPCMDPAR0(10)),
303 dump_register(DEPCMDPAR0(11)),
304 dump_register(DEPCMDPAR0(12)),
305 dump_register(DEPCMDPAR0(13)),
306 dump_register(DEPCMDPAR0(14)),
307 dump_register(DEPCMDPAR0(15)),
308 dump_register(DEPCMDPAR0(16)),
309 dump_register(DEPCMDPAR0(17)),
310 dump_register(DEPCMDPAR0(18)),
311 dump_register(DEPCMDPAR0(19)),
312 dump_register(DEPCMDPAR0(20)),
313 dump_register(DEPCMDPAR0(21)),
314 dump_register(DEPCMDPAR0(22)),
315 dump_register(DEPCMDPAR0(23)),
316 dump_register(DEPCMDPAR0(24)),
317 dump_register(DEPCMDPAR0(25)),
318 dump_register(DEPCMDPAR0(26)),
319 dump_register(DEPCMDPAR0(27)),
320 dump_register(DEPCMDPAR0(28)),
321 dump_register(DEPCMDPAR0(29)),
322 dump_register(DEPCMDPAR0(30)),
323 dump_register(DEPCMDPAR0(31)),
325 dump_register(DEPCMD(0)),
326 dump_register(DEPCMD(1)),
327 dump_register(DEPCMD(2)),
328 dump_register(DEPCMD(3)),
329 dump_register(DEPCMD(4)),
330 dump_register(DEPCMD(5)),
331 dump_register(DEPCMD(6)),
332 dump_register(DEPCMD(7)),
333 dump_register(DEPCMD(8)),
334 dump_register(DEPCMD(9)),
335 dump_register(DEPCMD(10)),
336 dump_register(DEPCMD(11)),
337 dump_register(DEPCMD(12)),
338 dump_register(DEPCMD(13)),
339 dump_register(DEPCMD(14)),
340 dump_register(DEPCMD(15)),
341 dump_register(DEPCMD(16)),
342 dump_register(DEPCMD(17)),
343 dump_register(DEPCMD(18)),
344 dump_register(DEPCMD(19)),
345 dump_register(DEPCMD(20)),
346 dump_register(DEPCMD(21)),
347 dump_register(DEPCMD(22)),
348 dump_register(DEPCMD(23)),
349 dump_register(DEPCMD(24)),
350 dump_register(DEPCMD(25)),
351 dump_register(DEPCMD(26)),
352 dump_register(DEPCMD(27)),
353 dump_register(DEPCMD(28)),
354 dump_register(DEPCMD(29)),
355 dump_register(DEPCMD(30)),
356 dump_register(DEPCMD(31)),
361 dump_register(OEVTEN),
365 static int dwc3_mode_show(struct seq_file *s, void *unused)
367 struct dwc3 *dwc = s->private;
371 if (atomic_read(&dwc->in_lpm)) {
372 seq_puts(s, "USB device is powered off\n");
376 spin_lock_irqsave(&dwc->lock, flags);
377 reg = dwc3_readl(dwc->regs, DWC3_GCTL);
378 spin_unlock_irqrestore(&dwc->lock, flags);
380 switch (DWC3_GCTL_PRTCAP(reg)) {
381 case DWC3_GCTL_PRTCAP_HOST:
382 seq_printf(s, "host\n");
384 case DWC3_GCTL_PRTCAP_DEVICE:
385 seq_printf(s, "device\n");
387 case DWC3_GCTL_PRTCAP_OTG:
388 seq_printf(s, "OTG\n");
391 seq_printf(s, "UNKNOWN %08x\n", DWC3_GCTL_PRTCAP(reg));
397 static int dwc3_mode_open(struct inode *inode, struct file *file)
399 return single_open(file, dwc3_mode_show, inode->i_private);
402 static ssize_t dwc3_mode_write(struct file *file,
403 const char __user *ubuf, size_t count, loff_t *ppos)
405 struct seq_file *s = file->private_data;
406 struct dwc3 *dwc = s->private;
411 if (atomic_read(&dwc->in_lpm)) {
412 dev_err(dwc->dev, "USB device is powered off\n");
416 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
419 if (!strncmp(buf, "host", 4))
420 mode |= DWC3_GCTL_PRTCAP_HOST;
422 if (!strncmp(buf, "device", 6))
423 mode |= DWC3_GCTL_PRTCAP_DEVICE;
425 if (!strncmp(buf, "otg", 3))
426 mode |= DWC3_GCTL_PRTCAP_OTG;
429 spin_lock_irqsave(&dwc->lock, flags);
430 dwc3_set_mode(dwc, mode);
431 spin_unlock_irqrestore(&dwc->lock, flags);
436 static const struct file_operations dwc3_mode_fops = {
437 .open = dwc3_mode_open,
438 .write = dwc3_mode_write,
441 .release = single_release,
444 static int dwc3_testmode_show(struct seq_file *s, void *unused)
446 struct dwc3 *dwc = s->private;
451 if (atomic_read(&dwc->in_lpm)) {
452 seq_puts(s, "USB device is powered off\n");
456 spin_lock_irqsave(&dwc->lock, flags);
457 reg = dwc3_readl(dwc->regs, DWC3_DCTL);
458 reg &= DWC3_DCTL_TSTCTRL_MASK;
460 spin_unlock_irqrestore(&dwc->lock, flags);
464 seq_printf(s, "no test\n");
467 seq_printf(s, "test_j\n");
470 seq_printf(s, "test_k\n");
473 seq_printf(s, "test_se0_nak\n");
476 seq_printf(s, "test_packet\n");
479 seq_printf(s, "test_force_enable\n");
482 seq_printf(s, "UNKNOWN %d\n", reg);
488 static int dwc3_testmode_open(struct inode *inode, struct file *file)
490 return single_open(file, dwc3_testmode_show, inode->i_private);
493 static ssize_t dwc3_testmode_write(struct file *file,
494 const char __user *ubuf, size_t count, loff_t *ppos)
496 struct seq_file *s = file->private_data;
497 struct dwc3 *dwc = s->private;
502 if (atomic_read(&dwc->in_lpm)) {
503 seq_puts(s, "USB device is powered off\n");
507 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
510 if (!strncmp(buf, "test_j", 6))
512 else if (!strncmp(buf, "test_k", 6))
514 else if (!strncmp(buf, "test_se0_nak", 12))
515 testmode = TEST_SE0_NAK;
516 else if (!strncmp(buf, "test_packet", 11))
517 testmode = TEST_PACKET;
518 else if (!strncmp(buf, "test_force_enable", 17))
519 testmode = TEST_FORCE_EN;
523 spin_lock_irqsave(&dwc->lock, flags);
524 dwc3_gadget_set_test_mode(dwc, testmode);
525 spin_unlock_irqrestore(&dwc->lock, flags);
530 static const struct file_operations dwc3_testmode_fops = {
531 .open = dwc3_testmode_open,
532 .write = dwc3_testmode_write,
535 .release = single_release,
538 static int dwc3_link_state_show(struct seq_file *s, void *unused)
540 struct dwc3 *dwc = s->private;
542 enum dwc3_link_state state;
545 if (atomic_read(&dwc->in_lpm)) {
546 seq_puts(s, "USB device is powered off\n");
550 spin_lock_irqsave(&dwc->lock, flags);
551 reg = dwc3_readl(dwc->regs, DWC3_DSTS);
552 state = DWC3_DSTS_USBLNKST(reg);
553 spin_unlock_irqrestore(&dwc->lock, flags);
556 case DWC3_LINK_STATE_U0:
557 seq_printf(s, "U0\n");
559 case DWC3_LINK_STATE_U1:
560 seq_printf(s, "U1\n");
562 case DWC3_LINK_STATE_U2:
563 seq_printf(s, "U2\n");
565 case DWC3_LINK_STATE_U3:
566 seq_printf(s, "U3\n");
568 case DWC3_LINK_STATE_SS_DIS:
569 seq_printf(s, "SS.Disabled\n");
571 case DWC3_LINK_STATE_RX_DET:
572 seq_printf(s, "Rx.Detect\n");
574 case DWC3_LINK_STATE_SS_INACT:
575 seq_printf(s, "SS.Inactive\n");
577 case DWC3_LINK_STATE_POLL:
578 seq_printf(s, "Poll\n");
580 case DWC3_LINK_STATE_RECOV:
581 seq_printf(s, "Recovery\n");
583 case DWC3_LINK_STATE_HRESET:
584 seq_printf(s, "HRESET\n");
586 case DWC3_LINK_STATE_CMPLY:
587 seq_printf(s, "Compliance\n");
589 case DWC3_LINK_STATE_LPBK:
590 seq_printf(s, "Loopback\n");
592 case DWC3_LINK_STATE_RESET:
593 seq_printf(s, "Reset\n");
595 case DWC3_LINK_STATE_RESUME:
596 seq_printf(s, "Resume\n");
599 seq_printf(s, "UNKNOWN %d\n", state);
605 static int dwc3_link_state_open(struct inode *inode, struct file *file)
607 return single_open(file, dwc3_link_state_show, inode->i_private);
610 static ssize_t dwc3_link_state_write(struct file *file,
611 const char __user *ubuf, size_t count, loff_t *ppos)
613 struct seq_file *s = file->private_data;
614 struct dwc3 *dwc = s->private;
616 enum dwc3_link_state state = 0;
619 if (atomic_read(&dwc->in_lpm)) {
620 seq_puts(s, "USB device is powered off\n");
624 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
627 if (!strncmp(buf, "SS.Disabled", 11))
628 state = DWC3_LINK_STATE_SS_DIS;
629 else if (!strncmp(buf, "Rx.Detect", 9))
630 state = DWC3_LINK_STATE_RX_DET;
631 else if (!strncmp(buf, "SS.Inactive", 11))
632 state = DWC3_LINK_STATE_SS_INACT;
633 else if (!strncmp(buf, "Recovery", 8))
634 state = DWC3_LINK_STATE_RECOV;
635 else if (!strncmp(buf, "Compliance", 10))
636 state = DWC3_LINK_STATE_CMPLY;
637 else if (!strncmp(buf, "Loopback", 8))
638 state = DWC3_LINK_STATE_LPBK;
642 spin_lock_irqsave(&dwc->lock, flags);
643 dwc3_gadget_set_link_state(dwc, state);
644 spin_unlock_irqrestore(&dwc->lock, flags);
649 static const struct file_operations dwc3_link_state_fops = {
650 .open = dwc3_link_state_open,
651 .write = dwc3_link_state_write,
654 .release = single_release,
658 static ssize_t dwc3_store_ep_num(struct file *file, const char __user *ubuf,
659 size_t count, loff_t *ppos)
661 struct seq_file *s = file->private_data;
662 struct dwc3 *dwc = s->private;
664 unsigned int num, dir, temp;
667 if (copy_from_user(kbuf, ubuf, min_t(size_t, sizeof(kbuf) - 1, count)))
670 if (sscanf(kbuf, "%u %u", &num, &dir) != 2)
673 if (dir != 0 && dir != 1)
676 temp = (num << 1) + dir;
677 if (temp >= (dwc->num_in_eps + dwc->num_out_eps) ||
678 temp >= DWC3_ENDPOINTS_NUM)
681 spin_lock_irqsave(&dwc->lock, flags);
683 spin_unlock_irqrestore(&dwc->lock, flags);
688 static int dwc3_ep_req_list_show(struct seq_file *s, void *unused)
690 struct dwc3 *dwc = s->private;
692 struct dwc3_request *req = NULL;
693 struct list_head *ptr = NULL;
696 spin_lock_irqsave(&dwc->lock, flags);
697 dep = dwc->eps[ep_num];
699 seq_printf(s, "%s request list: flags: 0x%x\n", dep->name, dep->flags);
700 list_for_each(ptr, &dep->request_list) {
701 req = list_entry(ptr, struct dwc3_request, list);
704 "req:0x%pK len: %d sts: %d dma:0x%pa num_sgs: %d\n",
705 req, req->request.length, req->request.status,
706 &req->request.dma, req->request.num_sgs);
708 spin_unlock_irqrestore(&dwc->lock, flags);
713 static int dwc3_ep_req_list_open(struct inode *inode, struct file *file)
715 return single_open(file, dwc3_ep_req_list_show, inode->i_private);
718 static const struct file_operations dwc3_ep_req_list_fops = {
719 .open = dwc3_ep_req_list_open,
720 .write = dwc3_store_ep_num,
723 .release = single_release,
726 static int dwc3_ep_queued_req_show(struct seq_file *s, void *unused)
728 struct dwc3 *dwc = s->private;
730 struct dwc3_request *req = NULL;
731 struct list_head *ptr = NULL;
734 spin_lock_irqsave(&dwc->lock, flags);
735 dep = dwc->eps[ep_num];
737 seq_printf(s, "%s queued reqs to HW: flags:0x%x\n", dep->name,
739 list_for_each(ptr, &dep->req_queued) {
740 req = list_entry(ptr, struct dwc3_request, list);
743 "req:0x%pK len:%d sts:%d dma:%pa nsg:%d trb:0x%pK\n",
744 req, req->request.length, req->request.status,
745 &req->request.dma, req->request.num_sgs, req->trb);
747 spin_unlock_irqrestore(&dwc->lock, flags);
752 static int dwc3_ep_queued_req_open(struct inode *inode, struct file *file)
754 return single_open(file, dwc3_ep_queued_req_show, inode->i_private);
757 const struct file_operations dwc3_ep_req_queued_fops = {
758 .open = dwc3_ep_queued_req_open,
759 .write = dwc3_store_ep_num,
762 .release = single_release,
765 static int dwc3_ep_trbs_show(struct seq_file *s, void *unused)
767 struct dwc3 *dwc = s->private;
769 struct dwc3_trb *trb;
776 spin_lock_irqsave(&dwc->lock, flags);
777 dep = dwc->eps[ep_num];
779 seq_printf(s, "%s trb pool: flags:0x%x freeslot:%d busyslot:%d\n",
780 dep->name, dep->flags, dep->free_slot, dep->busy_slot);
781 for (j = 0; j < DWC3_TRB_NUM; j++) {
782 trb = &dep->trb_pool[j];
783 seq_printf(s, "trb:0x%pK bph:0x%x bpl:0x%x size:0x%x ctrl: %x\n",
784 trb, trb->bph, trb->bpl, trb->size, trb->ctrl);
786 spin_unlock_irqrestore(&dwc->lock, flags);
791 static int dwc3_ep_trbs_list_open(struct inode *inode, struct file *file)
793 return single_open(file, dwc3_ep_trbs_show, inode->i_private);
796 const struct file_operations dwc3_ep_trb_list_fops = {
797 .open = dwc3_ep_trbs_list_open,
798 .write = dwc3_store_ep_num,
801 .release = single_release,
804 static unsigned int ep_addr_rxdbg_mask = 1;
805 module_param(ep_addr_rxdbg_mask, uint, S_IRUGO | S_IWUSR);
806 static unsigned int ep_addr_txdbg_mask = 1;
807 module_param(ep_addr_txdbg_mask, uint, S_IRUGO | S_IWUSR);
809 /* Maximum debug message length */
810 #define DBG_DATA_MSG 64UL
812 /* Maximum number of messages */
813 #define DBG_DATA_MAX 2048UL
816 char (buf[DBG_DATA_MAX])[DBG_DATA_MSG]; /* buffer */
817 unsigned idx; /* index */
818 unsigned tty; /* print to console? */
819 rwlock_t lck; /* lock */
823 .lck = __RW_LOCK_UNLOCKED(lck)
827 * dbg_dec: decrements debug event index
830 static inline void __maybe_unused dbg_dec(unsigned *idx)
832 *idx = (*idx - 1) % DBG_DATA_MAX;
836 * dbg_inc: increments debug event index
839 static inline void dbg_inc(unsigned *idx)
841 *idx = (*idx + 1) % DBG_DATA_MAX;
844 #define TIME_BUF_LEN 20
845 /*get_timestamp - returns time of day in us */
846 static char *get_timestamp(char *tbuf)
848 unsigned long long t;
849 unsigned long nanosec_rem;
851 t = cpu_clock(smp_processor_id());
852 nanosec_rem = do_div(t, 1000000000)/1000;
853 scnprintf(tbuf, TIME_BUF_LEN, "[%5lu.%06lu] ", (unsigned long)t,
858 static int allow_dbg_print(u8 ep_num)
862 /* allow bus wide events */
870 if (dir && (num & ep_addr_txdbg_mask))
872 if (!dir && (num & ep_addr_rxdbg_mask))
879 * dbg_print: prints the common part of the event
880 * @addr: endpoint address
883 * @extra: extra information
885 void dbg_print(u8 ep_num, const char *name, int status, const char *extra)
888 char tbuf[TIME_BUF_LEN];
890 if (!allow_dbg_print(ep_num))
893 write_lock_irqsave(&dbg_dwc3_data.lck, flags);
895 scnprintf(dbg_dwc3_data.buf[dbg_dwc3_data.idx], DBG_DATA_MSG,
896 "%s\t? %02X %-12.12s %4i ?\t%s\n",
897 get_timestamp(tbuf), ep_num, name, status, extra);
899 dbg_inc(&dbg_dwc3_data.idx);
901 write_unlock_irqrestore(&dbg_dwc3_data.lck, flags);
903 if (dbg_dwc3_data.tty != 0)
904 pr_notice("%s\t? %02X %-7.7s %4i ?\t%s\n",
905 get_timestamp(tbuf), ep_num, name, status, extra);
909 * dbg_done: prints a DONE event
910 * @addr: endpoint address
911 * @td: transfer descriptor
914 void dbg_done(u8 ep_num, const u32 count, int status)
916 char msg[DBG_DATA_MSG];
918 if (!allow_dbg_print(ep_num))
921 scnprintf(msg, sizeof(msg), "%d", count);
922 dbg_print(ep_num, "DONE", status, msg);
926 * dbg_event: prints a generic event
927 * @addr: endpoint address
931 void dbg_event(u8 ep_num, const char *name, int status)
933 if (!allow_dbg_print(ep_num))
937 dbg_print(ep_num, name, status, "");
941 * dbg_queue: prints a QUEUE event
942 * @addr: endpoint address
946 void dbg_queue(u8 ep_num, const struct usb_request *req, int status)
948 char msg[DBG_DATA_MSG];
950 if (!allow_dbg_print(ep_num))
954 scnprintf(msg, sizeof(msg),
955 "%d %d", !req->no_interrupt, req->length);
956 dbg_print(ep_num, "QUEUE", status, msg);
961 * dbg_setup: prints a SETUP event
962 * @addr: endpoint address
963 * @req: setup request
965 void dbg_setup(u8 ep_num, const struct usb_ctrlrequest *req)
967 char msg[DBG_DATA_MSG];
969 if (!allow_dbg_print(ep_num))
973 scnprintf(msg, sizeof(msg),
974 "%02X %02X %04X %04X %d", req->bRequestType,
975 req->bRequest, le16_to_cpu(req->wValue),
976 le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
977 dbg_print(ep_num, "SETUP", 0, msg);
982 * dbg_print_reg: prints a reg value
984 * @reg: reg value to be printed
986 void dbg_print_reg(const char *name, int reg)
990 write_lock_irqsave(&dbg_dwc3_data.lck, flags);
992 scnprintf(dbg_dwc3_data.buf[dbg_dwc3_data.idx], DBG_DATA_MSG,
993 "%s = 0x%08x\n", name, reg);
995 dbg_inc(&dbg_dwc3_data.idx);
997 write_unlock_irqrestore(&dbg_dwc3_data.lck, flags);
999 if (dbg_dwc3_data.tty != 0)
1000 pr_notice("%s = 0x%08x\n", name, reg);
1004 * store_events: configure if events are going to be also printed to console
1007 static ssize_t dwc3_store_events(struct file *file,
1008 const char __user *buf, size_t count, loff_t *ppos)
1014 pr_err("[%s] EINVAL\n", __func__);
1019 ret = kstrtou8_from_user(buf, count, 0, &tty);
1021 pr_err("can't get enter value.\n");
1026 pr_err("<1|0>: enable|disable console log\n");
1031 dbg_dwc3_data.tty = tty;
1032 pr_info("tty = %u", dbg_dwc3_data.tty);
1037 static int dwc3_gadget_data_events_show(struct seq_file *s, void *unused)
1039 unsigned long flags;
1042 read_lock_irqsave(&dbg_dwc3_data.lck, flags);
1044 i = dbg_dwc3_data.idx;
1045 if (strnlen(dbg_dwc3_data.buf[i], DBG_DATA_MSG))
1046 seq_printf(s, "%s\n", dbg_dwc3_data.buf[i]);
1047 for (dbg_inc(&i); i != dbg_dwc3_data.idx; dbg_inc(&i)) {
1048 if (!strnlen(dbg_dwc3_data.buf[i], DBG_DATA_MSG))
1050 seq_printf(s, "%s\n", dbg_dwc3_data.buf[i]);
1053 read_unlock_irqrestore(&dbg_dwc3_data.lck, flags);
1058 static int dwc3_gadget_data_events_open(struct inode *inode, struct file *f)
1060 return single_open(f, dwc3_gadget_data_events_show, inode->i_private);
1063 const struct file_operations dwc3_gadget_dbg_data_fops = {
1064 .open = dwc3_gadget_data_events_open,
1066 .write = dwc3_store_events,
1067 .llseek = seq_lseek,
1068 .release = single_release,
1071 static ssize_t dwc3_store_int_events(struct file *file,
1072 const char __user *ubuf, size_t count, loff_t *ppos)
1075 unsigned long flags;
1076 struct seq_file *s = file->private_data;
1077 struct dwc3 *dwc = s->private;
1078 struct dwc3_ep *dep;
1083 pr_err("[%s] EINVAL\n", __func__);
1088 ret = kstrtou8_from_user(ubuf, count, 0, &clear_stats);
1090 pr_err("can't get enter value.\n");
1094 if (clear_stats != 0) {
1095 pr_err("Wrong value. To clear stats, enter value as 0.\n");
1100 spin_lock_irqsave(&dwc->lock, flags);
1102 pr_debug("%s(): clearing debug interrupt buffers\n", __func__);
1103 ts = current_kernel_time();
1104 for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
1106 memset(&dep->dbg_ep_events, 0, sizeof(dep->dbg_ep_events));
1107 memset(&dep->dbg_ep_events_diff, 0, sizeof(dep->dbg_ep_events));
1108 dep->dbg_ep_events_ts = ts;
1110 memset(&dwc->dbg_gadget_events, 0, sizeof(dwc->dbg_gadget_events));
1112 spin_unlock_irqrestore(&dwc->lock, flags);
1117 static int dwc3_gadget_int_events_show(struct seq_file *s, void *unused)
1119 unsigned long flags;
1120 struct dwc3 *dwc = s->private;
1121 struct dwc3_gadget_events *dbg_gadget_events;
1122 struct dwc3_ep *dep;
1124 struct timespec ts_delta;
1125 struct timespec ts_current;
1128 spin_lock_irqsave(&dwc->lock, flags);
1129 dbg_gadget_events = &dwc->dbg_gadget_events;
1131 for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
1134 if (dep == NULL || !(dep->flags & DWC3_EP_ENABLED))
1137 ts_current = current_kernel_time();
1138 ts_delta = timespec_sub(ts_current, dep->dbg_ep_events_ts);
1139 ts_delta_ms = ts_delta.tv_nsec / NSEC_PER_MSEC +
1140 ts_delta.tv_sec * MSEC_PER_SEC;
1142 seq_printf(s, "\n\n===== dbg_ep_events for EP(%d) %s =====\n",
1144 seq_printf(s, "xfercomplete:%u @ %luHz\n",
1145 dep->dbg_ep_events.xfercomplete,
1146 ep_event_rate(xfercomplete, dep->dbg_ep_events,
1147 dep->dbg_ep_events_diff, ts_delta_ms));
1148 seq_printf(s, "xfernotready:%u @ %luHz\n",
1149 dep->dbg_ep_events.xfernotready,
1150 ep_event_rate(xfernotready, dep->dbg_ep_events,
1151 dep->dbg_ep_events_diff, ts_delta_ms));
1152 seq_printf(s, "control_data:%u @ %luHz\n",
1153 dep->dbg_ep_events.control_data,
1154 ep_event_rate(control_data, dep->dbg_ep_events,
1155 dep->dbg_ep_events_diff, ts_delta_ms));
1156 seq_printf(s, "control_status:%u @ %luHz\n",
1157 dep->dbg_ep_events.control_status,
1158 ep_event_rate(control_status, dep->dbg_ep_events,
1159 dep->dbg_ep_events_diff, ts_delta_ms));
1160 seq_printf(s, "xferinprogress:%u @ %luHz\n",
1161 dep->dbg_ep_events.xferinprogress,
1162 ep_event_rate(xferinprogress, dep->dbg_ep_events,
1163 dep->dbg_ep_events_diff, ts_delta_ms));
1164 seq_printf(s, "rxtxfifoevent:%u @ %luHz\n",
1165 dep->dbg_ep_events.rxtxfifoevent,
1166 ep_event_rate(rxtxfifoevent, dep->dbg_ep_events,
1167 dep->dbg_ep_events_diff, ts_delta_ms));
1168 seq_printf(s, "streamevent:%u @ %luHz\n",
1169 dep->dbg_ep_events.streamevent,
1170 ep_event_rate(streamevent, dep->dbg_ep_events,
1171 dep->dbg_ep_events_diff, ts_delta_ms));
1172 seq_printf(s, "epcmdcomplt:%u @ %luHz\n",
1173 dep->dbg_ep_events.epcmdcomplete,
1174 ep_event_rate(epcmdcomplete, dep->dbg_ep_events,
1175 dep->dbg_ep_events_diff, ts_delta_ms));
1176 seq_printf(s, "cmdcmplt:%u @ %luHz\n",
1177 dep->dbg_ep_events.cmdcmplt,
1178 ep_event_rate(cmdcmplt, dep->dbg_ep_events,
1179 dep->dbg_ep_events_diff, ts_delta_ms));
1180 seq_printf(s, "unknown:%u @ %luHz\n",
1181 dep->dbg_ep_events.unknown_event,
1182 ep_event_rate(unknown_event, dep->dbg_ep_events,
1183 dep->dbg_ep_events_diff, ts_delta_ms));
1184 seq_printf(s, "total:%u @ %luHz\n",
1185 dep->dbg_ep_events.total,
1186 ep_event_rate(total, dep->dbg_ep_events,
1187 dep->dbg_ep_events_diff, ts_delta_ms));
1189 dep->dbg_ep_events_ts = ts_current;
1190 dep->dbg_ep_events_diff = dep->dbg_ep_events;
1193 seq_puts(s, "\n=== dbg_gadget events ==\n");
1194 seq_printf(s, "disconnect:%u\n reset:%u\n",
1195 dbg_gadget_events->disconnect, dbg_gadget_events->reset);
1196 seq_printf(s, "connect:%u\n wakeup:%u\n",
1197 dbg_gadget_events->connect, dbg_gadget_events->wakeup);
1198 seq_printf(s, "link_status_change:%u\n eopf:%u\n",
1199 dbg_gadget_events->link_status_change, dbg_gadget_events->eopf);
1200 seq_printf(s, "sof:%u\n suspend:%u\n",
1201 dbg_gadget_events->sof, dbg_gadget_events->suspend);
1202 seq_printf(s, "erratic_error:%u\n overflow:%u\n",
1203 dbg_gadget_events->erratic_error,
1204 dbg_gadget_events->overflow);
1205 seq_printf(s, "vendor_dev_test_lmp:%u\n cmdcmplt:%u\n",
1206 dbg_gadget_events->vendor_dev_test_lmp,
1207 dbg_gadget_events->cmdcmplt);
1208 seq_printf(s, "unknown_event:%u\n", dbg_gadget_events->unknown_event);
1210 seq_printf(s, "\n\t== Last %d interrupts stats ==\t\n", MAX_INTR_STATS);
1211 seq_puts(s, "@ time (us):\t");
1212 for (i = 0; i < MAX_INTR_STATS; i++)
1213 seq_printf(s, "%lld\t", ktime_to_us(dwc->irq_start_time[i]));
1214 seq_puts(s, "\nhard irq time (us):\t");
1215 for (i = 0; i < MAX_INTR_STATS; i++)
1216 seq_printf(s, "%d\t", dwc->irq_completion_time[i]);
1217 seq_puts(s, "\nevents count:\t\t");
1218 for (i = 0; i < MAX_INTR_STATS; i++)
1219 seq_printf(s, "%d\t", dwc->irq_event_count[i]);
1220 seq_puts(s, "\nbh handled count:\t");
1221 for (i = 0; i < MAX_INTR_STATS; i++)
1222 seq_printf(s, "%d\t", dwc->bh_handled_evt_cnt[i]);
1223 seq_puts(s, "\nirq thread time (us):\t");
1224 for (i = 0; i < MAX_INTR_STATS; i++)
1225 seq_printf(s, "%d\t", dwc->bh_completion_time[i]);
1228 seq_printf(s, "t_pwr evt irq : %lld\n",
1229 ktime_to_us(dwc->t_pwr_evt_irq));
1231 seq_printf(s, "l1_remote_wakeup_cnt : %lu\n",
1232 dwc->l1_remote_wakeup_cnt);
1234 spin_unlock_irqrestore(&dwc->lock, flags);
1238 static int dwc3_gadget_events_open(struct inode *inode, struct file *f)
1240 return single_open(f, dwc3_gadget_int_events_show, inode->i_private);
1243 const struct file_operations dwc3_gadget_dbg_events_fops = {
1244 .open = dwc3_gadget_events_open,
1246 .write = dwc3_store_int_events,
1247 .llseek = seq_lseek,
1248 .release = single_release,
1251 int dwc3_debugfs_init(struct dwc3 *dwc)
1253 struct dentry *root;
1254 struct dentry *file;
1257 root = debugfs_create_dir(dev_name(dwc->dev), NULL);
1265 dwc->regset = kzalloc(sizeof(*dwc->regset), GFP_KERNEL);
1271 dwc->regset->regs = dwc3_regs;
1272 dwc->regset->nregs = ARRAY_SIZE(dwc3_regs);
1273 dwc->regset->base = dwc->regs;
1275 if (dwc->create_reg_debugfs) {
1276 file = debugfs_create_regset32("regdump", 0444,
1279 dev_dbg(dwc->dev, "Can't create debugfs regdump\n");
1285 if (IS_ENABLED(CONFIG_USB_DWC3_DUAL_ROLE)) {
1286 file = debugfs_create_file("mode", S_IRUGO | S_IWUSR, root,
1287 dwc, &dwc3_mode_fops);
1294 if (IS_ENABLED(CONFIG_USB_DWC3_DUAL_ROLE) ||
1295 IS_ENABLED(CONFIG_USB_DWC3_GADGET)) {
1296 file = debugfs_create_file("testmode", S_IRUGO | S_IWUSR, root,
1297 dwc, &dwc3_testmode_fops);
1303 file = debugfs_create_file("link_state", S_IRUGO | S_IWUSR, root,
1304 dwc, &dwc3_link_state_fops);
1311 file = debugfs_create_file("trbs", S_IRUGO | S_IWUSR, root,
1312 dwc, &dwc3_ep_trb_list_fops);
1318 file = debugfs_create_file("requests", S_IRUGO | S_IWUSR, root,
1319 dwc, &dwc3_ep_req_list_fops);
1325 file = debugfs_create_file("queued_reqs", S_IRUGO | S_IWUSR, root,
1326 dwc, &dwc3_ep_req_queued_fops);
1332 file = debugfs_create_file("events", S_IRUGO | S_IWUSR, root,
1333 dwc, &dwc3_gadget_dbg_data_fops);
1339 file = debugfs_create_file("int_events", S_IRUGO | S_IWUSR, root,
1340 dwc, &dwc3_gadget_dbg_events_fops);
1349 debugfs_remove_recursive(root);
1355 void dwc3_debugfs_exit(struct dwc3 *dwc)
1357 debugfs_remove_recursive(dwc->root);