xhci: tegra: support HSIC ports
[linux-3.10.git] / drivers / usb / host / imx21-dbg.c
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
23 static inline void create_debug_files(struct imx21 *imx21) { }
24 static inline void remove_debug_files(struct imx21 *imx21) { }
25 static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}
26 static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,
27         int status) {}
28 static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}
29 static inline void debug_urb_queued_for_etd(struct imx21 *imx21,
30         struct urb *urb) {}
31 static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,
32         struct urb *urb) {}
33 static inline void debug_etd_allocated(struct imx21 *imx21) {}
34 static inline void debug_etd_freed(struct imx21 *imx21) {}
35 static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}
36 static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}
37 static inline void debug_isoc_submitted(struct imx21 *imx21,
38         int frame, struct td *td) {}
39 static 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
47 static const char *dir_labels[] = {
48         "TD 0",
49         "OUT",
50         "IN",
51         "TD 1"
52 };
53
54 static const char *speed_labels[] = {
55         "Full",
56         "Low"
57 };
58
59 static const char *format_labels[] = {
60         "Control",
61         "ISO",
62         "Bulk",
63         "Interrupt"
64 };
65
66 static 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
73 static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)
74 {
75         stats_for_urb(imx21, urb)->submitted++;
76 }
77
78 static 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
86 static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)
87 {
88         stats_for_urb(imx21, urb)->unlinked++;
89 }
90
91 static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)
92 {
93         stats_for_urb(imx21, urb)->queue_etd++;
94 }
95
96 static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)
97 {
98         stats_for_urb(imx21, urb)->queue_dmem++;
99 }
100
101 static 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
108 static inline void debug_etd_freed(struct imx21 *imx21)
109 {
110         imx21->etd_usage.value--;
111 }
112
113 static 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
121 static inline void debug_dmem_freed(struct imx21 *imx21, int size)
122 {
123         imx21->dmem_usage.value -= size;
124 }
125
126
127 static 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
140 static 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
170 static 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
182 static 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
195 static 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 allocated: %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
258 static 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
279 static 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
347 static 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
366 static 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
381 static 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
400 static 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
422 static int debug_status_open(struct inode *inode, struct file *file)
423 {
424         return single_open(file, debug_status_show, inode->i_private);
425 }
426
427 static int debug_dmem_open(struct inode *inode, struct file *file)
428 {
429         return single_open(file, debug_dmem_show, inode->i_private);
430 }
431
432 static int debug_etd_open(struct inode *inode, struct file *file)
433 {
434         return single_open(file, debug_etd_show, inode->i_private);
435 }
436
437 static int debug_statistics_open(struct inode *inode, struct file *file)
438 {
439         return single_open(file, debug_statistics_show, inode->i_private);
440 }
441
442 static int debug_isoc_open(struct inode *inode, struct file *file)
443 {
444         return single_open(file, debug_isoc_show, inode->i_private);
445 }
446
447 static 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
454 static 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
461 static 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
468 static 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
475 static 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
482 static 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
510 failed_create:
511         debugfs_remove_recursive(imx21->debug_root);
512
513 failed_create_rootdir:
514         imx21->debug_root = NULL;
515 }
516
517
518 static 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