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

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, 2020-12-21 at 08:25 -0800, trix@xxxxxxxxxx wrote:
> From: Tom Rix <trix@xxxxxxxxxx>
> 
> 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@xxxxxxxxxx>
> ---
>  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);





[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux