Re: [PATCH] usb: musb: add printf attribute to log function

Joe Perches
2020-12-21T20:34:26Z

On Mon, 2020-12-21 at 08:25 -0800, trix@redhat.com wrote:
> From: Tom Rix <trix@redhat.com>
>
> Attributing the function allows the compiler to more thoroughly
> check the use of the function with -Wformat and similar flags.
>
> Signed-off-by: Tom Rix <trix@redhat.com>
> ---
>  drivers/usb/musb/musb_debug.h | 1 +
>  1 file changed, 1 insertion(+)
>
> diff --git a/drivers/usb/musb/musb_debug.h b/drivers/usb/musb/musb_debug.h
> index e5b3506c7b3f..dfc0d02695fa 100644
> --- a/drivers/usb/musb/musb_debug.h
> +++ b/drivers/usb/musb/musb_debug.h
> @@ -17,6 +17,7 @@
>  #define INFO(fmt, args...) yprintk(KERN_INFO, fmt, ## args)
>  #define ERR(fmt, args...) yprintk(KERN_ERR, fmt, ## args)
>
>
> +__printf(2, 3)
>  void musb_dbg(struct musb *musb, const char *fmt, ...);

Maybe convert all the WARN/INFO/ERR uses to dev_<level> equivalents too?

Use more typical logging styles:

o Add musb_<level> macros that use dev_<level>
o Add struct musb * to musb_<level> calls
o Remove __func__ and __LINE__ uses
o Remove newlines from formats and add to macros for consistency with musb_dbg
o Remove unnecessary newlines from musb_dbg uses
o Coalesce formats and align arguments

---

(compiled x86-64 only, untested)

drivers/usb/musb/am35x.c | 2 +-
drivers/usb/musb/cppi_dma.c | 160 ++++++++++++++++++-------------------
drivers/usb/musb/da8xx.c | 2 +-
drivers/usb/musb/davinci.c | 7 +-
drivers/usb/musb/musb_core.c | 74 ++++++++---------
drivers/usb/musb/musb_cppi41.c | 2 +-
drivers/usb/musb/musb_debug.h | 14 ++--
drivers/usb/musb/musb_dsps.c | 2 +-
drivers/usb/musb/musb_gadget.c | 76 +++++++++---------
drivers/usb/musb/musb_gadget_ep0.c | 33 ++++----
drivers/usb/musb/musb_host.c | 98 +++++++++++------------
drivers/usb/musb/musb_virthub.c | 4 +-
drivers/usb/musb/musbhsdma.c | 20 ++---
drivers/usb/musb/tusb6010.c | 24 +++---
drivers/usb/musb/tusb6010_omap.c | 4 +-
drivers/usb/musb/ux500_dma.c | 4 +-
16 files changed, 256 insertions(+), 270 deletions(-)

diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index 660641ab1545..39d830e633c1 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -260,7 +260,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);
- WARNING("VBUS error workaround (delay coming)\n");
+ musb_warn(musb, "VBUS error workaround (delay coming)");
} else if (drvvbus) {
MUSB_HST_MODE(musb);
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index edb5b63d7063..021395de3b38 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -317,7 +317,7 @@ cppi_channel_allocate(struct dma_controller *c,
*/
if (cppi_ch->hw_ep)
musb_dbg(musb, "re-allocating DMA%d %cX channel %p",
- index, transmit ? 'T' : 'R', cppi_ch);
+ index, transmit ? 'T' : 'R', cppi_ch);
cppi_ch->hw_ep = ep;
cppi_ch->channel.status = MUSB_DMA_STATUS_FREE;
cppi_ch->channel.max_len = 0x7fffffff;
@@ -338,7 +338,7 @@ static void cppi_channel_release(struct dma_channel *channel)
tibase = c->controller->tibase;
if (!c->hw_ep)
musb_dbg(c->controller->controller.musb,
- "releasing idle DMA channel %p", c);
+ "releasing idle DMA channel %p", c);
else if (!c->transmit)
core_rxirq_enable(tibase, c->index + 1);

@@ -357,23 +357,21 @@ cppi_dump_rx(int level, struct cppi_channel *c, const char *tag)
musb_ep_select(base, c->index + 1);

musb_dbg(c->controller->controller.musb,
- "RX DMA%d%s: %d left, csr %04x, "
- "%08x H%08x S%08x C%08x, "
- "B%08x L%08x %08x .. %08x",
- c->index, tag,
- musb_readl(c->controller->tibase,
- DAVINCI_RXCPPI_BUFCNT0_REG + 4 * c->index),
- musb_readw(c->hw_ep->regs, MUSB_RXCSR),
-
- musb_readl(&rx->rx_skipbytes, 0),
- musb_readl(&rx->rx_head, 0),
- musb_readl(&rx->rx_sop, 0),
- musb_readl(&rx->rx_current, 0),
-
- musb_readl(&rx->rx_buf_current, 0),
- musb_readl(&rx->rx_len_len, 0),
- musb_readl(&rx->rx_cnt_cnt, 0),
- musb_readl(&rx->rx_complete, 0)
+ "RX DMA%d%s: %d left, csr %04x, %08x H%08x S%08x C%08x, B%08x L%08x %08x .. %08x",
+ c->index, tag,
+ musb_readl(c->controller->tibase,
+ DAVINCI_RXCPPI_BUFCNT0_REG + 4 * c->index),
+ musb_readw(c->hw_ep->regs, MUSB_RXCSR),
+
+ musb_readl(&rx->rx_skipbytes, 0),
+ musb_readl(&rx->rx_head, 0),
+ musb_readl(&rx->rx_sop, 0),
+ musb_readl(&rx->rx_current, 0),
+
+ musb_readl(&rx->rx_buf_current, 0),
+ musb_readl(&rx->rx_len_len, 0),
+ musb_readl(&rx->rx_cnt_cnt, 0),
+ musb_readl(&rx->rx_complete, 0)
);
}

@@ -387,21 +385,19 @@ cppi_dump_tx(int level, struct cppi_channel *c, const char *tag)
musb_ep_select(base, c->index + 1);

musb_dbg(c->controller->controller.musb,
- "TX DMA%d%s: csr %04x, "
- "H%08x S%08x C%08x %08x, "
- "F%08x L%08x .. %08x",
- c->index, tag,
- musb_readw(c->hw_ep->regs, MUSB_TXCSR),
-
- musb_readl(&tx->tx_head, 0),
- musb_readl(&tx->tx_buf, 0),
- musb_readl(&tx->tx_current, 0),
- musb_readl(&tx->tx_buf_current, 0),
-
- musb_readl(&tx->tx_info, 0),
- musb_readl(&tx->tx_rem_len, 0),
- /* dummy/unused word 6 */
- musb_readl(&tx->tx_complete, 0)
+ "TX DMA%d%s: csr %04x, H%08x S%08x C%08x %08x, F%08x L%08x .. %08x",
+ c->index, tag,
+ musb_readw(c->hw_ep->regs, MUSB_TXCSR),
+
+ musb_readl(&tx->tx_head, 0),
+ musb_readl(&tx->tx_buf, 0),
+ musb_readl(&tx->tx_current, 0),
+ musb_readl(&tx->tx_buf_current, 0),
+
+ musb_readl(&tx->tx_info, 0),
+ musb_readl(&tx->tx_rem_len, 0),
+ /* dummy/unused word 6 */
+ musb_readl(&tx->tx_complete, 0)
);
}

