2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* UHCI-specific debugging code. Invaluable when something
|
|
|
|
* goes wrong, but don't get in my face.
|
|
|
|
*
|
2005-11-30 22:16:19 +00:00
|
|
|
* Kernel visible pointers are surrounded in []s and bus
|
|
|
|
* visible pointers are surrounded in ()s
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* (C) Copyright 1999 Linus Torvalds
|
|
|
|
* (C) Copyright 1999-2001 Johannes Erdfelt
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#include "uhci-hcd.h"
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
#define EXTRA_SPACE 1024
|
|
|
|
|
2005-12-17 23:03:37 +00:00
|
|
|
static struct dentry *uhci_debugfs_root;
|
|
|
|
|
2013-11-18 12:23:16 +00:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-30 22:16:19 +00:00
|
|
|
/* Handle REALLY large printks so we don't overflow buffers */
|
2005-12-17 23:03:37 +00:00
|
|
|
static void lprintk(char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
/* Just write one line at a time */
|
|
|
|
while (buf) {
|
|
|
|
p = strchr(buf, '\n');
|
|
|
|
if (p)
|
|
|
|
*p = 0;
|
|
|
|
printk(KERN_DEBUG "%s\n", buf);
|
|
|
|
buf = p;
|
|
|
|
if (buf)
|
|
|
|
buf++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
|
|
|
|
int len, int space)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *out = buf;
|
|
|
|
char *spid;
|
|
|
|
u32 status, token;
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
status = td_status(uhci, td);
|
|
|
|
out += sprintf(out, "%*s[%p] link (%08x) ", space, "", td,
|
|
|
|
hc32_to_cpu(uhci, td->link));
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "e%d %s%s%s%s%s%s%s%s%s%sLength=%x ",
|
|
|
|
((status >> 27) & 3),
|
|
|
|
(status & TD_CTRL_SPD) ? "SPD " : "",
|
|
|
|
(status & TD_CTRL_LS) ? "LS " : "",
|
|
|
|
(status & TD_CTRL_IOC) ? "IOC " : "",
|
|
|
|
(status & TD_CTRL_ACTIVE) ? "Active " : "",
|
|
|
|
(status & TD_CTRL_STALLED) ? "Stalled " : "",
|
|
|
|
(status & TD_CTRL_DBUFERR) ? "DataBufErr " : "",
|
|
|
|
(status & TD_CTRL_BABBLE) ? "Babble " : "",
|
|
|
|
(status & TD_CTRL_NAK) ? "NAK " : "",
|
|
|
|
(status & TD_CTRL_CRCTIMEO) ? "CRC/Timeo " : "",
|
|
|
|
(status & TD_CTRL_BITSTUFF) ? "BitStuff " : "",
|
|
|
|
status & 0x7ff);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
token = td_token(uhci, td);
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (uhci_packetid(token)) {
|
|
|
|
case USB_PID_SETUP:
|
|
|
|
spid = "SETUP";
|
|
|
|
break;
|
|
|
|
case USB_PID_OUT:
|
|
|
|
spid = "OUT";
|
|
|
|
break;
|
|
|
|
case USB_PID_IN:
|
|
|
|
spid = "IN";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
spid = "?";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out += sprintf(out, "MaxLen=%x DT%d EndPt=%x Dev=%x, PID=%x(%s) ",
|
|
|
|
token >> 21,
|
|
|
|
((token >> 19) & 1),
|
|
|
|
(token >> 15) & 15,
|
|
|
|
(token >> 8) & 127,
|
|
|
|
(token & 0xff),
|
|
|
|
spid);
|
2011-05-18 08:44:51 +00:00
|
|
|
out += sprintf(out, "(buf=%08x)\n", hc32_to_cpu(uhci, td->buffer));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
done:
|
|
|
|
if (out - buf > len)
|
|
|
|
out += sprintf(out, " ...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return out - buf;
|
|
|
|
}
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
|
|
|
|
char *buf, int len, int space)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *out = buf;
|
|
|
|
struct uhci_td *td;
|
2005-12-17 22:58:46 +00:00
|
|
|
int i, nactive, ninactive;
|
2006-05-05 20:26:58 +00:00
|
|
|
char *ptype;
|
2005-12-17 22:58:46 +00:00
|
|
|
|
|
|
|
|
|
|
|
out += sprintf(out, "urb_priv [%p] ", urbp);
|
|
|
|
out += sprintf(out, "urb [%p] ", urbp->urb);
|
|
|
|
out += sprintf(out, "qh [%p] ", urbp->qh);
|
|
|
|
out += sprintf(out, "Dev=%d ", usb_pipedevice(urbp->urb->pipe));
|
|
|
|
out += sprintf(out, "EP=%x(%s) ", usb_pipeendpoint(urbp->urb->pipe),
|
|
|
|
(usb_pipein(urbp->urb->pipe) ? "IN" : "OUT"));
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-12-17 22:58:46 +00:00
|
|
|
|
|
|
|
switch (usb_pipetype(urbp->urb->pipe)) {
|
2006-05-05 20:26:58 +00:00
|
|
|
case PIPE_ISOCHRONOUS: ptype = "ISO"; break;
|
|
|
|
case PIPE_INTERRUPT: ptype = "INT"; break;
|
|
|
|
case PIPE_BULK: ptype = "BLK"; break;
|
|
|
|
default:
|
|
|
|
case PIPE_CONTROL: ptype = "CTL"; break;
|
2005-12-17 22:58:46 +00:00
|
|
|
}
|
|
|
|
|
2006-05-05 20:26:58 +00:00
|
|
|
out += sprintf(out, "%s%s", ptype, (urbp->fsbr ? " FSBR" : ""));
|
2009-03-05 16:01:11 +00:00
|
|
|
out += sprintf(out, " Actlen=%d%s", urbp->urb->actual_length,
|
|
|
|
(urbp->qh->type == USB_ENDPOINT_XFER_CONTROL ?
|
|
|
|
"-8" : ""));
|
2005-12-17 22:58:46 +00:00
|
|
|
|
2007-08-21 19:40:36 +00:00
|
|
|
if (urbp->urb->unlinked)
|
|
|
|
out += sprintf(out, " Unlinked=%d", urbp->urb->unlinked);
|
2005-12-17 22:58:46 +00:00
|
|
|
out += sprintf(out, "\n");
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
2005-12-17 22:58:46 +00:00
|
|
|
i = nactive = ninactive = 0;
|
|
|
|
list_for_each_entry(td, &urbp->td_list, list) {
|
2006-05-19 20:52:35 +00:00
|
|
|
if (urbp->qh->type != USB_ENDPOINT_XFER_ISOC &&
|
|
|
|
(++i <= 10 || debug > 2)) {
|
2005-12-17 22:58:46 +00:00
|
|
|
out += sprintf(out, "%*s%d: ", space + 2, "", i);
|
2011-05-18 08:44:51 +00:00
|
|
|
out += uhci_show_td(uhci, td, out,
|
|
|
|
len - (out - buf), 0);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
2005-12-17 22:58:46 +00:00
|
|
|
} else {
|
2011-05-18 08:44:51 +00:00
|
|
|
if (td_status(uhci, td) & TD_CTRL_ACTIVE)
|
2005-12-17 22:58:46 +00:00
|
|
|
++nactive;
|
|
|
|
else
|
|
|
|
++ninactive;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (nactive + ninactive > 0)
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
"%*s[skipped %d inactive and %d active TDs]\n",
|
2005-12-17 22:58:46 +00:00
|
|
|
space, "", ninactive, nactive);
|
2013-01-23 08:13:41 +00:00
|
|
|
done:
|
|
|
|
if (out - buf > len)
|
|
|
|
out += sprintf(out, " ...\n");
|
|
|
|
tail:
|
2005-12-17 22:58:46 +00:00
|
|
|
return out - buf;
|
|
|
|
}
|
|
|
|
|
2007-03-19 19:31:42 +00:00
|
|
|
static int uhci_show_qh(struct uhci_hcd *uhci,
|
|
|
|
struct uhci_qh *qh, char *buf, int len, int space)
|
2005-12-17 22:58:46 +00:00
|
|
|
{
|
|
|
|
char *out = buf;
|
|
|
|
int i, nurbs;
|
2011-05-18 08:44:51 +00:00
|
|
|
__hc32 element = qh_element(qh);
|
2006-05-05 20:26:58 +00:00
|
|
|
char *qtype;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-05-05 20:26:58 +00:00
|
|
|
switch (qh->type) {
|
|
|
|
case USB_ENDPOINT_XFER_ISOC: qtype = "ISO"; break;
|
|
|
|
case USB_ENDPOINT_XFER_INT: qtype = "INT"; break;
|
|
|
|
case USB_ENDPOINT_XFER_BULK: qtype = "BLK"; break;
|
|
|
|
case USB_ENDPOINT_XFER_CONTROL: qtype = "CTL"; break;
|
|
|
|
default: qtype = "Skel" ; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out += sprintf(out, "%*s[%p] %s QH link (%08x) element (%08x)\n",
|
|
|
|
space, "", qh, qtype,
|
2011-05-18 08:44:51 +00:00
|
|
|
hc32_to_cpu(uhci, qh->link),
|
|
|
|
hc32_to_cpu(uhci, element));
|
2006-05-19 20:44:55 +00:00
|
|
|
if (qh->type == USB_ENDPOINT_XFER_ISOC)
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
"%*s period %d phase %d load %d us, frame %x desc [%p]\n",
|
2007-01-16 16:56:32 +00:00
|
|
|
space, "", qh->period, qh->phase, qh->load,
|
|
|
|
qh->iso_frame, qh->iso_packet_desc);
|
|
|
|
else if (qh->type == USB_ENDPOINT_XFER_INT)
|
|
|
|
out += sprintf(out, "%*s period %d phase %d load %d us\n",
|
|
|
|
space, "", qh->period, qh->phase, qh->load);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
if (element & UHCI_PTR_QH(uhci))
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "%*s Element points to QH (bug?)\n", space, "");
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
if (element & UHCI_PTR_DEPTH(uhci))
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "%*s Depth traverse\n", space, "");
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
if (element & cpu_to_hc32(uhci, 8))
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "%*s Bit 3 set (bug?)\n", space, "");
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
if (!(element & ~(UHCI_PTR_QH(uhci) | UHCI_PTR_DEPTH(uhci))))
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "%*s Element is NULL (bug?)\n", space, "");
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
2005-12-17 22:58:46 +00:00
|
|
|
if (list_empty(&qh->queue)) {
|
|
|
|
out += sprintf(out, "%*s queue is empty\n", space, "");
|
2013-01-23 08:13:41 +00:00
|
|
|
if (qh == uhci->skel_async_qh) {
|
2011-05-18 08:44:51 +00:00
|
|
|
out += uhci_show_td(uhci, uhci->term_td, out,
|
2007-03-19 19:31:42 +00:00
|
|
|
len - (out - buf), 0);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
|
|
|
}
|
2005-12-17 22:58:46 +00:00
|
|
|
} else {
|
|
|
|
struct urb_priv *urbp = list_entry(qh->queue.next,
|
|
|
|
struct urb_priv, node);
|
|
|
|
struct uhci_td *td = list_entry(urbp->td_list.next,
|
|
|
|
struct uhci_td, list);
|
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
if (element != LINK_TO_TD(uhci, td))
|
2005-12-17 22:58:46 +00:00
|
|
|
out += sprintf(out, "%*s Element != First TD\n",
|
|
|
|
space, "");
|
|
|
|
i = nurbs = 0;
|
|
|
|
list_for_each_entry(urbp, &qh->queue, node) {
|
2013-01-23 08:13:41 +00:00
|
|
|
if (++i <= 10) {
|
2011-05-18 08:44:51 +00:00
|
|
|
out += uhci_show_urbp(uhci, urbp, out,
|
2005-12-17 22:58:46 +00:00
|
|
|
len - (out - buf), space + 2);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
|
|
|
}
|
2005-12-17 22:58:46 +00:00
|
|
|
else
|
|
|
|
++nurbs;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-12-17 22:58:46 +00:00
|
|
|
if (nurbs > 0)
|
|
|
|
out += sprintf(out, "%*s Skipped %d URBs\n",
|
|
|
|
space, "", nurbs);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
2007-01-08 17:01:43 +00:00
|
|
|
if (qh->dummy_td) {
|
2005-12-17 23:00:12 +00:00
|
|
|
out += sprintf(out, "%*s Dummy TD\n", space, "");
|
2011-05-18 08:44:51 +00:00
|
|
|
out += uhci_show_td(uhci, qh->dummy_td, out,
|
|
|
|
len - (out - buf), 0);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
2005-12-17 23:00:12 +00:00
|
|
|
}
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
done:
|
|
|
|
if (out - buf > len)
|
|
|
|
out += sprintf(out, " ...\n");
|
|
|
|
tail:
|
2005-04-16 22:20:36 +00:00
|
|
|
return out - buf;
|
|
|
|
}
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
static int uhci_show_sc(int port, unsigned short status, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-01-23 08:13:41 +00:00
|
|
|
return sprintf(buf, " stat%d = %04x %s%s%s%s%s%s%s%s%s%s\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
port,
|
|
|
|
status,
|
|
|
|
(status & USBPORTSC_SUSP) ? " Suspend" : "",
|
|
|
|
(status & USBPORTSC_OCC) ? " OverCurrentChange" : "",
|
|
|
|
(status & USBPORTSC_OC) ? " OverCurrent" : "",
|
|
|
|
(status & USBPORTSC_PR) ? " Reset" : "",
|
|
|
|
(status & USBPORTSC_LSDA) ? " LowSpeed" : "",
|
|
|
|
(status & USBPORTSC_RD) ? " ResumeDetect" : "",
|
|
|
|
(status & USBPORTSC_PEC) ? " EnableChange" : "",
|
|
|
|
(status & USBPORTSC_PE) ? " Enabled" : "",
|
|
|
|
(status & USBPORTSC_CSC) ? " ConnectChange" : "",
|
|
|
|
(status & USBPORTSC_CCS) ? " Connected" : "");
|
|
|
|
}
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf)
|
2005-04-09 21:27:32 +00:00
|
|
|
{
|
|
|
|
char *rh_state;
|
|
|
|
|
|
|
|
switch (uhci->rh_state) {
|
|
|
|
case UHCI_RH_RESET:
|
|
|
|
rh_state = "reset"; break;
|
|
|
|
case UHCI_RH_SUSPENDED:
|
|
|
|
rh_state = "suspended"; break;
|
|
|
|
case UHCI_RH_AUTO_STOPPED:
|
|
|
|
rh_state = "auto-stopped"; break;
|
|
|
|
case UHCI_RH_RESUMING:
|
|
|
|
rh_state = "resuming"; break;
|
|
|
|
case UHCI_RH_SUSPENDING:
|
|
|
|
rh_state = "suspending"; break;
|
|
|
|
case UHCI_RH_RUNNING:
|
|
|
|
rh_state = "running"; break;
|
|
|
|
case UHCI_RH_RUNNING_NODEVS:
|
|
|
|
rh_state = "running, no devs"; break;
|
|
|
|
default:
|
|
|
|
rh_state = "?"; break;
|
|
|
|
}
|
2013-01-23 08:13:41 +00:00
|
|
|
return sprintf(buf, "Root-hub state: %s FSBR: %d\n",
|
2006-05-12 15:35:45 +00:00
|
|
|
rh_state, uhci->fsbr_is_on);
|
2005-04-09 21:27:32 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
|
|
|
|
{
|
|
|
|
char *out = buf;
|
|
|
|
unsigned short usbcmd, usbstat, usbint, usbfrnum;
|
|
|
|
unsigned int flbaseadd;
|
|
|
|
unsigned char sof;
|
|
|
|
unsigned short portsc1, portsc2;
|
|
|
|
|
|
|
|
|
2013-10-04 22:14:34 +00:00
|
|
|
usbcmd = uhci_readw(uhci, USBCMD);
|
|
|
|
usbstat = uhci_readw(uhci, USBSTS);
|
|
|
|
usbint = uhci_readw(uhci, USBINTR);
|
|
|
|
usbfrnum = uhci_readw(uhci, USBFRNUM);
|
|
|
|
flbaseadd = uhci_readl(uhci, USBFLBASEADD);
|
|
|
|
sof = uhci_readb(uhci, USBSOF);
|
|
|
|
portsc1 = uhci_readw(uhci, USBPORTSC1);
|
|
|
|
portsc2 = uhci_readw(uhci, USBPORTSC2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
out += sprintf(out, " usbcmd = %04x %s%s%s%s%s%s%s%s\n",
|
|
|
|
usbcmd,
|
|
|
|
(usbcmd & USBCMD_MAXP) ? "Maxp64 " : "Maxp32 ",
|
|
|
|
(usbcmd & USBCMD_CF) ? "CF " : "",
|
|
|
|
(usbcmd & USBCMD_SWDBG) ? "SWDBG " : "",
|
|
|
|
(usbcmd & USBCMD_FGR) ? "FGR " : "",
|
|
|
|
(usbcmd & USBCMD_EGSM) ? "EGSM " : "",
|
|
|
|
(usbcmd & USBCMD_GRESET) ? "GRESET " : "",
|
|
|
|
(usbcmd & USBCMD_HCRESET) ? "HCRESET " : "",
|
|
|
|
(usbcmd & USBCMD_RS) ? "RS " : "");
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
out += sprintf(out, " usbstat = %04x %s%s%s%s%s%s\n",
|
|
|
|
usbstat,
|
|
|
|
(usbstat & USBSTS_HCH) ? "HCHalted " : "",
|
|
|
|
(usbstat & USBSTS_HCPE) ? "HostControllerProcessError " : "",
|
|
|
|
(usbstat & USBSTS_HSE) ? "HostSystemError " : "",
|
|
|
|
(usbstat & USBSTS_RD) ? "ResumeDetect " : "",
|
|
|
|
(usbstat & USBSTS_ERROR) ? "USBError " : "",
|
|
|
|
(usbstat & USBSTS_USBINT) ? "USBINT " : "");
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
out += sprintf(out, " usbint = %04x\n", usbint);
|
|
|
|
out += sprintf(out, " usbfrnum = (%d)%03x\n", (usbfrnum >> 10) & 1,
|
|
|
|
0xfff & (4*(unsigned int)usbfrnum));
|
|
|
|
out += sprintf(out, " flbaseadd = %08x\n", flbaseadd);
|
|
|
|
out += sprintf(out, " sof = %02x\n", sof);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
out += uhci_show_sc(1, portsc1, out);
|
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
out += uhci_show_sc(2, portsc2, out);
|
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
out += sprintf(out,
|
|
|
|
"Most recent frame: %x (%d) Last ISO frame: %x (%d)\n",
|
2006-05-19 20:52:35 +00:00
|
|
|
uhci->frame_number, uhci->frame_number & 1023,
|
|
|
|
uhci->last_iso_frame, uhci->last_iso_frame & 1023);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
done:
|
|
|
|
if (out - buf > len)
|
|
|
|
out += sprintf(out, " ...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return out - buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
|
|
|
|
{
|
|
|
|
char *out = buf;
|
|
|
|
int i, j;
|
|
|
|
struct uhci_qh *qh;
|
|
|
|
struct uhci_td *td;
|
|
|
|
struct list_head *tmp, *head;
|
2007-01-08 17:00:28 +00:00
|
|
|
int nframes, nerrs;
|
2011-05-18 08:44:51 +00:00
|
|
|
__hc32 link;
|
|
|
|
__hc32 fsbr_link;
|
2007-02-19 20:52:45 +00:00
|
|
|
|
|
|
|
static const char * const qh_names[] = {
|
|
|
|
"unlink", "iso", "int128", "int64", "int32", "int16",
|
|
|
|
"int8", "int4", "int2", "async", "term"
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
out += uhci_show_root_hub_state(uhci, out);
|
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
out += sprintf(out, "HC status\n");
|
|
|
|
out += uhci_show_status(uhci, out, len - (out - buf));
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
2007-01-16 16:56:32 +00:00
|
|
|
|
|
|
|
out += sprintf(out, "Periodic load table\n");
|
|
|
|
for (i = 0; i < MAX_PHASE; ++i) {
|
|
|
|
out += sprintf(out, "\t%d", uhci->load[i]);
|
|
|
|
if (i % 8 == 7)
|
|
|
|
*out++ = '\n';
|
|
|
|
}
|
|
|
|
out += sprintf(out, "Total: %d, #INT: %d, #ISO: %d\n",
|
|
|
|
uhci->total_load,
|
|
|
|
uhci_to_hcd(uhci)->self.bandwidth_int_reqs,
|
|
|
|
uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs);
|
2005-12-17 22:58:46 +00:00
|
|
|
if (debug <= 1)
|
2013-01-23 08:13:41 +00:00
|
|
|
goto tail;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
out += sprintf(out, "Frame List\n");
|
2007-01-08 17:00:28 +00:00
|
|
|
nframes = 10;
|
|
|
|
nerrs = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < UHCI_NUMFRAMES; ++i) {
|
2011-05-18 08:44:51 +00:00
|
|
|
__hc32 qh_dma;
|
2007-01-08 17:00:28 +00:00
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2007-01-08 17:00:28 +00:00
|
|
|
j = 0;
|
2005-09-16 18:22:51 +00:00
|
|
|
td = uhci->frame_cpu[i];
|
2007-01-08 17:00:28 +00:00
|
|
|
link = uhci->frame[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!td)
|
2007-01-08 17:00:28 +00:00
|
|
|
goto check_link;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-08 17:00:28 +00:00
|
|
|
if (nframes > 0) {
|
|
|
|
out += sprintf(out, "- Frame %d -> (%08x)\n",
|
2011-05-18 08:44:51 +00:00
|
|
|
i, hc32_to_cpu(uhci, link));
|
2007-01-08 17:00:28 +00:00
|
|
|
j = 1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
head = &td->fl_list;
|
|
|
|
tmp = head;
|
|
|
|
do {
|
|
|
|
td = list_entry(tmp, struct uhci_td, fl_list);
|
|
|
|
tmp = tmp->next;
|
2011-05-18 08:44:51 +00:00
|
|
|
if (link != LINK_TO_TD(uhci, td)) {
|
2013-01-23 08:13:41 +00:00
|
|
|
if (nframes > 0) {
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
" link does not match list entry!\n");
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
} else
|
2007-01-08 17:00:28 +00:00
|
|
|
++nerrs;
|
|
|
|
}
|
2013-01-23 08:13:41 +00:00
|
|
|
if (nframes > 0) {
|
2011-05-18 08:44:51 +00:00
|
|
|
out += uhci_show_td(uhci, td, out,
|
2007-01-08 17:00:28 +00:00
|
|
|
len - (out - buf), 4);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
|
|
|
}
|
2007-01-08 17:00:28 +00:00
|
|
|
link = td->link;
|
2005-04-16 22:20:36 +00:00
|
|
|
} while (tmp != head);
|
2007-01-08 17:00:28 +00:00
|
|
|
|
|
|
|
check_link:
|
|
|
|
qh_dma = uhci_frame_skel_link(uhci, i);
|
|
|
|
if (link != qh_dma) {
|
|
|
|
if (nframes > 0) {
|
|
|
|
if (!j) {
|
|
|
|
out += sprintf(out,
|
|
|
|
"- Frame %d -> (%08x)\n",
|
2011-05-18 08:44:51 +00:00
|
|
|
i, hc32_to_cpu(uhci, link));
|
2007-01-08 17:00:28 +00:00
|
|
|
j = 1;
|
|
|
|
}
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
" link does not match QH (%08x)!\n",
|
2011-05-18 08:44:51 +00:00
|
|
|
hc32_to_cpu(uhci, qh_dma));
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2007-01-08 17:00:28 +00:00
|
|
|
} else
|
|
|
|
++nerrs;
|
|
|
|
}
|
|
|
|
nframes -= j;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-01-08 17:00:28 +00:00
|
|
|
if (nerrs > 0)
|
|
|
|
out += sprintf(out, "Skipped %d bad links\n", nerrs);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-30 22:16:19 +00:00
|
|
|
out += sprintf(out, "Skeleton QHs\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
|
2007-03-19 19:31:42 +00:00
|
|
|
fsbr_link = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < UHCI_NUM_SKELQH; ++i) {
|
2005-12-17 22:58:46 +00:00
|
|
|
int cnt = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
qh = uhci->skelqh[i];
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out, "- skel_%s_qh\n", qh_names[i]);
|
2007-03-19 19:31:42 +00:00
|
|
|
out += uhci_show_qh(uhci, qh, out, len - (out - buf), 4);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Last QH is the Terminating QH, it's different */
|
2007-02-19 20:52:45 +00:00
|
|
|
if (i == SKEL_TERM) {
|
2013-01-23 08:13:41 +00:00
|
|
|
if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td)) {
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
" skel_term_qh element is not set to term_td!\n");
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
|
|
|
}
|
2007-03-19 19:31:42 +00:00
|
|
|
link = fsbr_link;
|
|
|
|
if (!link)
|
2011-05-18 08:44:51 +00:00
|
|
|
link = LINK_TO_QH(uhci, uhci->skel_term_qh);
|
2007-03-19 19:31:42 +00:00
|
|
|
goto check_qh_link;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-12-17 22:58:46 +00:00
|
|
|
head = &qh->node;
|
2005-04-16 22:20:36 +00:00
|
|
|
tmp = head->next;
|
|
|
|
|
|
|
|
while (tmp != head) {
|
2005-12-17 22:58:46 +00:00
|
|
|
qh = list_entry(tmp, struct uhci_qh, node);
|
2005-04-16 22:20:36 +00:00
|
|
|
tmp = tmp->next;
|
2013-01-23 08:13:41 +00:00
|
|
|
if (++cnt <= 10) {
|
2007-03-19 19:31:42 +00:00
|
|
|
out += uhci_show_qh(uhci, qh, out,
|
2005-12-17 22:58:46 +00:00
|
|
|
len - (out - buf), 4);
|
2013-01-23 08:13:41 +00:00
|
|
|
if (out - buf > len)
|
|
|
|
goto tail;
|
|
|
|
}
|
2007-02-19 20:52:45 +00:00
|
|
|
if (!fsbr_link && qh->skel >= SKEL_FSBR)
|
2011-05-18 08:44:51 +00:00
|
|
|
fsbr_link = LINK_TO_QH(uhci, qh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-12-17 22:58:46 +00:00
|
|
|
if ((cnt -= 10) > 0)
|
|
|
|
out += sprintf(out, " Skipped %d QHs\n", cnt);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-18 08:44:51 +00:00
|
|
|
link = UHCI_PTR_TERM(uhci);
|
2007-02-19 20:52:45 +00:00
|
|
|
if (i <= SKEL_ISO)
|
|
|
|
;
|
|
|
|
else if (i < SKEL_ASYNC)
|
2011-05-18 08:44:51 +00:00
|
|
|
link = LINK_TO_QH(uhci, uhci->skel_async_qh);
|
2007-02-19 20:52:45 +00:00
|
|
|
else if (!uhci->fsbr_is_on)
|
|
|
|
;
|
|
|
|
else
|
2011-05-18 08:44:51 +00:00
|
|
|
link = LINK_TO_QH(uhci, uhci->skel_term_qh);
|
2007-02-19 20:52:45 +00:00
|
|
|
check_qh_link:
|
|
|
|
if (qh->link != link)
|
2013-01-24 01:41:45 +00:00
|
|
|
out += sprintf(out,
|
|
|
|
" last QH not linked to next skeleton!\n");
|
2013-01-23 08:13:41 +00:00
|
|
|
|
|
|
|
if (out - buf > len)
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-23 08:13:41 +00:00
|
|
|
done:
|
|
|
|
if (out - buf > len)
|
|
|
|
out += sprintf(out, " ...\n");
|
|
|
|
tail:
|
2005-04-16 22:20:36 +00:00
|
|
|
return out - buf;
|
|
|
|
}
|
|
|
|
|
2005-12-17 23:03:37 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MAX_OUTPUT (64 * 1024)
|
|
|
|
|
|
|
|
struct uhci_debug {
|
|
|
|
int size;
|
|
|
|
char *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int uhci_debug_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2006-09-27 08:50:46 +00:00
|
|
|
struct uhci_hcd *uhci = inode->i_private;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct uhci_debug *up;
|
2005-12-17 22:58:46 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
up = kmalloc(sizeof(*up), GFP_KERNEL);
|
|
|
|
if (!up)
|
2010-06-01 21:04:43 +00:00
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
up->data = kmalloc(MAX_OUTPUT, GFP_KERNEL);
|
|
|
|
if (!up->data) {
|
|
|
|
kfree(up);
|
2010-06-01 21:04:43 +00:00
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-12-17 23:03:37 +00:00
|
|
|
up->size = 0;
|
2005-12-17 22:58:46 +00:00
|
|
|
spin_lock_irqsave(&uhci->lock, flags);
|
2005-12-17 23:03:37 +00:00
|
|
|
if (uhci->is_initialized)
|
2013-01-23 08:13:41 +00:00
|
|
|
up->size = uhci_sprint_schedule(uhci, up->data,
|
|
|
|
MAX_OUTPUT - EXTRA_SPACE);
|
2005-12-17 22:58:46 +00:00
|
|
|
spin_unlock_irqrestore(&uhci->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
file->private_data = up;
|
|
|
|
|
2010-06-01 21:04:43 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static loff_t uhci_debug_lseek(struct file *file, loff_t off, int whence)
|
|
|
|
{
|
|
|
|
struct uhci_debug *up;
|
|
|
|
loff_t new = -1;
|
|
|
|
|
|
|
|
up = file->private_data;
|
|
|
|
|
2013-01-24 01:41:45 +00:00
|
|
|
/*
|
|
|
|
* XXX: atomic 64bit seek access, but that needs to be fixed in the VFS
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (whence) {
|
|
|
|
case 0:
|
|
|
|
new = off;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
new = file->f_pos + off;
|
|
|
|
break;
|
|
|
|
}
|
2010-06-01 21:04:43 +00:00
|
|
|
|
|
|
|
if (new < 0 || new > up->size)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2010-06-01 21:04:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return (file->f_pos = new);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uhci_debug_read(struct file *file, char __user *buf,
|
|
|
|
size_t nbytes, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct uhci_debug *up = file->private_data;
|
|
|
|
return simple_read_from_buffer(buf, nbytes, ppos, up->data, up->size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uhci_debug_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct uhci_debug *up = file->private_data;
|
|
|
|
|
|
|
|
kfree(up->data);
|
|
|
|
kfree(up);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-05 23:37:11 +00:00
|
|
|
static const struct file_operations uhci_debug_operations = {
|
2005-12-17 23:03:37 +00:00
|
|
|
.owner = THIS_MODULE,
|
2005-04-16 22:20:36 +00:00
|
|
|
.open = uhci_debug_open,
|
|
|
|
.llseek = uhci_debug_lseek,
|
|
|
|
.read = uhci_debug_read,
|
|
|
|
.release = uhci_debug_release,
|
|
|
|
};
|
2010-08-05 17:12:14 +00:00
|
|
|
#define UHCI_DEBUG_OPS
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-12-17 23:03:37 +00:00
|
|
|
#endif /* CONFIG_DEBUG_FS */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-11-18 12:23:16 +00:00
|
|
|
#else /* CONFIG_DYNAMIC_DEBUG*/
|
2005-12-17 23:03:37 +00:00
|
|
|
|
|
|
|
static inline void lprintk(char *buf)
|
|
|
|
{}
|
|
|
|
|
2007-03-19 19:31:42 +00:00
|
|
|
static inline int uhci_show_qh(struct uhci_hcd *uhci,
|
|
|
|
struct uhci_qh *qh, char *buf, int len, int space)
|
2005-12-17 23:03:37 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int uhci_sprint_schedule(struct uhci_hcd *uhci,
|
|
|
|
char *buf, int len)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#endif
|