Add a new module parameter, log_level to the xHCI driver. This will allow
developers to select which type of debugging messages they want to see.
log_level is a bit mask, so multiple types of debugging can be selected.
This new parameter will prevent log file corruption when
CONFIG_USB_XHCI_HCD_DEBUGGING is set to 'y'.
All calls to xhci_dbg() must now include a log level as the second
parameter. There are eleven different log levels to choose from:
- XHCI_LOG_QUIRKS
- XHCI_LOG_COMMANDS
- XHCI_LOG_COMMANDS_VERBOSE
- XHCI_LOG_INIT
- XHCI_LOG_EVENTS
- XHCI_LOG_DEVICE_STATE
- XHCI_LOG_TX
- XHCI_LOG_TX_VERBOSE
- XHCI_LOG_NOOPS
- XHCI_LOG_RINGS
- XHCI_LOG_PORTS
- XHCI_LOG_REGS
The default displayed debugging is messages with log level
XHCI_LOG_QUIRKS, XHCI_LOG_COMMANDS, or XHCI_LOG_TX.
While we're at it, remove unnecessary debugging messages that provide
little useful information.
Signed-off-by: Sarah Sharp <sarah.a.sharp@xxxxxxxxxxxxxxx>
---
Andiry, Libin, Cran, and Dong,
Can you try this patch out and see if the number of debugging messages
from the xHCI driver is more tolerable? It looks much better to me, but
please let me know if you spot more redundant or not useful debugging
messages.
Sarah Sharp
drivers/usb/host/xhci-dbg.c | 280 +++++++++++++++++++++++++++--------------
drivers/usb/host/xhci-hcd.c | 285 ++++++++++++++++++++++--------------------
drivers/usb/host/xhci-hub.c | 24 +++-
drivers/usb/host/xhci-mem.c | 93 ++++----------
drivers/usb/host/xhci-pci.c | 15 +--
drivers/usb/host/xhci-ring.c | 245 ++++++++++++++++++------------------
drivers/usb/host/xhci.h | 31 ++++-
7 files changed, 539 insertions(+), 434 deletions(-)
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 105fa8b..71c9485 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -30,80 +30,106 @@ void xhci_dbg_regs(struct xhci_hcd *xhci)
{
u32 temp;
- xhci_dbg(xhci, "// xHCI capability registers at %p:\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI capability registers at %p:\n",
xhci->cap_regs);
temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
- xhci_dbg(xhci, "// @%p = 0x%x (CAPLENGTH AND HCIVERSION)\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "@%p = 0x%x (CAPLENGTH AND HCIVERSION)\n",
&xhci->cap_regs->hc_capbase, temp);
- xhci_dbg(xhci, "// CAPLENGTH: 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " CAPLENGTH: 0x%x\n",
(unsigned int) HC_LENGTH(temp));
#if 0
xhci_dbg(xhci, "// HCIVERSION: 0x%x\n",
(unsigned int) HC_VERSION(temp));
#endif
- xhci_dbg(xhci, "// xHCI operational registers at %p:\n", xhci->op_regs);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI operational registers at %p:\n", xhci->op_regs);
temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);
- xhci_dbg(xhci, "// @%p = 0x%x RTSOFF\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "@%p = 0x%x RTSOFF\n",
&xhci->cap_regs->run_regs_off,
(unsigned int) temp & RTSOFF_MASK);
- xhci_dbg(xhci, "// xHCI runtime registers at %p:\n", xhci->run_regs);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI runtime registers at %p:\n", xhci->run_regs);
temp = xhci_readl(xhci, &xhci->cap_regs->db_off);
- xhci_dbg(xhci, "// @%p = 0x%x DBOFF\n", &xhci->cap_regs->db_off, temp);
- xhci_dbg(xhci, "// Doorbell array at %p:\n", xhci->dba);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "@%p = 0x%x DBOFF\n", &xhci->cap_regs->db_off, temp);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "Doorbell array at %p:\n", xhci->dba);
}
static void xhci_print_cap_regs(struct xhci_hcd *xhci)
{
u32 temp;
- xhci_dbg(xhci, "xHCI capability registers at %p:\n", xhci->cap_regs);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI capability registers at %p:\n", xhci->cap_regs);
temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
- xhci_dbg(xhci, "CAPLENGTH AND HCIVERSION 0x%x:\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "CAPLENGTH AND HCIVERSION 0x%x:\n",
(unsigned int) temp);
- xhci_dbg(xhci, "CAPLENGTH: 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "CAPLENGTH: 0x%x\n",
(unsigned int) HC_LENGTH(temp));
- xhci_dbg(xhci, "HCIVERSION: 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "HCIVERSION: 0x%x\n",
(unsigned int) HC_VERSION(temp));
temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
- xhci_dbg(xhci, "HCSPARAMS 1: 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "HCSPARAMS 1: 0x%x\n",
(unsigned int) temp);
- xhci_dbg(xhci, " Max device slots: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Max device slots: %u\n",
(unsigned int) HCS_MAX_SLOTS(temp));
- xhci_dbg(xhci, " Max interrupters: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Max interrupters: %u\n",
(unsigned int) HCS_MAX_INTRS(temp));
- xhci_dbg(xhci, " Max ports: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Max ports: %u\n",
(unsigned int) HCS_MAX_PORTS(temp));
temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
- xhci_dbg(xhci, "HCSPARAMS 2: 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "HCSPARAMS 2: 0x%x\n",
(unsigned int) temp);
- xhci_dbg(xhci, " Isoc scheduling threshold: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Isoc scheduling threshold: %u\n",
(unsigned int) HCS_IST(temp));
- xhci_dbg(xhci, " Maximum allowed segments in event ring: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Maximum allowed segments in event ring: %u\n",
(unsigned int) HCS_ERST_MAX(temp));
temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
- xhci_dbg(xhci, "HCSPARAMS 3 0x%x:\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "HCSPARAMS 3 0x%x:\n",
(unsigned int) temp);
- xhci_dbg(xhci, " Worst case U1 device exit latency: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Worst case U1 device exit latency: %u\n",
(unsigned int) HCS_U1_LATENCY(temp));
- xhci_dbg(xhci, " Worst case U2 device exit latency: %u\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Worst case U2 device exit latency: %u\n",
(unsigned int) HCS_U2_LATENCY(temp));
temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
- xhci_dbg(xhci, "HCC PARAMS 0x%x:\n", (unsigned int) temp);
- xhci_dbg(xhci, " HC generates %s bit addresses\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "HCC PARAMS 0x%x:\n", (unsigned int) temp);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " HC generates %s bit addresses\n",
HCC_64BIT_ADDR(temp) ? "64" : "32");
/* FIXME */
- xhci_dbg(xhci, " FIXME: more HCCPARAMS debugging\n");
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " FIXME: more HCCPARAMS debugging\n");
temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);
- xhci_dbg(xhci, "RTSOFF 0x%x:\n", temp & RTSOFF_MASK);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "RTSOFF 0x%x:\n", temp & RTSOFF_MASK);
}
static void xhci_print_command_reg(struct xhci_hcd *xhci)
@@ -111,16 +137,22 @@ static void xhci_print_command_reg(struct xhci_hcd *xhci)
u32 temp;
temp = xhci_readl(xhci, &xhci->op_regs->command);
- xhci_dbg(xhci, "USBCMD 0x%x:\n", temp);
- xhci_dbg(xhci, " HC is %s\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "USBCMD 0x%x:\n", temp);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " HC is %s\n",
(temp & CMD_RUN) ? "running" : "being stopped");
- xhci_dbg(xhci, " HC has %sfinished hard reset\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " HC has %sfinished hard reset\n",
(temp & CMD_RESET) ? "not " : "");
- xhci_dbg(xhci, " Event Interrupts %s\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Event Interrupts %s\n",
(temp & CMD_EIE) ? "enabled " : "disabled");
- xhci_dbg(xhci, " Host System Error Interrupts %s\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Host System Error Interrupts %s\n",
(temp & CMD_EIE) ? "enabled " : "disabled");
- xhci_dbg(xhci, " HC has %sfinished light reset\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " HC has %sfinished light reset\n",
(temp & CMD_LRESET) ? "not " : "");
}
@@ -129,18 +161,23 @@ static void xhci_print_status(struct xhci_hcd *xhci)
u32 temp;
temp = xhci_readl(xhci, &xhci->op_regs->status);
- xhci_dbg(xhci, "USBSTS 0x%x:\n", temp);
- xhci_dbg(xhci, " Event ring is %sempty\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "USBSTS 0x%x:\n", temp);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " Event ring is %sempty\n",
(temp & STS_EINT) ? "not " : "");
- xhci_dbg(xhci, " %sHost System Error\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %sHost System Error\n",
(temp & STS_FATAL) ? "WARNING: " : "No ");
- xhci_dbg(xhci, " HC is %s\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " HC is %s\n",
(temp & STS_HALT) ? "halted" : "running");
}
static void xhci_print_op_regs(struct xhci_hcd *xhci)
{
- xhci_dbg(xhci, "xHCI operational registers at %p:\n", xhci->op_regs);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI operational registers at %p:\n", xhci->op_regs);
xhci_print_command_reg(xhci);
xhci_print_status(xhci);
}
@@ -161,7 +198,8 @@ static void xhci_print_ports(struct xhci_hcd *xhci)
addr = &xhci->op_regs->port_status_base;
for (i = 0; i < ports; i++) {
for (j = 0; j < NUM_PORT_REGS; ++j) {
- xhci_dbg(xhci, "%p port %s reg = 0x%x\n",
+ xhci_dbg(xhci, (XHCI_LOG_PORTS | XHCI_LOG_REGS),
+ "%p port %s reg = 0x%x\n",
addr, names[j],
(unsigned int) xhci_readl(xhci, addr));
addr++;
@@ -180,35 +218,42 @@ void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int
if (temp == XHCI_INIT_VALUE)
return;
- xhci_dbg(xhci, " %p: ir_set[%i]\n", ir_set, set_num);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set[%i]\n", ir_set, set_num);
- xhci_dbg(xhci, " %p: ir_set.pending = 0x%x\n", addr,
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set.pending = 0x%x\n", addr,
(unsigned int)temp);
addr = &ir_set->irq_control;
temp = xhci_readl(xhci, addr);
- xhci_dbg(xhci, " %p: ir_set.control = 0x%x\n", addr,
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set.control = 0x%x\n", addr,
(unsigned int)temp);
addr = &ir_set->erst_size;
temp = xhci_readl(xhci, addr);
- xhci_dbg(xhci, " %p: ir_set.erst_size = 0x%x\n", addr,
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set.erst_size = 0x%x\n", addr,
(unsigned int)temp);
addr = &ir_set->rsvd;
temp = xhci_readl(xhci, addr);
if (temp != XHCI_INIT_VALUE)
- xhci_dbg(xhci, " WARN: %p: ir_set.rsvd = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " WARN: %p: ir_set.rsvd = 0x%x\n",
addr, (unsigned int)temp);
addr = &ir_set->erst_base;
temp_64 = xhci_read_64(xhci, addr);
- xhci_dbg(xhci, " %p: ir_set.erst_base = @%08llx\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set.erst_base = @%08llx\n",
addr, temp_64);
addr = &ir_set->erst_dequeue;
temp_64 = xhci_read_64(xhci, addr);
- xhci_dbg(xhci, " %p: ir_set.erst_dequeue = @%08llx\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: ir_set.erst_dequeue = @%08llx\n",
addr, temp_64);
}
@@ -217,15 +262,18 @@ void xhci_print_run_regs(struct xhci_hcd *xhci)
u32 temp;
int i;
- xhci_dbg(xhci, "xHCI runtime registers at %p:\n", xhci->run_regs);
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ "xHCI runtime registers at %p:\n", xhci->run_regs);
temp = xhci_readl(xhci, &xhci->run_regs->microframe_index);
- xhci_dbg(xhci, " %p: Microframe index = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " %p: Microframe index = 0x%x\n",
&xhci->run_regs->microframe_index,
(unsigned int) temp);
for (i = 0; i < 7; ++i) {
temp = xhci_readl(xhci, &xhci->run_regs->rsvd[i]);
if (temp != XHCI_INIT_VALUE)
- xhci_dbg(xhci, " WARN: %p: Rsvd[%i] = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_REGS,
+ " WARN: %p: Rsvd[%i] = 0x%x\n",
&xhci->run_regs->rsvd[i],
i, (unsigned int) temp);
}
@@ -242,7 +290,8 @@ void xhci_print_trb_offsets(struct xhci_hcd *xhci, union xhci_trb *trb)
{
int i;
for (i = 0; i < 4; ++i)
- xhci_dbg(xhci, "Offset 0x%x = 0x%x\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Offset 0x%x = 0x%x\n",
i*4, trb->generic.field[i]);
}
@@ -253,22 +302,30 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
{
u64 address;
u32 type = xhci_readl(xhci, &trb->link.control) & TRB_TYPE_BITMASK;
+ unsigned int temp;
switch (type) {
case TRB_TYPE(TRB_LINK):
- xhci_dbg(xhci, "Link TRB:\n");
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Link TRB:\n");
xhci_print_trb_offsets(xhci, trb);
address = trb->link.segment_ptr;
- xhci_dbg(xhci, "Next ring segment DMA address = 0x%llx\n", address);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Next ring segment DMA address = 0x%llx\n",
+ address);
- xhci_dbg(xhci, "Interrupter target = 0x%x\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Interrupter target = 0x%x\n",
GET_INTR_TARGET(trb->link.intr_target));
- xhci_dbg(xhci, "Cycle bit = %u\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Cycle bit = %u\n",
(unsigned int) (trb->link.control & TRB_CYCLE));
- xhci_dbg(xhci, "Toggle cycle bit = %u\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Toggle cycle bit = %u\n",
(unsigned int) (trb->link.control & LINK_TOGGLE));
- xhci_dbg(xhci, "No Snoop bit = %u\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "No Snoop bit = %u\n",
(unsigned int) (trb->link.control & TRB_NO_SNOOP));
break;
case TRB_TYPE(TRB_TRANSFER):
@@ -277,17 +334,24 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
* FIXME: look at flags to figure out if it's an address or if
* the data is directly in the buffer field.
*/
- xhci_dbg(xhci, "DMA address or buffer contents= %llu\n", address);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "DMA address or buffer contents= %llu\n",
+ address);
break;
case TRB_TYPE(TRB_COMPLETION):
address = trb->event_cmd.cmd_trb;
- xhci_dbg(xhci, "Command TRB pointer = %llu\n", address);
- xhci_dbg(xhci, "Completion status = %u\n",
- (unsigned int) GET_COMP_CODE(trb->event_cmd.status));
- xhci_dbg(xhci, "Flags = 0x%x\n", (unsigned int) trb->event_cmd.flags);
+ temp = GET_COMP_CODE(trb->event_cmd.status);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Command TRB pointer = %llu\n", address);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Completion status = %u\n", temp);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Flags = 0x%x\n",
+ (unsigned int) trb->event_cmd.flags);
break;
default:
- xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n",
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_TX_VERBOSE),
+ "Unknown TRB with TRB type ID %u\n",
(unsigned int) type>>10);
xhci_print_trb_offsets(xhci, trb);
break;
@@ -315,7 +379,8 @@ void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg)
for (i = 0; i < TRBS_PER_SEGMENT; ++i) {
trb = &seg->trbs[i];
- xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n", addr,
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "@%08x %08x %08x %08x %08x\n",
+ addr,
lower_32_bits(trb->link.segment_ptr),
upper_32_bits(trb->link.segment_ptr),
(unsigned int) trb->link.intr_target,
@@ -326,17 +391,17 @@ void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg)
void xhci_dbg_ring_ptrs(struct xhci_hcd *xhci, struct xhci_ring *ring)
{
- xhci_dbg(xhci, "Ring deq = %p (virt), 0x%llx (dma)\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ring deq = %p (virt), 0x%llx (dma)\n",
ring->dequeue,
(unsigned long long)xhci_trb_virt_to_dma(ring->deq_seg,
ring->dequeue));
- xhci_dbg(xhci, "Ring deq updated %u times\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ring deq updated %u times\n",
ring->deq_updates);
- xhci_dbg(xhci, "Ring enq = %p (virt), 0x%llx (dma)\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ring enq = %p (virt), 0x%llx (dma)\n",
ring->enqueue,
(unsigned long long)xhci_trb_virt_to_dma(ring->enq_seg,
ring->enqueue));
- xhci_dbg(xhci, "Ring enq updated %u times\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ring enq updated %u times\n",
ring->enq_updates);
}
@@ -357,7 +422,8 @@ void xhci_debug_ring(struct xhci_hcd *xhci, struct xhci_ring *ring)
xhci_debug_segment(xhci, first_seg);
if (!ring->enq_updates && !ring->deq_updates) {
- xhci_dbg(xhci, " Ring has not been updated\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ " Ring has not been updated\n");
return;
}
for (seg = first_seg->next; seg != first_seg; seg = seg->next)
@@ -372,7 +438,8 @@ void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
for (i = 0; i < erst->num_entries; ++i) {
entry = &erst->entries[i];
- xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "@%08x %08x %08x %08x %08x\n",
(unsigned int) addr,
lower_32_bits(entry->seg_addr),
upper_32_bits(entry->seg_addr),
@@ -387,21 +454,25 @@ void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci)
u64 val;
val = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
- xhci_dbg(xhci, "// xHC command ring deq ptr low bits + flags = @%08x\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "xHC command ring deq ptr low bits + flags = @%08x\n",
lower_32_bits(val));
- xhci_dbg(xhci, "// xHC command ring deq ptr high bits = @%08x\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "xHC command ring deq ptr high bits = @%08x\n",
upper_32_bits(val));
}
/* Print the last 32 bytes for 64-byte contexts */
-static void dbg_rsvd64(struct xhci_hcd *xhci, u64 *ctx, dma_addr_t dma)
+static void dbg_rsvd64(struct xhci_hcd *xhci, u64 *ctx, dma_addr_t dma,
+ int log_level)
{
int i;
for (i = 0; i < 4; ++i) {
- xhci_dbg(xhci, "@%p (virt) @%08llx "
- "(dma) %#08llx - rsvd64[%d]\n",
- &ctx[4 + i], (unsigned long long)dma,
- ctx[4 + i], i);
+ xhci_dbg(xhci, log_level,
+ "@%p (virt) @%08llx "
+ "(dma) %#08llx - rsvd64[%d]\n",
+ &ctx[4 + i], (unsigned long long)dma,
+ ctx[4 + i], i);
dma += 8;
}
}
@@ -436,32 +507,37 @@ void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
((unsigned long)slot_ctx - (unsigned long)ctx->bytes);
int csz = HCC_64BYTE_CONTEXT(xhci->hcc_params);
- xhci_dbg(xhci, "Slot Context:\n");
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE, "Slot Context:\n");
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - dev_info\n",
&slot_ctx->dev_info,
(unsigned long long)dma, slot_ctx->dev_info);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info2\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - dev_info2\n",
&slot_ctx->dev_info2,
(unsigned long long)dma, slot_ctx->dev_info2);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tt_info\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - tt_info\n",
&slot_ctx->tt_info,
(unsigned long long)dma, slot_ctx->tt_info);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_state\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - dev_state\n",
&slot_ctx->dev_state,
(unsigned long long)dma, slot_ctx->dev_state);
dma += field_size;
for (i = 0; i < 4; ++i) {
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
&slot_ctx->reserved[i], (unsigned long long)dma,
slot_ctx->reserved[i], i);
dma += field_size;
}
if (csz)
- dbg_rsvd64(xhci, (u64 *)slot_ctx, dma);
+ dbg_rsvd64(xhci, (u64 *)slot_ctx, dma, XHCI_LOG_DEVICE_STATE);
}
void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
@@ -481,25 +557,32 @@ void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
dma_addr_t dma = ctx->dma +
((unsigned long)ep_ctx - (unsigned long)ctx->bytes);
- xhci_dbg(xhci, "Endpoint %02d Context:\n", i);
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "Endpoint %02d Context:\n", i);
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - ep_info\n",
&ep_ctx->ep_info,
(unsigned long long)dma, ep_ctx->ep_info);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info2\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - ep_info2\n",
&ep_ctx->ep_info2,
(unsigned long long)dma, ep_ctx->ep_info2);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08llx - deq\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08llx - deq\n",
&ep_ctx->deq,
(unsigned long long)dma, ep_ctx->deq);
dma += 2*field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tx_info\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x - tx_info\n",
&ep_ctx->tx_info,
(unsigned long long)dma, ep_ctx->tx_info);
dma += field_size;
for (j = 0; j < 3; ++j) {
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "@%p (virt) @%08llx (dma) %#08x "
+ "- rsvd[%d]\n",
&ep_ctx->reserved[j],
(unsigned long long)dma,
ep_ctx->reserved[j], j);
@@ -507,7 +590,8 @@ void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
}
if (csz)
- dbg_rsvd64(xhci, (u64 *)ep_ctx, dma);
+ dbg_rsvd64(xhci, (u64 *)ep_ctx, dma,
+ XHCI_LOG_DEVICE_STATE);
}
}
@@ -525,23 +609,29 @@ void xhci_dbg_ctx(struct xhci_hcd *xhci,
if (ctx->type == XHCI_CTX_TYPE_INPUT) {
struct xhci_input_control_ctx *ctrl_ctx =
xhci_get_input_control_ctx(xhci, ctx);
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - drop flags\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "@%p (virt) @%08llx (dma) %#08x - drop flags\n",
&ctrl_ctx->drop_flags, (unsigned long long)dma,
ctrl_ctx->drop_flags);
dma += field_size;
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - add flags\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "@%p (virt) @%08llx (dma) %#08x - add flags\n",
&ctrl_ctx->add_flags, (unsigned long long)dma,
ctrl_ctx->add_flags);
dma += field_size;
for (i = 0; i < 6; ++i) {
- xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd2[%d]\n",
- &ctrl_ctx->rsvd2[i], (unsigned long long)dma,
- ctrl_ctx->rsvd2[i], i);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "@%p (virt) @%08llx (dma) %#08x"
+ " - rsvd2[%d]\n",
+ &ctrl_ctx->rsvd2[i],
+ (unsigned long long)dma,
+ ctrl_ctx->rsvd2[i], i);
dma += field_size;
}
if (csz)
- dbg_rsvd64(xhci, (u64 *)ctrl_ctx, dma);
+ dbg_rsvd64(xhci, (u64 *)ctrl_ctx, dma,
+ XHCI_LOG_COMMANDS_VERBOSE);
}
slot_ctx = xhci_get_slot_ctx(xhci, ctx);
diff --git a/drivers/usb/host/xhci-hcd.c b/drivers/usb/host/xhci-hcd.c
index 4cb69e0..200cd47 100644
--- a/drivers/usb/host/xhci-hcd.c
+++ b/drivers/usb/host/xhci-hcd.c
@@ -34,6 +34,11 @@ static int link_quirk;
module_param(link_quirk, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
+/* Logging level bitmask, see xhci.h */
+static int log_level = XHCI_LOG_QUIRKS | XHCI_LOG_COMMANDS | XHCI_LOG_TX;
+module_param(log_level, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(log_level, "Log level bitmask");
+
/* TODO: copied from ehci-hcd.c - can this be refactored? */
/*
* handshake - spin reading hc until handshake completes or fails
@@ -96,7 +101,7 @@ void xhci_quiesce(struct xhci_hcd *xhci)
*/
int xhci_halt(struct xhci_hcd *xhci)
{
- xhci_dbg(xhci, "// Halt the HC\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS, "Halt the HC\n");
xhci_quiesce(xhci);
return handshake(xhci, &xhci->op_regs->status,
@@ -121,7 +126,7 @@ int xhci_reset(struct xhci_hcd *xhci)
return 0;
}
- xhci_dbg(xhci, "// Reset the HC\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS, "Reset the HC\n");
command = xhci_readl(xhci, &xhci->op_regs->command);
command |= CMD_RESET;
xhci_writel(xhci, command, &xhci->op_regs->command);
@@ -164,7 +169,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
xhci_err(xhci, "Failed to allocate MSI-X interrupt\n");
goto disable_msix;
}
- xhci_dbg(xhci, "Finished setting up MSI-X\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Finished setting up MSI-X\n");
return 0;
disable_msix:
@@ -187,7 +192,7 @@ static void xhci_cleanup_msix(struct xhci_hcd *xhci)
pci_disable_msix(pdev);
kfree(xhci->msix_entries);
xhci->msix_entries = NULL;
- xhci_dbg(xhci, "Finished cleaning up MSI-X\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Finished cleaning up MSI-X\n");
}
#endif
@@ -203,16 +208,19 @@ int xhci_init(struct usb_hcd *hcd)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
int retval = 0;
- xhci_dbg(xhci, "xhci_init\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "xhci_init\n");
spin_lock_init(&xhci->lock);
if (link_quirk) {
- xhci_dbg(xhci, "QUIRK: Not clearing Link TRB chain bits.\n");
+ xhci_dbg(xhci, XHCI_LOG_QUIRKS,
+ "QUIRK: Not clearing Link TRB chain bits.\n");
xhci->quirks |= XHCI_LINK_TRB_QUIRK;
} else {
- xhci_dbg(xhci, "xHCI doesn't need link TRB QUIRK\n");
+ xhci_dbg(xhci, XHCI_LOG_QUIRKS,
+ "xHCI doesn't need link TRB QUIRK\n");
}
+ xhci->log_level = log_level;
retval = xhci_mem_init(xhci, GFP_KERNEL);
- xhci_dbg(xhci, "Finished xhci_init\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Finished xhci_init\n");
return retval;
}
@@ -247,7 +255,7 @@ static void xhci_work(struct xhci_hcd *xhci)
xhci_readl(xhci, &xhci->ir_set->irq_pending);
if (xhci->xhc_state & XHCI_STATE_DYING)
- xhci_dbg(xhci, "xHCI dying, ignoring interrupt. "
+ xhci_warn(xhci, "xHCI dying, ignoring interrupt. "
"Shouldn't IRQs be disabled?\n");
else
/* FIXME this should be a delayed service routine
@@ -287,10 +295,9 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
spin_unlock(&xhci->lock);
return IRQ_NONE;
}
- xhci_dbg(xhci, "op reg status = %08x\n", temp);
- xhci_dbg(xhci, "ir set irq_pending = %08x\n", temp2);
- xhci_dbg(xhci, "Event ring dequeue ptr:\n");
- xhci_dbg(xhci, "@%llx %08x %08x %08x %08x\n",
+ xhci_dbg(xhci, XHCI_LOG_EVENTS,
+ "xHCI IRQ -- event ring dequeue ptr:\n");
+ xhci_dbg(xhci, XHCI_LOG_EVENTS, "@%llx %08x %08x %08x %08x\n",
(unsigned long long)xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, trb),
lower_32_bits(trb->link.segment_ptr),
upper_32_bits(trb->link.segment_ptr),
@@ -321,29 +328,33 @@ void xhci_event_ring_work(unsigned long arg)
struct xhci_hcd *xhci = (struct xhci_hcd *) arg;
int i, j;
- xhci_dbg(xhci, "Poll event ring: %lu\n", jiffies);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Poll event ring: %lu\n", jiffies);
spin_lock_irqsave(&xhci->lock, flags);
temp = xhci_readl(xhci, &xhci->op_regs->status);
- xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "op reg status = 0x%x\n", temp);
if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
- xhci_dbg(xhci, "HW died, polling stopped.\n");
+ xhci_warn(xhci, "HW died, polling stopped.\n");
spin_unlock_irqrestore(&xhci->lock, flags);
return;
}
temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
- xhci_dbg(xhci, "ir_set 0 pending = 0x%x\n", temp);
- xhci_dbg(xhci, "No-op commands handled = %d\n", xhci->noops_handled);
- xhci_dbg(xhci, "HC error bitmask = 0x%x\n", xhci->error_bitmask);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "ir_set 0 pending = 0x%x\n", temp);
+ xhci_dbg(xhci, XHCI_LOG_NOOPS, "No-op commands handled = %d\n",
+ xhci->noops_handled);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "HC error bitmask = 0x%x\n",
+ xhci->error_bitmask);
+
xhci->error_bitmask = 0;
- xhci_dbg(xhci, "Event ring:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Event ring:\n");
xhci_debug_segment(xhci, xhci->event_ring->deq_seg);
xhci_dbg_ring_ptrs(xhci, xhci->event_ring);
temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
temp_64 &= ~ERST_PTR_MASK;
- xhci_dbg(xhci, "ERST deq = 64'h%0lx\n", (long unsigned int) temp_64);
- xhci_dbg(xhci, "Command ring:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "ERST deq = 64'h%0lx\n",
+ (long unsigned int) temp_64);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Command ring:\n");
xhci_debug_segment(xhci, xhci->cmd_ring->deq_seg);
xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
xhci_dbg_cmd_ptrs(xhci);
@@ -354,7 +365,14 @@ void xhci_event_ring_work(unsigned long arg)
struct xhci_ring *ring = xhci->devs[i]->eps[j].ring;
if (!ring)
continue;
- xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);
+ if (!ring->enq_updates && !ring->deq_updates) {
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Dev %d endpoint ring %d "
+ "is unused:\n", i, j);
+ continue;
+ }
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Dev %d endpoint ring %d:\n", i, j);
xhci_debug_segment(xhci, ring->deq_seg);
}
}
@@ -366,8 +384,6 @@ void xhci_event_ring_work(unsigned long arg)
if (!xhci->zombie)
mod_timer(&xhci->event_ring_timer, jiffies + POLL_TIMEOUT * HZ);
- else
- xhci_dbg(xhci, "Quit polling the event ring.\n");
}
#endif
@@ -393,7 +409,6 @@ int xhci_run(struct usb_hcd *hcd)
hcd->uses_new_polling = 1;
hcd->poll_rh = 0;
- xhci_dbg(xhci, "xhci_run\n");
#if 0 /* FIXME: MSI not setup yet */
/* Do this at the very last minute */
ret = xhci_setup_msix(xhci);
@@ -409,25 +424,25 @@ int xhci_run(struct usb_hcd *hcd)
/* Poll the event ring */
xhci->event_ring_timer.expires = jiffies + POLL_TIMEOUT * HZ;
xhci->zombie = 0;
- xhci_dbg(xhci, "Setting event ring polling timer\n");
add_timer(&xhci->event_ring_timer);
#endif
- xhci_dbg(xhci, "Command ring memory map follows:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Command ring memory map follows:\n");
xhci_debug_ring(xhci, xhci->cmd_ring);
xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
xhci_dbg_cmd_ptrs(xhci);
- xhci_dbg(xhci, "ERST memory map follows:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "ERST memory map follows:\n");
xhci_dbg_erst(xhci, &xhci->erst);
- xhci_dbg(xhci, "Event ring:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Event ring:\n");
xhci_debug_ring(xhci, xhci->event_ring);
xhci_dbg_ring_ptrs(xhci, xhci->event_ring);
temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
temp_64 &= ~ERST_PTR_MASK;
- xhci_dbg(xhci, "ERST deq = 64'h%0lx\n", (long unsigned int) temp_64);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "ERST deq = 64'h%0lx\n",
+ (long unsigned int) temp_64);
- xhci_dbg(xhci, "// Set the interrupt modulation register\n");
+ /* Set the interrupt modulation register */
temp = xhci_readl(xhci, &xhci->ir_set->irq_control);
temp &= ~ER_IRQ_INTERVAL_MASK;
temp |= (u32) 160;
@@ -437,13 +452,9 @@ int xhci_run(struct usb_hcd *hcd)
hcd->state = HC_STATE_RUNNING;
temp = xhci_readl(xhci, &xhci->op_regs->command);
temp |= (CMD_EIE);
- xhci_dbg(xhci, "// Enable interrupts, cmd = 0x%x.\n",
- temp);
xhci_writel(xhci, temp, &xhci->op_regs->command);
temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
- xhci_dbg(xhci, "// Enabling event ring interrupter %p by writing 0x%x to irq_pending\n",
- xhci->ir_set, (unsigned int) ER_IRQ_ENABLE(temp));
xhci_writel(xhci, ER_IRQ_ENABLE(temp),
&xhci->ir_set->irq_pending);
xhci_print_ir_set(xhci, xhci->ir_set, 0);
@@ -453,16 +464,14 @@ int xhci_run(struct usb_hcd *hcd)
temp = xhci_readl(xhci, &xhci->op_regs->command);
temp |= (CMD_RUN);
- xhci_dbg(xhci, "// Turn on HC, cmd = 0x%x.\n",
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Turn on HC, cmd = 0x%x.\n",
temp);
xhci_writel(xhci, temp, &xhci->op_regs->command);
/* Flush PCI posted writes */
temp = xhci_readl(xhci, &xhci->op_regs->command);
- xhci_dbg(xhci, "// @%p = 0x%x\n", &xhci->op_regs->command, temp);
if (doorbell)
(*doorbell)(xhci);
- xhci_dbg(xhci, "Finished xhci_run\n");
return 0;
}
@@ -494,7 +503,6 @@ void xhci_stop(struct usb_hcd *hcd)
del_timer_sync(&xhci->event_ring_timer);
#endif
- xhci_dbg(xhci, "// Disabling event ring interrupts\n");
temp = xhci_readl(xhci, &xhci->op_regs->status);
xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
@@ -502,9 +510,8 @@ void xhci_stop(struct usb_hcd *hcd)
&xhci->ir_set->irq_pending);
xhci_print_ir_set(xhci, xhci->ir_set, 0);
- xhci_dbg(xhci, "cleaning up memory\n");
xhci_mem_cleanup(xhci);
- xhci_dbg(xhci, "xhci_stop completed - status = %x\n",
+ xhci_dbg(xhci, XHCI_LOG_INIT, "xhci_stop completed - status = %x\n",
xhci_readl(xhci, &xhci->op_regs->status));
}
@@ -527,7 +534,7 @@ void xhci_shutdown(struct usb_hcd *hcd)
xhci_cleanup_msix(xhci);
#endif
- xhci_dbg(xhci, "xhci_shutdown completed - status = %x\n",
+ xhci_dbg(xhci, XHCI_LOG_INIT, "xhci_shutdown completed - status = %x\n",
xhci_readl(xhci, &xhci->op_regs->status));
}
@@ -588,21 +595,12 @@ unsigned int xhci_last_valid_endpoint(u32 added_ctxs)
*/
int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
struct usb_host_endpoint *ep, int check_ep, const char *func) {
- if (!hcd || (check_ep && !ep) || !udev) {
- printk(KERN_DEBUG "xHCI %s called with invalid args\n",
- func);
+ if (!hcd || (check_ep && !ep) || !udev)
return -EINVAL;
- }
- if (!udev->parent) {
- printk(KERN_DEBUG "xHCI %s called for root hub\n",
- func);
+ if (!udev->parent)
return 0;
- }
- if (!udev->slot_id) {
- printk(KERN_DEBUG "xHCI %s called with unaddressed device\n",
- func);
+ if (!udev->slot_id)
return -EINVAL;
- }
return 1;
}
@@ -632,12 +630,16 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
hw_max_packet_size = MAX_PACKET_DECODED(ep_ctx->ep_info2);
max_packet_size = urb->dev->ep0.desc.wMaxPacketSize;
if (hw_max_packet_size != max_packet_size) {
- xhci_dbg(xhci, "Max Packet Size for ep 0 changed.\n");
- xhci_dbg(xhci, "Max packet size in usb_device = %d\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Max Packet Size for ep 0 changed.\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Max packet size in usb_device = %d\n",
max_packet_size);
- xhci_dbg(xhci, "Max packet size in xHCI HW = %d\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Max packet size in xHCI HW = %d\n",
hw_max_packet_size);
- xhci_dbg(xhci, "Issuing evaluate context command.\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Issuing evaluate context command.\n");
/* Set up the modified control endpoint 0 */
xhci_endpoint_copy(xhci, xhci->devs[slot_id]->in_ctx,
@@ -655,9 +657,11 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
ctrl_ctx->add_flags = EP0_FLAG;
ctrl_ctx->drop_flags = 0;
- xhci_dbg(xhci, "Slot %d input context\n", slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot %d input context\n", slot_id);
xhci_dbg_ctx(xhci, in_ctx, ep_index);
- xhci_dbg(xhci, "Slot %d output context\n", slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot %d output context\n", slot_id);
xhci_dbg_ctx(xhci, out_ctx, ep_index);
ret = xhci_configure_endpoint(xhci, urb->dev, NULL,
@@ -690,14 +694,14 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
ep_index = xhci_get_endpoint_index(&urb->ep->desc);
if (!xhci->devs || !xhci->devs[slot_id]) {
- if (!in_interrupt())
- dev_warn(&urb->dev->dev, "WARN: urb submitted for dev with no Slot ID\n");
+ xhci_warn(xhci, "WARN: urb submitted for dev "
+ "with no Slot ID\n");
ret = -EINVAL;
goto exit;
}
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
- if (!in_interrupt())
- xhci_dbg(xhci, "urb submitted during PCI suspend\n");
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "urb submitted during PCI suspend\n");
ret = -ESHUTDOWN;
goto exit;
}
@@ -741,7 +745,7 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
exit:
return ret;
dying:
- xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for "
+ xhci_dbg(xhci, XHCI_LOG_TX, "Ep 0x%x: URB %p submitted for "
"non-responsive xHCI host.\n",
urb->ep->desc.bEndpointAddress, urb);
spin_unlock_irqrestore(&xhci->lock, flags);
@@ -798,7 +802,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
goto done;
temp = xhci_readl(xhci, &xhci->op_regs->status);
if (temp == 0xffffffff) {
- xhci_dbg(xhci, "HW died, freeing TD.\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "HW died, freeing TD.\n");
td = (struct xhci_td *) urb->hcpriv;
usb_hcd_unlink_urb_from_ep(hcd, urb);
@@ -808,7 +812,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
return ret;
}
if (xhci->xhc_state & XHCI_STATE_DYING) {
- xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
+ xhci_dbg(xhci, XHCI_LOG_TX, "Ep 0x%x: URB %p to be canceled on "
"non-responsive xHCI host.\n",
urb->ep->desc.bEndpointAddress, urb);
/* Let the stop endpoint command watchdog timer (which set this
@@ -819,13 +823,13 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
goto done;
}
- xhci_dbg(xhci, "Cancel URB %p\n", urb);
- xhci_dbg(xhci, "Event ring:\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Cancel URB %p\n", urb);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Event ring:\n");
xhci_debug_ring(xhci, xhci->event_ring);
ep_index = xhci_get_endpoint_index(&urb->ep->desc);
ep = &xhci->devs[urb->dev->slot_id]->eps[ep_index];
ep_ring = ep->ring;
- xhci_dbg(xhci, "Endpoint ring:\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Endpoint ring:\n");
xhci_debug_ring(xhci, ep_ring);
td = (struct xhci_td *) urb->hcpriv;
@@ -878,12 +882,11 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
if (ret <= 0)
return ret;
xhci = hcd_to_xhci(hcd);
- xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "%s called for udev %p\n", __func__, udev);
drop_flag = xhci_get_endpoint_flag(&ep->desc);
if (drop_flag == SLOT_FLAG || drop_flag == EP0_FLAG) {
- xhci_dbg(xhci, "xHCI %s - can't drop slot or ep 0 %#x\n",
- __func__, drop_flag);
return 0;
}
@@ -925,7 +928,9 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep);
- xhci_dbg(xhci, "drop ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x, new slot info = %#x\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "drop ep 0x%x, slot id %d, new drop flags = %#x, "
+ "new add flags = %#x, new slot info = %#x\n",
(unsigned int) ep->desc.bEndpointAddress,
udev->slot_id,
(unsigned int) new_drop_flags,
@@ -972,12 +977,6 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
added_ctxs = xhci_get_endpoint_flag(&ep->desc);
last_ctx = xhci_last_valid_endpoint(added_ctxs);
if (added_ctxs == SLOT_FLAG || added_ctxs == EP0_FLAG) {
- /* FIXME when we have to issue an evaluate endpoint command to
- * deal with ep0 max packet size changing once we get the
- * descriptors
- */
- xhci_dbg(xhci, "xHCI %s - can't add slot or ep 0 %#x\n",
- __func__, added_ctxs);
return 0;
}
@@ -1008,7 +1007,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
*/
if (xhci_endpoint_init(xhci, xhci->devs[udev->slot_id],
udev, ep, GFP_NOIO) < 0) {
- dev_dbg(&udev->dev, "%s - could not initialize ep %#x\n",
+ xhci_warn(xhci, "%s - could not initialize ep %#x\n",
__func__, ep->desc.bEndpointAddress);
return -ENOMEM;
}
@@ -1035,7 +1034,9 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
/* Store the usb_device pointer for later use */
ep->hcpriv = udev;
- xhci_dbg(xhci, "add ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x, new slot info = %#x\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "add ep 0x%x, slot id %d, new drop flags = %#x, "
+ "new add flags = %#x, new slot info = %#x\n",
(unsigned int) ep->desc.bEndpointAddress,
udev->slot_id,
(unsigned int) new_drop_flags,
@@ -1079,26 +1080,27 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
switch (*cmd_status) {
case COMP_ENOMEM:
- dev_warn(&udev->dev, "Not enough host controller resources "
+ xhci_warn(xhci, "Not enough host controller resources "
"for new device state.\n");
ret = -ENOMEM;
/* FIXME: can we allocate more resources for the HC? */
break;
case COMP_BW_ERR:
- dev_warn(&udev->dev, "Not enough bandwidth "
+ xhci_warn(xhci, "Not enough bandwidth "
"for new device state.\n");
ret = -ENOSPC;
/* FIXME: can we go back to the old state? */
break;
case COMP_TRB_ERR:
/* the HCD set up something wrong */
- dev_warn(&udev->dev, "ERROR: Endpoint drop flag = 0, "
+ xhci_warn(xhci, "ERROR: Endpoint drop flag = 0, "
"add flag = 1, "
"and endpoint is not disabled.\n");
ret = -EINVAL;
break;
case COMP_SUCCESS:
- dev_dbg(&udev->dev, "Successful Endpoint Configure command\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Successful Endpoint Configure command\n");
ret = 0;
break;
default:
@@ -1118,21 +1120,22 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
switch (*cmd_status) {
case COMP_EINVAL:
- dev_warn(&udev->dev, "WARN: xHCI driver setup invalid evaluate "
+ xhci_warn(xhci, "WARN: xHCI driver setup invalid evaluate "
"context command.\n");
ret = -EINVAL;
break;
case COMP_EBADSLT:
- dev_warn(&udev->dev, "WARN: slot not enabled for"
+ xhci_warn(xhci, "WARN: slot not enabled for"
"evaluate context command.\n");
case COMP_CTX_STATE:
- dev_warn(&udev->dev, "WARN: invalid context state for "
+ xhci_warn(xhci, "WARN: invalid context state for "
"evaluate context command.\n");
xhci_dbg_ctx(xhci, virt_dev->out_ctx, 1);
ret = -EINVAL;
break;
case COMP_SUCCESS:
- dev_dbg(&udev->dev, "Successful evaluate context command\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Successful evaluate context command\n");
ret = 0;
break;
default:
@@ -1184,7 +1187,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
if (command)
list_del(&command->cmd_list);
spin_unlock_irqrestore(&xhci->lock, flags);
- xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
+ xhci_warn(xhci, "FIXME allocate a new ring segment\n");
return -ENOMEM;
}
xhci_ring_cmd_db(xhci);
@@ -1238,7 +1241,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
__func__);
return -EINVAL;
}
- xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "%s called for udev %p\n", __func__, udev);
virt_dev = xhci->devs[udev->slot_id];
/* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
@@ -1247,7 +1251,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
ctrl_ctx->add_flags &= ~EP0_FLAG;
ctrl_ctx->drop_flags &= ~SLOT_FLAG;
ctrl_ctx->drop_flags &= ~EP0_FLAG;
- xhci_dbg(xhci, "New Input Control Context:\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "New Input Control Context:\n");
slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
xhci_dbg_ctx(xhci, virt_dev->in_ctx,
LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
@@ -1259,7 +1264,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
return ret;
}
- xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Output context after successful config ep cmd:\n");
xhci_dbg_ctx(xhci, virt_dev->out_ctx,
LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
@@ -1297,7 +1303,8 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
__func__);
return;
}
- xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "%s called for udev %p\n", __func__, udev);
virt_dev = xhci->devs[udev->slot_id];
/* Free any rings allocated for added endpoints */
for (i = 0; i < 31; ++i) {
@@ -1321,7 +1328,7 @@ static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci,
xhci_slot_copy(xhci, in_ctx, out_ctx);
ctrl_ctx->add_flags |= SLOT_FLAG;
- xhci_dbg(xhci, "Input Context:\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE, "Input Context:\n");
xhci_dbg_ctx(xhci, in_ctx, xhci_last_valid_endpoint(add_flags));
}
@@ -1361,7 +1368,8 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
struct xhci_dequeue_state deq_state;
struct xhci_virt_ep *ep;
- xhci_dbg(xhci, "Cleaning up stalled endpoint ring\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Cleaning up stalled endpoint ring\n");
ep = &xhci->devs[udev->slot_id]->eps[ep_index];
/* We need to move the HW's dequeue pointer past this TD,
* or it will attempt to resend it on the next doorbell ring.
@@ -1374,14 +1382,16 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
* issue a configure endpoint command later.
*/
if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {
- xhci_dbg(xhci, "Queueing new dequeue state\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Queueing new dequeue state\n");
xhci_queue_new_dequeue_state(xhci, udev->slot_id,
ep_index, &deq_state);
} else {
/* Better hope no one uses the input context between now and the
* reset endpoint completion!
*/
- xhci_dbg(xhci, "Setting up input context for "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Setting up input context for "
"configure endpoint command\n");
xhci_setup_input_ctx_for_quirk(xhci, udev->slot_id,
ep_index, &deq_state);
@@ -1414,16 +1424,13 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
ep_index = xhci_get_endpoint_index(&ep->desc);
virt_ep = &xhci->devs[udev->slot_id]->eps[ep_index];
if (!virt_ep->stopped_td) {
- xhci_dbg(xhci, "Endpoint 0x%x not halted, refusing to reset.\n",
- ep->desc.bEndpointAddress);
return;
}
if (usb_endpoint_xfer_control(&ep->desc)) {
- xhci_dbg(xhci, "Control endpoint stall already handled.\n");
return;
}
- xhci_dbg(xhci, "Queueing reset endpoint command\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS, "Queueing reset endpoint command\n");
spin_lock_irqsave(&xhci->lock, flags);
ret = xhci_queue_reset_ep(xhci, udev->slot_id, ep_index);
/*
@@ -1473,12 +1480,14 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
slot_id = udev->slot_id;
virt_dev = xhci->devs[slot_id];
if (!virt_dev) {
- xhci_dbg(xhci, "%s called with invalid slot ID %u\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "%s called with invalid slot ID %u\n",
__func__, slot_id);
return -EINVAL;
}
- xhci_dbg(xhci, "Resetting device with slot ID %u\n", slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Resetting device with slot ID %u\n", slot_id);
/* Allocate the command structure that holds the struct completion.
* Assume we're in process context, since the normal device reset
* process has to wait for the device anyway. Storage devices are
@@ -1487,7 +1496,8 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
*/
reset_device_cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
if (!reset_device_cmd) {
- xhci_dbg(xhci, "Couldn't allocate command structure.\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Couldn't allocate command structure.\n");
return -ENOMEM;
}
@@ -1497,7 +1507,7 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
ret = xhci_queue_reset_device(xhci, slot_id);
if (ret) {
- xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+ xhci_warn(xhci, "FIXME: allocate a command ring segment\n");
list_del(&reset_device_cmd->cmd_list);
spin_unlock_irqrestore(&xhci->lock, flags);
goto command_cleanup;
@@ -1539,7 +1549,8 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
ret = 0;
goto command_cleanup;
case COMP_SUCCESS:
- xhci_dbg(xhci, "Successful reset device command.\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Successful reset device command.\n");
break;
default:
if (xhci_is_vendor_info_code(xhci, ret))
@@ -1558,7 +1569,8 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
last_freed_endpoint = i;
}
- xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Output context after successful reset device cmd:\n");
xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
ret = 0;
@@ -1603,7 +1615,7 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
if (xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id)) {
spin_unlock_irqrestore(&xhci->lock, flags);
- xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+ xhci_warn(xhci, "FIXME: allocate a command ring segment\n");
return;
}
xhci_ring_cmd_db(xhci);
@@ -1629,7 +1641,7 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0);
if (ret) {
spin_unlock_irqrestore(&xhci->lock, flags);
- xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+ xhci_warn(xhci, "FIXME: allocate a command ring segment\n");
return 0;
}
xhci_ring_cmd_db(xhci);
@@ -1686,7 +1698,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
u64 temp_64;
if (!udev->slot_id) {
- xhci_dbg(xhci, "Bad Slot ID %d\n", udev->slot_id);
+ xhci_warn(xhci, "Bad Slot ID %d\n", udev->slot_id);
return -EINVAL;
}
@@ -1696,7 +1708,8 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
if (!udev->config)
xhci_setup_addressable_virt_dev(xhci, udev);
/* Otherwise, assume the core has the device configured how it wants */
- xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot ID %d Input Context:\n", udev->slot_id);
xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
spin_lock_irqsave(&xhci->lock, flags);
@@ -1704,7 +1717,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
udev->slot_id);
if (ret) {
spin_unlock_irqrestore(&xhci->lock, flags);
- xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+ xhci_warn(xhci, "FIXME: allocate a command ring segment\n");
return ret;
}
xhci_ring_cmd_db(xhci);
@@ -1732,16 +1745,18 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
ret = -EINVAL;
break;
case COMP_TX_ERR:
- dev_warn(&udev->dev, "Device not responding to set address.\n");
+ xhci_warn(xhci, "Device not responding to set address.\n");
ret = -EPROTO;
break;
case COMP_SUCCESS:
- xhci_dbg(xhci, "Successful Address Device command\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Successful Address Device command\n");
break;
default:
xhci_err(xhci, "ERROR: unexpected command completion "
"code 0x%x.\n", virt_dev->cmd_status);
- xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot ID %d Output Context:\n", udev->slot_id);
xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
ret = -EINVAL;
break;
@@ -1750,17 +1765,11 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
return ret;
}
temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
- xhci_dbg(xhci, "Op regs DCBAA ptr = %#016llx\n", temp_64);
- xhci_dbg(xhci, "Slot ID %d dcbaa entry @%p = %#016llx\n",
- udev->slot_id,
- &xhci->dcbaa->dev_context_ptrs[udev->slot_id],
- (unsigned long long)
- xhci->dcbaa->dev_context_ptrs[udev->slot_id]);
- xhci_dbg(xhci, "Output Context DMA address = %#08llx\n",
- (unsigned long long)virt_dev->out_ctx->dma);
- xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot ID %d Input Context:\n", udev->slot_id);
xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
- xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot ID %d Output Context:\n", udev->slot_id);
xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
/*
* USB core uses address 1 for the roothubs, so we add one to the
@@ -1773,7 +1782,8 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
ctrl_ctx->add_flags = 0;
ctrl_ctx->drop_flags = 0;
- xhci_dbg(xhci, "Device address = %d\n", udev->devnum);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Device address = %d\n", udev->devnum);
/* XXX Meh, not sure if anyone else but choose_address uses this. */
set_bit(udev->devnum, udev->bus->devmap.devicemap);
@@ -1806,7 +1816,7 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
}
config_cmd = xhci_alloc_command(xhci, true, true, mem_flags);
if (!config_cmd) {
- xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
+ xhci_warn(xhci, "Could not allocate xHCI command structure.\n");
return -ENOMEM;
}
@@ -1819,7 +1829,8 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
if (tt->multi)
slot_ctx->dev_info |= DEV_MTT;
if (xhci->hci_version > 0x95) {
- xhci_dbg(xhci, "xHCI version %x needs hub "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "xHCI version %x needs hub "
"TT think time and number of ports\n",
(unsigned int) xhci->hci_version);
slot_ctx->dev_info2 |= XHCI_MAX_PORTS(hdev->maxchild);
@@ -1832,17 +1843,20 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
think_time = (think_time / 666) - 1;
slot_ctx->tt_info |= TT_THINK_TIME(think_time);
} else {
- xhci_dbg(xhci, "xHCI version %x doesn't need hub "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "xHCI version %x doesn't need hub "
"TT think time or number of ports\n",
(unsigned int) xhci->hci_version);
}
slot_ctx->dev_state = 0;
spin_unlock_irqrestore(&xhci->lock, flags);
- xhci_dbg(xhci, "Set up %s for hub device.\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Set up %s for hub device.\n",
(xhci->hci_version > 0x95) ?
"configure endpoint" : "evaluate context");
- xhci_dbg(xhci, "Slot %u Input Context:\n", hdev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot %u Input Context:\n", hdev->slot_id);
xhci_dbg_ctx(xhci, config_cmd->in_ctx, 0);
/* Issue and wait for the configure endpoint or
@@ -1855,7 +1869,8 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
ret = xhci_configure_endpoint(xhci, hdev, config_cmd,
true, false);
- xhci_dbg(xhci, "Slot %u Output Context:\n", hdev->slot_id);
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Slot %u Output Context:\n", hdev->slot_id);
xhci_dbg_ctx(xhci, vdev->out_ctx, 0);
xhci_free_command(xhci, config_cmd);
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 208b805..dd73a2c 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -135,7 +135,8 @@ static void xhci_disable_port(struct xhci_hcd *xhci, u16 wIndex,
/* Write 1 to disable the port */
xhci_writel(xhci, port_status | PORT_PE, addr);
port_status = xhci_readl(xhci, addr);
- xhci_dbg(xhci, "disable port, actual port %d status = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_PORTS,
+ "disable port, actual port %d status = 0x%x\n",
wIndex, port_status);
}
@@ -169,8 +170,10 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
/* Change bits are all write 1 to clear */
xhci_writel(xhci, port_status | status, addr);
port_status = xhci_readl(xhci, addr);
- xhci_dbg(xhci, "clear port %s change, actual port %d status = 0x%x\n",
- port_change_bit, wIndex, port_status);
+ xhci_dbg(xhci, XHCI_LOG_PORTS,
+ "Clear port %d %s change,"
+ " actual status = 0x%x\n",
+ wIndex, port_change_bit, status);
}
int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
@@ -201,7 +204,6 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
status = 0;
addr = &xhci->op_regs->port_status_base + NUM_PORT_REGS*(wIndex & 0xff);
temp = xhci_readl(xhci, addr);
- xhci_dbg(xhci, "get port status, actual port %d status = 0x%x\n", wIndex, temp);
/* wPortChange bits */
if (temp & PORT_CSC)
@@ -226,7 +228,10 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
status |= 1 << USB_PORT_FEAT_RESET;
if (temp & PORT_POWER)
status |= 1 << USB_PORT_FEAT_POWER;
- xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
+ xhci_dbg(xhci, XHCI_LOG_PORTS,
+ "Get port %d status, actual status = 0x%x, "
+ "returned status = 0x%x\n",
+ wIndex, temp, status);
put_unaligned(cpu_to_le32(status), (__le32 *) buf);
break;
case SetPortFeature:
@@ -248,14 +253,19 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
xhci_writel(xhci, temp | PORT_POWER, addr);
temp = xhci_readl(xhci, addr);
- xhci_dbg(xhci, "set port power, actual port %d status = 0x%x\n", wIndex, temp);
+ xhci_dbg(xhci, XHCI_LOG_PORTS,
+ "Set port %d power, "
+ "actual status = 0x%x\n",
+ wIndex, temp);
break;
case USB_PORT_FEAT_RESET:
temp = (temp | PORT_RESET);
xhci_writel(xhci, temp, addr);
temp = xhci_readl(xhci, addr);
- xhci_dbg(xhci, "set port reset, actual port %d status = 0x%x\n", wIndex, temp);
+ xhci_dbg(xhci, XHCI_LOG_PORTS, "Set port %d reset, "
+ "actual status = 0x%x\n",
+ wIndex, temp);
break;
default:
goto error;
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 49f7d72..d3b4eda 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -41,15 +41,15 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flag
seg = kzalloc(sizeof *seg, flags);
if (!seg)
return 0;
- xhci_dbg(xhci, "Allocating priv segment structure at %p\n", seg);
seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma);
if (!seg->trbs) {
kfree(seg);
return 0;
}
- xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n",
- seg->trbs, (unsigned long long)dma);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Allocating DMA segment at 0x%llx (DMA)\n",
+ (unsigned long long)dma);
memset(seg->trbs, 0, SEGMENT_SIZE);
seg->dma = dma;
@@ -63,12 +63,12 @@ static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
if (!seg)
return;
if (seg->trbs) {
- xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n",
- seg->trbs, (unsigned long long)seg->dma);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Freeing DMA segment at 0x%llx (DMA)\n",
+ (unsigned long long)seg->dma);
dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma);
seg->trbs = NULL;
}
- xhci_dbg(xhci, "Freeing priv segment structure at %p\n", seg);
kfree(seg);
}
@@ -99,9 +99,6 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
val |= TRB_CHAIN;
prev->trbs[TRBS_PER_SEGMENT-1].link.control = val;
}
- xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n",
- (unsigned long long)prev->dma,
- (unsigned long long)next->dma);
}
/* XXX: Do we need the hcd structure in all these functions? */
@@ -114,7 +111,7 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
return;
first_seg = ring->first_seg;
seg = first_seg->next;
- xhci_dbg(xhci, "Freeing ring at %p\n", ring);
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Freeing ring at %p\n", ring);
while (seg != first_seg) {
struct xhci_segment *next = seg->next;
xhci_segment_free(xhci, seg);
@@ -156,7 +153,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
struct xhci_segment *prev;
ring = kzalloc(sizeof *(ring), flags);
- xhci_dbg(xhci, "Allocating ring at %p\n", ring);
if (!ring)
return 0;
@@ -186,9 +182,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
if (link_trbs) {
/* See section 4.9.2.1 and 6.4.4.1 */
prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE);
- xhci_dbg(xhci, "Wrote link toggle flag to"
- " segment %p (virtual), 0x%llx (DMA)\n",
- prev, (unsigned long long)prev->dma);
}
xhci_initialize_ring_info(ring);
return ring;
@@ -210,13 +203,13 @@ void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
rings_cached = virt_dev->num_rings_cached;
virt_dev->ring_cache[rings_cached] =
virt_dev->eps[ep_index].ring;
- xhci_dbg(xhci, "Cached old ring, "
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Cached old ring, "
"%d ring%s cached\n",
rings_cached,
(rings_cached > 1) ? "s" : "");
} else {
xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
- xhci_dbg(xhci, "Ring cache full (%d rings), "
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ring cache full (%d rings), "
"freeing ring\n",
virt_dev->num_rings_cached);
}
@@ -357,6 +350,8 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
xhci_warn(xhci, "Bad Slot ID %d\n", slot_id);
return 0;
}
+ xhci_dbg(xhci, XHCI_LOG_DEVICE_STATE,
+ "Allocate device structure for slot ID %i\n", slot_id);
xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags);
if (!xhci->devs[slot_id])
@@ -368,17 +363,11 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
if (!dev->out_ctx)
goto fail;
- xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id,
- (unsigned long long)dev->out_ctx->dma);
-
/* Allocate the (input) device context for address device command */
dev->in_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, flags);
if (!dev->in_ctx)
goto fail;
- xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id,
- (unsigned long long)dev->in_ctx->dma);
-
/* Initialize the cancellation list and watchdog timers for each ep */
for (i = 0; i < 31; i++) {
xhci_init_endpoint_timer(xhci, &dev->eps[i]);
@@ -403,10 +392,6 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
/* Point to output device context in dcbaa. */
xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma;
- xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
- slot_id,
- &xhci->dcbaa->dev_context_ptrs[slot_id],
- (unsigned long long) xhci->dcbaa->dev_context_ptrs[slot_id]);
return 1;
fail:
@@ -455,7 +440,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
slot_ctx->dev_info |= (u32) SLOT_SPEED_LS;
break;
case USB_SPEED_WIRELESS:
- xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
+ xhci_warn(xhci, "FIXME xHCI doesn't support wireless speeds\n");
return -EINVAL;
break;
default:
@@ -467,7 +452,6 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
top_dev = top_dev->parent)
/* Found device below root hub */;
slot_ctx->dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum);
- xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum);
/* Is this a LS/FS device under a HS hub? */
if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) &&
@@ -477,8 +461,6 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
if (udev->tt->multi)
slot_ctx->dev_info |= DEV_MTT;
}
- xhci_dbg(xhci, "udev->tt = %p\n", udev->tt);
- xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport);
/* Step 4 - ring already allocated */
/* Step 5 */
@@ -499,7 +481,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
ep0_ctx->ep_info2 |= MAX_PACKET(8);
break;
case USB_SPEED_WIRELESS:
- xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
+ xhci_warn(xhci, "FIXME xHCI doesn't support wireless speeds\n");
return -EINVAL;
break;
default:
@@ -657,7 +639,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
max_packet = ep->desc.wMaxPacketSize;
ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
/* dig out max burst from ep companion desc */
- if (!ep->ss_ep_comp) {
+ if (!ep->ss_ep_comp && udev->parent) {
xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n");
max_packet = 0;
} else {
@@ -755,7 +737,8 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
struct device *dev = xhci_to_hcd(xhci)->self.controller;
int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);
- xhci_dbg(xhci, "Allocating %d scratchpad buffers\n", num_sp);
+ xhci_dbg(xhci, XHCI_LOG_INIT,
+ "Allocating %d scratchpad buffers\n", num_sp);
if (!num_sp)
return 0;
@@ -907,17 +890,14 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
pci_free_consistent(pdev, size,
xhci->erst.entries, xhci->erst.erst_dma_addr);
xhci->erst.entries = NULL;
- xhci_dbg(xhci, "Freed ERST\n");
if (xhci->event_ring)
xhci_ring_free(xhci, xhci->event_ring);
xhci->event_ring = NULL;
- xhci_dbg(xhci, "Freed event ring\n");
xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring);
if (xhci->cmd_ring)
xhci_ring_free(xhci, xhci->cmd_ring);
xhci->cmd_ring = NULL;
- xhci_dbg(xhci, "Freed command ring\n");
for (i = 1; i < MAX_HC_SLOTS; ++i)
xhci_free_virt_device(xhci, i);
@@ -925,12 +905,10 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
if (xhci->segment_pool)
dma_pool_destroy(xhci->segment_pool);
xhci->segment_pool = NULL;
- xhci_dbg(xhci, "Freed segment pool\n");
if (xhci->device_pool)
dma_pool_destroy(xhci->device_pool);
xhci->device_pool = NULL;
- xhci_dbg(xhci, "Freed device context pool\n");
xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr);
if (xhci->dcbaa)
@@ -1095,7 +1073,7 @@ static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags)
if (ret < 0)
return ret;
}
- xhci_dbg(xhci, "TRB math tests passed.\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "TRB math tests passed.\n");
return 0;
}
@@ -1111,32 +1089,33 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
int i;
page_size = xhci_readl(xhci, &xhci->op_regs->page_size);
- xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size);
for (i = 0; i < 16; i++) {
if ((0x1 & page_size) != 0)
break;
page_size = page_size >> 1;
}
if (i < 16)
- xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024);
+ xhci_dbg(xhci, XHCI_LOG_INIT,
+ "Supported page size of %iK\n",
+ (1 << (i+12)) / 1024);
else
xhci_warn(xhci, "WARN: no supported page size\n");
/* Use 4K pages, since that's common and the minimum the HC supports */
xhci->page_shift = 12;
xhci->page_size = 1 << xhci->page_shift;
- xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024);
+ xhci_dbg(xhci, XHCI_LOG_INIT,
+ "HCD page size set to %iK\n", xhci->page_size / 1024);
/*
* Program the Number of Device Slots Enabled field in the CONFIG
* register with the max value of slots the HC can handle.
*/
val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1));
- xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n",
+ xhci_dbg(xhci, XHCI_LOG_INIT,
+ "xHC can handle at most %d device slots.\n",
(unsigned int) val);
val2 = xhci_readl(xhci, &xhci->op_regs->config_reg);
val |= (val2 & ~HCS_SLOTS_MASK);
- xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n",
- (unsigned int) val);
xhci_writel(xhci, val, &xhci->op_regs->config_reg);
/*
@@ -1149,8 +1128,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
goto fail;
memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa));
xhci->dcbaa->dma = dma;
- xhci_dbg(xhci, "// Device context base array address = 0x%llx (DMA), %p (virt)\n",
- (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa);
xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr);
/*
@@ -1169,25 +1146,23 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
goto fail;
/* Set up the command ring to have one segments for now. */
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Allocating command ring\n");
xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags);
if (!xhci->cmd_ring)
goto fail;
- xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring);
- xhci_dbg(xhci, "First segment DMA is 0x%llx\n",
- (unsigned long long)xhci->cmd_ring->first_seg->dma);
/* Set the address in the Command Ring Control register */
val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
(xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) |
xhci->cmd_ring->cycle_state;
- xhci_dbg(xhci, "// Setting command ring address to 0x%x\n", val);
xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
xhci_dbg_cmd_ptrs(xhci);
val = xhci_readl(xhci, &xhci->cap_regs->db_off);
val &= DBOFF_MASK;
- xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x"
+ xhci_dbg(xhci, XHCI_LOG_INIT,
+ "Doorbell array is located at offset 0x%x"
" from cap regs base addr\n", val);
xhci->dba = (void *) xhci->cap_regs + val;
xhci_dbg_regs(xhci);
@@ -1199,7 +1174,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
* Event ring setup: Allocate a normal ring, but also setup
* the event ring segment table (ERST). Section 4.9.3.
*/
- xhci_dbg(xhci, "// Allocating event ring\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Allocating event ring\n");
xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags);
if (!xhci->event_ring)
goto fail;
@@ -1210,16 +1185,10 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma);
if (!xhci->erst.entries)
goto fail;
- xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n",
- (unsigned long long)dma);
memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS);
xhci->erst.num_entries = ERST_NUM_SEGS;
xhci->erst.erst_dma_addr = dma;
- xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx\n",
- xhci->erst.num_entries,
- xhci->erst.entries,
- (unsigned long long)xhci->erst.erst_dma_addr);
/* set ring base address and size for each segment table entry */
for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) {
@@ -1234,14 +1203,9 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
val = xhci_readl(xhci, &xhci->ir_set->erst_size);
val &= ERST_SIZE_MASK;
val |= ERST_NUM_SEGS;
- xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n",
- val);
xhci_writel(xhci, val, &xhci->ir_set->erst_size);
- xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n");
/* set the segment table base address */
- xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%llx\n",
- (unsigned long long)xhci->erst.erst_dma_addr);
val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base);
val_64 &= ERST_PTR_MASK;
val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK);
@@ -1249,7 +1213,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
/* Set the event ring dequeue address */
xhci_set_hc_event_deq(xhci);
- xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n");
xhci_print_ir_set(xhci, xhci->ir_set, 0);
/*
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 417d37a..77d766a 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -41,9 +41,9 @@ static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
/* PCI Memory-Write-Invalidate cycle support is optional (uncommon) */
if (!pci_set_mwi(pdev))
- xhci_dbg(xhci, "MWI active\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "MWI active\n");
- xhci_dbg(xhci, "Finished xhci_pci_reinit\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Finished xhci_pci_reinit\n");
return 0;
}
@@ -75,7 +75,8 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
pdev->revision == 0x0) {
xhci->quirks |= XHCI_RESET_EP_QUIRK;
- xhci_dbg(xhci, "QUIRK: Fresco Logic xHC needs configure"
+ xhci_dbg(xhci, XHCI_LOG_QUIRKS,
+ "QUIRK: Fresco Logic xHC needs config"
" endpoint cmd after reset endpoint\n");
}
@@ -84,22 +85,20 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
if (retval)
return retval;
- xhci_dbg(xhci, "Resetting HCD\n");
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Resetting HCD\n");
/* Reset the internal HC memory state and registers. */
retval = xhci_reset(xhci);
if (retval)
return retval;
- xhci_dbg(xhci, "Reset complete\n");
- xhci_dbg(xhci, "Calling HCD init\n");
/* Initialize HCD and host controller data structures. */
retval = xhci_init(hcd);
if (retval)
return retval;
- xhci_dbg(xhci, "Called HCD init\n");
pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn);
- xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn);
+ xhci_dbg(xhci, XHCI_LOG_INIT, "Got SBRN %u\n",
+ (unsigned int) xhci->sbrn);
/* Find any debug ports */
return xhci_pci_reinit(xhci, pdev);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 6ba841b..9a55668 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -144,10 +144,10 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
while (last_trb(xhci, ring, ring->deq_seg, next)) {
if (consumer && last_trb_on_last_seg(xhci, ring, ring->deq_seg, next)) {
ring->cycle_state = (ring->cycle_state ? 0 : 1);
- if (!in_interrupt())
- xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n",
- ring,
- (unsigned int) ring->cycle_state);
+ xhci_dbg(xhci, (XHCI_LOG_QUIRKS | XHCI_LOG_RINGS),
+ "Toggle cycle state for ring %p = %i\n",
+ ring,
+ (unsigned int) ring->cycle_state);
}
ring->deq_seg = ring->deq_seg->next;
ring->dequeue = ring->deq_seg->trbs;
@@ -155,11 +155,14 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
}
addr = (unsigned long long) xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
if (ring == xhci->event_ring)
- xhci_dbg(xhci, "Event ring deq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Event ring deq = 0x%llx (DMA)\n", addr);
else if (ring == xhci->cmd_ring)
- xhci_dbg(xhci, "Command ring deq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Command ring deq = 0x%llx (DMA)\n", addr);
else
- xhci_dbg(xhci, "Ring deq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Ring deq = 0x%llx (DMA)\n", addr);
}
/*
@@ -181,6 +184,7 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
u32 chain;
union xhci_trb *next;
unsigned long long addr;
+ unsigned int temp;
chain = ring->enqueue->generic.field[3] & TRB_CHAIN;
next = ++(ring->enqueue);
@@ -209,11 +213,11 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
}
/* Toggle the cycle bit after the last ring segment. */
if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
+ temp = ring->cycle_state;
ring->cycle_state = (ring->cycle_state ? 0 : 1);
- if (!in_interrupt())
- xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n",
- ring,
- (unsigned int) ring->cycle_state);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Toggle cycle state for ring "
+ "%p = %i\n", ring, temp);
}
}
ring->enq_seg = ring->enq_seg->next;
@@ -222,11 +226,14 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
}
addr = (unsigned long long) xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
if (ring == xhci->event_ring)
- xhci_dbg(xhci, "Event ring enq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Event ring enq = 0x%llx (DMA)\n", addr);
else if (ring == xhci->cmd_ring)
- xhci_dbg(xhci, "Command ring enq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Command ring enq = 0x%llx (DMA)\n", addr);
else
- xhci_dbg(xhci, "Ring enq = 0x%llx (DMA)\n", addr);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Ring enq = 0x%llx (DMA)\n", addr);
}
/*
@@ -275,7 +282,6 @@ void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
* there might be more events to service.
*/
temp &= ~ERST_EHB;
- xhci_dbg(xhci, "// Write event ring dequeue pointer, preserving EHB bit\n");
xhci_write_64(xhci, ((u64) deq & (u64) ~ERST_PTR_MASK) | temp,
&xhci->ir_set->erst_dequeue);
}
@@ -285,7 +291,7 @@ void xhci_ring_cmd_db(struct xhci_hcd *xhci)
{
u32 temp;
- xhci_dbg(xhci, "// Ding dong!\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Ding dong! (Command ring)\n");
temp = xhci_readl(xhci, &xhci->dba->doorbell[0]) & DB_MASK;
xhci_writel(xhci, temp | DB_TARGET_HOST, &xhci->dba->doorbell[0]);
/* Flush PCI posted writes */
@@ -369,19 +375,16 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
dma_addr_t addr;
state->new_cycle_state = 0;
- xhci_dbg(xhci, "Finding segment containing stopped TRB.\n");
state->new_deq_seg = find_trb_seg(cur_td->start_seg,
dev->eps[ep_index].stopped_trb,
&state->new_cycle_state);
if (!state->new_deq_seg)
BUG();
/* Dig out the cycle state saved by the xHC during the stop ep cmd */
- xhci_dbg(xhci, "Finding endpoint context\n");
ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
state->new_cycle_state = 0x1 & ep_ctx->deq;
state->new_deq_ptr = cur_td->last_trb;
- xhci_dbg(xhci, "Finding segment containing last TRB in TD.\n");
state->new_deq_seg = find_trb_seg(state->new_deq_seg,
state->new_deq_ptr,
&state->new_cycle_state);
@@ -395,12 +398,12 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
/* Don't update the ring cycle state for the producer (us). */
- xhci_dbg(xhci, "New dequeue segment = %p (virtual)\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "Found new ring dequeue pointer.\n");
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "New dequeue segment = %p (virtual)\n",
state->new_deq_seg);
addr = xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr);
- xhci_dbg(xhci, "New dequeue pointer = 0x%llx (DMA)\n",
+ xhci_dbg(xhci, XHCI_LOG_RINGS, "New dequeue pointer = 0x%llx (DMA)\n",
(unsigned long long) addr);
- xhci_dbg(xhci, "Setting dequeue pointer in internal ring state.\n");
ep_ring->dequeue = state->new_deq_ptr;
ep_ring->deq_seg = state->new_deq_seg;
}
@@ -420,13 +423,6 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
* leave the pointers intact.
*/
cur_trb->generic.field[3] &= ~TRB_CHAIN;
- xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
- xhci_dbg(xhci, "Address = %p (0x%llx dma); "
- "in seg %p (0x%llx dma)\n",
- cur_trb,
- (unsigned long long)xhci_trb_virt_to_dma(cur_seg, cur_trb),
- cur_seg,
- (unsigned long long)cur_seg->dma);
} else {
cur_trb->generic.field[0] = 0;
cur_trb->generic.field[1] = 0;
@@ -434,12 +430,6 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
/* Preserve only the cycle bit of this TRB */
cur_trb->generic.field[3] &= TRB_CYCLE;
cur_trb->generic.field[3] |= TRB_TYPE(TRB_TR_NOOP);
- xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
- "in seg %p (0x%llx dma)\n",
- cur_trb,
- (unsigned long long)xhci_trb_virt_to_dma(cur_seg, cur_trb),
- cur_seg,
- (unsigned long long)cur_seg->dma);
}
if (cur_trb == cur_td->last_trb)
break;
@@ -456,7 +446,8 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
{
struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
- xhci_dbg(xhci, "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), "
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_COMMANDS),
+ "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), "
"new deq ptr = %p (0x%llx dma), new cycle = %u\n",
deq_state->new_deq_seg,
(unsigned long long)deq_state->new_deq_seg->dma,
@@ -495,13 +486,14 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
cur_td->urb->hcpriv = NULL;
usb_hcd_unlink_urb_from_ep(hcd, cur_td->urb);
- xhci_dbg(xhci, "Giveback %s URB %p\n", adjective, cur_td->urb);
+ xhci_dbg(xhci, XHCI_LOG_TX, "Giveback %s URB %p\n",
+ adjective, cur_td->urb);
spin_unlock(&xhci->lock);
usb_hcd_giveback_urb(hcd, cur_td->urb, status);
kfree(cur_td);
spin_lock(&xhci->lock);
- xhci_dbg(xhci, "%s URB given back\n", adjective);
+ xhci_dbg(xhci, XHCI_LOG_TX, "%s URB given back\n", adjective);
}
/*
@@ -546,9 +538,6 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
*/
list_for_each(entry, &ep->cancelled_td_list) {
cur_td = list_entry(entry, struct xhci_td, cancelled_td_list);
- xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n",
- cur_td->first_trb,
- (unsigned long long)xhci_trb_virt_to_dma(cur_td->start_seg, cur_td->first_trb));
/*
* If we stopped on the TD we need to cancel, then we have to
* move the xHC endpoint ring dequeue pointer past this TD.
@@ -640,13 +629,15 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
ep->stop_cmds_pending--;
if (xhci->xhc_state & XHCI_STATE_DYING) {
- xhci_dbg(xhci, "Stop EP timer ran, but another timer marked "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Stop EP timer ran, but another timer marked "
"xHCI as DYING, exiting.\n");
spin_unlock(&xhci->lock);
return;
}
if (!(ep->stop_cmds_pending == 0 && (ep->ep_state & EP_HALT_PENDING))) {
- xhci_dbg(xhci, "Stop EP timer ran, but no command pending, "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Stop EP timer ran, but no command pending, "
"exiting.\n");
spin_unlock(&xhci->lock);
return;
@@ -690,7 +681,8 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
ring = temp_ep->ring;
if (!ring)
continue;
- xhci_dbg(xhci, "Killing URBs for slot ID %u, "
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "Killing URBs for slot ID %u, "
"ep index %u\n", i, j);
while (!list_empty(&ring->td_list)) {
cur_td = list_first_entry(&ring->td_list,
@@ -715,9 +707,8 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
}
spin_unlock(&xhci->lock);
xhci_to_hcd(xhci)->state = HC_STATE_HALT;
- xhci_dbg(xhci, "Calling usb_hc_died()\n");
usb_hc_died(xhci_to_hcd(xhci));
- xhci_dbg(xhci, "xHCI host controller is dead.\n");
+ xhci_warn(xhci, "xHCI host controller is dead.\n");
}
/*
@@ -761,7 +752,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
ep_state &= EP_STATE_MASK;
slot_state = slot_ctx->dev_state;
slot_state = GET_SLOT_STATE(slot_state);
- xhci_dbg(xhci, "Slot state = %u, EP state = %u\n",
+ xhci_warn(xhci, "Slot state = %u, EP state = %u\n",
slot_state, ep_state);
break;
case COMP_EBADSLT:
@@ -781,8 +772,9 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
* cancelling URBs, which might not be an error...
*/
} else {
- xhci_dbg(xhci, "Successful Set TR Deq Ptr cmd, deq = @%08llx\n",
- ep_ctx->deq);
+ xhci_dbg(xhci, (XHCI_LOG_RINGS | XHCI_LOG_COMMANDS),
+ "Successful Set TR Deq Ptr cmd, "
+ "deq = @%08llx\n", ep_ctx->deq);
}
dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
@@ -803,7 +795,8 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
/* This command will only fail if the endpoint wasn't halted,
* but we don't care.
*/
- xhci_dbg(xhci, "Ignoring reset ep completion code of %u\n",
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS_VERBOSE,
+ "Ignoring reset ep completion code of %u\n",
(unsigned int) GET_COMP_CODE(event->status));
/* HW with the reset endpoint quirk needs to have a configure endpoint
@@ -811,7 +804,8 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
* because the HW can't handle two commands being queued in a row.
*/
if (xhci->quirks & XHCI_RESET_EP_QUIRK) {
- xhci_dbg(xhci, "Queueing configure endpoint command\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Queueing configure endpoint command\n");
xhci_queue_configure_endpoint(xhci,
xhci->devs[slot_id]->in_ctx->dma, slot_id,
false);
@@ -915,7 +909,8 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
if (!(ep_state & EP_HALTED))
goto bandwidth_change;
- xhci_dbg(xhci, "Completed config ep cmd - "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Completed config ep cmd - "
"last ep index = %d, state = %d\n",
ep_index, ep_state);
/* Clear our internal halted state and restart ring */
@@ -925,7 +920,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
break;
}
bandwidth_change:
- xhci_dbg(xhci, "Completed config ep cmd\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS, "Completed config ep cmd\n");
xhci->devs[slot_id]->cmd_status =
GET_COMP_CODE(event->status);
complete(&xhci->devs[slot_id]->cmd_completion);
@@ -954,7 +949,8 @@ bandwidth_change:
handle_reset_ep_completion(xhci, event, xhci->cmd_ring->dequeue);
break;
case TRB_TYPE(TRB_RESET_DEV):
- xhci_dbg(xhci, "Completed reset device command.\n");
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "Completed reset device command.\n");
slot_id = TRB_TO_SLOT_ID(
xhci->cmd_ring->dequeue->generic.field[3]);
virt_dev = xhci->devs[slot_id];
@@ -984,7 +980,8 @@ static void handle_port_status(struct xhci_hcd *xhci,
}
/* FIXME: core doesn't care about all port link state changes yet */
port_id = GET_PORT_ID(event->generic.field[0]);
- xhci_dbg(xhci, "Port Status Change Event for port %d\n", port_id);
+ xhci_dbg(xhci, XHCI_LOG_PORTS,
+ "Port Status Change Event for port %d\n", port_id);
/* Update event ring dequeue pointer before dropping the lock */
inc_deq(xhci, xhci->event_ring, true);
@@ -1097,9 +1094,13 @@ int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code)
/* Vendor defined "informational" completion code,
* treat as not-an-error.
*/
- xhci_dbg(xhci, "Vendor defined info completion code %u\n",
+ xhci_dbg(xhci, (XHCI_LOG_COMMANDS_VERBOSE |
+ XHCI_LOG_TX_VERBOSE),
+ "Vendor defined info completion code %u\n",
trb_comp_code);
- xhci_dbg(xhci, "Treating code as success.\n");
+ xhci_dbg(xhci, (XHCI_LOG_COMMANDS_VERBOSE |
+ XHCI_LOG_TX_VERBOSE),
+ "Treating code as success.\n");
return 1;
}
return 0;
@@ -1127,7 +1128,6 @@ static int handle_tx_event(struct xhci_hcd *xhci,
struct xhci_ep_ctx *ep_ctx;
u32 trb_comp_code;
- xhci_dbg(xhci, "In %s\n", __func__);
slot_id = TRB_TO_SLOT_ID(event->flags);
xdev = xhci->devs[slot_id];
if (!xdev) {
@@ -1137,7 +1137,6 @@ static int handle_tx_event(struct xhci_hcd *xhci,
/* Endpoint ID is 1 based, our index is zero based */
ep_index = TRB_TO_EP_ID(event->flags) - 1;
- xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
ep = &xdev->eps[ep_index];
ep_ring = ep->ring;
ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
@@ -1148,39 +1147,40 @@ static int handle_tx_event(struct xhci_hcd *xhci,
event_dma = event->buffer;
/* This TRB should be in the TD at the head of this ring's TD list */
- xhci_dbg(xhci, "%s - checking for list empty\n", __func__);
if (list_empty(&ep_ring->td_list)) {
xhci_warn(xhci, "WARN Event TRB for slot %d ep %d with no TDs queued?\n",
TRB_TO_SLOT_ID(event->flags), ep_index);
- xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",
+ xhci_warn(xhci, "Event TRB with TRB type ID %u\n",
(unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10);
xhci_print_trb_offsets(xhci, (union xhci_trb *) event);
urb = NULL;
goto cleanup;
}
- xhci_dbg(xhci, "%s - getting list entry\n", __func__);
td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list);
/* Is this a TRB in the currently executing TD? */
- xhci_dbg(xhci, "%s - looking for TD\n", __func__);
event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
td->last_trb, event_dma);
- xhci_dbg(xhci, "%s - found event_seg = %p\n", __func__, event_seg);
if (!event_seg) {
/* HC is busted, give up! */
xhci_err(xhci, "ERROR Transfer event TRB DMA ptr not part of current TD\n");
return -ESHUTDOWN;
}
event_trb = &event_seg->trbs[(event_dma - event_seg->dma) / sizeof(*event_trb)];
- xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Event TRB with TRB type ID %u\n",
(unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10);
- xhci_dbg(xhci, "Offset 0x00 (buffer lo) = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Offset 0x00 (buffer lo) = 0x%x\n",
lower_32_bits(event->buffer));
- xhci_dbg(xhci, "Offset 0x04 (buffer hi) = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Offset 0x04 (buffer hi) = 0x%x\n",
upper_32_bits(event->buffer));
- xhci_dbg(xhci, "Offset 0x08 (transfer length) = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Offset 0x08 (transfer length) = 0x%x\n",
(unsigned int) event->transfer_len);
- xhci_dbg(xhci, "Offset 0x0C (flags) = 0x%x\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Offset 0x0C (flags) = 0x%x\n",
(unsigned int) event->flags);
/* Look for common error cases */
@@ -1193,13 +1193,13 @@ static int handle_tx_event(struct xhci_hcd *xhci,
case COMP_SHORT_TX:
break;
case COMP_STOP:
- xhci_dbg(xhci, "Stopped on Transfer TRB\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Stopped on Transfer TRB\n");
break;
case COMP_STOP_INVAL:
- xhci_dbg(xhci, "Stopped on No-op or Link TRB\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Stopped on No-op or Link TRB\n");
break;
case COMP_STALL:
- xhci_warn(xhci, "WARN: Stalled endpoint\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Stalled endpoint\n");
ep->ep_state |= EP_HALTED;
status = -EPIPE;
break;
@@ -1209,11 +1209,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
break;
case COMP_SPLIT_ERR:
case COMP_TX_ERR:
- xhci_warn(xhci, "WARN: transfer error on endpoint\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Transfer error on endpoint\n");
status = -EPROTO;
break;
case COMP_BABBLE:
- xhci_warn(xhci, "WARN: babble error on endpoint\n");
+ xhci_dbg(xhci, XHCI_LOG_TX, "Babble error on endpoint\n");
status = -EOVERFLOW;
break;
case COMP_DB_ERR:
@@ -1242,12 +1242,15 @@ static int handle_tx_event(struct xhci_hcd *xhci,
xhci_warn(xhci, "WARN: Success on ctrl data TRB without IOC set??\n");
status = -ESHUTDOWN;
} else {
- xhci_dbg(xhci, "Successful control transfer!\n");
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Successful "
+ "control transfer!\n");
status = 0;
}
break;
case COMP_SHORT_TX:
- xhci_warn(xhci, "WARN: short transfer on control ep\n");
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "Short transfer on control ep\n");
if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
status = -EREMOTEIO;
else
@@ -1258,7 +1261,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
if (!xhci_requires_manual_halt_cleanup(xhci,
ep_ctx, trb_comp_code))
break;
- xhci_dbg(xhci, "TRB error code %u, "
+ xhci_dbg(xhci, XHCI_LOG_TX, "TRB error code %u, "
"halted endpoint index = %u\n",
trb_comp_code, ep_index);
/* else fall through */
@@ -1302,7 +1305,9 @@ static int handle_tx_event(struct xhci_hcd *xhci,
td->urb->actual_length =
td->urb->transfer_buffer_length -
TRB_LEN(event->transfer_len);
- xhci_dbg(xhci, "Waiting for status stage event\n");
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "Waiting for "
+ "status stage event\n");
urb = NULL;
goto cleanup;
}
@@ -1321,10 +1326,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
status = 0;
} else {
if (usb_endpoint_xfer_bulk(&td->urb->ep->desc))
- xhci_dbg(xhci, "Successful bulk "
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Successful bulk "
"transfer!\n");
else
- xhci_dbg(xhci, "Successful interrupt "
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Successful interrupt "
"transfer!\n");
status = 0;
}
@@ -1339,9 +1346,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
/* Others already handled above */
break;
}
- dev_dbg(&td->urb->dev->dev,
- "ep %#x - asked for %d bytes, "
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "slot ID %u, ep %#x - asked for %d bytes, "
"%d bytes untransferred\n",
+ td->urb->dev->slot_id,
td->urb->ep->desc.bEndpointAddress,
td->urb->transfer_buffer_length,
TRB_LEN(event->transfer_len));
@@ -1483,7 +1491,8 @@ cleanup:
/* FIXME for multi-TD URBs (who have buffers bigger than 64MB) */
if (urb) {
usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), urb);
- xhci_dbg(xhci, "Giveback URB %p, len = %d, status = %d\n",
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Giveback URB %p, len = %d, status = %d\n",
urb, urb->actual_length, status);
spin_unlock(&xhci->lock);
usb_hcd_giveback_urb(xhci_to_hcd(xhci), urb, status);
@@ -1502,7 +1511,6 @@ void xhci_handle_event(struct xhci_hcd *xhci)
int update_ptrs = 1;
int ret;
- xhci_dbg(xhci, "In %s\n", __func__);
if (!xhci->event_ring || !xhci->event_ring->dequeue) {
xhci->error_bitmask |= 1 << 1;
return;
@@ -1515,25 +1523,18 @@ void xhci_handle_event(struct xhci_hcd *xhci)
xhci->error_bitmask |= 1 << 2;
return;
}
- xhci_dbg(xhci, "%s - OS owns TRB\n", __func__);
/* FIXME: Handle more event types. */
switch ((event->event_cmd.flags & TRB_TYPE_BITMASK)) {
case TRB_TYPE(TRB_COMPLETION):
- xhci_dbg(xhci, "%s - calling handle_cmd_completion\n", __func__);
handle_cmd_completion(xhci, &event->event_cmd);
- xhci_dbg(xhci, "%s - returned from handle_cmd_completion\n", __func__);
break;
case TRB_TYPE(TRB_PORT_STATUS):
- xhci_dbg(xhci, "%s - calling handle_port_status\n", __func__);
handle_port_status(xhci, event);
- xhci_dbg(xhci, "%s - returned from handle_port_status\n", __func__);
update_ptrs = 0;
break;
case TRB_TYPE(TRB_TRANSFER):
- xhci_dbg(xhci, "%s - calling handle_tx_event\n", __func__);
ret = handle_tx_event(xhci, &event->trans_event);
- xhci_dbg(xhci, "%s - returned from handle_tx_event\n", __func__);
if (ret < 0)
xhci->error_bitmask |= 1 << 9;
else
@@ -1546,7 +1547,8 @@ void xhci_handle_event(struct xhci_hcd *xhci)
* to make sure a watchdog timer didn't mark the host as non-responsive.
*/
if (xhci->xhc_state & XHCI_STATE_DYING) {
- xhci_dbg(xhci, "xHCI host dying, returning from "
+ xhci_dbg(xhci, XHCI_LOG_COMMANDS,
+ "xHCI host dying, returning from "
"event handler.\n");
return;
}
@@ -1588,7 +1590,11 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
u32 ep_state, unsigned int num_trbs, gfp_t mem_flags)
{
/* Make sure the endpoint has been added to xHC schedule */
- xhci_dbg(xhci, "Endpoint state = 0x%x\n", ep_state);
+ if (ep_state != EP_STATE_STOPPED &&
+ ep_state != EP_STATE_RUNNING)
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "Endpoint state = 0x%x\n", ep_state);
+
switch (ep_state) {
case EP_STATE_DISABLED:
/*
@@ -1603,7 +1609,8 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
/* XXX not sure if this should be -ENOENT or not */
return -EINVAL;
case EP_STATE_HALTED:
- xhci_dbg(xhci, "WARN halted endpoint, queueing URB anyway.\n");
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "Halted endpoint, queueing URB anyway.\n");
case EP_STATE_STOPPED:
case EP_STATE_RUNNING:
break;
@@ -1669,10 +1676,8 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
num_sgs = urb->num_sgs;
temp = urb->transfer_buffer_length;
- xhci_dbg(xhci, "count sg list trbs: \n");
num_trbs = 0;
for_each_sg(urb->sg->sg, sg, num_sgs, i) {
- unsigned int previous_total_trbs = num_trbs;
unsigned int len = sg_dma_len(sg);
/* Scatter gather list entries may cross 64KB boundaries */
@@ -1686,21 +1691,19 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
num_trbs++;
running_total += TRB_MAX_BUFF_SIZE;
}
- xhci_dbg(xhci, " sg #%d: dma = %#llx, len = %#x (%d), num_trbs = %d\n",
- i, (unsigned long long)sg_dma_address(sg),
- len, len, num_trbs - previous_total_trbs);
len = min_t(int, len, temp);
temp -= len;
if (temp == 0)
break;
}
- xhci_dbg(xhci, "\n");
- if (!in_interrupt())
- dev_dbg(&urb->dev->dev, "ep %#x - urb len = %d, sglist used, num_trbs = %d\n",
- urb->ep->desc.bEndpointAddress,
- urb->transfer_buffer_length,
- num_trbs);
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ "slot ID %u ep %#x - urb len = %d, "
+ "sglist used, num_trbs = %d\n",
+ urb->dev->slot_id,
+ urb->ep->desc.bEndpointAddress,
+ urb->transfer_buffer_length,
+ num_trbs);
return num_trbs;
}
@@ -1758,7 +1761,8 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
*/
if (xhci_interval != ep_interval) {
if (!printk_ratelimit())
- dev_dbg(&urb->dev->dev, "Driver uses different interval"
+ xhci_dbg(xhci, XHCI_LOG_TX,
+ "Driver uses different interval"
" (%d microframe%s) than xHCI "
"(%d microframe%s)\n",
ep_interval,
@@ -1838,8 +1842,6 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
trb_buff_len = min_t(int, trb_buff_len, this_sg_len);
if (trb_buff_len > urb->transfer_buffer_length)
trb_buff_len = urb->transfer_buffer_length;
- xhci_dbg(xhci, "First length to xfer from 1st sglist entry = %u\n",
- trb_buff_len);
first_trb = true;
/* Queue the first TRB, even if it's zero-length */
@@ -1864,7 +1866,8 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
td->last_trb = ep_ring->enqueue;
field |= TRB_IOC;
}
- xhci_dbg(xhci, " sg entry: dma = %#x, len = %#x (%d), "
+ xhci_dbg(xhci, XHCI_LOG_RINGS,
+ " sg entry: dma = %#x, len = %#x (%d), "
"64KB boundary at %#x, end dma = %#x\n",
(unsigned int) addr, trb_buff_len, trb_buff_len,
(unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
@@ -1872,7 +1875,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
if (TRB_MAX_BUFF_SIZE -
(addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1)) < trb_buff_len) {
xhci_warn(xhci, "WARN: sg dma xfer crosses 64KB boundaries!\n");
- xhci_dbg(xhci, "Next boundary at %#x, end dma = %#x\n",
+ xhci_warn(xhci, "Next boundary at %#x, end dma = %#x\n",
(unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
(unsigned int) addr + trb_buff_len);
}
@@ -1959,13 +1962,15 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
}
/* FIXME: this doesn't deal with URB_ZERO_PACKET - need one more */
- if (!in_interrupt())
- dev_dbg(&urb->dev->dev, "ep %#x - urb len = %#x (%d), addr = %#llx, num_trbs = %d\n",
- urb->ep->desc.bEndpointAddress,
- urb->transfer_buffer_length,
- urb->transfer_buffer_length,
- (unsigned long long)urb->transfer_dma,
- num_trbs);
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Slot ID %u ep %#x - urb len = %#x (%d), "
+ "addr = %#llx, num_trbs = %d\n",
+ urb->dev->slot_id,
+ urb->ep->desc.bEndpointAddress,
+ urb->transfer_buffer_length,
+ urb->transfer_buffer_length,
+ (unsigned long long)urb->transfer_dma,
+ num_trbs);
ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
num_trbs, urb, &td, mem_flags);
@@ -2063,9 +2068,9 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
if (!urb->setup_packet)
return -EINVAL;
- if (!in_interrupt())
- xhci_dbg(xhci, "Queueing ctrl tx for slot id %d, ep %d\n",
- slot_id, ep_index);
+ xhci_dbg(xhci, XHCI_LOG_TX_VERBOSE,
+ "Queueing ctrl tx for slot id %d, ep %d\n",
+ slot_id, ep_index);
/* 1 TRB for setup, 1 for status */
num_trbs = 2;
/*
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index e5eb09b..0197540 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1112,6 +1112,19 @@ struct xhci_hcd {
unsigned int quirks;
#define XHCI_LINK_TRB_QUIRK (1 << 0)
#define XHCI_RESET_EP_QUIRK (1 << 1)
+ unsigned int log_level;
+#define XHCI_LOG_QUIRKS (1 << 0)
+#define XHCI_LOG_COMMANDS (1 << 1)
+#define XHCI_LOG_COMMANDS_VERBOSE (1 << 2)
+#define XHCI_LOG_INIT (1 << 3)
+#define XHCI_LOG_EVENTS (1 << 4)
+#define XHCI_LOG_DEVICE_STATE (1 << 5)
+#define XHCI_LOG_TX (1 << 6)
+#define XHCI_LOG_TX_VERBOSE (1 << 7)
+#define XHCI_LOG_NOOPS (1 << 8)
+#define XHCI_LOG_RINGS (1 << 9)
+#define XHCI_LOG_PORTS (1 << 10)
+#define XHCI_LOG_REGS (1 << 11)
};
/* For testing purposes */
@@ -1134,8 +1147,18 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
#define XHCI_DEBUG 0
#endif
-#define xhci_dbg(xhci, fmt, args...) \
- do { if (XHCI_DEBUG) dev_dbg(xhci_to_hcd(xhci)->self.controller , fmt , ## args); } while (0)
+#if XHCI_DEBUG
+#define xhci_dbg(xhci, lvl, fmt, args...) \
+do { \
+ if (lvl & xhci->log_level) \
+ dev_dbg(xhci_to_hcd(xhci)->self.controller , \
+ fmt , ## args); \
+} while (0)
+#else
+#define xhci_dbg(xhci, lvl, fmt, args...) \
+do {} while (0)
+#endif
+
#define xhci_info(xhci, fmt, args...) \
do { if (XHCI_DEBUG) dev_info(xhci_to_hcd(xhci)->self.controller , fmt , ## args); } while (0)
#define xhci_err(xhci, fmt, args...) \
@@ -1153,7 +1176,7 @@ static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
static inline void xhci_writel(struct xhci_hcd *xhci,
const unsigned int val, __u32 __iomem *regs)
{
- xhci_dbg(xhci,
+ xhci_dbg(xhci, XHCI_LOG_REGS,
"`MEM_WRITE_DWORD(3'b000, 32'h%p, 32'h%0x, 4'hf);\n",
regs, val);
writel(val, regs);
@@ -1183,7 +1206,7 @@ static inline void xhci_write_64(struct xhci_hcd *xhci,
u32 val_lo = lower_32_bits(val);
u32 val_hi = upper_32_bits(val);
- xhci_dbg(xhci,
+ xhci_dbg(xhci, XHCI_LOG_REGS,
"`MEM_WRITE_DWORD(3'b000, 64'h%p, 64'h%0lx, 4'hf);\n",
regs, (long unsigned int) val);
writel(val_lo, ptr);
--
1.6.3.3
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
