2 * OHCI HCD (Host Controller Driver) for USB.
4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
7 * This file is licenced under the GPL.
10 /*-------------------------------------------------------------------------*/
14 #define edstring(ed_type) ({ char *temp; \
16 case PIPE_CONTROL: temp = "ctrl"; break; \
17 case PIPE_BULK: temp = "bulk"; break; \
18 case PIPE_INTERRUPT: temp = "intr"; break; \
19 default: temp = "isoc"; break; \
21 #define pipestring(pipe) edstring(usb_pipetype(pipe))
23 /* debug| print the main components of an URB
24 * small: 0) header + data packets 1) just header
26 static void __attribute__((unused))
27 urb_print(struct urb * urb, char * str, int small)
29 unsigned int pipe= urb->pipe;
31 if (!urb->dev || !urb->dev->bus) {
32 dbg("%s URB: no dev", str);
36 #ifndef ADMHC_VERBOSE_DEBUG
39 dbg("%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d",
42 usb_pipedevice (pipe),
43 usb_pipeendpoint (pipe),
44 usb_pipeout(pipe)? "out" : "in",
48 urb->transfer_buffer_length,
51 #ifdef ADMHC_VERBOSE_DEBUG
55 if (usb_pipecontrol(pipe)) {
56 printk(KERN_DEBUG __FILE__ ": setup(8):");
57 for (i = 0; i < 8 ; i++)
58 printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
61 if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
62 printk(KERN_DEBUG __FILE__ ": data(%d/%d):",
64 urb->transfer_buffer_length);
65 len = usb_pipeout(pipe)?
66 urb->transfer_buffer_length: urb->actual_length;
67 for (i = 0; i < 16 && i < len; i++)
68 printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
69 printk ("%s stat:%d\n", i < len? "...": "", urb->status);
72 #endif /* ADMHC_VERBOSE_DEBUG */
75 #define admhc_dbg_sw(ahcd, next, size, format, arg...) \
79 s_len = scnprintf(*next, *size, format, ## arg ); \
80 *size -= s_len; *next += s_len; \
82 admhc_dbg(ahcd,format, ## arg ); \
86 static void admhc_dump_intr_mask (
93 admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s\n",
96 (mask & ADMHC_INTR_INTA) ? " INTA" : "",
97 (mask & ADMHC_INTR_FATI) ? " FATI" : "",
98 (mask & ADMHC_INTR_SWI) ? " SWI" : "",
99 (mask & ADMHC_INTR_TDC) ? " TDC" : "",
100 (mask & ADMHC_INTR_FNO) ? " FNO" : "",
101 (mask & ADMHC_INTR_SO) ? " SO" : "",
102 (mask & ADMHC_INTR_INSM) ? " INSM" : "",
103 (mask & ADMHC_INTR_BABI) ? " BABI" : "",
104 (mask & ADMHC_INTR_RESI) ? " RESI" : "",
105 (mask & ADMHC_INTR_SOFI) ? " SOFI" : ""
109 static void maybe_print_eds (
117 admhc_dbg_sw(ahcd, next, size, "%s %08x\n", label, value);
120 static char *buss2string (int state)
123 case ADMHC_BUSS_RESET:
125 case ADMHC_BUSS_RESUME:
127 case ADMHC_BUSS_OPER:
128 return "operational";
129 case ADMHC_BUSS_SUSPEND:
132 return "(bad state)";
136 admhc_dump_status(struct admhcd *ahcd, char **next, unsigned *size)
138 struct admhcd_regs __iomem *regs = ahcd->regs;
141 temp = admhc_readl(ahcd, ®s->gencontrol);
142 admhc_dbg_sw(ahcd, next, size,
143 "gencontrol 0x%08x%s%s%s%s\n",
145 (temp & ADMHC_CTRL_UHFE) ? " UHFE" : "",
146 (temp & ADMHC_CTRL_SIR) ? " SIR" : "",
147 (temp & ADMHC_CTRL_DMAA) ? " DMAA" : "",
148 (temp & ADMHC_CTRL_SR) ? " SR" : ""
151 temp = admhc_readl(ahcd, ®s->host_control);
152 admhc_dbg_sw(ahcd, next, size,
153 "host_control 0x%08x BUSS=%s%s\n",
155 buss2string (temp & ADMHC_HC_BUSS),
156 (temp & ADMHC_HC_DMAE) ? " DMAE" : ""
159 admhc_dump_intr_mask(ahcd, "int_status",
160 admhc_readl(ahcd, ®s->int_status),
162 admhc_dump_intr_mask(ahcd, "int_enable",
163 admhc_readl(ahcd, ®s->int_enable),
166 maybe_print_eds(ahcd, "hosthead",
167 admhc_readl(ahcd, ®s->hosthead), next, size);
170 #define dbg_port_sw(hc,num,value,next,size) \
171 admhc_dbg_sw(hc, next, size, \
173 "0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
175 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
176 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
177 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
178 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
179 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
181 (temp & ADMHC_PS_LSDA) ? " LSDA" : "", \
182 (temp & ADMHC_PS_PPS) ? " PPS" : "", \
183 (temp & ADMHC_PS_PRS) ? " PRS" : "", \
184 (temp & ADMHC_PS_POCI) ? " POCI" : "", \
185 (temp & ADMHC_PS_PSS) ? " PSS" : "", \
187 (temp & ADMHC_PS_PES) ? " PES" : "", \
188 (temp & ADMHC_PS_CCS) ? " CCS" : "" \
201 temp = admhc_get_rhdesc(ahcd);
206 admhc_dbg_sw(ahcd, next, size,
207 "rhdesc %08x%s%s%s%s%s%s PPCM=%02x%s%s%s%s NUMP=%d(%d)\n",
209 (temp & ADMHC_RH_CRWE) ? " CRWE" : "",
210 (temp & ADMHC_RH_OCIC) ? " OCIC" : "",
211 (temp & ADMHC_RH_LPSC) ? " LPSC" : "",
212 (temp & ADMHC_RH_LPSC) ? " DRWE" : "",
213 (temp & ADMHC_RH_LPSC) ? " OCI" : "",
214 (temp & ADMHC_RH_LPSC) ? " LPS" : "",
215 ((temp & ADMHC_RH_PPCM) >> 16),
216 (temp & ADMHC_RH_NOCP) ? " NOCP" : "",
217 (temp & ADMHC_RH_OCPM) ? " OCPM" : "",
218 (temp & ADMHC_RH_NPS) ? " NPS" : "",
219 (temp & ADMHC_RH_PSM) ? " PSM" : "",
220 (temp & ADMHC_RH_NUMP), ahcd->num_ports
224 for (i = 0; i < ahcd->num_ports; i++) {
225 temp = admhc_get_portstatus(ahcd, i);
226 dbg_port_sw(ahcd, i, temp, next, size);
230 static void admhc_dump(struct admhcd *ahcd, int verbose)
232 admhc_dbg(ahcd, "ADMHC ahcd state\n");
234 /* dumps some of the state we know about */
235 admhc_dump_status(ahcd, NULL, NULL);
236 admhc_dbg(ahcd,"current frame #%04x\n",
237 admhc_frame_no(ahcd));
239 admhc_dump_roothub(ahcd, verbose, NULL, NULL);
242 static const char data0[] = "DATA0";
243 static const char data1[] = "DATA1";
245 static void admhc_dump_td(const struct admhcd *ahcd, const char *label,
248 u32 tmp = hc32_to_cpup(ahcd, &td->hwINFO);
250 admhc_dbg(ahcd, "%s td %p; urb %p index %d; hwNextTD %08x\n",
253 hc32_to_cpup(ahcd, &td->hwNextTD));
255 if ((td->flags & TD_FLAG_ISO) == 0) {
256 const char *toggle, *pid;
258 switch (tmp & TD_T) {
259 case TD_T_DATA0: toggle = data0; break;
260 case TD_T_DATA1: toggle = data1; break;
261 case TD_T_CARRY: toggle = "CARRY"; break;
262 default: toggle = "(bad toggle)"; break;
264 switch (tmp & TD_DP) {
265 case TD_DP_SETUP: pid = "SETUP"; break;
266 case TD_DP_IN: pid = "IN"; break;
267 case TD_DP_OUT: pid = "OUT"; break;
268 default: pid = "(bad pid)"; break;
271 " status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n",
273 (tmp & TD_OWN) ? " OWN" : "",
281 #if 0 /* TODO: remove */
283 admhc_dbg(ahcd, " info %08x CC=%x FC=%d DI=%d SF=%04x\n", tmp,
288 admhc_dbg(ahcd, " bp0 %08x be %08x\n",
289 hc32_to_cpup (ahcd, &td->hwCBP) & ~0x0fff,
290 hc32_to_cpup (ahcd, &td->hwBE));
294 tmp = hc32_to_cpup(ahcd, &td->hwCBL);
295 admhc_dbg(ahcd, " dbp %08x; cbl %08x; LEN=%d%s\n",
296 hc32_to_cpup (ahcd, &td->hwDBP),
299 (tmp & TD_IE) ? " IE" : ""
303 /* caller MUST own hcd spinlock if verbose is set! */
304 static void __attribute__((unused))
305 admhc_dump_ed(const struct admhcd *ahcd, const char *label,
306 const struct ed *ed, int verbose)
308 u32 tmp = hc32_to_cpu(ahcd, ed->hwINFO);
310 admhc_dbg(ahcd, "%s ed %p state 0x%x type %s; next ed %08x\n",
312 ed, ed->state, edstring (ed->type),
313 hc32_to_cpup (ahcd, &ed->hwNextED));
315 admhc_dbg(ahcd, " info %08x MAX=%d%s%s%s%s EP=%d DEV=%d\n", tmp,
317 (tmp & ED_ISO) ? " ISO" : "",
318 (tmp & ED_SKIP) ? " SKIP" : "",
319 (tmp & ED_SPEED_FULL) ? " FULL" : " LOW",
320 (tmp & ED_INT) ? " INT" : "",
324 tmp = hc32_to_cpup(ahcd, &ed->hwHeadP);
325 admhc_dbg(ahcd, " tds: head %08x tail %08x %s%s%s\n",
327 hc32_to_cpup (ahcd, &ed->hwTailP),
328 (tmp & ED_C) ? data1 : data0,
329 (tmp & ED_H) ? " HALT" : "",
330 verbose ? " td list follows" : " (not listing)");
333 struct list_head *tmp;
335 /* use ed->td_list because HC concurrently modifies
336 * hwNextTD as it accumulates ed_donelist.
338 list_for_each(tmp, &ed->td_list) {
340 td = list_entry(tmp, struct td, td_list);
341 admhc_dump_td (ahcd, " ->", td);
346 #else /* ifdef DEBUG */
348 static inline void urb_print(struct urb * urb, char * str, int small) {}
349 static inline void admhc_dump_ed(const struct admhcd *ahcd, const char *label,
350 const struct ed *ed, int verbose) {}
351 static inline void admhc_dump(struct admhcd *ahcd, int verbose) {}
353 #undef ADMHC_VERBOSE_DEBUG
357 /*-------------------------------------------------------------------------*/
359 #ifdef STUB_DEBUG_FILES
361 static inline void create_debug_files(struct admhcd *bus) { }
362 static inline void remove_debug_files(struct admhcd *bus) { }
367 show_list(struct admhcd *ahcd, char *buf, size_t count, struct ed *ed)
369 unsigned temp, size = count;
375 /* print first --> last */
380 /* dump a snapshot of the bulk or control schedule */
382 u32 info = hc32_to_cpu(ahcd, ed->hwINFO);
383 u32 headp = hc32_to_cpu(ahcd, ed->hwHeadP);
384 struct list_head *entry;
387 temp = scnprintf(buf, size,
388 "ed/%p %s %cs dev%d ep%d %s%smax %d %08x%s%s %s",
391 (info & ED_SPEED_FULL) ? 'f' : 'l',
393 (info >> ED_EN_SHIFT) & ED_EN_MASK,
394 (info & ED_INT) ? "INT " : "",
395 (info & ED_ISO) ? "ISO " : "",
396 (info >> ED_MPS_SHIFT) & ED_MPS_MASK ,
398 (info & ED_SKIP) ? " S" : "",
399 (headp & ED_H) ? " H" : "",
400 (headp & ED_C) ? data1 : data0);
404 list_for_each(entry, &ed->td_list) {
407 td = list_entry(entry, struct td, td_list);
408 info = hc32_to_cpup (ahcd, &td->hwINFO);
409 dbp = hc32_to_cpup (ahcd, &td->hwDBP);
410 cbl = hc32_to_cpup (ahcd, &td->hwCBL);
412 temp = scnprintf(buf, size,
413 "\n\ttd %p %s %d %s%scc=%x urb %p (%08x,%08x)",
416 switch (info & TD_DP) {
417 case TD_DP_SETUP: pid = "setup"; break;
418 case TD_DP_IN: pid = "in"; break;
419 case TD_DP_OUT: pid = "out"; break;
420 default: pid = "(bad pid)"; break;
423 (info & TD_OWN) ? "" : "DONE ",
424 (cbl & TD_IE) ? "IE " : "",
425 TD_CC_GET (info), td->urb, info, cbl);
430 temp = scnprintf(buf, size, "\n");
440 show_async(struct class_device *class_dev, char *buf)
448 bus = class_get_devdata(class_dev);
449 hcd = bus_to_hcd(bus);
450 ahcd = hcd_to_admhcd(hcd);
452 /* display control and bulk lists together, for simplicity */
453 spin_lock_irqsave(&ahcd->lock, flags);
455 temp = show_list (ahcd, buf, PAGE_SIZE, ahcd->ed_tails[ED_TAIL_CONTROL]);
456 temp += show_list (ahcd, buf + temp, PAGE_SIZE - temp,
457 ahcd->ed_tails[ED_TAIL_BULK]);
460 temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head);
462 temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head);
465 spin_unlock_irqrestore(&ahcd->lock, flags);
469 static CLASS_DEVICE_ATTR(async, S_IRUGO, show_async, NULL);
472 #define DBG_SCHED_LIMIT 64
475 show_periodic(struct class_device *class_dev, char *buf)
480 struct ed **seen, *ed;
482 unsigned temp, size, seen_count;
486 if (!(seen = kmalloc(DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC)))
490 bus = class_get_devdata(class_dev);
491 hcd = bus_to_hcd(bus);
492 ahcd = hcd_to_admhcd(hcd);
496 temp = scnprintf(next, size, "size = %d\n", NUM_INTS);
500 /* dump a snapshot of the periodic schedule (and load) */
501 spin_lock_irqsave(&ahcd->lock, flags);
502 for (i = 0; i < NUM_INTS; i++) {
503 if (!(ed = ahcd->periodic [i]))
506 temp = scnprintf(next, size, "%2d [%3d]:", i, ahcd->load [i]);
511 temp = scnprintf(next, size, " ed%d/%p",
515 for (temp = 0; temp < seen_count; temp++) {
516 if (seen [temp] == ed)
520 /* show more info the first time around */
521 if (temp == seen_count) {
522 u32 info = hc32_to_cpu (ahcd, ed->hwINFO);
523 struct list_head *entry;
526 /* qlen measured here in TDs, not urbs */
527 list_for_each (entry, &ed->td_list)
529 temp = scnprintf(next, size,
530 " (%cs dev%d ep%d%s qlen %u"
532 (info & ED_SPEED_FULL) ? 'f' : 'l',
535 (info & ED_ISO) ? "iso" : "int",
539 (info & ED_SKIP) ? " K" : "",
541 cpu_to_hc32(ahcd, ED_H)) ?
546 if (seen_count < DBG_SCHED_LIMIT)
547 seen [seen_count++] = ed;
552 /* we've seen it and what's after */
559 temp = scnprintf(next, size, "\n");
563 spin_unlock_irqrestore(&ahcd->lock, flags);
566 return PAGE_SIZE - size;
568 static CLASS_DEVICE_ATTR(periodic, S_IRUGO, show_periodic, NULL);
571 #undef DBG_SCHED_LIMIT
574 show_registers(struct class_device *class_dev, char *buf)
579 struct admhcd_regs __iomem *regs;
585 bus = class_get_devdata(class_dev);
586 hcd = bus_to_hcd(bus);
587 ahcd = hcd_to_admhcd(hcd);
592 spin_lock_irqsave(&ahcd->lock, flags);
594 /* dump driver info, then registers in spec order */
596 admhc_dbg_sw(ahcd, &next, &size,
597 "bus %s, device %s\n"
599 "%s version " DRIVER_VERSION "\n",
600 hcd->self.controller->bus->name,
601 hcd->self.controller->bus_id,
605 if (bus->controller->power.power_state.event) {
606 size -= scnprintf(next, size,
607 "SUSPENDED (no register access)\n");
611 admhc_dump_status(ahcd, &next, &size);
613 /* other registers mostly affect frame timings */
614 rdata = admhc_readl(ahcd, ®s->fminterval);
615 temp = scnprintf(next, size,
616 "fmintvl 0x%08x %sFSLDP=0x%04x FI=0x%04x\n",
617 rdata, (rdata & ADMHC_SFI_FIT) ? "FIT " : "",
618 (rdata >> ADMHC_SFI_FSLDP_SHIFT) & ADMHC_SFI_FSLDP_MASK,
619 rdata & ADMHC_SFI_FI_MASK);
623 rdata = admhc_readl(ahcd, ®s->fmnumber);
624 temp = scnprintf(next, size, "fmnumber 0x%08x %sFR=0x%04x FN=%04x\n",
625 rdata, (rdata & ADMHC_SFN_FRT) ? "FRT " : "",
626 (rdata >> ADMHC_SFN_FR_SHIFT) & ADMHC_SFN_FR_MASK,
627 rdata & ADMHC_SFN_FN_MASK);
631 /* TODO: use predefined bitmask */
632 rdata = admhc_readl(ahcd, ®s->lsthresh);
633 temp = scnprintf(next, size, "lsthresh 0x%04x\n",
638 temp = scnprintf(next, size, "hub poll timer: %s\n",
639 admhcd_to_hcd(ahcd)->poll_rh ? "ON" : "OFF");
644 admhc_dump_roothub(ahcd, 1, &next, &size);
647 spin_unlock_irqrestore(&ahcd->lock, flags);
648 return PAGE_SIZE - size;
650 static CLASS_DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
653 static inline void create_debug_files (struct admhcd *ahcd)
655 struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
658 retval = class_device_create_file(cldev, &class_device_attr_async);
659 retval = class_device_create_file(cldev, &class_device_attr_periodic);
660 retval = class_device_create_file(cldev, &class_device_attr_registers);
661 admhc_dbg(ahcd, "created debug files\n");
664 static inline void remove_debug_files (struct admhcd *ahcd)
666 struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
668 class_device_remove_file(cldev, &class_device_attr_async);
669 class_device_remove_file(cldev, &class_device_attr_periodic);
670 class_device_remove_file(cldev, &class_device_attr_registers);
675 /*-------------------------------------------------------------------------*/