@@ -592,11 +588,11 @@ cppi_next_tx_segment(struct musb *musb, struct cppi_channel *tx)
}

musb_dbg(musb, "TX DMA%d, pktSz %d %s bds %d dma 0x%llx len %u",
- tx->index,
- maxpacket,
- rndis ? "rndis" : "transparent",
- n_bds,
- (unsigned long long)addr, length);
+ tx->index,
+ maxpacket,
+ rndis ? "rndis" : "transparent",
+ n_bds,
+ (unsigned long long)addr, length);

cppi_rndis_update(tx, 0, musb->ctrl_base, rndis);

@@ -649,8 +645,8 @@ cppi_next_tx_segment(struct musb *musb, struct cppi_channel *tx)
}

musb_dbg(musb, "TXBD %p: nxt %08x buf %08x len %04x opt %08x",
- bd, bd->hw_next, bd->hw_bufp,
- bd->hw_off_len, bd->hw_options);
+ bd, bd->hw_next, bd->hw_bufp,
+ bd->hw_off_len, bd->hw_options);

/* update the last BD enqueued to the list */
tx->tail = bd;
@@ -812,18 +808,17 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)

length = min(n_bds * maxpacket, length);

- musb_dbg(musb, "RX DMA%d seg, maxp %d %s bds %d (cnt %d) "
- "dma 0x%llx len %u %u/%u",
- rx->index, maxpacket,
- onepacket
- ? (is_rndis ? "rndis" : "onepacket")
- : "multipacket",
- n_bds,
- musb_readl(tibase,
- DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4))
- & 0xffff,
- (unsigned long long)addr, length,
- rx->channel.actual_len, rx->buf_len);
+ musb_dbg(musb, "RX DMA%d seg, maxp %d %s bds %d (cnt %d) dma 0x%llx len %u %u/%u",
+ rx->index, maxpacket,
+ onepacket
+ ? (is_rndis ? "rndis" : "onepacket")
+ : "multipacket",
+ n_bds,
+ musb_readl(tibase,
+ DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4))
+ & 0xffff,
+ (unsigned long long)addr, length,
+ rx->channel.actual_len, rx->buf_len);

/* only queue one segment at a time, since the hardware prevents
* correct queue shutdown after unexpected short packets
@@ -863,10 +858,13 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)

/* we always expect at least one reusable BD! */
if (!tail) {
- WARNING("rx dma%d -- no BDs? need %d\n", rx->index, n_bds);
+ musb_warn(musb, "rx dma%d -- no BDs? need %d",
+ rx->index, n_bds);
return;
- } else if (i < n_bds)
- WARNING("rx dma%d -- only %d of %d BDs\n", rx->index, i, n_bds);
+ }
+ if (i < n_bds)
+ musb_warn(musb, "rx dma%d -- only %d of %d BDs",
+ rx->index, i, n_bds);

tail->next = NULL;
tail->hw_next = 0;
@@ -924,7 +922,7 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)
& 0xffff;
if (i < (2 + n_bds)) {
musb_dbg(musb, "bufcnt%d underrun - %d (for %d)",
- rx->index, i, n_bds);
+ rx->index, i, n_bds);
musb_writel(tibase,
DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4),
n_bds + 2);
@@ -960,21 +958,21 @@ static int cppi_channel_program(struct dma_channel *ch,
case MUSB_DMA_STATUS_BUS_ABORT:
case MUSB_DMA_STATUS_CORE_ABORT:
/* fault irq handler should have handled cleanup */
- WARNING("%cX DMA%d not cleaned up after abort!\n",
- cppi_ch->transmit ? 'T' : 'R',
- cppi_ch->index);
+ musb_warn(musb, "%cX DMA%d not cleaned up after abort!",
+ cppi_ch->transmit ? 'T' : 'R',
+ cppi_ch->index);
/* WARN_ON(1); */
break;
case MUSB_DMA_STATUS_BUSY:
- WARNING("program active channel? %cX DMA%d\n",
- cppi_ch->transmit ? 'T' : 'R',
- cppi_ch->index);
+ musb_warn(musb, "program active channel? %cX DMA%d",
+ cppi_ch->transmit ? 'T' : 'R',
+ cppi_ch->index);
/* WARN_ON(1); */
break;
case MUSB_DMA_STATUS_UNKNOWN:
musb_dbg(musb, "%cX DMA%d not allocated!",
- cppi_ch->transmit ? 'T' : 'R',
- cppi_ch->index);
+ cppi_ch->transmit ? 'T' : 'R',
+ cppi_ch->index);
fallthrough;
case MUSB_DMA_STATUS_FREE:
break;
@@ -1028,11 +1026,10 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
if (!completed && (bd->hw_options & CPPI_OWN_SET))
break;

- musb_dbg(musb, "C/RXBD %llx: nxt %08x buf %08x "
- "off.len %08x opt.len %08x (%d)",
- (unsigned long long)bd->dma, bd->hw_next, bd->hw_bufp,
- bd->hw_off_len, bd->hw_options,
- rx->channel.actual_len);
+ musb_dbg(musb, "C/RXBD %llx: nxt %08x buf %08x off.len %08x opt.len %08x (%d)",
+ (unsigned long long)bd->dma, bd->hw_next, bd->hw_bufp,
+ bd->hw_off_len, bd->hw_options,
+ rx->channel.actual_len);

/* actual packet received length */
if ((bd->hw_options & CPPI_SOP_SET) && !completed)
@@ -1051,8 +1048,7 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
*/
completed = true;
musb_dbg(musb, "rx short %d/%d (%d)",
- len, bd->buflen,
- rx->channel.actual_len);
+ len, bd->buflen, rx->channel.actual_len);
}

