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

Tom Rix
2020-12-21T20:57:46Z

On 12/21/20 12:33 PM, Joe Perches wrote:
> 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

I will looking into cleaning these up.

The propose of this and similar changes today was to add the __printf so the the %hhx cleaner would find them.

Thanks for the suggestion,

Tom

>
> ---
>
> (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);
>
>