[adm5120] USB driver updates, the driver passes usbtests 1-10 now
[openwrt/svn-archive/archive.git] / target / linux / adm5120 / files / drivers / usb / host / adm5120-dbg.c
1 /*
2 * OHCI HCD (Host Controller Driver) for USB.
3 *
4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
6 *
7 * This file is licenced under the GPL.
8 */
9
10 /*-------------------------------------------------------------------------*/
11
12 static inline char *ed_typestring(int ed_type)
13 {
14 switch (ed_type) {
15 case PIPE_CONTROL:
16 return "ctrl";
17 case PIPE_BULK:
18 return "bulk";
19 case PIPE_INTERRUPT:
20 return "intr";
21 case PIPE_ISOCHRONOUS:
22 return "isoc";
23 }
24 return "(bad ed_type)";
25 }
26
27 static inline char *ed_statestring(int state)
28 {
29 switch (state) {
30 case ED_IDLE:
31 return "IDLE";
32 case ED_UNLINK:
33 return "UNLINK";
34 case ED_OPER:
35 return "OPER";
36 }
37 return "?STATE";
38 }
39
40 static inline char *pipestring(int pipe)
41 {
42 return ed_typestring(usb_pipetype(pipe));
43 }
44
45 static inline char *td_pidstring(u32 info)
46 {
47 switch (info & TD_DP) {
48 case TD_DP_SETUP:
49 return "SETUP";
50 case TD_DP_IN:
51 return "IN";
52 case TD_DP_OUT:
53 return "OUT";
54 }
55 return "?PID";
56 }
57
58 static inline char *td_togglestring(u32 info)
59 {
60 switch (info & TD_T) {
61 case TD_T_DATA0:
62 return "DATA0";
63 case TD_T_DATA1:
64 return "DATA1";
65 case TD_T_CARRY:
66 return "CARRY";
67 }
68 return "?TOGGLE";
69 }
70
71 /*-------------------------------------------------------------------------*/
72
73 #ifdef DEBUG
74
75 /* debug| print the main components of an URB
76 * small: 0) header + data packets 1) just header
77 */
78 static void __attribute__((unused))
79 urb_print(struct admhcd *ahcd, struct urb *urb, char * str, int small)
80 {
81 unsigned int pipe = urb->pipe;
82
83 if (!urb->dev || !urb->dev->bus) {
84 admhc_dbg("%s URB: no dev", str);
85 return;
86 }
87
88 #ifndef ADMHC_VERBOSE_DEBUG
89 if (urb->status != 0)
90 #endif
91 admhc_dbg(ahcd, "URB-%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d "
92 "stat=%d",
93 str,
94 urb,
95 usb_pipedevice (pipe),
96 usb_pipeendpoint (pipe),
97 usb_pipeout(pipe)? "out" : "in",
98 pipestring(pipe),
99 urb->transfer_flags,
100 urb->actual_length,
101 urb->transfer_buffer_length,
102 urb->status);
103
104 #ifdef ADMHC_VERBOSE_DEBUG
105 if (!small) {
106 int i, len;
107
108 if (usb_pipecontrol(pipe)) {
109 admhc_dbg(ahcd, "setup(8):");
110 for (i = 0; i < 8 ; i++)
111 printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
112 printk ("\n");
113 }
114 if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
115 printk(KERN_DEBUG __FILE__ ": data(%d/%d):",
116 urb->actual_length,
117 urb->transfer_buffer_length);
118 len = usb_pipeout(pipe)?
119 urb->transfer_buffer_length: urb->actual_length;
120 for (i = 0; i < 16 && i < len; i++)
121 printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
122 admhc_dbg("%s stat:%d\n", i < len? "...": "", urb->status);
123 }
124 }
125 #endif /* ADMHC_VERBOSE_DEBUG */
126 }
127
128 #define admhc_dbg_sw(ahcd, next, size, format, arg...) \
129 do { \
130 if (next) { \
131 unsigned s_len; \
132 s_len = scnprintf(*next, *size, format, ## arg ); \
133 *size -= s_len; *next += s_len; \
134 } else \
135 admhc_dbg(ahcd,format, ## arg ); \
136 } while (0);
137
138
139 static void admhc_dump_intr_mask(struct admhcd *ahcd, char *label, u32 mask,
140 char **next, unsigned *size)
141 {
142 admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n",
143 label,
144 mask,
145 (mask & ADMHC_INTR_INTA) ? " INTA" : "",
146 (mask & ADMHC_INTR_FATI) ? " FATI" : "",
147 (mask & ADMHC_INTR_SWI) ? " SWI" : "",
148 (mask & ADMHC_INTR_TDC) ? " TDC" : "",
149 (mask & ADMHC_INTR_FNO) ? " FNO" : "",
150 (mask & ADMHC_INTR_SO) ? " SO" : "",
151 (mask & ADMHC_INTR_INSM) ? " INSM" : "",
152 (mask & ADMHC_INTR_BABI) ? " BABI" : "",
153 (mask & ADMHC_INTR_7) ? " !7!" : "",
154 (mask & ADMHC_INTR_6) ? " !6!" : "",
155 (mask & ADMHC_INTR_RESI) ? " RESI" : "",
156 (mask & ADMHC_INTR_SOFI) ? " SOFI" : ""
157 );
158 }
159
160 static void maybe_print_eds(struct admhcd *ahcd, char *label, u32 value,
161 char **next, unsigned *size)
162 {
163 if (value)
164 admhc_dbg_sw(ahcd, next, size, "%s %08x\n", label, value);
165 }
166
167 static char *buss2string (int state)
168 {
169 switch (state) {
170 case ADMHC_BUSS_RESET:
171 return "reset";
172 case ADMHC_BUSS_RESUME:
173 return "resume";
174 case ADMHC_BUSS_OPER:
175 return "operational";
176 case ADMHC_BUSS_SUSPEND:
177 return "suspend";
178 }
179 return "?state";
180 }
181
182 static void
183 admhc_dump_status(struct admhcd *ahcd, char **next, unsigned *size)
184 {
185 struct admhcd_regs __iomem *regs = ahcd->regs;
186 u32 temp;
187
188 temp = admhc_readl(ahcd, &regs->gencontrol);
189 admhc_dbg_sw(ahcd, next, size,
190 "gencontrol 0x%08x%s%s%s%s\n",
191 temp,
192 (temp & ADMHC_CTRL_UHFE) ? " UHFE" : "",
193 (temp & ADMHC_CTRL_SIR) ? " SIR" : "",
194 (temp & ADMHC_CTRL_DMAA) ? " DMAA" : "",
195 (temp & ADMHC_CTRL_SR) ? " SR" : ""
196 );
197
198 temp = admhc_readl(ahcd, &regs->host_control);
199 admhc_dbg_sw(ahcd, next, size,
200 "host_control 0x%08x BUSS=%s%s\n",
201 temp,
202 buss2string(temp & ADMHC_HC_BUSS),
203 (temp & ADMHC_HC_DMAE) ? " DMAE" : ""
204 );
205
206 admhc_dump_intr_mask(ahcd, "int_status",
207 admhc_readl(ahcd, &regs->int_status),
208 next, size);
209 admhc_dump_intr_mask(ahcd, "int_enable",
210 admhc_readl(ahcd, &regs->int_enable),
211 next, size);
212
213 maybe_print_eds(ahcd, "hosthead",
214 admhc_readl(ahcd, &regs->hosthead), next, size);
215 }
216
217 #define dbg_port_sw(hc,num,value,next,size) \
218 admhc_dbg_sw(hc, next, size, \
219 "portstatus [%d] " \
220 "0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
221 num, temp, \
222 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
223 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
224 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
225 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
226 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
227 \
228 (temp & ADMHC_PS_LSDA) ? " LSDA" : "", \
229 (temp & ADMHC_PS_PPS) ? " PPS" : "", \
230 (temp & ADMHC_PS_PRS) ? " PRS" : "", \
231 (temp & ADMHC_PS_POCI) ? " POCI" : "", \
232 (temp & ADMHC_PS_PSS) ? " PSS" : "", \
233 \
234 (temp & ADMHC_PS_PES) ? " PES" : "", \
235 (temp & ADMHC_PS_CCS) ? " CCS" : "" \
236 );
237
238
239 static void
240 admhc_dump_roothub(
241 struct admhcd *ahcd,
242 int verbose,
243 char **next,
244 unsigned *size)
245 {
246 u32 temp, i;
247
248 temp = admhc_read_rhdesc(ahcd);
249 if (temp == ~(u32)0)
250 return;
251
252 if (verbose) {
253 admhc_dbg_sw(ahcd, next, size,
254 "rhdesc %08x%s%s%s%s%s%s PPCM=%02x%s%s%s%s NUMP=%d(%d)\n",
255 temp,
256 (temp & ADMHC_RH_CRWE) ? " CRWE" : "",
257 (temp & ADMHC_RH_OCIC) ? " OCIC" : "",
258 (temp & ADMHC_RH_LPSC) ? " LPSC" : "",
259 (temp & ADMHC_RH_LPSC) ? " DRWE" : "",
260 (temp & ADMHC_RH_LPSC) ? " OCI" : "",
261 (temp & ADMHC_RH_LPSC) ? " LPS" : "",
262 ((temp & ADMHC_RH_PPCM) >> 16),
263 (temp & ADMHC_RH_NOCP) ? " NOCP" : "",
264 (temp & ADMHC_RH_OCPM) ? " OCPM" : "",
265 (temp & ADMHC_RH_NPS) ? " NPS" : "",
266 (temp & ADMHC_RH_PSM) ? " PSM" : "",
267 (temp & ADMHC_RH_NUMP), ahcd->num_ports
268 );
269 }
270
271 for (i = 0; i < ahcd->num_ports; i++) {
272 temp = admhc_read_portstatus(ahcd, i);
273 dbg_port_sw(ahcd, i, temp, next, size);
274 }
275 }
276
277 static void admhc_dump(struct admhcd *ahcd, int verbose)
278 {
279 admhc_dbg(ahcd, "ADMHC ahcd state\n");
280
281 /* dumps some of the state we know about */
282 admhc_dump_status(ahcd, NULL, NULL);
283 admhc_dbg(ahcd,"current frame #%04x\n",
284 admhc_frame_no(ahcd));
285
286 admhc_dump_roothub(ahcd, verbose, NULL, NULL);
287 }
288
289 static const char data0[] = "DATA0";
290 static const char data1[] = "DATA1";
291
292 static void admhc_dump_td(const struct admhcd *ahcd, const char *label,
293 const struct td *td)
294 {
295 u32 tmp;
296
297 admhc_dbg(ahcd, "%s td %p; urb %p index %d; hwNextTD %08x\n",
298 label, td,
299 td->urb, td->index,
300 hc32_to_cpup(ahcd, &td->hwNextTD));
301
302 tmp = hc32_to_cpup(ahcd, &td->hwINFO);
303 admhc_dbg(ahcd, " status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n",
304 tmp,
305 (tmp & TD_OWN) ? " OWN" : "",
306 TD_CC_GET(tmp),
307 TD_EC_GET(tmp),
308 td_togglestring(tmp),
309 td_pidstring(tmp),
310 TD_ISI_GET(tmp),
311 TD_FN_GET(tmp));
312
313 tmp = hc32_to_cpup(ahcd, &td->hwCBL);
314 admhc_dbg(ahcd, " dbp %08x; cbl %08x; LEN=%d%s\n",
315 hc32_to_cpup(ahcd, &td->hwDBP),
316 tmp,
317 TD_BL_GET(tmp),
318 (tmp & TD_IE) ? " IE" : "");
319 }
320
321 /* caller MUST own hcd spinlock if verbose is set! */
322 static void __attribute__((unused))
323 admhc_dump_ed(const struct admhcd *ahcd, const char *label,
324 const struct ed *ed, int verbose)
325 {
326 u32 tmp = hc32_to_cpu(ahcd, ed->hwINFO);
327
328 admhc_dbg(ahcd, "%s ed %p %s type %s; next ed %08x\n",
329 label,
330 ed, ed_statestring(ed->state), ed_typestring(ed->type),
331 hc32_to_cpup(ahcd, &ed->hwNextED));
332
333 admhc_dbg(ahcd, " info %08x MAX=%d%s%s%s%s EP=%d DEV=%d\n", tmp,
334 ED_MPS_GET(tmp),
335 (tmp & ED_ISO) ? " ISO" : "",
336 (tmp & ED_SKIP) ? " SKIP" : "",
337 (tmp & ED_SPEED_FULL) ? " FULL" : " LOW",
338 (tmp & ED_INT) ? " INT" : "",
339 ED_EN_GET(tmp),
340 ED_FA_GET(tmp));
341
342 tmp = hc32_to_cpup(ahcd, &ed->hwHeadP);
343 admhc_dbg(ahcd, " tds: head %08x tail %08x %s%s%s\n",
344 tmp & TD_MASK,
345 hc32_to_cpup (ahcd, &ed->hwTailP),
346 (tmp & ED_C) ? data1 : data0,
347 (tmp & ED_H) ? " HALT" : "",
348 verbose ? " td list follows" : " (not listing)");
349
350 if (verbose) {
351 struct list_head *tmp;
352
353 /* use ed->td_list because HC concurrently modifies
354 * hwNextTD as it accumulates ed_donelist.
355 */
356 list_for_each(tmp, &ed->td_list) {
357 struct td *td;
358 td = list_entry(tmp, struct td, td_list);
359 admhc_dump_td (ahcd, " ->", td);
360 }
361 }
362 }
363
364 #else /* ifdef DEBUG */
365
366 static inline void urb_print(struct urb * urb, char * str, int small) {}
367 static inline void admhc_dump_ed(const struct admhcd *ahcd, const char *label,
368 const struct ed *ed, int verbose) {}
369 static inline void admhc_dump_td(const struct admhcd *ahcd, const char *label,
370 const struct td *td) {}
371 static inline void admhc_dump(struct admhcd *ahcd, int verbose) {}
372
373 #undef ADMHC_VERBOSE_DEBUG
374
375 #endif /* DEBUG */
376
377 /*-------------------------------------------------------------------------*/
378
379 #ifdef STUB_DEBUG_FILES
380
381 static inline void create_debug_files(struct admhcd *bus) { }
382 static inline void remove_debug_files(struct admhcd *bus) { }
383
384 #else
385
386 static ssize_t
387 show_list(struct admhcd *ahcd, char *buf, size_t count, struct ed *ed)
388 {
389 unsigned temp, size = count;
390
391 if (!ed)
392 return 0;
393
394 /* dump a snapshot of the bulk or control schedule */
395 while (ed) {
396 u32 info = hc32_to_cpu(ahcd, ed->hwINFO);
397 u32 headp = hc32_to_cpu(ahcd, ed->hwHeadP);
398 u32 tailp = hc32_to_cpu(ahcd, ed->hwTailP);
399 struct list_head *entry;
400 struct td *td;
401
402 temp = scnprintf(buf, size,
403 "ed/%p %s %s %cs dev%d ep%d %s%smax %d %08x%s%s %s"
404 " h:%08x t:%08x",
405 ed,
406 ed_statestring(ed->state),
407 ed_typestring (ed->type),
408 (info & ED_SPEED_FULL) ? 'f' : 'l',
409 info & ED_FA_MASK,
410 (info >> ED_EN_SHIFT) & ED_EN_MASK,
411 (info & ED_INT) ? "INT " : "",
412 (info & ED_ISO) ? "ISO " : "",
413 (info >> ED_MPS_SHIFT) & ED_MPS_MASK ,
414 info,
415 (info & ED_SKIP) ? " S" : "",
416 (headp & ED_H) ? " H" : "",
417 (headp & ED_C) ? data1 : data0,
418 headp & ED_MASK,tailp);
419 size -= temp;
420 buf += temp;
421
422 list_for_each(entry, &ed->td_list) {
423 u32 dbp, cbl;
424
425 td = list_entry(entry, struct td, td_list);
426 info = hc32_to_cpup (ahcd, &td->hwINFO);
427 dbp = hc32_to_cpup (ahcd, &td->hwDBP);
428 cbl = hc32_to_cpup (ahcd, &td->hwCBL);
429
430 temp = scnprintf(buf, size,
431 "\n\ttd/%p %s %d %s%scc=%x urb %p (%08x,%08x)",
432 td,
433 td_pidstring(info),
434 TD_BL_GET(cbl),
435 (info & TD_OWN) ? "" : "DONE ",
436 (cbl & TD_IE) ? "IE " : "",
437 TD_CC_GET (info), td->urb, info, cbl);
438 size -= temp;
439 buf += temp;
440 }
441
442 temp = scnprintf(buf, size, "\n");
443 size -= temp;
444 buf += temp;
445
446 ed = ed->ed_next;
447 }
448 return count - size;
449 }
450
451 static ssize_t
452 show_async(struct class_device *class_dev, char *buf)
453 {
454 struct usb_bus *bus;
455 struct usb_hcd *hcd;
456 struct admhcd *ahcd;
457 size_t temp;
458 unsigned long flags;
459
460 bus = class_get_devdata(class_dev);
461 hcd = bus_to_hcd(bus);
462 ahcd = hcd_to_admhcd(hcd);
463
464 /* display control and bulk lists together, for simplicity */
465 spin_lock_irqsave(&ahcd->lock, flags);
466 temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head);
467 spin_unlock_irqrestore(&ahcd->lock, flags);
468
469 return temp;
470 }
471 static CLASS_DEVICE_ATTR(async, S_IRUGO, show_async, NULL);
472
473
474 #define DBG_SCHED_LIMIT 64
475
476 static ssize_t
477 show_periodic(struct class_device *class_dev, char *buf)
478 {
479 struct usb_bus *bus;
480 struct usb_hcd *hcd;
481 struct admhcd *ahcd;
482 struct ed **seen, *ed;
483 unsigned long flags;
484 unsigned temp, size, seen_count;
485 char *next;
486 unsigned i;
487
488 if (!(seen = kmalloc(DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC)))
489 return 0;
490 seen_count = 0;
491
492 bus = class_get_devdata(class_dev);
493 hcd = bus_to_hcd(bus);
494 ahcd = hcd_to_admhcd(hcd);
495 next = buf;
496 size = PAGE_SIZE;
497
498 temp = scnprintf(next, size, "size = %d\n", NUM_INTS);
499 size -= temp;
500 next += temp;
501
502 /* dump a snapshot of the periodic schedule (and load) */
503 spin_lock_irqsave(&ahcd->lock, flags);
504 for (i = 0; i < NUM_INTS; i++) {
505 if (!(ed = ahcd->periodic [i]))
506 continue;
507
508 temp = scnprintf(next, size, "%2d [%3d]:", i, ahcd->load [i]);
509 size -= temp;
510 next += temp;
511
512 do {
513 temp = scnprintf(next, size, " ed%d/%p",
514 ed->interval, ed);
515 size -= temp;
516 next += temp;
517 for (temp = 0; temp < seen_count; temp++) {
518 if (seen [temp] == ed)
519 break;
520 }
521
522 /* show more info the first time around */
523 if (temp == seen_count) {
524 u32 info = hc32_to_cpu (ahcd, ed->hwINFO);
525 struct list_head *entry;
526 unsigned qlen = 0;
527
528 /* qlen measured here in TDs, not urbs */
529 list_for_each (entry, &ed->td_list)
530 qlen++;
531 temp = scnprintf(next, size,
532 " (%cs dev%d ep%d%s qlen %u"
533 " max %d %08x%s%s)",
534 (info & ED_SPEED_FULL) ? 'f' : 'l',
535 ED_FA_GET(info),
536 ED_EN_GET(info),
537 (info & ED_ISO) ? "iso" : "int",
538 qlen,
539 ED_MPS_GET(info),
540 info,
541 (info & ED_SKIP) ? " K" : "",
542 (ed->hwHeadP &
543 cpu_to_hc32(ahcd, ED_H)) ?
544 " H" : "");
545 size -= temp;
546 next += temp;
547
548 if (seen_count < DBG_SCHED_LIMIT)
549 seen [seen_count++] = ed;
550
551 ed = ed->ed_next;
552
553 } else {
554 /* we've seen it and what's after */
555 temp = 0;
556 ed = NULL;
557 }
558
559 } while (ed);
560
561 temp = scnprintf(next, size, "\n");
562 size -= temp;
563 next += temp;
564 }
565 spin_unlock_irqrestore(&ahcd->lock, flags);
566 kfree (seen);
567
568 return PAGE_SIZE - size;
569 }
570 static CLASS_DEVICE_ATTR(periodic, S_IRUGO, show_periodic, NULL);
571
572
573 #undef DBG_SCHED_LIMIT
574
575 static ssize_t
576 show_registers(struct class_device *class_dev, char *buf)
577 {
578 struct usb_bus *bus;
579 struct usb_hcd *hcd;
580 struct admhcd *ahcd;
581 struct admhcd_regs __iomem *regs;
582 unsigned long flags;
583 unsigned temp, size;
584 char *next;
585 u32 rdata;
586
587 bus = class_get_devdata(class_dev);
588 hcd = bus_to_hcd(bus);
589 ahcd = hcd_to_admhcd(hcd);
590 regs = ahcd->regs;
591 next = buf;
592 size = PAGE_SIZE;
593
594 spin_lock_irqsave(&ahcd->lock, flags);
595
596 /* dump driver info, then registers in spec order */
597
598 admhc_dbg_sw(ahcd, &next, &size,
599 "bus %s, device %s\n"
600 "%s\n"
601 "%s version " DRIVER_VERSION "\n",
602 hcd->self.controller->bus->name,
603 hcd->self.controller->bus_id,
604 hcd->product_desc,
605 hcd_name);
606
607 if (bus->controller->power.power_state.event) {
608 size -= scnprintf(next, size,
609 "SUSPENDED (no register access)\n");
610 goto done;
611 }
612
613 admhc_dump_status(ahcd, &next, &size);
614
615 /* other registers mostly affect frame timings */
616 rdata = admhc_readl(ahcd, &regs->fminterval);
617 temp = scnprintf(next, size,
618 "fmintvl 0x%08x %sFSLDP=0x%04x FI=0x%04x\n",
619 rdata, (rdata & ADMHC_SFI_FIT) ? "FIT " : "",
620 (rdata >> ADMHC_SFI_FSLDP_SHIFT) & ADMHC_SFI_FSLDP_MASK,
621 rdata & ADMHC_SFI_FI_MASK);
622 size -= temp;
623 next += temp;
624
625 rdata = admhc_readl(ahcd, &regs->fmnumber);
626 temp = scnprintf(next, size, "fmnumber 0x%08x %sFR=0x%04x FN=%04x\n",
627 rdata, (rdata & ADMHC_SFN_FRT) ? "FRT " : "",
628 (rdata >> ADMHC_SFN_FR_SHIFT) & ADMHC_SFN_FR_MASK,
629 rdata & ADMHC_SFN_FN_MASK);
630 size -= temp;
631 next += temp;
632
633 /* TODO: use predefined bitmask */
634 rdata = admhc_readl(ahcd, &regs->lsthresh);
635 temp = scnprintf(next, size, "lsthresh 0x%04x\n",
636 rdata & 0x3fff);
637 size -= temp;
638 next += temp;
639
640 temp = scnprintf(next, size, "hub poll timer: %s\n",
641 admhcd_to_hcd(ahcd)->poll_rh ? "ON" : "OFF");
642 size -= temp;
643 next += temp;
644
645 /* roothub */
646 admhc_dump_roothub(ahcd, 1, &next, &size);
647
648 done:
649 spin_unlock_irqrestore(&ahcd->lock, flags);
650 return PAGE_SIZE - size;
651 }
652 static CLASS_DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
653
654
655 static inline void create_debug_files (struct admhcd *ahcd)
656 {
657 struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
658 int retval;
659
660 retval = class_device_create_file(cldev, &class_device_attr_async);
661 retval = class_device_create_file(cldev, &class_device_attr_periodic);
662 retval = class_device_create_file(cldev, &class_device_attr_registers);
663 admhc_dbg(ahcd, "created debug files\n");
664 }
665
666 static inline void remove_debug_files (struct admhcd *ahcd)
667 {
668 struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
669
670 class_device_remove_file(cldev, &class_device_attr_async);
671 class_device_remove_file(cldev, &class_device_attr_periodic);
672 class_device_remove_file(cldev, &class_device_attr_registers);
673 }
674
675 #endif
676
677 /*-------------------------------------------------------------------------*/
678