/* If we got here, we expect to ack at least one BD; meanwhile
@@ -1101,14 +1097,14 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
csr = musb_readw(regs, MUSB_RXCSR);
if (csr & MUSB_RXCSR_DMAENAB) {
musb_dbg(musb, "list%d %p/%p, last %llx%s, csr %04x",
- rx->index,
- rx->head, rx->tail,
- rx->last_processed
- ? (unsigned long long)
- rx->last_processed->dma
- : 0,
- completed ? ", completed" : "",
- csr);
+ rx->index,
+ rx->head, rx->tail,
+ rx->last_processed
+ ? (unsigned long long)
+ rx->last_processed->dma
+ : 0,
+ completed ? ", completed" : "",
+ csr);
cppi_dump_rxq(4, "/what?", rx);
}
}
@@ -1207,8 +1203,8 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
break;

musb_dbg(musb, "C/TXBD %p n %x b %x off %x opt %x",
- bd, bd->hw_next, bd->hw_bufp,
- bd->hw_off_len, bd->hw_options);
+ bd, bd->hw_next, bd->hw_bufp,
+ bd->hw_off_len, bd->hw_options);

len = bd->hw_off_len & CPPI_BUFFER_LEN_MASK;
tx_ch->channel.actual_len += len;
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 1c023c0091c4..2bc2924af5d9 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -276,7 +276,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);
- WARNING("VBUS error workaround (delay coming)\n");
+ musb_warn(musb, "VBUS error workaround (delay coming)");
} else if (drvvbus) {
MUSB_HST_MODE(musb);
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 704435526394..625cd2e07fa6 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -92,8 +92,7 @@ static void davinci_musb_enable(struct musb *musb)
musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);

if (is_dma_capable() && !dma_off)
- printk(KERN_WARNING "%s %s: dma not reactivated\n",
- __FILE__, __func__);
+ musb_warn(musb, "dma not reactivated");
else
dma_off = 0;

@@ -119,7 +118,7 @@ static void davinci_musb_disable(struct musb *musb)
musb_writel(musb->ctrl_base, DAVINCI_USB_EOI_REG, 0);

if (is_dma_capable() && !dma_off)
- WARNING("dma still active\n");
+ musb_warn(musb, "dma still active");
}

@@ -308,7 +307,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);
- WARNING("VBUS error workaround (delay coming)\n");
+ musb_warn(musb, "VBUS error workaround (delay coming)");
} else if (drvvbus) {
MUSB_HST_MODE(musb);
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 849e0b770130..c6961184afff 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -600,8 +600,7 @@ static void musb_otg_timer_func(struct timer_list *t)
spin_lock_irqsave(&musb->lock, flags);
switch (musb->xceiv->otg->state) {
case OTG_STATE_B_WAIT_ACON:
- musb_dbg(musb,
- "HNP: b_wait_acon timeout; back to b_peripheral");
+ musb_dbg(musb, "HNP: b_wait_acon timeout; back to b_peripheral");
musb_g_disconnect(musb);
musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
musb->is_active = 0;
@@ -609,13 +608,13 @@ static void musb_otg_timer_func(struct timer_list *t)
case OTG_STATE_A_SUSPEND:
case OTG_STATE_A_WAIT_BCON:
musb_dbg(musb, "HNP: %s timeout",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
musb_platform_set_vbus(musb, 0);
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
break;
default:
musb_dbg(musb, "HNP: Unhandled mode %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
}
spin_unlock_irqrestore(&musb->lock, flags);
}
@@ -630,13 +629,13 @@ void musb_hnp_stop(struct musb *musb)
u8 reg;

musb_dbg(musb, "HNP: stop from %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));

switch (musb->xceiv->otg->state) {
case OTG_STATE_A_PERIPHERAL:
musb_g_disconnect(musb);
musb_dbg(musb, "HNP: back to %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
break;
case OTG_STATE_B_HOST:
musb_dbg(musb, "HNP: Disabling HR");
@@ -651,7 +650,7 @@ void musb_hnp_stop(struct musb *musb)
break;
default:
musb_dbg(musb, "HNP: Stopping in unknown state %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
}

/*
@@ -667,7 +666,7 @@ static void musb_recover_from_babble(struct musb *musb);
static void musb_handle_intr_resume(struct musb *musb, u8 devctl)
{
musb_dbg(musb, "RESUME (%s)",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));

if (devctl & MUSB_DEVCTL_HM) {
switch (musb->xceiv->otg->state) {
@@ -690,9 +689,8 @@ static void musb_handle_intr_resume(struct musb *musb, u8 devctl)
MUSB_DEV_MODE(musb);
break;
default:
- WARNING("bogus %s RESUME (%s)\n",
- "host",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "bogus host RESUME (%s)",
+ usb_otg_state_string(musb->xceiv->otg->state));
}
} else {
switch (musb->xceiv->otg->state) {
@@ -719,9 +717,8 @@ static void musb_handle_intr_resume(struct musb *musb, u8 devctl)
musb->int_usb &= ~MUSB_INTR_SUSPEND;
break;
default:
- WARNING("bogus %s RESUME (%s)\n",
- "peripheral",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "bogus peripheral RESUME (%s)",
+ usb_otg_state_string(musb->xceiv->otg->state));
}
}
}
@@ -738,7 +735,7 @@ static irqreturn_t musb_handle_intr_sessreq(struct musb *musb, u8 devctl)
}

musb_dbg(musb, "SESSION_REQUEST (%s)",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));

/* IRQ arrives from ID pin sense or (later, if VBUS power
* is removed) SRP. responses are time critical:
@@ -830,7 +827,7 @@ static void musb_handle_intr_vbuserr(struct musb *musb, u8 devctl)
static void musb_handle_intr_suspend(struct musb *musb, u8 devctl)
{
musb_dbg(musb, "SUSPEND (%s) devctl %02x",
- usb_otg_state_string(musb->xceiv->otg->state), devctl);
+ usb_otg_state_string(musb->xceiv->otg->state), devctl);

switch (musb->xceiv->otg->state) {
case OTG_STATE_A_PERIPHERAL:
@@ -938,14 +935,14 @@ static void musb_handle_intr_connect(struct musb *musb, u8 devctl, u8 int_usb)
musb_host_poke_root_hub(musb);

musb_dbg(musb, "CONNECT (%s) devctl %02x",
- usb_otg_state_string(musb->xceiv->otg->state), devctl);
+ usb_otg_state_string(musb->xceiv->otg->state), devctl);
}

static void musb_handle_intr_disconnect(struct musb *musb, u8 devctl)
{
musb_dbg(musb, "DISCONNECT (%s) as %s, devctl %02x",
- usb_otg_state_string(musb->xceiv->otg->state),
- MUSB_MODE(musb), devctl);
+ usb_otg_state_string(musb->xceiv->otg->state),
+ MUSB_MODE(musb), devctl);

switch (musb->xceiv->otg->state) {
case OTG_STATE_A_HOST:
@@ -979,8 +976,8 @@ static void musb_handle_intr_disconnect(struct musb *musb, u8 devctl)
musb_g_disconnect(musb);
break;
default:
- WARNING("unhandled DISCONNECT transition (%s)\n",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "unhandled DISCONNECT transition (%s)",
+ usb_otg_state_string(musb->xceiv->otg->state));
break;
}
}
@@ -1004,7 +1001,7 @@ static void musb_handle_intr_reset(struct musb *musb)
musb_recover_from_babble(musb);
} else {
musb_dbg(musb, "BUS RESET as %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
switch (musb->xceiv->otg->state) {
case OTG_STATE_A_SUSPEND:
musb_g_reset(musb);
@@ -1012,8 +1009,8 @@ static void musb_handle_intr_reset(struct musb *musb)
case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */
/* never use invalid T(a_wait_bcon) */
musb_dbg(musb, "HNP: in %s, %d msec timeout",
- usb_otg_state_string(musb->xceiv->otg->state),
- TA_WAIT_BCON(musb));
+ usb_otg_state_string(musb->xceiv->otg->state),
+ TA_WAIT_BCON(musb));
mod_timer(&musb->otg_timer, jiffies
+ msecs_to_jiffies(TA_WAIT_BCON(musb)));
break;
@@ -1023,7 +1020,7 @@ static void musb_handle_intr_reset(struct musb *musb)
break;
case OTG_STATE_B_WAIT_ACON:
musb_dbg(musb, "HNP: RESET (%s), to b_peripheral",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
musb_g_reset(musb);
break;
@@ -1035,7 +1032,7 @@ static void musb_handle_intr_reset(struct musb *musb)
break;
default:
musb_dbg(musb, "Unhandled BUS RESET as %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
}
}
}
@@ -1692,19 +1689,19 @@ static int musb_core_init(u16 musb_type, struct musb *musb)

