Loading...
1/*
2 * Copyright (c) 2009 by Martin Fuzzey
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19/* this file is part of imx21-hcd.c */
20
21#ifndef DEBUG
22
23static inline void create_debug_files(struct imx21 *imx21) { }
24static inline void remove_debug_files(struct imx21 *imx21) { }
25static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}
26static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,
27 int status) {}
28static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}
29static inline void debug_urb_queued_for_etd(struct imx21 *imx21,
30 struct urb *urb) {}
31static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,
32 struct urb *urb) {}
33static inline void debug_etd_allocated(struct imx21 *imx21) {}
34static inline void debug_etd_freed(struct imx21 *imx21) {}
35static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}
36static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}
37static inline void debug_isoc_submitted(struct imx21 *imx21,
38 int frame, struct td *td) {}
39static inline void debug_isoc_completed(struct imx21 *imx21,
40 int frame, struct td *td, int cc, int len) {}
41
42#else
43
44#include <linux/debugfs.h>
45#include <linux/seq_file.h>
46
47static const char *dir_labels[] = {
48 "TD 0",
49 "OUT",
50 "IN",
51 "TD 1"
52};
53
54static const char *speed_labels[] = {
55 "Full",
56 "Low"
57};
58
59static const char *format_labels[] = {
60 "Control",
61 "ISO",
62 "Bulk",
63 "Interrupt"
64};
65
66static inline struct debug_stats *stats_for_urb(struct imx21 *imx21,
67 struct urb *urb)
68{
69 return usb_pipeisoc(urb->pipe) ?
70 &imx21->isoc_stats : &imx21->nonisoc_stats;
71}
72
73static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)
74{
75 stats_for_urb(imx21, urb)->submitted++;
76}
77
78static void debug_urb_completed(struct imx21 *imx21, struct urb *urb, int st)
79{
80 if (st)
81 stats_for_urb(imx21, urb)->completed_failed++;
82 else
83 stats_for_urb(imx21, urb)->completed_ok++;
84}
85
86static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)
87{
88 stats_for_urb(imx21, urb)->unlinked++;
89}
90
91static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)
92{
93 stats_for_urb(imx21, urb)->queue_etd++;
94}
95
96static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)
97{
98 stats_for_urb(imx21, urb)->queue_dmem++;
99}
100
101static inline void debug_etd_allocated(struct imx21 *imx21)
102{
103 imx21->etd_usage.maximum = max(
104 ++(imx21->etd_usage.value),
105 imx21->etd_usage.maximum);
106}
107
108static inline void debug_etd_freed(struct imx21 *imx21)
109{
110 imx21->etd_usage.value--;
111}
112
113static inline void debug_dmem_allocated(struct imx21 *imx21, int size)
114{
115 imx21->dmem_usage.value += size;
116 imx21->dmem_usage.maximum = max(
117 imx21->dmem_usage.value,
118 imx21->dmem_usage.maximum);
119}
120
121static inline void debug_dmem_freed(struct imx21 *imx21, int size)
122{
123 imx21->dmem_usage.value -= size;
124}
125
126
127static void debug_isoc_submitted(struct imx21 *imx21,
128 int frame, struct td *td)
129{
130 struct debug_isoc_trace *trace = &imx21->isoc_trace[
131 imx21->isoc_trace_index++];
132
133 imx21->isoc_trace_index %= ARRAY_SIZE(imx21->isoc_trace);
134 trace->schedule_frame = td->frame;
135 trace->submit_frame = frame;
136 trace->request_len = td->len;
137 trace->td = td;
138}
139
140static inline void debug_isoc_completed(struct imx21 *imx21,
141 int frame, struct td *td, int cc, int len)
142{
143 struct debug_isoc_trace *trace, *trace_failed;
144 int i;
145 int found = 0;
146
147 trace = imx21->isoc_trace;
148 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++) {
149 if (trace->td == td) {
150 trace->done_frame = frame;
151 trace->done_len = len;
152 trace->cc = cc;
153 trace->td = NULL;
154 found = 1;
155 break;
156 }
157 }
158
159 if (found && cc) {
160 trace_failed = &imx21->isoc_trace_failed[
161 imx21->isoc_trace_index_failed++];
162
163 imx21->isoc_trace_index_failed %= ARRAY_SIZE(
164 imx21->isoc_trace_failed);
165 *trace_failed = *trace;
166 }
167}
168
169
170static char *format_ep(struct usb_host_endpoint *ep, char *buf, int bufsize)
171{
172 if (ep)
173 snprintf(buf, bufsize, "ep_%02x (type:%02X kaddr:%p)",
174 ep->desc.bEndpointAddress,
175 usb_endpoint_type(&ep->desc),
176 ep);
177 else
178 snprintf(buf, bufsize, "none");
179 return buf;
180}
181
182static char *format_etd_dword0(u32 value, char *buf, int bufsize)
183{
184 snprintf(buf, bufsize,
185 "addr=%d ep=%d dir=%s speed=%s format=%s halted=%d",
186 value & 0x7F,
187 (value >> DW0_ENDPNT) & 0x0F,
188 dir_labels[(value >> DW0_DIRECT) & 0x03],
189 speed_labels[(value >> DW0_SPEED) & 0x01],
190 format_labels[(value >> DW0_FORMAT) & 0x03],
191 (value >> DW0_HALTED) & 0x01);
192 return buf;
193}
194
195static int debug_status_show(struct seq_file *s, void *v)
196{
197 struct imx21 *imx21 = s->private;
198 int etds_allocated = 0;
199 int etds_sw_busy = 0;
200 int etds_hw_busy = 0;
201 int dmem_blocks = 0;
202 int queued_for_etd = 0;
203 int queued_for_dmem = 0;
204 unsigned int dmem_bytes = 0;
205 int i;
206 struct etd_priv *etd;
207 u32 etd_enable_mask;
208 unsigned long flags;
209 struct imx21_dmem_area *dmem;
210 struct ep_priv *ep_priv;
211
212 spin_lock_irqsave(&imx21->lock, flags);
213
214 etd_enable_mask = readl(imx21->regs + USBH_ETDENSET);
215 for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
216 if (etd->alloc)
217 etds_allocated++;
218 if (etd->urb)
219 etds_sw_busy++;
220 if (etd_enable_mask & (1<<i))
221 etds_hw_busy++;
222 }
223
224 list_for_each_entry(dmem, &imx21->dmem_list, list) {
225 dmem_bytes += dmem->size;
226 dmem_blocks++;
227 }
228
229 list_for_each_entry(ep_priv, &imx21->queue_for_etd, queue)
230 queued_for_etd++;
231
232 list_for_each_entry(etd, &imx21->queue_for_dmem, queue)
233 queued_for_dmem++;
234
235 spin_unlock_irqrestore(&imx21->lock, flags);
236
237 seq_printf(s,
238 "Frame: %d\n"
239 "ETDs allocated: %d/%d (max=%d)\n"
240 "ETDs in use sw: %d\n"
241 "ETDs in use hw: %d\n"
242 "DMEM alocated: %d/%d (max=%d)\n"
243 "DMEM blocks: %d\n"
244 "Queued waiting for ETD: %d\n"
245 "Queued waiting for DMEM: %d\n",
246 readl(imx21->regs + USBH_FRMNUB) & 0xFFFF,
247 etds_allocated, USB_NUM_ETD, imx21->etd_usage.maximum,
248 etds_sw_busy,
249 etds_hw_busy,
250 dmem_bytes, DMEM_SIZE, imx21->dmem_usage.maximum,
251 dmem_blocks,
252 queued_for_etd,
253 queued_for_dmem);
254
255 return 0;
256}
257
258static int debug_dmem_show(struct seq_file *s, void *v)
259{
260 struct imx21 *imx21 = s->private;
261 struct imx21_dmem_area *dmem;
262 unsigned long flags;
263 char ep_text[40];
264
265 spin_lock_irqsave(&imx21->lock, flags);
266
267 list_for_each_entry(dmem, &imx21->dmem_list, list)
268 seq_printf(s,
269 "%04X: size=0x%X "
270 "ep=%s\n",
271 dmem->offset, dmem->size,
272 format_ep(dmem->ep, ep_text, sizeof(ep_text)));
273
274 spin_unlock_irqrestore(&imx21->lock, flags);
275
276 return 0;
277}
278
279static int debug_etd_show(struct seq_file *s, void *v)
280{
281 struct imx21 *imx21 = s->private;
282 struct etd_priv *etd;
283 char buf[60];
284 u32 dword;
285 int i, j;
286 unsigned long flags;
287
288 spin_lock_irqsave(&imx21->lock, flags);
289
290 for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
291 int state = -1;
292 struct urb_priv *urb_priv;
293 if (etd->urb) {
294 urb_priv = etd->urb->hcpriv;
295 if (urb_priv)
296 state = urb_priv->state;
297 }
298
299 seq_printf(s,
300 "etd_num: %d\n"
301 "ep: %s\n"
302 "alloc: %d\n"
303 "len: %d\n"
304 "busy sw: %d\n"
305 "busy hw: %d\n"
306 "urb state: %d\n"
307 "current urb: %p\n",
308
309 i,
310 format_ep(etd->ep, buf, sizeof(buf)),
311 etd->alloc,
312 etd->len,
313 etd->urb != NULL,
314 (readl(imx21->regs + USBH_ETDENSET) & (1 << i)) > 0,
315 state,
316 etd->urb);
317
318 for (j = 0; j < 4; j++) {
319 dword = etd_readl(imx21, i, j);
320 switch (j) {
321 case 0:
322 format_etd_dword0(dword, buf, sizeof(buf));
323 break;
324 case 2:
325 snprintf(buf, sizeof(buf),
326 "cc=0X%02X", dword >> DW2_COMPCODE);
327 break;
328 default:
329 *buf = 0;
330 break;
331 }
332 seq_printf(s,
333 "dword %d: submitted=%08X cur=%08X [%s]\n",
334 j,
335 etd->submitted_dwords[j],
336 dword,
337 buf);
338 }
339 seq_printf(s, "\n");
340 }
341
342 spin_unlock_irqrestore(&imx21->lock, flags);
343
344 return 0;
345}
346
347static void debug_statistics_show_one(struct seq_file *s,
348 const char *name, struct debug_stats *stats)
349{
350 seq_printf(s, "%s:\n"
351 "submitted URBs: %lu\n"
352 "completed OK: %lu\n"
353 "completed failed: %lu\n"
354 "unlinked: %lu\n"
355 "queued for ETD: %lu\n"
356 "queued for DMEM: %lu\n\n",
357 name,
358 stats->submitted,
359 stats->completed_ok,
360 stats->completed_failed,
361 stats->unlinked,
362 stats->queue_etd,
363 stats->queue_dmem);
364}
365
366static int debug_statistics_show(struct seq_file *s, void *v)
367{
368 struct imx21 *imx21 = s->private;
369 unsigned long flags;
370
371 spin_lock_irqsave(&imx21->lock, flags);
372
373 debug_statistics_show_one(s, "nonisoc", &imx21->nonisoc_stats);
374 debug_statistics_show_one(s, "isoc", &imx21->isoc_stats);
375 seq_printf(s, "unblock kludge triggers: %lu\n", imx21->debug_unblocks);
376 spin_unlock_irqrestore(&imx21->lock, flags);
377
378 return 0;
379}
380
381static void debug_isoc_show_one(struct seq_file *s,
382 const char *name, int index, struct debug_isoc_trace *trace)
383{
384 seq_printf(s, "%s %d:\n"
385 "cc=0X%02X\n"
386 "scheduled frame %d (%d)\n"
387 "submitted frame %d (%d)\n"
388 "completed frame %d (%d)\n"
389 "requested length=%d\n"
390 "completed length=%d\n\n",
391 name, index,
392 trace->cc,
393 trace->schedule_frame, trace->schedule_frame & 0xFFFF,
394 trace->submit_frame, trace->submit_frame & 0xFFFF,
395 trace->done_frame, trace->done_frame & 0xFFFF,
396 trace->request_len,
397 trace->done_len);
398}
399
400static int debug_isoc_show(struct seq_file *s, void *v)
401{
402 struct imx21 *imx21 = s->private;
403 struct debug_isoc_trace *trace;
404 unsigned long flags;
405 int i;
406
407 spin_lock_irqsave(&imx21->lock, flags);
408
409 trace = imx21->isoc_trace_failed;
410 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace_failed); i++, trace++)
411 debug_isoc_show_one(s, "isoc failed", i, trace);
412
413 trace = imx21->isoc_trace;
414 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++)
415 debug_isoc_show_one(s, "isoc", i, trace);
416
417 spin_unlock_irqrestore(&imx21->lock, flags);
418
419 return 0;
420}
421
422static int debug_status_open(struct inode *inode, struct file *file)
423{
424 return single_open(file, debug_status_show, inode->i_private);
425}
426
427static int debug_dmem_open(struct inode *inode, struct file *file)
428{
429 return single_open(file, debug_dmem_show, inode->i_private);
430}
431
432static int debug_etd_open(struct inode *inode, struct file *file)
433{
434 return single_open(file, debug_etd_show, inode->i_private);
435}
436
437static int debug_statistics_open(struct inode *inode, struct file *file)
438{
439 return single_open(file, debug_statistics_show, inode->i_private);
440}
441
442static int debug_isoc_open(struct inode *inode, struct file *file)
443{
444 return single_open(file, debug_isoc_show, inode->i_private);
445}
446
447static const struct file_operations debug_status_fops = {
448 .open = debug_status_open,
449 .read = seq_read,
450 .llseek = seq_lseek,
451 .release = single_release,
452};
453
454static const struct file_operations debug_dmem_fops = {
455 .open = debug_dmem_open,
456 .read = seq_read,
457 .llseek = seq_lseek,
458 .release = single_release,
459};
460
461static const struct file_operations debug_etd_fops = {
462 .open = debug_etd_open,
463 .read = seq_read,
464 .llseek = seq_lseek,
465 .release = single_release,
466};
467
468static const struct file_operations debug_statistics_fops = {
469 .open = debug_statistics_open,
470 .read = seq_read,
471 .llseek = seq_lseek,
472 .release = single_release,
473};
474
475static const struct file_operations debug_isoc_fops = {
476 .open = debug_isoc_open,
477 .read = seq_read,
478 .llseek = seq_lseek,
479 .release = single_release,
480};
481
482static void create_debug_files(struct imx21 *imx21)
483{
484 imx21->debug_root = debugfs_create_dir(dev_name(imx21->dev), NULL);
485 if (!imx21->debug_root)
486 goto failed_create_rootdir;
487
488 if (!debugfs_create_file("status", S_IRUGO,
489 imx21->debug_root, imx21, &debug_status_fops))
490 goto failed_create;
491
492 if (!debugfs_create_file("dmem", S_IRUGO,
493 imx21->debug_root, imx21, &debug_dmem_fops))
494 goto failed_create;
495
496 if (!debugfs_create_file("etd", S_IRUGO,
497 imx21->debug_root, imx21, &debug_etd_fops))
498 goto failed_create;
499
500 if (!debugfs_create_file("statistics", S_IRUGO,
501 imx21->debug_root, imx21, &debug_statistics_fops))
502 goto failed_create;
503
504 if (!debugfs_create_file("isoc", S_IRUGO,
505 imx21->debug_root, imx21, &debug_isoc_fops))
506 goto failed_create;
507
508 return;
509
510failed_create:
511 debugfs_remove_recursive(imx21->debug_root);
512
513failed_create_rootdir:
514 imx21->debug_root = NULL;
515}
516
517
518static void remove_debug_files(struct imx21 *imx21)
519{
520 if (imx21->debug_root) {
521 debugfs_remove_recursive(imx21->debug_root);
522 imx21->debug_root = NULL;
523 }
524}
525
526#endif
527
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (c) 2009 by Martin Fuzzey
4 */
5
6/* this file is part of imx21-hcd.c */
7
8#ifdef CONFIG_DYNAMIC_DEBUG
9#define DEBUG
10#endif
11
12#ifndef DEBUG
13
14static inline void create_debug_files(struct imx21 *imx21) { }
15static inline void remove_debug_files(struct imx21 *imx21) { }
16static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}
17static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,
18 int status) {}
19static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}
20static inline void debug_urb_queued_for_etd(struct imx21 *imx21,
21 struct urb *urb) {}
22static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,
23 struct urb *urb) {}
24static inline void debug_etd_allocated(struct imx21 *imx21) {}
25static inline void debug_etd_freed(struct imx21 *imx21) {}
26static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}
27static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}
28static inline void debug_isoc_submitted(struct imx21 *imx21,
29 int frame, struct td *td) {}
30static inline void debug_isoc_completed(struct imx21 *imx21,
31 int frame, struct td *td, int cc, int len) {}
32
33#else
34
35#include <linux/debugfs.h>
36#include <linux/seq_file.h>
37
38static const char *dir_labels[] = {
39 "TD 0",
40 "OUT",
41 "IN",
42 "TD 1"
43};
44
45static const char *speed_labels[] = {
46 "Full",
47 "Low"
48};
49
50static const char *format_labels[] = {
51 "Control",
52 "ISO",
53 "Bulk",
54 "Interrupt"
55};
56
57static inline struct debug_stats *stats_for_urb(struct imx21 *imx21,
58 struct urb *urb)
59{
60 return usb_pipeisoc(urb->pipe) ?
61 &imx21->isoc_stats : &imx21->nonisoc_stats;
62}
63
64static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)
65{
66 stats_for_urb(imx21, urb)->submitted++;
67}
68
69static void debug_urb_completed(struct imx21 *imx21, struct urb *urb, int st)
70{
71 if (st)
72 stats_for_urb(imx21, urb)->completed_failed++;
73 else
74 stats_for_urb(imx21, urb)->completed_ok++;
75}
76
77static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)
78{
79 stats_for_urb(imx21, urb)->unlinked++;
80}
81
82static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)
83{
84 stats_for_urb(imx21, urb)->queue_etd++;
85}
86
87static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)
88{
89 stats_for_urb(imx21, urb)->queue_dmem++;
90}
91
92static inline void debug_etd_allocated(struct imx21 *imx21)
93{
94 imx21->etd_usage.maximum = max(
95 ++(imx21->etd_usage.value),
96 imx21->etd_usage.maximum);
97}
98
99static inline void debug_etd_freed(struct imx21 *imx21)
100{
101 imx21->etd_usage.value--;
102}
103
104static inline void debug_dmem_allocated(struct imx21 *imx21, int size)
105{
106 imx21->dmem_usage.value += size;
107 imx21->dmem_usage.maximum = max(
108 imx21->dmem_usage.value,
109 imx21->dmem_usage.maximum);
110}
111
112static inline void debug_dmem_freed(struct imx21 *imx21, int size)
113{
114 imx21->dmem_usage.value -= size;
115}
116
117
118static void debug_isoc_submitted(struct imx21 *imx21,
119 int frame, struct td *td)
120{
121 struct debug_isoc_trace *trace = &imx21->isoc_trace[
122 imx21->isoc_trace_index++];
123
124 imx21->isoc_trace_index %= ARRAY_SIZE(imx21->isoc_trace);
125 trace->schedule_frame = td->frame;
126 trace->submit_frame = frame;
127 trace->request_len = td->len;
128 trace->td = td;
129}
130
131static inline void debug_isoc_completed(struct imx21 *imx21,
132 int frame, struct td *td, int cc, int len)
133{
134 struct debug_isoc_trace *trace, *trace_failed;
135 int i;
136 int found = 0;
137
138 trace = imx21->isoc_trace;
139 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++) {
140 if (trace->td == td) {
141 trace->done_frame = frame;
142 trace->done_len = len;
143 trace->cc = cc;
144 trace->td = NULL;
145 found = 1;
146 break;
147 }
148 }
149
150 if (found && cc) {
151 trace_failed = &imx21->isoc_trace_failed[
152 imx21->isoc_trace_index_failed++];
153
154 imx21->isoc_trace_index_failed %= ARRAY_SIZE(
155 imx21->isoc_trace_failed);
156 *trace_failed = *trace;
157 }
158}
159
160
161static char *format_ep(struct usb_host_endpoint *ep, char *buf, int bufsize)
162{
163 if (ep)
164 snprintf(buf, bufsize, "ep_%02x (type:%02X kaddr:%p)",
165 ep->desc.bEndpointAddress,
166 usb_endpoint_type(&ep->desc),
167 ep);
168 else
169 snprintf(buf, bufsize, "none");
170 return buf;
171}
172
173static char *format_etd_dword0(u32 value, char *buf, int bufsize)
174{
175 snprintf(buf, bufsize,
176 "addr=%d ep=%d dir=%s speed=%s format=%s halted=%d",
177 value & 0x7F,
178 (value >> DW0_ENDPNT) & 0x0F,
179 dir_labels[(value >> DW0_DIRECT) & 0x03],
180 speed_labels[(value >> DW0_SPEED) & 0x01],
181 format_labels[(value >> DW0_FORMAT) & 0x03],
182 (value >> DW0_HALTED) & 0x01);
183 return buf;
184}
185
186static int debug_status_show(struct seq_file *s, void *v)
187{
188 struct imx21 *imx21 = s->private;
189 int etds_allocated = 0;
190 int etds_sw_busy = 0;
191 int etds_hw_busy = 0;
192 int dmem_blocks = 0;
193 int queued_for_etd = 0;
194 int queued_for_dmem = 0;
195 unsigned int dmem_bytes = 0;
196 int i;
197 struct etd_priv *etd;
198 u32 etd_enable_mask;
199 unsigned long flags;
200 struct imx21_dmem_area *dmem;
201 struct ep_priv *ep_priv;
202
203 spin_lock_irqsave(&imx21->lock, flags);
204
205 etd_enable_mask = readl(imx21->regs + USBH_ETDENSET);
206 for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
207 if (etd->alloc)
208 etds_allocated++;
209 if (etd->urb)
210 etds_sw_busy++;
211 if (etd_enable_mask & (1<<i))
212 etds_hw_busy++;
213 }
214
215 list_for_each_entry(dmem, &imx21->dmem_list, list) {
216 dmem_bytes += dmem->size;
217 dmem_blocks++;
218 }
219
220 list_for_each_entry(ep_priv, &imx21->queue_for_etd, queue)
221 queued_for_etd++;
222
223 list_for_each_entry(etd, &imx21->queue_for_dmem, queue)
224 queued_for_dmem++;
225
226 spin_unlock_irqrestore(&imx21->lock, flags);
227
228 seq_printf(s,
229 "Frame: %d\n"
230 "ETDs allocated: %d/%d (max=%d)\n"
231 "ETDs in use sw: %d\n"
232 "ETDs in use hw: %d\n"
233 "DMEM allocated: %d/%d (max=%d)\n"
234 "DMEM blocks: %d\n"
235 "Queued waiting for ETD: %d\n"
236 "Queued waiting for DMEM: %d\n",
237 readl(imx21->regs + USBH_FRMNUB) & 0xFFFF,
238 etds_allocated, USB_NUM_ETD, imx21->etd_usage.maximum,
239 etds_sw_busy,
240 etds_hw_busy,
241 dmem_bytes, DMEM_SIZE, imx21->dmem_usage.maximum,
242 dmem_blocks,
243 queued_for_etd,
244 queued_for_dmem);
245
246 return 0;
247}
248DEFINE_SHOW_ATTRIBUTE(debug_status);
249
250static int debug_dmem_show(struct seq_file *s, void *v)
251{
252 struct imx21 *imx21 = s->private;
253 struct imx21_dmem_area *dmem;
254 unsigned long flags;
255 char ep_text[40];
256
257 spin_lock_irqsave(&imx21->lock, flags);
258
259 list_for_each_entry(dmem, &imx21->dmem_list, list)
260 seq_printf(s,
261 "%04X: size=0x%X "
262 "ep=%s\n",
263 dmem->offset, dmem->size,
264 format_ep(dmem->ep, ep_text, sizeof(ep_text)));
265
266 spin_unlock_irqrestore(&imx21->lock, flags);
267
268 return 0;
269}
270DEFINE_SHOW_ATTRIBUTE(debug_dmem);
271
272static int debug_etd_show(struct seq_file *s, void *v)
273{
274 struct imx21 *imx21 = s->private;
275 struct etd_priv *etd;
276 char buf[60];
277 u32 dword;
278 int i, j;
279 unsigned long flags;
280
281 spin_lock_irqsave(&imx21->lock, flags);
282
283 for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
284 int state = -1;
285 struct urb_priv *urb_priv;
286 if (etd->urb) {
287 urb_priv = etd->urb->hcpriv;
288 if (urb_priv)
289 state = urb_priv->state;
290 }
291
292 seq_printf(s,
293 "etd_num: %d\n"
294 "ep: %s\n"
295 "alloc: %d\n"
296 "len: %d\n"
297 "busy sw: %d\n"
298 "busy hw: %d\n"
299 "urb state: %d\n"
300 "current urb: %p\n",
301
302 i,
303 format_ep(etd->ep, buf, sizeof(buf)),
304 etd->alloc,
305 etd->len,
306 etd->urb != NULL,
307 (readl(imx21->regs + USBH_ETDENSET) & (1 << i)) > 0,
308 state,
309 etd->urb);
310
311 for (j = 0; j < 4; j++) {
312 dword = etd_readl(imx21, i, j);
313 switch (j) {
314 case 0:
315 format_etd_dword0(dword, buf, sizeof(buf));
316 break;
317 case 2:
318 snprintf(buf, sizeof(buf),
319 "cc=0X%02X", dword >> DW2_COMPCODE);
320 break;
321 default:
322 *buf = 0;
323 break;
324 }
325 seq_printf(s,
326 "dword %d: submitted=%08X cur=%08X [%s]\n",
327 j,
328 etd->submitted_dwords[j],
329 dword,
330 buf);
331 }
332 seq_printf(s, "\n");
333 }
334
335 spin_unlock_irqrestore(&imx21->lock, flags);
336
337 return 0;
338}
339DEFINE_SHOW_ATTRIBUTE(debug_etd);
340
341static void debug_statistics_show_one(struct seq_file *s,
342 const char *name, struct debug_stats *stats)
343{
344 seq_printf(s, "%s:\n"
345 "submitted URBs: %lu\n"
346 "completed OK: %lu\n"
347 "completed failed: %lu\n"
348 "unlinked: %lu\n"
349 "queued for ETD: %lu\n"
350 "queued for DMEM: %lu\n\n",
351 name,
352 stats->submitted,
353 stats->completed_ok,
354 stats->completed_failed,
355 stats->unlinked,
356 stats->queue_etd,
357 stats->queue_dmem);
358}
359
360static int debug_statistics_show(struct seq_file *s, void *v)
361{
362 struct imx21 *imx21 = s->private;
363 unsigned long flags;
364
365 spin_lock_irqsave(&imx21->lock, flags);
366
367 debug_statistics_show_one(s, "nonisoc", &imx21->nonisoc_stats);
368 debug_statistics_show_one(s, "isoc", &imx21->isoc_stats);
369 seq_printf(s, "unblock kludge triggers: %lu\n", imx21->debug_unblocks);
370 spin_unlock_irqrestore(&imx21->lock, flags);
371
372 return 0;
373}
374DEFINE_SHOW_ATTRIBUTE(debug_statistics);
375
376static void debug_isoc_show_one(struct seq_file *s,
377 const char *name, int index, struct debug_isoc_trace *trace)
378{
379 seq_printf(s, "%s %d:\n"
380 "cc=0X%02X\n"
381 "scheduled frame %d (%d)\n"
382 "submitted frame %d (%d)\n"
383 "completed frame %d (%d)\n"
384 "requested length=%d\n"
385 "completed length=%d\n\n",
386 name, index,
387 trace->cc,
388 trace->schedule_frame, trace->schedule_frame & 0xFFFF,
389 trace->submit_frame, trace->submit_frame & 0xFFFF,
390 trace->done_frame, trace->done_frame & 0xFFFF,
391 trace->request_len,
392 trace->done_len);
393}
394
395static int debug_isoc_show(struct seq_file *s, void *v)
396{
397 struct imx21 *imx21 = s->private;
398 struct debug_isoc_trace *trace;
399 unsigned long flags;
400 int i;
401
402 spin_lock_irqsave(&imx21->lock, flags);
403
404 trace = imx21->isoc_trace_failed;
405 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace_failed); i++, trace++)
406 debug_isoc_show_one(s, "isoc failed", i, trace);
407
408 trace = imx21->isoc_trace;
409 for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++)
410 debug_isoc_show_one(s, "isoc", i, trace);
411
412 spin_unlock_irqrestore(&imx21->lock, flags);
413
414 return 0;
415}
416DEFINE_SHOW_ATTRIBUTE(debug_isoc);
417
418static void create_debug_files(struct imx21 *imx21)
419{
420 struct dentry *root;
421
422 root = debugfs_create_dir(dev_name(imx21->dev), usb_debug_root);
423 imx21->debug_root = root;
424
425 debugfs_create_file("status", S_IRUGO, root, imx21, &debug_status_fops);
426 debugfs_create_file("dmem", S_IRUGO, root, imx21, &debug_dmem_fops);
427 debugfs_create_file("etd", S_IRUGO, root, imx21, &debug_etd_fops);
428 debugfs_create_file("statistics", S_IRUGO, root, imx21,
429 &debug_statistics_fops);
430 debugfs_create_file("isoc", S_IRUGO, root, imx21, &debug_isoc_fops);
431}
432
433static void remove_debug_files(struct imx21 *imx21)
434{
435 debugfs_remove_recursive(imx21->debug_root);
436}
437
438#endif
439