projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ath9k: allow run-time change of the chanbw debugfs file
[openwrt.git] / target / linux / adm5120 / files / drivers / usb / host / adm5120-dbg.c
1 /*
2 * ADM5120 HCD (Host Controller Driver) for USB
3 *
4 * Copyright (C) 2007-2008 Gabor Juhos <juhosg@openwrt.org>
5 *
6 * This file was derived from: drivers/usb/host/ohci-dbg.c
7 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
8 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License version 2 as published
12 * by the Free Software Foundation.
13 *
14 */
15
16 /*-------------------------------------------------------------------------*/
17
18 static inline char *ed_typestring(int ed_type)
19 {
20 switch (ed_type) {
21 case PIPE_CONTROL:
22 return "ctrl";
23 case PIPE_BULK:
24 return "bulk";
25 case PIPE_INTERRUPT:
26 return "intr";
27 case PIPE_ISOCHRONOUS:
28 return "isoc";
29 }
30 return "(bad ed_type)";
31 }
32
33 static inline char *ed_statestring(int state)
34 {
35 switch (state) {
36 case ED_IDLE:
37 return "IDLE";
38 case ED_UNLINK:
39 return "UNLINK";
40 case ED_OPER:
41 return "OPER";
42 }
43 return "?STATE";
44 }
45
46 static inline char *pipestring(int pipe)
47 {
48 return ed_typestring(usb_pipetype(pipe));
49 }
50
51 static inline char *td_pidstring(u32 info)
52 {
53 switch (info & TD_DP) {
54 case TD_DP_SETUP:
55 return "SETUP";
56 case TD_DP_IN:
57 return "IN";
58 case TD_DP_OUT:
59 return "OUT";
60 }
61 return "?PID";
62 }
63
64 static inline char *td_togglestring(u32 info)
65 {
66 switch (info & TD_T) {
67 case TD_T_DATA0:
68 return "DATA0";
69 case TD_T_DATA1:
70 return "DATA1";
71 case TD_T_CARRY:
72 return "CARRY";
73 }
74 return "?TOGGLE";
75 }
76
77 /*-------------------------------------------------------------------------*/
78
79 #ifdef DEBUG
80
81 /* debug| print the main components of an URB
82 * small: 0) header + data packets 1) just header
83 */
84 static void __attribute__((unused))
85 urb_print(struct admhcd *ahcd, struct urb *urb, char *str, int small, int status)
86 {
87 unsigned int pipe = urb->pipe;
88
89 if (!urb->dev || !urb->dev->bus) {
90 admhc_dbg(ahcd, "%s URB: no dev", str);
91 return;
92 }
93
94 #ifndef ADMHC_VERBOSE_DEBUG
95 if (status != 0)
96 #endif
97 admhc_dbg(ahcd, "URB-%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d "
98 "stat=%d\n",
99 str,
100 urb,
101 usb_pipedevice(pipe),
102 usb_pipeendpoint(pipe),
103 usb_pipeout(pipe) ? "out" : "in",
104 pipestring(pipe),
105 urb->transfer_flags,
106 urb->actual_length,
107 urb->transfer_buffer_length,
108 status);
109
110 #ifdef ADMHC_VERBOSE_DEBUG
111 if (!small) {
112 int i, len;
113
114 if (usb_pipecontrol(pipe)) {
115 admhc_dbg(ahcd, "setup(8):");
116 for (i = 0; i < 8 ; i++)
117 printk(KERN_INFO" %02x", ((__u8 *)urb->setup_packet)[i]);
118 printk(KERN_INFO "\n");
119 }
120 if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
121 admhc_dbg(ahcd, "data(%d/%d):",
122 urb->actual_length,
123 urb->transfer_buffer_length);
124 len = usb_pipeout(pipe) ?
125 urb->transfer_buffer_length : urb->actual_length;
126 for (i = 0; i < 16 && i < len; i++)
127 printk(KERN_INFO " %02x", ((__u8 *)urb->transfer_buffer)[i]);
128 printk(KERN_INFO "%s stat:%d\n", i < len ? "..." : "", status);
129 }
130 }
131 #endif /* ADMHC_VERBOSE_DEBUG */
132 }
133
134 #define admhc_dbg_sw(ahcd, next, size, format, arg...) \
135 do { \
136 if (next) { \
137 unsigned s_len; \
138 s_len = scnprintf(*next, *size, format, ## arg); \
139 *size -= s_len; *next += s_len; \
140 } else \
141 admhc_dbg(ahcd, format, ## arg); \
142 } while (0);
143
144
145 static void admhc_dump_intr_mask(struct admhcd *ahcd, char *label, u32 mask,
146 char **next, unsigned *size)
147 {
148 admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n",
149 label,
150 mask,
151 (mask & ADMHC_INTR_INTA) ? " INTA" : "",
152 (mask & ADMHC_INTR_FATI) ? " FATI" : "",
153 (mask & ADMHC_INTR_SWI) ? " SWI" : "",
154 (mask & ADMHC_INTR_TDC) ? " TDC" : "",
155 (mask & ADMHC_INTR_FNO) ? " FNO" : "",
156 (mask & ADMHC_INTR_SO) ? " SO" : "",
157 (mask & ADMHC_INTR_INSM) ? " INSM" : "",
158 (mask & ADMHC_INTR_BABI) ? " BABI" : "",
159 (mask & ADMHC_INTR_7) ? " !7!" : "",
160 (mask & ADMHC_INTR_6) ? " !6!" : "",
161 (mask & ADMHC_INTR_RESI) ? " RESI" : "",
162 (mask & ADMHC_INTR_SOFI) ? " SOFI" : ""
163 );
164 }
165
166 static void maybe_print_eds(struct admhcd *ahcd, char *label, u32 value,
167 char **next, unsigned *size)
168 {
169 if (value)
170 admhc_dbg_sw(ahcd, next, size, "%s %08x\n", label, value);
171 }
172
173 static char *buss2string(int state)
174 {
175 switch (state) {
176 case ADMHC_BUSS_RESET:
177 return "reset";
178 case ADMHC_BUSS_RESUME:
179 return "resume";
180 case ADMHC_BUSS_OPER:
181 return "operational";
182 case ADMHC_BUSS_SUSPEND:
183 return "suspend";
184 }
185 return "?state";
186 }
187
188 static void
189 admhc_dump_status(struct admhcd *ahcd, char **next, unsigned *size)
190 {
191 struct admhcd_regs __iomem *regs = ahcd->regs;
192 u32 temp;
193
194 temp = admhc_readl(ahcd, &regs->gencontrol);
195 admhc_dbg_sw(ahcd, next, size,
196 "gencontrol 0x%08x%s%s%s%s\n",
197 temp,
198 (temp & ADMHC_CTRL_UHFE) ? " UHFE" : "",
199 (temp & ADMHC_CTRL_SIR) ? " SIR" : "",
200 (temp & ADMHC_CTRL_DMAA) ? " DMAA" : "",
201 (temp & ADMHC_CTRL_SR) ? " SR" : ""
202 );
203
204 temp = admhc_readl(ahcd, &regs->host_control);
205 admhc_dbg_sw(ahcd, next, size,
206 "host_control 0x%08x BUSS=%s%s\n",
207 temp,
208 buss2string(temp & ADMHC_HC_BUSS),
209 (temp & ADMHC_HC_DMAE) ? " DMAE" : ""
210 );
211
212 admhc_dump_intr_mask(ahcd, "int_status",
213 admhc_readl(ahcd, &regs->int_status),
214 next, size);
215 admhc_dump_intr_mask(ahcd, "int_enable",
216 admhc_readl(ahcd, &regs->int_enable),
217 next, size);
218
219 maybe_print_eds(ahcd, "hosthead",
220 admhc_readl(ahcd, &regs->hosthead), next, size);
221 }
222
223 #define dbg_port_sw(hc, num, value, next, size) \
224 admhc_dbg_sw(hc, next, size, \
225 "portstatus [%d] " \
226 "0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
227 num, temp, \
228 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
229 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
230 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
231 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
232 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
233 \
234 (temp & ADMHC_PS_LSDA) ? " LSDA" : "", \
235 (temp & ADMHC_PS_PPS) ? " PPS" : "", \
236 (temp & ADMHC_PS_PRS) ? " PRS" : "", \
237 (temp & ADMHC_PS_POCI) ? " POCI" : "", \
238 (temp & ADMHC_PS_PSS) ? " PSS" : "", \
239 \
240 (temp & ADMHC_PS_PES) ? " PES" : "", \
241 (temp & ADMHC_PS_CCS) ? " CCS" : "" \
242 );
243
244
245 static void
246 admhc_dump_roothub(
247 struct admhcd *ahcd,
248 int verbose,
249 char **next,
250 unsigned *size)
251 {
252 u32 temp, i;
253
254 temp = admhc_read_rhdesc(ahcd);
255 if (temp == ~(u32)0)
256 return;
257
258 if (verbose) {
259 admhc_dbg_sw(ahcd, next, size,
260 "rhdesc %08x%s%s%s%s%s%s PPCM=%02x%s%s%s%s NUMP=%d(%d)\n",
261 temp,
262 (temp & ADMHC_RH_CRWE) ? " CRWE" : "",
263 (temp & ADMHC_RH_OCIC) ? " OCIC" : "",
264 (temp & ADMHC_RH_LPSC) ? " LPSC" : "",
265 (temp & ADMHC_RH_LPSC) ? " DRWE" : "",
266 (temp & ADMHC_RH_LPSC) ? " OCI" : "",
267 (temp & ADMHC_RH_LPSC) ? " LPS" : "",
268 ((temp & ADMHC_RH_PPCM) >> 16),
269 (temp & ADMHC_RH_NOCP) ? " NOCP" : "",
270 (temp & ADMHC_RH_OCPM) ? " OCPM" : "",
271 (temp & ADMHC_RH_NPS) ? " NPS" : "",
272 (temp & ADMHC_RH_PSM) ? " PSM" : "",
273 (temp & ADMHC_RH_NUMP), ahcd->num_ports
274 );
275 }
276
277 for (i = 0; i < ahcd->num_ports; i++) {
278 temp = admhc_read_portstatus(ahcd, i);
279 dbg_port_sw(ahcd, i, temp, next, size);
280 }
281 }
282
283 static void admhc_dump(struct admhcd *ahcd, int verbose)
284 {
285 admhc_dbg(ahcd, "ADMHC ahcd state\n");
286
287 /* dumps some of the state we know about */
288 admhc_dump_status(ahcd, NULL, NULL);
289 admhc_dbg(ahcd, "current frame #%04x\n",
290 admhc_frame_no(ahcd));
291
292 admhc_dump_roothub(ahcd, verbose, NULL, NULL);
293 }
294
295 static const char data0[] = "DATA0";
296 static const char data1[] = "DATA1";
297
298 static void admhc_dump_td(const struct admhcd *ahcd, const char *label,
299 const struct td *td)
300 {
301 u32 tmp;
302
303 admhc_dbg(ahcd, "%s td %p; urb %p index %d; hwNextTD %08x\n",
304 label, td,
305 td->urb, td->index,
306 hc32_to_cpup(ahcd, &td->hwNextTD));
307
308 tmp = hc32_to_cpup(ahcd, &td->hwINFO);
309 admhc_dbg(ahcd, " status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n",
310 tmp,
311 (tmp & TD_OWN) ? " OWN" : "",
312 TD_CC_GET(tmp),
313 TD_EC_GET(tmp),
314 td_togglestring(tmp),
315 td_pidstring(tmp),
316 TD_ISI_GET(tmp),
317 TD_FN_GET(tmp));
318
319 tmp = hc32_to_cpup(ahcd, &td->hwCBL);
320 admhc_dbg(ahcd, " dbp %08x; cbl %08x; LEN=%d%s\n",
321 hc32_to_cpup(ahcd, &td->hwDBP),
322 tmp,
323 TD_BL_GET(tmp),
324 (tmp & TD_IE) ? " IE" : "");
325 }
326
327 /* caller MUST own hcd spinlock if verbose is set! */
328 static void __attribute__((unused))
329 admhc_dump_ed(const struct admhcd *ahcd, const char *label,
330 const struct ed *ed, int verbose)
331 {
332 u32 tmp = hc32_to_cpu(ahcd, ed->hwINFO);
333
334 admhc_dbg(ahcd, "%s ed %p %s type %s; next ed %08x\n",
335 label,
336 ed, ed_statestring(ed->state), ed_typestring(ed->type),
337 hc32_to_cpup(ahcd, &ed->hwNextED));
338
339 admhc_dbg(ahcd, " info %08x MAX=%d%s%s%s%s EP=%d DEV=%d\n", tmp,
340 ED_MPS_GET(tmp),
341 (tmp & ED_ISO) ? " ISO" : "",
342 (tmp & ED_SKIP) ? " SKIP" : "",
343 (tmp & ED_SPEED_FULL) ? " FULL" : " LOW",
344 (tmp & ED_INT) ? " INT" : "",
345 ED_EN_GET(tmp),
346 ED_FA_GET(tmp));
347
348 tmp = hc32_to_cpup(ahcd, &ed->hwHeadP);
349 admhc_dbg(ahcd, " tds: head %08x tail %08x %s%s%s\n",
350 tmp & TD_MASK,
351 hc32_to_cpup(ahcd, &ed->hwTailP),
352 (tmp & ED_C) ? data1 : data0,
353 (tmp & ED_H) ? " HALT" : "",
354 verbose ? " td list follows" : " (not listing)");
355
356 if (verbose) {
357 struct list_head *tmp;
358
359 /* use ed->td_list because HC concurrently modifies
360 * hwNextTD as it accumulates ed_donelist.
361 */
362 list_for_each(tmp, &ed->td_list) {
363 struct td *td;
364 td = list_entry(tmp, struct td, td_list);
365 admhc_dump_td(ahcd, " ->", td);
366 }
367 }
368 }
369
370 #else /* ifdef DEBUG */
371
372 static inline void urb_print(struct admhcd *ahcd, struct urb * urb, char * str,
373 int small, int status) {}
374 static inline void admhc_dump_ed(const struct admhcd *ahcd, const char *label,
375 const struct ed *ed, int verbose) {}
376 static inline void admhc_dump_td(const struct admhcd *ahcd, const char *label,
377 const struct td *td) {}
378 static inline void admhc_dump(struct admhcd *ahcd, int verbose) {}
379
380 #undef ADMHC_VERBOSE_DEBUG
381
382 #endif /* DEBUG */
383
384 /*-------------------------------------------------------------------------*/
385
386 #ifdef STUB_DEBUG_FILES
387
388 static inline void create_debug_files(struct admhcd *bus) { }
389 static inline void remove_debug_files(struct admhcd *bus) { }
390
391 #else
392
393 static int debug_async_open(struct inode *, struct file *);
394 static int debug_periodic_open(struct inode *, struct file *);
395 static int debug_registers_open(struct inode *, struct file *);
396 static ssize_t debug_output(struct file*, char __user*, size_t, loff_t*);
397 static int debug_close(struct inode *, struct file *);
398
399 static const struct file_operations debug_async_fops = {
400 .owner = THIS_MODULE,
401 .open = debug_async_open,
402 .read = debug_output,
403 .release = debug_close,
404 };
405 static const struct file_operations debug_periodic_fops = {
406 .owner = THIS_MODULE,
407 .open = debug_periodic_open,
408 .read = debug_output,
409 .release = debug_close,
410 };
411 static const struct file_operations debug_registers_fops = {
412 .owner = THIS_MODULE,
413 .open = debug_registers_open,
414 .read = debug_output,
415 .release = debug_close,
416 };
417
418 static struct dentry *admhc_debug_root;
419
420 struct debug_buffer {
421 ssize_t (*fill_func)(struct debug_buffer *); /* fill method */
422 struct device *dev;
423 struct mutex mutex; /* protect filling of buffer */
424 size_t count; /* number of characters filled into buffer */
425 char *page;
426 };
427
428 static ssize_t
429 show_list(struct admhcd *ahcd, char *buf, size_t count, struct ed *ed)
430 {
431 unsigned temp;
432 unsigned size = count;
433
434 if (!ed)
435 return 0;
436
437 /* dump a snapshot of the bulk or control schedule */
438 while (ed) {
439 u32 info = hc32_to_cpu(ahcd, ed->hwINFO);
440 u32 headp = hc32_to_cpu(ahcd, ed->hwHeadP);
441 u32 tailp = hc32_to_cpu(ahcd, ed->hwTailP);
442 struct list_head *entry;
443 struct td *td;
444
445 temp = scnprintf(buf, size,
446 "ed/%p %s %s %cs dev%d ep%d %s%smax %d %08x%s%s %s"
447 " h:%08x t:%08x",
448 ed,
449 ed_statestring(ed->state),
450 ed_typestring(ed->type),
451 (info & ED_SPEED_FULL) ? 'f' : 'l',
452 info & ED_FA_MASK,
453 (info >> ED_EN_SHIFT) & ED_EN_MASK,
454 (info & ED_INT) ? "INT " : "",
455 (info & ED_ISO) ? "ISO " : "",
456 (info >> ED_MPS_SHIFT) & ED_MPS_MASK ,
457 info,
458 (info & ED_SKIP) ? " S" : "",
459 (headp & ED_H) ? " H" : "",
460 (headp & ED_C) ? data1 : data0,
461 headp & ED_MASK, tailp);
462 size -= temp;
463 buf += temp;
464
465 list_for_each(entry, &ed->td_list) {
466 u32 dbp, cbl;
467
468 td = list_entry(entry, struct td, td_list);
469 info = hc32_to_cpup(ahcd, &td->hwINFO);
470 dbp = hc32_to_cpup(ahcd, &td->hwDBP);
471 cbl = hc32_to_cpup(ahcd, &td->hwCBL);
472
473 temp = scnprintf(buf, size,
474 "\n\ttd/%p %s %d %s%scc=%x urb %p (%08x,%08x)",
475 td,
476 td_pidstring(info),
477 TD_BL_GET(cbl),
478 (info & TD_OWN) ? "" : "DONE ",
479 (cbl & TD_IE) ? "IE " : "",
480 TD_CC_GET(info), td->urb, info, cbl);
481 size -= temp;
482 buf += temp;
483 }
484
485 temp = scnprintf(buf, size, "\n");
486 size -= temp;
487 buf += temp;
488
489 ed = ed->ed_next;
490 }
491
492 return count - size;
493 }
494
495 static ssize_t fill_async_buffer(struct debug_buffer *buf)
496 {
497 struct usb_bus *bus;
498 struct usb_hcd *hcd;
499 struct admhcd *ahcd;
500 size_t temp;
501 unsigned long flags;
502
503 bus = dev_get_drvdata(buf->dev);
504 hcd = bus_to_hcd(bus);
505 ahcd = hcd_to_admhcd(hcd);
506
507 spin_lock_irqsave(&ahcd->lock, flags);
508 temp = show_list(ahcd, buf->page, PAGE_SIZE, ahcd->ed_head);
509 spin_unlock_irqrestore(&ahcd->lock, flags);
510
511 return temp;
512 }
513
514
515 #define DBG_SCHED_LIMIT 64
516
517 static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
518 {
519 struct usb_bus *bus;
520 struct usb_hcd *hcd;
521 struct admhcd *ahcd;
522 struct ed **seen, *ed;
523 unsigned long flags;
524 unsigned temp, size, seen_count;
525 char *next;
526 unsigned i;
527
528 seen = kmalloc(DBG_SCHED_LIMIT * sizeof(*seen), GFP_ATOMIC);
529 if (!seen)
530 return 0;
531 seen_count = 0;
532
533 bus = dev_get_drvdata(buf->dev);
534 hcd = bus_to_hcd(bus);
535 ahcd = hcd_to_admhcd(hcd);
536 next = buf->page;
537 size = PAGE_SIZE;
538
539 temp = scnprintf(next, size, "size = %d\n", NUM_INTS);
540 size -= temp;
541 next += temp;
542
543 /* dump a snapshot of the periodic schedule (and load) */
544 spin_lock_irqsave(&ahcd->lock, flags);
545 for (i = 0; i < NUM_INTS; i++) {
546 ed = ahcd->periodic[i];
547 if (!ed)
548 continue;
549
550 temp = scnprintf(next, size, "%2d [%3d]:", i, ahcd->load[i]);
551 size -= temp;
552 next += temp;
553
554 do {
555 temp = scnprintf(next, size, " ed%d/%p",
556 ed->interval, ed);
557 size -= temp;
558 next += temp;
559 for (temp = 0; temp < seen_count; temp++) {
560 if (seen[temp] == ed)
561 break;
562 }
563
564 /* show more info the first time around */
565 if (temp == seen_count) {
566 u32 info = hc32_to_cpu(ahcd, ed->hwINFO);
567 struct list_head *entry;
568 unsigned qlen = 0;
569
570 /* qlen measured here in TDs, not urbs */
571 list_for_each(entry, &ed->td_list)
572 qlen++;
573 temp = scnprintf(next, size,
574 " (%cs dev%d ep%d%s qlen %u"
575 " max %d %08x%s%s)",
576 (info & ED_SPEED_FULL) ? 'f' : 'l',
577 ED_FA_GET(info),
578 ED_EN_GET(info),
579 (info & ED_ISO) ? "iso" : "int",
580 qlen,
581 ED_MPS_GET(info),
582 info,
583 (info & ED_SKIP) ? " K" : "",
584 (ed->hwHeadP &
585 cpu_to_hc32(ahcd, ED_H)) ?
586 " H" : "");
587 size -= temp;
588 next += temp;
589
590 if (seen_count < DBG_SCHED_LIMIT)
591 seen[seen_count++] = ed;
592
593 ed = ed->ed_next;
594
595 } else {
596 /* we've seen it and what's after */
597 temp = 0;
598 ed = NULL;
599 }
600
601 } while (ed);
602
603 temp = scnprintf(next, size, "\n");
604 size -= temp;
605 next += temp;
606 }
607 spin_unlock_irqrestore(&ahcd->lock, flags);
608 kfree(seen);
609
610 return PAGE_SIZE - size;
611 }
612
613
614 #undef DBG_SCHED_LIMIT
615
616 static ssize_t fill_registers_buffer(struct debug_buffer *buf)
617 {
618 struct usb_bus *bus;
619 struct usb_hcd *hcd;
620 struct admhcd *ahcd;
621 struct admhcd_regs __iomem *regs;
622 unsigned long flags;
623 unsigned temp, size;
624 char *next;
625 u32 rdata;
626
627 bus = dev_get_drvdata(buf->dev);
628 hcd = bus_to_hcd(bus);
629 ahcd = hcd_to_admhcd(hcd);
630 regs = ahcd->regs;
631 next = buf->page;
632 size = PAGE_SIZE;
633
634 spin_lock_irqsave(&ahcd->lock, flags);
635
636 /* dump driver info, then registers in spec order */
637
638 admhc_dbg_sw(ahcd, &next, &size,
639 "bus %s, device %s\n"
640 "%s\n"
641 "%s version " DRIVER_VERSION "\n",
642 hcd->self.controller->bus->name,
643 dev_name(hcd->self.controller),
644 hcd->product_desc,
645 hcd_name);
646
647 if (bus->controller->power.power_state.event) {
648 size -= scnprintf(next, size,
649 "SUSPENDED (no register access)\n");
650 goto done;
651 }
652
653 admhc_dump_status(ahcd, &next, &size);
654
655 /* other registers mostly affect frame timings */
656 rdata = admhc_readl(ahcd, &regs->fminterval);
657 temp = scnprintf(next, size,
658 "fmintvl 0x%08x %sFSLDP=0x%04x FI=0x%04x\n",
659 rdata, (rdata & ADMHC_SFI_FIT) ? "FIT " : "",
660 (rdata >> ADMHC_SFI_FSLDP_SHIFT) & ADMHC_SFI_FSLDP_MASK,
661 rdata & ADMHC_SFI_FI_MASK);
662 size -= temp;
663 next += temp;
664
665 rdata = admhc_readl(ahcd, &regs->fmnumber);
666 temp = scnprintf(next, size, "fmnumber 0x%08x %sFR=0x%04x FN=%04x\n",
667 rdata, (rdata & ADMHC_SFN_FRT) ? "FRT " : "",
668 (rdata >> ADMHC_SFN_FR_SHIFT) & ADMHC_SFN_FR_MASK,
669 rdata & ADMHC_SFN_FN_MASK);
670 size -= temp;
671 next += temp;
672
673 /* TODO: use predefined bitmask */
674 rdata = admhc_readl(ahcd, &regs->lsthresh);
675 temp = scnprintf(next, size, "lsthresh 0x%04x\n",
676 rdata & 0x3fff);
677 size -= temp;
678 next += temp;
679
680 temp = scnprintf(next, size, "hub poll timer: %s\n",
681 admhcd_to_hcd(ahcd)->poll_rh ? "ON" : "OFF");
682 size -= temp;
683 next += temp;
684
685 /* roothub */
686 admhc_dump_roothub(ahcd, 1, &next, &size);
687
688 done:
689 spin_unlock_irqrestore(&ahcd->lock, flags);
690 return PAGE_SIZE - size;
691 }
692
693
694 static struct debug_buffer *alloc_buffer(struct device *dev,
695 ssize_t (*fill_func)(struct debug_buffer *))
696 {
697 struct debug_buffer *buf;
698
699 buf = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL);
700
701 if (buf) {
702 buf->dev = dev;
703 buf->fill_func = fill_func;
704 mutex_init(&buf->mutex);
705 }
706
707 return buf;
708 }
709
710 static int fill_buffer(struct debug_buffer *buf)
711 {
712 int ret = 0;
713
714 if (!buf->page)
715 buf->page = (char *)get_zeroed_page(GFP_KERNEL);
716
717 if (!buf->page) {
718 ret = -ENOMEM;
719 goto out;
720 }
721
722 ret = buf->fill_func(buf);
723
724 if (ret >= 0) {
725 buf->count = ret;
726 ret = 0;
727 }
728
729 out:
730 return ret;
731 }
732
733 static ssize_t debug_output(struct file *file, char __user *user_buf,
734 size_t len, loff_t *offset)
735 {
736 struct debug_buffer *buf = file->private_data;
737 int ret = 0;
738
739 mutex_lock(&buf->mutex);
740 if (buf->count == 0) {
741 ret = fill_buffer(buf);
742 if (ret != 0) {
743 mutex_unlock(&buf->mutex);
744 goto out;
745 }
746 }
747 mutex_unlock(&buf->mutex);
748
749 ret = simple_read_from_buffer(user_buf, len, offset,
750 buf->page, buf->count);
751
752 out:
753 return ret;
754 }
755
756 static int debug_close(struct inode *inode, struct file *file)
757 {
758 struct debug_buffer *buf = file->private_data;
759
760 if (buf) {
761 if (buf->page)
762 free_page((unsigned long)buf->page);
763 kfree(buf);
764 }
765
766 return 0;
767 }
768
769 static int debug_async_open(struct inode *inode, struct file *file)
770 {
771 file->private_data = alloc_buffer(inode->i_private, fill_async_buffer);
772
773 return file->private_data ? 0 : -ENOMEM;
774 }
775
776 static int debug_periodic_open(struct inode *inode, struct file *file)
777 {
778 file->private_data = alloc_buffer(inode->i_private,
779 fill_periodic_buffer);
780
781 return file->private_data ? 0 : -ENOMEM;
782 }
783
784 static int debug_registers_open(struct inode *inode, struct file *file)
785 {
786 file->private_data = alloc_buffer(inode->i_private,
787 fill_registers_buffer);
788
789 return file->private_data ? 0 : -ENOMEM;
790 }
791
792 static inline void create_debug_files(struct admhcd *ahcd)
793 {
794 struct usb_bus *bus = &admhcd_to_hcd(ahcd)->self;
795 struct device *dev = bus->dev;
796
797 ahcd->debug_dir = debugfs_create_dir(bus->bus_name, admhc_debug_root);
798 if (!ahcd->debug_dir)
799 goto dir_error;
800
801 ahcd->debug_async = debugfs_create_file("async", S_IRUGO,
802 ahcd->debug_dir, dev,
803 &debug_async_fops);
804 if (!ahcd->debug_async)
805 goto async_error;
806
807 ahcd->debug_periodic = debugfs_create_file("periodic", S_IRUGO,
808 ahcd->debug_dir, dev,
809 &debug_periodic_fops);
810 if (!ahcd->debug_periodic)
811 goto periodic_error;
812
813 ahcd->debug_registers = debugfs_create_file("registers", S_IRUGO,
814 ahcd->debug_dir, dev,
815 &debug_registers_fops);
816 if (!ahcd->debug_registers)
817 goto registers_error;
818
819 admhc_dbg(ahcd, "created debug files\n");
820 return;
821
822 registers_error:
823 debugfs_remove(ahcd->debug_periodic);
824 periodic_error:
825 debugfs_remove(ahcd->debug_async);
826 async_error:
827 debugfs_remove(ahcd->debug_dir);
828 dir_error:
829 ahcd->debug_periodic = NULL;
830 ahcd->debug_async = NULL;
831 ahcd->debug_dir = NULL;
832 }
833
834 static inline void remove_debug_files(struct admhcd *ahcd)
835 {
836 debugfs_remove(ahcd->debug_registers);
837 debugfs_remove(ahcd->debug_periodic);
838 debugfs_remove(ahcd->debug_async);
839 debugfs_remove(ahcd->debug_dir);
840 }
841
842 #endif
843
844 /*-------------------------------------------------------------------------*/
Personal OpenWRT clone
This page took 0.087234 seconds and 5 git commands to generate.