if (hw_ep->max_packet_sz_tx) {
musb_dbg(musb, "%s: hw_ep %d%s, %smax %d",
- musb_driver_name, i,
- hw_ep->is_shared_fifo ? "shared" : "tx",
- hw_ep->tx_double_buffered
- ? "doublebuffer, " : "",
- hw_ep->max_packet_sz_tx);
+ musb_driver_name, i,
+ hw_ep->is_shared_fifo ? "shared" : "tx",
+ hw_ep->tx_double_buffered
+ ? "doublebuffer, " : "",
+ hw_ep->max_packet_sz_tx);
}
if (hw_ep->max_packet_sz_rx && !hw_ep->is_shared_fifo) {
musb_dbg(musb, "%s: hw_ep %d%s, %smax %d",
- musb_driver_name, i,
- "rx",
- hw_ep->rx_double_buffered
- ? "doublebuffer, " : "",
- hw_ep->max_packet_sz_rx);
+ musb_driver_name, i,
+ "rx",
+ hw_ep->rx_double_buffered
+ ? "doublebuffer, " : "",
+ hw_ep->max_packet_sz_rx);
}
if (!(hw_ep->max_packet_sz_tx || hw_ep->max_packet_sz_rx))
musb_dbg(musb, "hw_ep %d not configured", i);
@@ -2004,7 +2001,7 @@ static void musb_pm_runtime_check_session(struct musb *musb)
MUSB_DEVCTL_HR;
switch (devctl & ~s) {
case MUSB_QUIRK_B_DISCONNECT_99:
- musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
+ musb_dbg(musb, "Poll devctl in case of suspend after disconnect");
schedule_delayed_work(&musb->irq_work,
msecs_to_jiffies(1000));
break;
@@ -2048,8 +2045,7 @@ static void musb_pm_runtime_check_session(struct musb *musb)
musb_dbg(musb, "Block PM on active session: %02x", devctl);
error = pm_runtime_get_sync(musb->controller);
if (error < 0)
- dev_err(musb->controller, "Could not enable: %i\n",
- error);
+ musb_err(musb, "Could not enable: %i", error);
musb->quirk_retries = 3;
} else {
musb_dbg(musb, "Allow PM with no session: %02x", devctl);
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index 7fbb8a307145..2e8323fd4613 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -91,7 +91,7 @@ static void update_rx_toggle(struct cppi41_dma_channel *cppi41_channel)
if (!toggle && toggle == cppi41_channel->usb_toggle) {
csr |= MUSB_RXCSR_H_DATATOGGLE | MUSB_RXCSR_H_WR_DATATOGGLE;
musb_writew(cppi41_channel->hw_ep->regs, MUSB_RXCSR, csr);
- musb_dbg(musb, "Restoring DATA1 toggle.");
+ musb_dbg(musb, "Restoring DATA1 toggle");
}

cppi41_channel->usb_toggle = toggle;
diff --git a/drivers/usb/musb/musb_debug.h b/drivers/usb/musb/musb_debug.h
index e5b3506c7b3f..8c96428dade5 100644
--- a/drivers/usb/musb/musb_debug.h
+++ b/drivers/usb/musb/musb_debug.h
@@ -10,12 +10,14 @@
#ifndef __MUSB_LINUX_DEBUG_H__
#define __MUSB_LINUX_DEBUG_H__

-#define yprintk(facility, format, args...) \
- do { printk(facility "%s %d: " format , \
- __func__, __LINE__ , ## args); } while (0)
-#define WARNING(fmt, args...) yprintk(KERN_WARNING, fmt, ## args)
-#define INFO(fmt, args...) yprintk(KERN_INFO, fmt, ## args)
-#define ERR(fmt, args...) yprintk(KERN_ERR, fmt, ## args)
+#define musb_err(musb, fmt, ...) \
+ dev_err((musb)->controller, fmt "\n", ##__VA_ARGS__)
+#define musb_warn(musb, fmt, ...) \
+ dev_warn((musb)->controller, fmt "\n", ##__VA_ARGS__)
+#define musb_notice(musb, fmt, ...) \
+ dev_notice((musb)->controller, fmt "\n", ##__VA_ARGS__)
+#define musb_info(musb, fmt, ...) \
+ dev_info((musb)->controller, fmt "\n", ##__VA_ARGS__)

void musb_dbg(struct musb *musb, const char *fmt, ...);

diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 5892f3ce0cdc..a045cd85197b 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -366,7 +366,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
dsps_mod_timer_optional(glue);
- WARNING("VBUS error workaround (delay coming)\n");
+ musb_warn(musb, "VBUS error workaround (delay coming)");
} else if (drvvbus) {
MUSB_HST_MODE(musb);
musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index f62ffaede1ab..f5b76e689fca 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -234,7 +234,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
/* Check if EP is disabled */
if (!musb_ep->desc) {
musb_dbg(musb, "ep:%s disabled - ignore request",
- musb_ep->end_point.name);
+ musb_ep->end_point.name);
return;
}

@@ -252,20 +252,19 @@ static void txstate(struct musb *musb, struct musb_request *req)
(int)(request->length - request->actual));

if (csr & MUSB_TXCSR_TXPKTRDY) {
- musb_dbg(musb, "%s old packet still ready , txcsr %03x",
- musb_ep->end_point.name, csr);
+ musb_dbg(musb, "%s old packet still ready, txcsr %03x",
+ musb_ep->end_point.name, csr);
return;
}

if (csr & MUSB_TXCSR_P_SENDSTALL) {
musb_dbg(musb, "%s stalling, txcsr %03x",
- musb_ep->end_point.name, csr);
+ musb_ep->end_point.name, csr);
return;
}

musb_dbg(musb, "hw_ep%d, maxpacket %d, fifo count %d, txcsr %03x",
- epnum, musb_ep->packet_sz, fifo_count,
- csr);
+ epnum, musb_ep->packet_sz, fifo_count, csr);

#ifndef CONFIG_MUSB_PIO_ONLY
if (is_buffer_mapped(req)) {
@@ -392,11 +391,11 @@ static void txstate(struct musb *musb, struct musb_request *req)

/* host may already have the data when this message shows... */
musb_dbg(musb, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d",
- musb_ep->end_point.name, use_dma ? "dma" : "pio",
- request->actual, request->length,
- musb_readw(epio, MUSB_TXCSR),
- fifo_count,
- musb_readw(epio, MUSB_TXMAXP));
+ musb_ep->end_point.name, use_dma ? "dma" : "pio",
+ request->actual, request->length,
+ musb_readw(epio, MUSB_TXCSR),
+ fifo_count,
+ musb_readw(epio, MUSB_TXMAXP));
}

/*
@@ -464,7 +463,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
csr = musb_readw(epio, MUSB_TXCSR);
request->actual += musb_ep->dma->actual_len;
musb_dbg(musb, "TXCSR%d %04x, DMA off, len %zu, req %p",
- epnum, csr, musb_ep->dma->actual_len, request);
+ epnum, csr, musb_ep->dma->actual_len, request);
}

/*
@@ -501,7 +500,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
req = musb_ep->desc ? next_request(musb_ep) : NULL;
if (!req) {
musb_dbg(musb, "%s idle now",
- musb_ep->end_point.name);
+ musb_ep->end_point.name);
return;
}
}
@@ -537,7 +536,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
/* Check if EP is disabled */
if (!musb_ep->desc) {
musb_dbg(musb, "ep:%s disabled - ignore request",
- musb_ep->end_point.name);
+ musb_ep->end_point.name);
return;
}

@@ -549,7 +548,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)

if (csr & MUSB_RXCSR_P_SENDSTALL) {
musb_dbg(musb, "%s stalling, RXCSR %04x",
- musb_ep->end_point.name, csr);
+ musb_ep->end_point.name, csr);
return;
}

@@ -724,9 +723,9 @@ static void rxstate(struct musb *musb, struct musb_request *req)

len = request->length - request->actual;
musb_dbg(musb, "%s OUT/RX pio fifo %d/%d, maxpacket %d",
- musb_ep->end_point.name,
- fifo_count, len,
- musb_ep->packet_sz);
+ musb_ep->end_point.name,
+ fifo_count, len,
+ musb_ep->packet_sz);

fifo_count = min_t(unsigned, len, fifo_count);

@@ -812,8 +811,8 @@ void musb_g_rx(struct musb *musb, u8 epnum)
csr = musb_readw(epio, MUSB_RXCSR);
dma = is_dma_capable() ? musb_ep->dma : NULL;

- musb_dbg(musb, "<== %s, rxcsr %04x%s %p", musb_ep->end_point.name,
- csr, dma ? " (dma)" : "", request);
+ musb_dbg(musb, "<== %s, rxcsr %04x%s %p",
+ musb_ep->end_point.name, csr, dma ? " (dma)" : "", request);

if (csr & MUSB_RXCSR_P_SENTSTALL) {
csr |= MUSB_RXCSR_P_WZC_BITS;
@@ -839,7 +838,7 @@ void musb_g_rx(struct musb *musb, u8 epnum)
if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
/* "should not happen"; likely RXPKTRDY pending for DMA */
musb_dbg(musb, "%s busy, csr %04x",
- musb_ep->end_point.name, csr);
+ musb_ep->end_point.name, csr);
return;
}

@@ -1232,8 +1231,8 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,

/* don't queue if the ep is down */
if (!musb_ep->desc) {
- musb_dbg(musb, "req %p queued to %s while ep %s",
- req, ep->name, "disabled");
+ musb_dbg(musb, "req %p queued to %s while ep disabled",
+ req, ep->name);
status = -ESHUTDOWN;
unmap_dma_buffer(request, musb);
goto unlock;
@@ -1349,7 +1348,7 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
if (value) {
if (request) {
musb_dbg(musb, "request in progress, cannot halt %s",
- ep->name);
+ ep->name);
status = -EAGAIN;
goto done;
}
@@ -1358,7 +1357,7 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
csr = musb_readw(epio, MUSB_TXCSR);
if (csr & MUSB_TXCSR_FIFONOTEMPTY) {
musb_dbg(musb, "FIFO busy, cannot halt %s",
- ep->name);
+ ep->name);
status = -EAGAIN;
goto done;
}
@@ -1559,7 +1558,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
goto done;
default:
musb_dbg(musb, "Unhandled wake: %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
goto done;
}

@@ -1600,8 +1599,7 @@ static void musb_pullup(struct musb *musb, int is_on)

/* FIXME if on, HdrcStart; if off, HdrcStop */

- musb_dbg(musb, "gadget D+ pullup %s",
- is_on ? "on" : "off");
+ musb_dbg(musb, "gadget D+ pullup %s", is_on ? "on" : "off");
musb_writeb(musb->mregs, MUSB_POWER, power);
}

@@ -1936,8 +1934,8 @@ void musb_g_resume(struct musb *musb)
}
break;
default:
- WARNING("unhandled RESUME transition (%s)\n",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "unhandled RESUME transition (%s)",
+ usb_otg_state_string(musb->xceiv->otg->state));
}
}

@@ -1966,8 +1964,8 @@ void musb_g_suspend(struct musb *musb)
/* REVISIT if B_HOST, clear DEVCTL.HOSTREQ;
* A_PERIPHERAL may need care too
*/
- WARNING("unhandled SUSPEND transition (%s)",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "unhandled SUSPEND transition (%s)",
+ usb_otg_state_string(musb->xceiv->otg->state));
}
}

@@ -2001,7 +1999,7 @@ void musb_g_disconnect(struct musb *musb)
switch (musb->xceiv->otg->state) {
default:
musb_dbg(musb, "Unhandled disconnect %s, setting a_idle",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
musb->xceiv->otg->state = OTG_STATE_A_IDLE;
MUSB_HST_MODE(musb);
break;
@@ -2031,12 +2029,12 @@ __acquires(musb->lock)
u8 power;

musb_dbg(musb, "<== %s driver '%s'",
- (devctl & MUSB_DEVCTL_BDEVICE)
- ? "B-Device" : "A-Device",
- musb->gadget_driver
- ? musb->gadget_driver->driver.name
- : NULL
- );
+ (devctl & MUSB_DEVCTL_BDEVICE)
+ ? "B-Device" : "A-Device",
+ musb->gadget_driver
+ ? musb->gadget_driver->driver.name
+ : NULL
+ );

/* report reset, if we didn't already (flushing EP state) */
if (musb->gadget_driver && musb->g.speed != USB_SPEED_UNKNOWN) {
diff --git a/drivers/usb/musb/musb_gadget_ep0.c b/drivers/usb/musb/musb_gadget_ep0.c
index 6d7336727388..130db182bf09 100644
--- a/drivers/usb/musb/musb_gadget_ep0.c
+++ b/drivers/usb/musb/musb_gadget_ep0.c
@@ -583,11 +583,11 @@ musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
* order, but now USB packets always stay in USB byte order.
*/
musb_dbg(musb, "SETUP req%02x.%02x v%04x i%04x l%d",
- req->bRequestType,
- req->bRequest,
- le16_to_cpu(req->wValue),
- le16_to_cpu(req->wIndex),
- le16_to_cpu(req->wLength));
+ req->bRequestType,
+ req->bRequest,
+ le16_to_cpu(req->wValue),
+ le16_to_cpu(req->wIndex),
+ le16_to_cpu(req->wLength));

/* clean up any leftover transfers */
r = next_ep0_request(musb);
@@ -651,7 +651,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
len = musb_readb(regs, MUSB_COUNT0);

musb_dbg(musb, "csr %04x, count %d, ep0stage %s",
- csr, len, decode_ep0stage(musb->ep0_state));
+ csr, len, decode_ep0stage(musb->ep0_state));

if (csr & MUSB_CSR0_P_DATAEND) {
/*
@@ -683,8 +683,8 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;
break;
default:
- ERR("SetupEnd came in a wrong ep0stage %s\n",
- decode_ep0stage(musb->ep0_state));
+ musb_err(musb, "SetupEnd came in a wrong ep0stage %s",
+ decode_ep0stage(musb->ep0_state));
}
csr = musb_readw(regs, MUSB_CSR0);
/* NOTE: request may need completion */
@@ -776,7 +776,8 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
int handled = 0;

if (len != 8) {
- ERR("SETUP packet len %d != 8 ?\n", len);
+ musb_err(musb, "SETUP packet len %d != 8 ?",
+ len);
break;
}
musb_read_setup(musb, &setup);
@@ -786,9 +787,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
if (unlikely(musb->g.speed == USB_SPEED_UNKNOWN)) {
u8 power;

- printk(KERN_NOTICE "%s: peripheral reset "
- "irq lost!\n",
- musb_driver_name);
+ musb_notice(musb, "peripheral reset irq lost!");
power = musb_readb(mbase, MUSB_POWER);
musb->g.speed = (power & MUSB_POWER_HSMODE)
? USB_SPEED_HIGH : USB_SPEED_FULL;
@@ -840,8 +839,8 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
}

musb_dbg(musb, "handled %d, csr %04x, ep0stage %s",
- handled, csr,
- decode_ep0stage(musb->ep0_state));
+ handled, csr,
+ decode_ep0stage(musb->ep0_state));

/* unless we need to delegate this to the gadget
* driver, we know how to wrap this up: csr0 has
@@ -937,7 +936,7 @@ musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
break;
default:
musb_dbg(musb, "ep0 request queued in state %d",
- musb->ep0_state);
+ musb->ep0_state);
status = -EINVAL;
goto cleanup;
}
@@ -946,8 +945,8 @@ musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
list_add_tail(&req->list, &ep->req_list);

musb_dbg(musb, "queue to %s (%s), length=%d",
- ep->name, ep->is_in ? "IN/TX" : "OUT/RX",
- req->request.length);
+ ep->name, ep->is_in ? "IN/TX" : "OUT/RX",
+ req->request.length);

musb_ep_select(musb->mregs, 0);

diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 30c5e7de0761..abc2af31dc4e 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -263,8 +263,8 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
break;
default:
start:
- musb_dbg(musb, "Start TX%d %s", epnum,
- hw_ep->tx_channel ? "dma" : "pio");
+ musb_dbg(musb, "Start TX%d %s",
+ epnum, hw_ep->tx_channel ? "dma" : "pio");

if (!hw_ep->tx_channel)
musb_h_tx_start(hw_ep);
@@ -376,7 +376,7 @@ static void musb_advance_schedule(struct musb *musb, struct urb *urb,

if (qh != NULL && qh->is_ready) {
musb_dbg(musb, "... next ep%d %cX urb %p",
- hw_ep->epnum, is_in ? 'R' : 'T', next_urb(qh));
+ hw_ep->epnum, is_in ? 'R' : 'T', next_urb(qh));
musb_start_urb(musb, is_in, qh);
}
}
@@ -420,9 +420,10 @@ musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)

/* musb_ep_select(mbase, epnum); */
rx_count = musb_readw(epio, MUSB_RXCOUNT);
- musb_dbg(musb, "RX%d count %d, buffer %p len %d/%d", epnum, rx_count,
- urb->transfer_buffer, qh->offset,
- urb->transfer_buffer_length);
+ musb_dbg(musb, "RX%d count %d, buffer %p len %d/%d",
+ epnum, rx_count,
+ urb->transfer_buffer, qh->offset,
+ urb->transfer_buffer_length);

/* unload FIFO */
if (usb_pipeisoc(pipe)) {
@@ -537,8 +538,8 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, u8 epnum)
}
csr = musb_readw(ep->regs, MUSB_RXCSR);
if (csr & MUSB_RXCSR_RXPKTRDY)
- WARNING("rx%d, packet/%d ready?\n", ep->epnum,
- musb_readw(ep->regs, MUSB_RXCOUNT));
+ musb_warn(musb, "rx%d, packet/%d ready?",
+ ep->epnum, musb_readw(ep->regs, MUSB_RXCOUNT));

musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG);

@@ -681,13 +682,12 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
u8 use_dma = 1;
u16 csr;

- musb_dbg(musb, "%s hw%d urb %p spd%d dev%d ep%d%s "
- "h_addr%02x h_port%02x bytes %d",
- is_out ? "-->" : "<--",
- epnum, urb, urb->dev->speed,
- qh->addr_reg, qh->epnum, is_out ? "out" : "in",
- qh->h_addr_reg, qh->h_port_reg,
- len);
+ musb_dbg(musb, "%s hw%d urb %p spd%d dev%d ep%d%s h_addr%02x h_port%02x bytes %d",
+ is_out ? "-->" : "<--",
+ epnum, urb, urb->dev->speed,
+ qh->addr_reg, qh->epnum, is_out ? "out" : "in",
+ qh->h_addr_reg, qh->h_port_reg,
+ len);

musb_ep_select(mbase, epnum);

@@ -852,8 +852,8 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
if (csr & (MUSB_RXCSR_RXPKTRDY
| MUSB_RXCSR_DMAENAB
| MUSB_RXCSR_H_REQPKT))
- ERR("broken !rx_reinit, ep%d csr %04x\n",
- hw_ep->epnum, csr);
+ musb_err(musb, "broken !rx_reinit, ep%d csr %04x",
+ hw_ep->epnum, csr);

/* scrub any stale state, leaving toggle alone */
csr &= MUSB_RXCSR_DISNYET;
@@ -1028,9 +1028,9 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
fifo_dest = (u8 *) (urb->transfer_buffer
+ urb->actual_length);
musb_dbg(musb, "Sending %d byte%s to ep0 fifo %p",
- fifo_count,
- (fifo_count == 1) ? "" : "s",
- fifo_dest);
+ fifo_count,
+ (fifo_count == 1) ? "" : "s",
+ fifo_dest);
musb_write_fifo(hw_ep, fifo_count, fifo_dest);

urb->actual_length += fifo_count;
@@ -1038,7 +1038,7 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
}
break;
default:
- ERR("bogus ep0 stage %d\n", musb->ep0_stage);
+ musb_err(musb, "bogus ep0 stage %d", musb->ep0_stage);
break;
}

@@ -1073,7 +1073,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
: 0;

musb_dbg(musb, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d",
- csr, qh, len, urb, musb->ep0_stage);
+ csr, qh, len, urb, musb->ep0_stage);

/* if we just did status stage, we are done */
if (MUSB_EP0_STATUS == musb->ep0_stage) {
@@ -1131,7 +1131,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
if (unlikely(!urb)) {
/* stop endpoint since we have no place for its data, this
* SHOULD NEVER HAPPEN! */
- ERR("no URB for end 0\n");
+ musb_err(musb, "no URB for end 0");

musb_h_ep0_flush_fifo(hw_ep);
goto done;
@@ -1220,8 +1220,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
pipe = urb->pipe;
dma = is_dma_capable() ? hw_ep->tx_channel : NULL;
trace_musb_urb_tx(musb, urb);
- musb_dbg(musb, "OUT/TX%d end, csr %04x%s", epnum, tx_csr,
- dma ? ", dma" : "");
+ musb_dbg(musb, "OUT/TX%d end, csr %04x%s",
+ epnum, tx_csr, dma ? ", dma" : "");

/* check for errors */
if (tx_csr & MUSB_TXCSR_H_RXSTALL) {
@@ -1349,8 +1349,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
*/
if (tx_csr & (MUSB_TXCSR_FIFONOTEMPTY | MUSB_TXCSR_TXPKTRDY)) {
musb_dbg(musb,
- "DMA complete but FIFO not empty, CSR %04x",
- tx_csr);
+ "DMA complete but FIFO not empty, CSR %04x",
+ tx_csr);
return;
}
}
@@ -1635,7 +1635,7 @@ static int musb_rx_dma_in_inventra_cppi41(struct dma_controller *dma,
urb->error_count++;
}
musb_dbg(musb, "** OVERFLOW %d into %d",
- rx_count, d->length);
+ rx_count, d->length);

length = d->length;
} else
@@ -1758,7 +1758,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
* with fifo full. (Only with DMA??)
*/
musb_dbg(musb, "BOGUS RX%d ready, csr %04x, count %d",
- epnum, val, musb_readw(epio, MUSB_RXCOUNT));
+ epnum, val, musb_readw(epio, MUSB_RXCOUNT));
musb_h_flush_rxfifo(hw_ep, MUSB_RXCSR_CLRDATATOG);
return;
}
@@ -1820,7 +1820,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
}
} else if (rx_csr & MUSB_RXCSR_INCOMPRX) {
musb_dbg(musb, "end %d high bandwidth incomplete ISO packet RX",
- epnum);
+ epnum);
status = -EPROTO;
}

@@ -1840,7 +1840,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)

if (unlikely(dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY)) {
/* SHOULD NEVER HAPPEN ... but at least DaVinci has done it */
- ERR("RX%d dma busy, csr %04x\n", epnum, rx_csr);
+ musb_err(musb, "RX%d dma busy, csr %04x", epnum, rx_csr);
goto finish;
}

@@ -1864,8 +1864,8 @@ void musb_host_rx(struct musb *musb, u8 epnum)
done = true;
}

- musb_dbg(musb, "RXCSR%d %04x, reqpkt, len %zu%s", epnum, rx_csr,
- xfer_len, dma ? ", dma" : "");
+ musb_dbg(musb, "RXCSR%d %04x, reqpkt, len %zu%s",
+ epnum, rx_csr, xfer_len, dma ? ", dma" : "");
rx_csr &= ~MUSB_RXCSR_H_REQPKT;

musb_ep_select(mbase, epnum);
@@ -1886,10 +1886,10 @@ void musb_host_rx(struct musb *musb, u8 epnum)
musb_dma_cppi41(musb)) {
done = musb_rx_dma_inventra_cppi41(c, hw_ep, qh, urb, xfer_len);
musb_dbg(hw_ep->musb,
- "ep %d dma %s, rxcsr %04x, rxcount %d",
- epnum, done ? "off" : "reset",
- musb_readw(epio, MUSB_RXCSR),
- musb_readw(epio, MUSB_RXCOUNT));
+ "ep %d dma %s, rxcsr %04x, rxcount %d",
+ epnum, done ? "off" : "reset",
+ musb_readw(epio, MUSB_RXCSR),
+ musb_readw(epio, MUSB_RXCOUNT));
} else {
done = true;
}
@@ -1898,7 +1898,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
/* if no errors, be sure a packet is ready for unloading */
if (unlikely(!(rx_csr & MUSB_RXCSR_RXPKTRDY))) {
status = -EPROTO;
- ERR("Rx interrupt with no errors or packet!\n");
+ musb_err(musb, "Rx interrupt with no errors or packet!");

/* FIXME this is another "SHOULD NEVER HAPPEN" */

@@ -1914,12 +1914,10 @@ void musb_host_rx(struct musb *musb, u8 epnum)
if ((musb_dma_inventra(musb) || musb_dma_ux500(musb) ||
musb_dma_cppi41(musb)) && dma) {
musb_dbg(hw_ep->musb,
- "RX%d count %d, buffer 0x%llx len %d/%d",
- epnum, musb_readw(epio, MUSB_RXCOUNT),
- (unsigned long long) urb->transfer_dma
- + urb->actual_length,
- qh->offset,
- urb->transfer_buffer_length);
+ "RX%d count %d, buffer 0x%llx len %d/%d",
+ epnum, musb_readw(epio, MUSB_RXCOUNT),
+ (u64)urb->transfer_dma + urb->actual_length,
+ qh->offset, urb->transfer_buffer_length);

if (musb_rx_dma_in_inventra_cppi41(c, hw_ep, qh, urb,
xfer_len, iso_err))
@@ -2324,8 +2322,7 @@ static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh)
if (dma) {
status = ep->musb->dma_controller->channel_abort(dma);
musb_dbg(musb, "abort %cX%d DMA for urb %p --> %d",
- is_in ? 'R' : 'T', ep->epnum,
- urb, status);
+ is_in ? 'R' : 'T', ep->epnum, urb, status);
urb->actual_length += dma->actual_len;
}
}
@@ -2524,11 +2521,12 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
}

if (musb->is_active) {
- WARNING("trying to suspend as %s while active\n",
- usb_otg_state_string(musb->xceiv->otg->state));
+ musb_warn(musb, "trying to suspend as %s while active",
+ usb_otg_state_string(musb->xceiv->otg->state));
return -EBUSY;
- } else
- return 0;
+ }
+
+ return 0;
}

static int musb_bus_resume(struct usb_hcd *hcd)
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index cafc69536e1d..065fdb8b91e0 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -102,7 +102,7 @@ int musb_port_suspend(struct musb *musb, bool do_suspend)
break;
default:
musb_dbg(musb, "bogus rh suspend? %s",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
}
} else if (power & MUSB_POWER_SUSPENDM) {
power &= ~MUSB_POWER_SUSPENDM;
@@ -221,7 +221,7 @@ void musb_root_disconnect(struct musb *musb)
break;
default:
musb_dbg(musb, "host disconnect (%s)",
- usb_otg_state_string(musb->xceiv->otg->state));
+ usb_otg_state_string(musb->xceiv->otg->state));
}
}
EXPORT_SYMBOL_GPL(musb_root_disconnect);
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 0aacfc8be5a1..d8130f58bca3 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -152,7 +152,7 @@ static void configure_channel(struct dma_channel *channel,
u16 csr = 0;

musb_dbg(musb, "%p, pkt_sz %d, addr %pad, len %d, mode %d",
- channel, packet_sz, &dma_addr, len, mode);
+ channel, packet_sz, &dma_addr, len, mode);

if (mode) {
csr |= 1 << MUSB_HSDMA_MODE1_SHIFT;
@@ -187,9 +187,9 @@ static int dma_channel_program(struct dma_channel *channel,
struct musb *musb = controller->private_data;

musb_dbg(musb, "ep%d-%s pkt_sz %d, dma_addr %pad length %d, mode %d",
- musb_channel->epnum,
- musb_channel->transmit ? "Tx" : "Rx",
- packet_sz, &dma_addr, len, mode);
+ musb_channel->epnum,
+ musb_channel->transmit ? "Tx" : "Rx",
+ packet_sz, &dma_addr, len, mode);

BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
channel->status == MUSB_DMA_STATUS_BUSY);
@@ -329,12 +329,12 @@ irqreturn_t dma_controller_irq(int irq, void *private_data)
- musb_channel->start_addr;

musb_dbg(musb, "ch %p, 0x%x -> 0x%x (%zu / %d) %s",
- channel, musb_channel->start_addr,
- addr, channel->actual_len,
- musb_channel->len,
- (channel->actual_len
- < musb_channel->len) ?
- "=> reconfig 0" : "=> complete");
+ channel, musb_channel->start_addr,
+ addr, channel->actual_len,
+ musb_channel->len,
+ (channel->actual_len
+ < musb_channel->len) ?
+ "=> reconfig 0" : "=> complete");

devctl = musb_readb(mbase, MUSB_DEVCTL);

diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index c42937692207..4147c361bfc6 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -667,8 +667,8 @@ static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT);
if ((musb_mode == MUSB_PERIPHERAL) &&
!(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS))
- INFO("Cannot be peripheral with mini-A cable "
- "otg_stat: %08x\n", otg_stat);
+ musb_info(musb, "Cannot be peripheral with mini-A cable otg_stat: %08x",
+ otg_stat);

return 0;
}
@@ -793,7 +793,8 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
+ msecs_to_jiffies(musb->a_wait_bcon);
} else {
/* REVISIT report overcurrent to hub? */
- ERR("vbus too slow, devctl %02x\n", devctl);
+ musb_err(musb, "vbus too slow, devctl %02x",
+ devctl);
tusb_musb_set_vbus(musb, 0);
}
break;
@@ -957,8 +958,7 @@ static void tusb_musb_enable(struct musb *musb)
TUSB_INT_SRC_ID_STATUS_CHNG);

if (is_dma_capable() && dma_off)
- printk(KERN_WARNING "%s %s: dma not reactivated\n",
- __FILE__, __func__);
+ musb_warn(musb, "dma not reactivated");
else
dma_off = 1;
}
@@ -981,8 +981,7 @@ static void tusb_musb_disable(struct musb *musb)
del_timer(&musb->dev_timer);

if (is_dma_capable() && !dma_off) {
- printk(KERN_WARNING "%s %s: dma still active\n",
- __FILE__, __func__);
+ musb_warn(musb, "dma still active");
dma_off = 1;
}
}
@@ -1028,7 +1027,7 @@ static int tusb_musb_start(struct musb *musb)
if (musb->board_set_power)
ret = musb->board_set_power(1);
if (ret != 0) {
- printk(KERN_ERR "tusb: Cannot enable TUSB6010\n");
+ musb_err(musb, "tusb: Cannot enable TUSB6010");
return ret;
}

@@ -1036,15 +1035,15 @@ static int tusb_musb_start(struct musb *musb)

if (musb_readl(tbase, TUSB_PROD_TEST_RESET) !=
TUSB_PROD_TEST_RESET_VAL) {
- printk(KERN_ERR "tusb: Unable to detect TUSB6010\n");
+ musb_err(musb, "tusb: Unable to detect TUSB6010");
goto err;
}

musb->tusb_revision = tusb_get_revision(musb);
tusb_print_revision(musb);
if (musb->tusb_revision < 2) {
- printk(KERN_ERR "tusb: Unsupported TUSB6010 revision %i\n",
- musb->tusb_revision);
+ musb_err(musb, "tusb: Unsupported TUSB6010 revision %i",
+ musb->tusb_revision);
goto err;
}

@@ -1129,8 +1128,7 @@ static int tusb_musb_init(struct musb *musb)

ret = tusb_musb_start(musb);
if (ret) {
- printk(KERN_ERR "Could not start tusb6010 (%d)\n",
- ret);
+ musb_err(musb, "Could not start tusb6010 (%d)", ret);
goto done;
}
musb->isr = tusb_musb_interrupt;
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index 60a93b8bbe3c..88f2923cfdc4 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -83,8 +83,8 @@ static inline void tusb_omap_free_shared_dmareq(struct tusb_omap_dma_ch *chdat)
u32 reg = musb_readl(chdat->tbase, TUSB_DMA_EP_MAP);

if ((reg & 0xf) != chdat->epnum) {
- printk(KERN_ERR "ep%i trying to release dmareq0 for ep%i\n",
- chdat->epnum, reg & 0xf);
+ musb_err(chdat->musb, "ep%i trying to release dmareq0 for ep%i",
+ chdat->epnum, reg & 0xf);
return;
}
musb_writel(chdat->tbase, TUSB_DMA_EP_MAP, 0);
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
index d5cf5e8bb1ca..9979a733954d 100644
--- a/drivers/usb/musb/ux500_dma.c
+++ b/drivers/usb/musb/ux500_dma.c
@@ -323,8 +323,8 @@ static int ux500_dma_controller_start(struct ux500_dma_controller *controller)
NULL);

if (!ux500_channel->dma_chan) {
- ERR("Dma pipe allocation error dir=%d ch=%d\n",
- dir, ch_num);
+ musb_err(musb, "Dma pipe allocation error dir=%d ch=%d",
+ dir, ch_num);

/* Release already allocated channels */
ux500_dma_controller_stop(controller);