From: Tony Lindgren <tony@atomide.com>
To: linux-omap-open-source@linux.omap.com
Subject: [PATCH 2/8] musb_hdrc: Search and replace MGC_M_ with MUSB_
Date: Wed, 15 Aug 2007 07:21:39 -0700 [thread overview]
Message-ID: <1187187711983-git-send-email-tony@atomide.com> (raw)
In-Reply-To: <11871877071348-git-send-email-tony@atomide.com>
Search and replace MGC_M_ with MUSB_
Signed-off-by: Tony Lindgren <tony@atomide.com>
---
drivers/usb/musb/cppi_dma.c | 26 ++--
drivers/usb/musb/davinci.c | 24 ++--
drivers/usb/musb/g_ep0.c | 82 +++++++-------
drivers/usb/musb/musb_gadget.c | 216 +++++++++++++++++-----------------
drivers/usb/musb/musb_host.c | 232 ++++++++++++++++++------------------
drivers/usb/musb/musb_procfs.c | 16 ++--
drivers/usb/musb/musbdefs.h | 2 +-
drivers/usb/musb/musbhdrc.h | 242 +++++++++++++++++++-------------------
drivers/usb/musb/musbhsdma.c | 18 ++--
drivers/usb/musb/omap2430.c | 4 +-
drivers/usb/musb/plat_uds.c | 120 ++++++++++----------
drivers/usb/musb/tusb6010.c | 12 +-
drivers/usb/musb/tusb6010_omap.c | 16 ++--
drivers/usb/musb/virthub.c | 46 ++++----
14 files changed, 528 insertions(+), 528 deletions(-)
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index db1fe8f..d902eaa 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -501,8 +501,8 @@ static inline int cppi_autoreq_update(struct cppi_channel *rx,
void *__iomem regs = rx->hw_ep->regs;
val = musb_readw(regs, MUSB_RXCSR);
- if (!(val & MGC_M_RXCSR_H_REQPKT)) {
- val |= MGC_M_RXCSR_H_REQPKT | MGC_M_RXCSR_H_WZC_BITS;
+ if (!(val & MUSB_RXCSR_H_REQPKT)) {
+ val |= MUSB_RXCSR_H_REQPKT | MUSB_RXCSR_H_WZC_BITS;
musb_writew(regs, MUSB_RXCSR, val);
/* flush writebufer */
val = musb_readw(regs, MUSB_RXCSR);
@@ -1096,7 +1096,7 @@ static int cppi_rx_scan(struct cppi *cppi, unsigned ch)
}
musb_ep_select(cppi->pCoreBase, rx->chNo + 1);
csr = musb_readw(regs, MUSB_RXCSR);
- if (csr & MGC_M_RXCSR_DMAENAB) {
+ if (csr & MUSB_RXCSR_DMAENAB) {
DBG(4, "list%d %p/%p, last %08x%s, csr %04x\n",
rx->chNo,
rx->activeQueueHead, rx->activeQueueTail,
@@ -1119,10 +1119,10 @@ static int cppi_rx_scan(struct cppi *cppi, unsigned ch)
csr = musb_readw(rx->hw_ep->regs, MUSB_RXCSR);
if (is_host_active(cppi->musb)
&& bd
- && !(csr & MGC_M_RXCSR_H_REQPKT)) {
- csr |= MGC_M_RXCSR_H_REQPKT;
+ && !(csr & MUSB_RXCSR_H_REQPKT)) {
+ csr |= MUSB_RXCSR_H_REQPKT;
musb_writew(regs, MUSB_RXCSR,
- MGC_M_RXCSR_H_WZC_BITS | csr);
+ MUSB_RXCSR_H_WZC_BITS | csr);
csr = musb_readw(rx->hw_ep->regs, MUSB_RXCSR);
}
} else {
@@ -1247,7 +1247,7 @@ void cppi_completion(struct musb *musb, u32 rx, u32 tx)
csr = musb_readw(hw_ep->regs,
MUSB_TXCSR);
- if (csr & MGC_M_TXCSR_TXPKTRDY)
+ if (csr & MUSB_TXCSR_TXPKTRDY)
#endif
bReqComplete = 0;
}
@@ -1439,8 +1439,8 @@ static int cppi_channel_abort(struct dma_channel *channel)
*/
regVal = musb_readw(regs, MUSB_TXCSR);
- regVal &= ~MGC_M_TXCSR_DMAENAB;
- regVal |= MGC_M_TXCSR_FLUSHFIFO;
+ regVal &= ~MUSB_TXCSR_DMAENAB;
+ regVal |= MUSB_TXCSR_FLUSHFIFO;
musb_writew(regs, MUSB_TXCSR, regVal);
musb_writew(regs, MUSB_TXCSR, regVal);
@@ -1500,13 +1500,13 @@ static int cppi_channel_abort(struct dma_channel *channel)
/* for host, clear (just) ReqPkt at end of current packet(s) */
if (is_host_active(otgCh->pController->musb)) {
- csr |= MGC_M_RXCSR_H_WZC_BITS;
- csr &= ~MGC_M_RXCSR_H_REQPKT;
+ csr |= MUSB_RXCSR_H_WZC_BITS;
+ csr &= ~MUSB_RXCSR_H_REQPKT;
} else
- csr |= MGC_M_RXCSR_P_WZC_BITS;
+ csr |= MUSB_RXCSR_P_WZC_BITS;
/* clear dma enable */
- csr &= ~(MGC_M_RXCSR_DMAENAB);
+ csr &= ~(MUSB_RXCSR_DMAENAB);
musb_writew(regs, MUSB_RXCSR, csr);
csr = musb_readw(regs, MUSB_RXCSR);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 8b87424..a7f04a7 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -86,7 +86,7 @@ void musb_platform_enable(struct musb *musb)
musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
tmp |= old;
- val = ~MGC_M_INTR_SOF;
+ val = ~MUSB_INTR_SOF;
tmp |= ((val & 0x01ff) << DAVINCI_USB_USBINT_SHIFT);
musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
@@ -218,13 +218,13 @@ static void otg_timer(unsigned long _musb)
* case "recover"), in routine "VBUS was valid by the time
* VBUSERR got reported during enumeration" cases.
*/
- if (devctl & MGC_M_DEVCTL_VBUS) {
+ if (devctl & MUSB_DEVCTL_VBUS) {
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
break;
}
musb->xceiv.state = OTG_STATE_A_WAIT_VRISE;
musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
- MGC_M_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
+ MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
break;
case OTG_STATE_B_IDLE:
if (!is_peripheral_enabled(musb))
@@ -242,9 +242,9 @@ static void otg_timer(unsigned long _musb)
* SRP, but clearly it doesn't.
*/
musb_writeb(mregs, MUSB_DEVCTL,
- devctl | MGC_M_DEVCTL_SESSION);
+ devctl | MUSB_DEVCTL_SESSION);
devctl = musb_readb(mregs, MUSB_DEVCTL);
- if (devctl & MGC_M_DEVCTL_BDEVICE)
+ if (devctl & MUSB_DEVCTL_BDEVICE)
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
else
musb->xceiv.state = OTG_STATE_A_IDLE;
@@ -311,10 +311,10 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
int drvvbus = musb_readl(tibase, DAVINCI_USB_STAT_REG);
void *__iomem mregs = musb->mregs;
u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
- int err = musb->int_usb & MGC_M_INTR_VBUSERROR;
+ int err = musb->int_usb & MUSB_INTR_VBUSERROR;
err = is_host_enabled(musb)
- && (musb->int_usb & MGC_M_INTR_VBUSERROR);
+ && (musb->int_usb & MUSB_INTR_VBUSERROR);
if (err) {
/* The Mentor core doesn't debounce VBUS as needed
* to cope with device connect current spikes. This
@@ -326,7 +326,7 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
* without waiting (on EVM, a **long** time) for VBUS
* to stop registering in devctl.
*/
- musb->int_usb &= ~MGC_M_INTR_VBUSERROR;
+ musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv.state = OTG_STATE_A_WAIT_VFALL;
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
WARN("VBUS error workaround (delay coming)\n");
@@ -441,10 +441,10 @@ int musb_platform_exit(struct musb *musb)
*/
do {
devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
- if (!(devctl & MGC_M_DEVCTL_VBUS))
+ if (!(devctl & MUSB_DEVCTL_VBUS))
break;
- if ((devctl & MGC_M_DEVCTL_VBUS) != warn) {
- warn = devctl & MGC_M_DEVCTL_VBUS;
+ if ((devctl & MUSB_DEVCTL_VBUS) != warn) {
+ warn = devctl & MUSB_DEVCTL_VBUS;
DBG(1, "VBUS %d\n", warn >> MGC_S_DEVCTL_VBUS);
}
msleep(1000);
@@ -452,7 +452,7 @@ int musb_platform_exit(struct musb *musb)
} while (maxdelay > 0);
/* in OTG mode, another host might be connected */
- if (devctl & MGC_M_DEVCTL_VBUS)
+ if (devctl & MUSB_DEVCTL_VBUS)
DBG(1, "VBUS off timeout (devctl %02x)\n", devctl);
}
diff --git a/drivers/usb/musb/g_ep0.c b/drivers/usb/musb/g_ep0.c
index fda3a54..1fa0cad 100644
--- a/drivers/usb/musb/g_ep0.c
+++ b/drivers/usb/musb/g_ep0.c
@@ -130,10 +130,10 @@ static int service_tx_status_request(
musb_ep_select(mbase, epnum);
if (is_in)
tmp = musb_readw(regs, MUSB_TXCSR)
- & MGC_M_TXCSR_P_SENDSTALL;
+ & MUSB_TXCSR_P_SENDSTALL;
else
tmp = musb_readw(regs, MUSB_RXCSR)
- & MGC_M_RXCSR_P_SENDSTALL;
+ & MUSB_RXCSR_P_SENDSTALL;
musb_ep_select(mbase, 0);
result[0] = tmp ? 1 : 0;
@@ -210,7 +210,7 @@ static inline void musb_try_b_hnp_enable(struct musb *musb)
DBG(1, "HNP: Setting HR\n");
devctl = musb_readb(mbase, MUSB_DEVCTL);
- musb_writeb(mbase, MUSB_DEVCTL, devctl | MGC_M_DEVCTL_HR);
+ musb_writeb(mbase, MUSB_DEVCTL, devctl | MUSB_DEVCTL_HR);
}
/*
@@ -307,25 +307,25 @@ __acquires(musb->lock)
pr_debug("TEST_J\n");
/* TEST_J */
musb->test_mode_nr =
- MGC_M_TEST_J;
+ MUSB_TEST_J;
break;
case 2:
/* TEST_K */
pr_debug("TEST_K\n");
musb->test_mode_nr =
- MGC_M_TEST_K;
+ MUSB_TEST_K;
break;
case 3:
/* TEST_SE0_NAK */
pr_debug("TEST_SE0_NAK\n");
musb->test_mode_nr =
- MGC_M_TEST_SE0_NAK;
+ MUSB_TEST_SE0_NAK;
break;
case 4:
/* TEST_PACKET */
pr_debug("TEST_PACKET\n");
musb->test_mode_nr =
- MGC_M_TEST_PACKET;
+ MUSB_TEST_PACKET;
break;
default:
goto stall;
@@ -392,20 +392,20 @@ stall:
if (is_in) {
csr = musb_readw(regs,
MUSB_TXCSR);
- if (csr & MGC_M_TXCSR_FIFONOTEMPTY)
- csr |= MGC_M_TXCSR_FLUSHFIFO;
- csr |= MGC_M_TXCSR_P_SENDSTALL
- | MGC_M_TXCSR_CLRDATATOG
- | MGC_M_TXCSR_P_WZC_BITS;
+ if (csr & MUSB_TXCSR_FIFONOTEMPTY)
+ csr |= MUSB_TXCSR_FLUSHFIFO;
+ csr |= MUSB_TXCSR_P_SENDSTALL
+ | MUSB_TXCSR_CLRDATATOG
+ | MUSB_TXCSR_P_WZC_BITS;
musb_writew(regs, MUSB_TXCSR,
csr);
} else {
csr = musb_readw(regs,
MUSB_RXCSR);
- csr |= MGC_M_RXCSR_P_SENDSTALL
- | MGC_M_RXCSR_FLUSHFIFO
- | MGC_M_RXCSR_CLRDATATOG
- | MGC_M_TXCSR_P_WZC_BITS;
+ csr |= MUSB_RXCSR_P_SENDSTALL
+ | MUSB_RXCSR_FLUSHFIFO
+ | MUSB_RXCSR_CLRDATATOG
+ | MUSB_TXCSR_P_WZC_BITS;
musb_writew(regs, MUSB_RXCSR,
csr);
}
@@ -456,14 +456,14 @@ static void ep0_rxstate(struct musb *this)
}
musb_read_fifo(&this->endpoints[0], tmp, buf);
req->actual += tmp;
- tmp = MGC_M_CSR0_P_SVDRXPKTRDY;
+ tmp = MUSB_CSR0_P_SVDRXPKTRDY;
if (tmp < 64 || req->actual == req->length) {
this->ep0_state = MGC_END0_STAGE_STATUSIN;
- tmp |= MGC_M_CSR0_P_DATAEND;
+ tmp |= MUSB_CSR0_P_DATAEND;
} else
req = NULL;
} else
- tmp = MGC_M_CSR0_P_SVDRXPKTRDY | MGC_M_CSR0_P_SENDSTALL;
+ tmp = MUSB_CSR0_P_SVDRXPKTRDY | MUSB_CSR0_P_SENDSTALL;
musb_writew(regs, MUSB_CSR0, tmp);
@@ -485,7 +485,7 @@ static void ep0_txstate(struct musb *musb)
{
void __iomem *regs = musb->control_ep->regs;
struct usb_request *request = next_ep0_request(musb);
- u16 csr = MGC_M_CSR0_TXPKTRDY;
+ u16 csr = MUSB_CSR0_TXPKTRDY;
u8 *pFifoSource;
u8 fifo_count;
@@ -506,7 +506,7 @@ static void ep0_txstate(struct musb *musb)
if (fifo_count < MUSB_MAX_END0_PACKET
|| request->actual == request->length) {
musb->ep0_state = MGC_END0_STAGE_STATUSOUT;
- csr |= MGC_M_CSR0_P_DATAEND;
+ csr |= MUSB_CSR0_P_DATAEND;
} else
request = NULL;
@@ -560,16 +560,16 @@ musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
* to switch modes...
*/
musb->set_address = FALSE;
- musb->ackpend = MGC_M_CSR0_P_SVDRXPKTRDY;
+ musb->ackpend = MUSB_CSR0_P_SVDRXPKTRDY;
if (req->wLength == 0) {
if (req->bRequestType & USB_DIR_IN)
- musb->ackpend |= MGC_M_CSR0_TXPKTRDY;
+ musb->ackpend |= MUSB_CSR0_TXPKTRDY;
musb->ep0_state = MGC_END0_STAGE_ACKWAIT;
} else if (req->bRequestType & USB_DIR_IN) {
musb->ep0_state = MGC_END0_STAGE_TX;
- musb_writew(regs, MUSB_CSR0, MGC_M_CSR0_P_SVDRXPKTRDY);
+ musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SVDRXPKTRDY);
while ((musb_readw(regs, MUSB_CSR0)
- & MGC_M_CSR0_RXPKTRDY) != 0)
+ & MUSB_CSR0_RXPKTRDY) != 0)
cpu_relax();
musb->ackpend = 0;
} else
@@ -614,17 +614,17 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
decode_ep0stage(musb->ep0_state));
/* I sent a stall.. need to acknowledge it now.. */
- if (csr & MGC_M_CSR0_P_SENTSTALL) {
+ if (csr & MUSB_CSR0_P_SENTSTALL) {
musb_writew(regs, MUSB_CSR0,
- csr & ~MGC_M_CSR0_P_SENTSTALL);
+ csr & ~MUSB_CSR0_P_SENTSTALL);
retval = IRQ_HANDLED;
musb->ep0_state = MGC_END0_STAGE_SETUP;
csr = musb_readw(regs, MUSB_CSR0);
}
/* request ended "early" */
- if (csr & MGC_M_CSR0_P_SETUPEND) {
- musb_writew(regs, MUSB_CSR0, MGC_M_CSR0_P_SVDSETUPEND);
+ if (csr & MUSB_CSR0_P_SETUPEND) {
+ musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SVDSETUPEND);
retval = IRQ_HANDLED;
musb->ep0_state = MGC_END0_STAGE_SETUP;
csr = musb_readw(regs, MUSB_CSR0);
@@ -639,7 +639,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
case MGC_END0_STAGE_TX:
/* irq on clearing txpktrdy */
- if ((csr & MGC_M_CSR0_TXPKTRDY) == 0) {
+ if ((csr & MUSB_CSR0_TXPKTRDY) == 0) {
ep0_txstate(musb);
retval = IRQ_HANDLED;
}
@@ -647,7 +647,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
case MGC_END0_STAGE_RX:
/* irq on set rxpktrdy */
- if (csr & MGC_M_CSR0_RXPKTRDY) {
+ if (csr & MUSB_CSR0_RXPKTRDY) {
ep0_rxstate(musb);
retval = IRQ_HANDLED;
}
@@ -670,7 +670,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
else if (musb->test_mode) {
DBG(1, "entering TESTMODE\n");
- if (MGC_M_TEST_PACKET == musb->test_mode_nr)
+ if (MUSB_TEST_PACKET == musb->test_mode_nr)
musb_load_testpacket(musb);
musb_writeb(mbase, MUSB_TESTMODE,
@@ -692,7 +692,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
/* FALLTHROUGH */
case MGC_END0_STAGE_SETUP:
- if (csr & MGC_M_CSR0_RXPKTRDY) {
+ if (csr & MUSB_CSR0_RXPKTRDY) {
struct usb_ctrlrequest setup;
int handled = 0;
@@ -711,7 +711,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
"irq lost!\n",
musb_driver_name);
power = musb_readb(mbase, MUSB_POWER);
- musb->g.speed = (power & MGC_M_POWER_HSMODE)
+ musb->g.speed = (power & MUSB_POWER_HSMODE)
? USB_SPEED_HIGH : USB_SPEED_FULL;
}
@@ -729,7 +729,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
/* status stage might be immediate */
if (handled > 0) {
- musb->ackpend |= MGC_M_CSR0_P_DATAEND;
+ musb->ackpend |= MUSB_CSR0_P_DATAEND;
musb->ep0_state =
MGC_END0_STAGE_STATUSIN;
}
@@ -742,8 +742,8 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
case MGC_END0_STAGE_TX:
handled = service_in_request(musb, &setup);
if (handled > 0) {
- musb->ackpend = MGC_M_CSR0_TXPKTRDY
- | MGC_M_CSR0_P_DATAEND;
+ musb->ackpend = MUSB_CSR0_TXPKTRDY
+ | MUSB_CSR0_P_DATAEND;
musb->ep0_state =
MGC_END0_STAGE_STATUSOUT;
}
@@ -772,7 +772,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
musb_ep_select(mbase, 0);
stall:
DBG(3, "stall (%d)\n", handled);
- musb->ackpend |= MGC_M_CSR0_P_SENDSTALL;
+ musb->ackpend |= MUSB_CSR0_P_SENDSTALL;
musb->ep0_state = MGC_END0_STAGE_SETUP;
finish:
musb_writew(regs, MUSB_CSR0,
@@ -792,7 +792,7 @@ finish:
default:
/* "can't happen" */
WARN_ON(1);
- musb_writew(regs, MUSB_CSR0, MGC_M_CSR0_P_SENDSTALL);
+ musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SENDSTALL);
musb->ep0_state = MGC_END0_STAGE_SETUP;
break;
}
@@ -877,7 +877,7 @@ musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
else {
musb->ep0_state = MGC_END0_STAGE_STATUSIN;
musb_writew(regs, MUSB_CSR0,
- musb->ackpend | MGC_M_CSR0_P_DATAEND);
+ musb->ackpend | MUSB_CSR0_P_DATAEND);
musb->ackpend = 0;
musb_g_ep0_giveback(ep->musb, r);
}
@@ -935,7 +935,7 @@ static int musb_g_ep0_halt(struct usb_ep *e, int value)
musb_ep_select(base, 0);
csr = musb_readw(regs, MUSB_CSR0);
- csr |= MGC_M_CSR0_P_SENDSTALL;
+ csr |= MUSB_CSR0_P_SENDSTALL;
musb_writew(regs, MUSB_CSR0, csr);
musb->ep0_state = MGC_END0_STAGE_SETUP;
break;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 7e05e15..691d1aa 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -168,14 +168,14 @@ static void nuke(struct musb_ep *ep, const int status)
int value;
if (ep->is_in) {
musb_writew(epio, MUSB_TXCSR,
- 0 | MGC_M_TXCSR_FLUSHFIFO);
+ 0 | MUSB_TXCSR_FLUSHFIFO);
musb_writew(epio, MUSB_TXCSR,
- 0 | MGC_M_TXCSR_FLUSHFIFO);
+ 0 | MUSB_TXCSR_FLUSHFIFO);
} else {
musb_writew(epio, MUSB_RXCSR,
- 0 | MGC_M_RXCSR_FLUSHFIFO);
+ 0 | MUSB_RXCSR_FLUSHFIFO);
musb_writew(epio, MUSB_RXCSR,
- 0 | MGC_M_RXCSR_FLUSHFIFO);
+ 0 | MUSB_RXCSR_FLUSHFIFO);
}
value = c->channel_abort(ep->dma);
@@ -274,13 +274,13 @@ static void txstate(struct musb *musb, struct musb_request *req)
fifo_count = min(max_ep_writesize(musb, musb_ep),
(int)(request->length - request->actual));
- if (csr & MGC_M_TXCSR_TXPKTRDY) {
+ if (csr & MUSB_TXCSR_TXPKTRDY) {
DBG(5, "%s old packet still ready , txcsr %03x\n",
musb_ep->end_point.name, csr);
return;
}
- if (csr & MGC_M_TXCSR_P_SENDSTALL) {
+ if (csr & MUSB_TXCSR_P_SENDSTALL) {
DBG(5, "%s stalling, txcsr %03x\n",
musb_ep->end_point.name, csr);
return;
@@ -296,7 +296,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
use_dma = (request->dma != DMA_ADDR_INVALID);
- /* MGC_M_TXCSR_P_ISO is still set correctly */
+ /* MUSB_TXCSR_P_ISO is still set correctly */
#ifdef CONFIG_USB_INVENTRA_DMA
{
@@ -317,32 +317,32 @@ static void txstate(struct musb *musb, struct musb_request *req)
if (use_dma) {
if (musb_ep->dma->desired_mode == 0) {
/* ASSERT: DMAENAB is clear */
- csr &= ~(MGC_M_TXCSR_AUTOSET |
- MGC_M_TXCSR_DMAMODE);
- csr |= (MGC_M_TXCSR_DMAENAB |
- MGC_M_TXCSR_MODE);
+ csr &= ~(MUSB_TXCSR_AUTOSET |
+ MUSB_TXCSR_DMAMODE);
+ csr |= (MUSB_TXCSR_DMAENAB |
+ MUSB_TXCSR_MODE);
// against programming guide
}
else
- csr |= (MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_MODE);
+ csr |= (MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_MODE);
- csr &= ~MGC_M_TXCSR_P_UNDERRUN;
+ csr &= ~MUSB_TXCSR_P_UNDERRUN;
musb_writew(epio, MUSB_TXCSR, csr);
}
}
#elif defined(CONFIG_USB_TI_CPPI_DMA)
/* program endpoint CSR first, then setup DMA */
- csr &= ~(MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_P_UNDERRUN
- | MGC_M_TXCSR_TXPKTRDY);
- csr |= MGC_M_TXCSR_MODE | MGC_M_TXCSR_DMAENAB;
+ csr &= ~(MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_P_UNDERRUN
+ | MUSB_TXCSR_TXPKTRDY);
+ csr |= MUSB_TXCSR_MODE | MUSB_TXCSR_DMAENAB;
musb_writew(epio, MUSB_TXCSR,
- (MGC_M_TXCSR_P_WZC_BITS & ~MGC_M_TXCSR_P_UNDERRUN)
+ (MUSB_TXCSR_P_WZC_BITS & ~MUSB_TXCSR_P_UNDERRUN)
| csr);
/* ensure writebuffer is empty */
@@ -367,7 +367,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
c->channel_release(musb_ep->dma);
musb_ep->dma = NULL;
/* ASSERT: DMAENAB clear */
- csr &= ~(MGC_M_TXCSR_DMAMODE | MGC_M_TXCSR_MODE);
+ csr &= ~(MUSB_TXCSR_DMAMODE | MUSB_TXCSR_MODE);
/* invariant: prequest->buf is non-null */
}
#elif defined(CONFIG_USB_TUSB_OMAP_DMA)
@@ -384,8 +384,8 @@ static void txstate(struct musb *musb, struct musb_request *req)
musb_write_fifo(musb_ep->hw_ep, fifo_count,
(u8 *) (request->buf + request->actual));
request->actual += fifo_count;
- csr |= MGC_M_TXCSR_TXPKTRDY;
- csr &= ~MGC_M_TXCSR_P_UNDERRUN;
+ csr |= MUSB_TXCSR_TXPKTRDY;
+ csr &= ~MUSB_TXCSR_P_UNDERRUN;
musb_writew(epio, MUSB_TXCSR, csr);
}
@@ -419,12 +419,12 @@ void musb_g_tx(struct musb *musb, u8 epnum)
dma = is_dma_capable() ? musb_ep->dma : NULL;
do {
- /* REVISIT for high bandwidth, MGC_M_TXCSR_P_INCOMPTX
+ /* REVISIT for high bandwidth, MUSB_TXCSR_P_INCOMPTX
* probably rates reporting as a host error
*/
- if (csr & MGC_M_TXCSR_P_SENTSTALL) {
- csr |= MGC_M_TXCSR_P_WZC_BITS;
- csr &= ~MGC_M_TXCSR_P_SENTSTALL;
+ if (csr & MUSB_TXCSR_P_SENTSTALL) {
+ csr |= MUSB_TXCSR_P_WZC_BITS;
+ csr &= ~MUSB_TXCSR_P_SENTSTALL;
musb_writew(epio, MUSB_TXCSR, csr);
if (dma_channel_status(dma) == MGC_DMA_STATUS_BUSY) {
dma->status = MGC_DMA_STATUS_CORE_ABORT;
@@ -437,11 +437,11 @@ void musb_g_tx(struct musb *musb, u8 epnum)
break;
}
- if (csr & MGC_M_TXCSR_P_UNDERRUN) {
+ if (csr & MUSB_TXCSR_P_UNDERRUN) {
/* we NAKed, no big deal ... little reason to care */
- csr |= MGC_M_TXCSR_P_WZC_BITS;
- csr &= ~(MGC_M_TXCSR_P_UNDERRUN
- | MGC_M_TXCSR_TXPKTRDY);
+ csr |= MUSB_TXCSR_P_WZC_BITS;
+ csr &= ~(MUSB_TXCSR_P_UNDERRUN
+ | MUSB_TXCSR_TXPKTRDY);
musb_writew(epio, MUSB_TXCSR, csr);
DBG(20, "underrun on ep%d, req %p\n", epnum, request);
}
@@ -457,12 +457,12 @@ void musb_g_tx(struct musb *musb, u8 epnum)
if (request) {
u8 is_dma = 0;
- if (dma && (csr & MGC_M_TXCSR_DMAENAB)) {
+ if (dma && (csr & MUSB_TXCSR_DMAENAB)) {
is_dma = 1;
- csr |= MGC_M_TXCSR_P_WZC_BITS;
- csr &= ~(MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_P_UNDERRUN
- | MGC_M_TXCSR_TXPKTRDY);
+ csr |= MUSB_TXCSR_P_WZC_BITS;
+ csr &= ~(MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_P_UNDERRUN
+ | MUSB_TXCSR_TXPKTRDY);
musb_writew(epio, MUSB_TXCSR, csr);
/* ensure writebuffer is empty */
csr = musb_readw(epio, MUSB_TXCSR);
@@ -495,13 +495,13 @@ void musb_g_tx(struct musb *musb, u8 epnum)
/* on dma completion, fifo may not
* be available yet ...
*/
- if (csr & MGC_M_TXCSR_TXPKTRDY)
+ if (csr & MUSB_TXCSR_TXPKTRDY)
break;
DBG(4, "sending zero pkt\n");
musb_writew(epio, MUSB_TXCSR,
- MGC_M_TXCSR_MODE
- | MGC_M_TXCSR_TXPKTRDY);
+ MUSB_TXCSR_MODE
+ | MUSB_TXCSR_TXPKTRDY);
request->zero = 0;
}
@@ -516,7 +516,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
*/
musb_ep_select(mbase, epnum);
csr = musb_readw(epio, MUSB_TXCSR);
- if (csr & MGC_M_TXCSR_FIFONOTEMPTY)
+ if (csr & MUSB_TXCSR_FIFONOTEMPTY)
break;
request = musb_ep->desc
? next_request(musb_ep)
@@ -601,15 +601,15 @@ static void rxstate(struct musb *musb, struct musb_request *req)
* the cppi engine will be ready to take it as soon
* as DMA is enabled
*/
- csr &= ~(MGC_M_RXCSR_AUTOCLEAR
- | MGC_M_RXCSR_DMAMODE);
- csr |= MGC_M_RXCSR_DMAENAB | MGC_M_RXCSR_P_WZC_BITS;
+ csr &= ~(MUSB_RXCSR_AUTOCLEAR
+ | MUSB_RXCSR_DMAMODE);
+ csr |= MUSB_RXCSR_DMAENAB | MUSB_RXCSR_P_WZC_BITS;
musb_writew(epio, MUSB_RXCSR, csr);
return;
}
}
- if (csr & MGC_M_RXCSR_RXPKTRDY) {
+ if (csr & MUSB_RXCSR_RXPKTRDY) {
len = musb_readw(epio, MUSB_RXCOUNT);
if (request->actual < request->length) {
#ifdef CONFIG_USB_INVENTRA_DMA
@@ -642,17 +642,17 @@ static void rxstate(struct musb *musb, struct musb_request *req)
* then becomes usable as a runtime "use mode 1" hint...
*/
- csr |= MGC_M_RXCSR_DMAENAB;
+ csr |= MUSB_RXCSR_DMAENAB;
#ifdef USE_MODE1
- csr |= MGC_M_RXCSR_AUTOCLEAR;
-// csr |= MGC_M_RXCSR_DMAMODE;
+ csr |= MUSB_RXCSR_AUTOCLEAR;
+// csr |= MUSB_RXCSR_DMAMODE;
/* this special sequence (enabling and then
- disabling MGC_M_RXCSR_DMAMODE) is required
+ disabling MUSB_RXCSR_DMAMODE) is required
to get DMAReq to activate
*/
musb_writew(epio, MUSB_RXCSR,
- csr | MGC_M_RXCSR_DMAMODE);
+ csr | MUSB_RXCSR_DMAMODE);
#endif
musb_writew(epio, MUSB_RXCSR,
csr);
@@ -718,8 +718,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
*/
/* ack the read! */
- csr |= MGC_M_RXCSR_P_WZC_BITS;
- csr &= ~MGC_M_RXCSR_RXPKTRDY;
+ csr |= MUSB_RXCSR_P_WZC_BITS;
+ csr &= ~MUSB_RXCSR_RXPKTRDY;
musb_writew(epio, MUSB_RXCSR, csr);
}
}
@@ -751,15 +751,15 @@ void musb_g_rx(struct musb *musb, u8 epnum)
DBG(4, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
csr, dma ? " (dma)" : "", request);
- if (csr & MGC_M_RXCSR_P_SENTSTALL) {
+ if (csr & MUSB_RXCSR_P_SENTSTALL) {
if (dma_channel_status(dma) == MGC_DMA_STATUS_BUSY) {
dma->status = MGC_DMA_STATUS_CORE_ABORT;
(void) musb->dma_controller->channel_abort(dma);
request->actual += musb_ep->dma->actual_len;
}
- csr |= MGC_M_RXCSR_P_WZC_BITS;
- csr &= ~MGC_M_RXCSR_P_SENTSTALL;
+ csr |= MUSB_RXCSR_P_WZC_BITS;
+ csr &= ~MUSB_RXCSR_P_SENTSTALL;
musb_writew(epio, MUSB_RXCSR, csr);
if (request)
@@ -767,34 +767,34 @@ void musb_g_rx(struct musb *musb, u8 epnum)
goto done;
}
- if (csr & MGC_M_RXCSR_P_OVERRUN) {
- // csr |= MGC_M_RXCSR_P_WZC_BITS;
- csr &= ~MGC_M_RXCSR_P_OVERRUN;
+ if (csr & MUSB_RXCSR_P_OVERRUN) {
+ // csr |= MUSB_RXCSR_P_WZC_BITS;
+ csr &= ~MUSB_RXCSR_P_OVERRUN;
musb_writew(epio, MUSB_RXCSR, csr);
DBG(3, "%s iso overrun on %p\n", musb_ep->name, request);
if (request && request->status == -EINPROGRESS)
request->status = -EOVERFLOW;
}
- if (csr & MGC_M_RXCSR_INCOMPRX) {
+ if (csr & MUSB_RXCSR_INCOMPRX) {
/* REVISIT not necessarily an error */
DBG(4, "%s, incomprx\n", musb_ep->end_point.name);
}
if (dma_channel_status(dma) == MGC_DMA_STATUS_BUSY) {
/* "should not happen"; likely RXPKTRDY pending for DMA */
- DBG((csr & MGC_M_RXCSR_DMAENAB) ? 4 : 1,
+ DBG((csr & MUSB_RXCSR_DMAENAB) ? 4 : 1,
"%s busy, csr %04x\n",
musb_ep->end_point.name, csr);
goto done;
}
- if (dma && (csr & MGC_M_RXCSR_DMAENAB)) {
- csr &= ~(MGC_M_RXCSR_AUTOCLEAR
- | MGC_M_RXCSR_DMAENAB
- | MGC_M_RXCSR_DMAMODE);
+ if (dma && (csr & MUSB_RXCSR_DMAENAB)) {
+ csr &= ~(MUSB_RXCSR_AUTOCLEAR
+ | MUSB_RXCSR_DMAENAB
+ | MUSB_RXCSR_DMAMODE);
musb_writew(epio, MUSB_RXCSR,
- MGC_M_RXCSR_P_WZC_BITS | csr);
+ MUSB_RXCSR_P_WZC_BITS | csr);
request->actual += musb_ep->dma->actual_len;
@@ -809,7 +809,7 @@ void musb_g_rx(struct musb *musb, u8 epnum)
|| (dma->actual_len
& (musb_ep->packet_sz - 1))) {
/* ack the read! */
- csr &= ~MGC_M_RXCSR_RXPKTRDY;
+ csr &= ~MUSB_RXCSR_RXPKTRDY;
musb_writew(epio, MUSB_RXCSR, csr);
}
@@ -828,7 +828,7 @@ void musb_g_rx(struct musb *musb, u8 epnum)
/* don't start more i/o till the stall clears */
musb_ep_select(mbase, epnum);
csr = musb_readw(epio, MUSB_RXCSR);
- if (csr & MGC_M_RXCSR_P_SENDSTALL)
+ if (csr & MUSB_RXCSR_P_SENDSTALL)
goto done;
}
@@ -911,12 +911,12 @@ static int musb_gadget_enable(struct usb_ep *ep,
*/
musb_writew(regs, MUSB_TXMAXP, tmp);
- csr = MGC_M_TXCSR_MODE | MGC_M_TXCSR_CLRDATATOG;
+ csr = MUSB_TXCSR_MODE | MUSB_TXCSR_CLRDATATOG;
if (musb_readw(regs, MUSB_TXCSR)
- & MGC_M_TXCSR_FIFONOTEMPTY)
- csr |= MGC_M_TXCSR_FLUSHFIFO;
+ & MUSB_TXCSR_FIFONOTEMPTY)
+ csr |= MUSB_TXCSR_FLUSHFIFO;
if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
- csr |= MGC_M_TXCSR_P_ISO;
+ csr |= MUSB_TXCSR_P_ISO;
/* set twice in case of double buffering */
musb_writew(regs, MUSB_TXCSR, csr);
@@ -944,15 +944,15 @@ static int musb_gadget_enable(struct usb_ep *ep,
/* force shared fifo to OUT-only mode */
if (hw_ep->is_shared_fifo) {
csr = musb_readw(regs, MUSB_TXCSR);
- csr &= ~(MGC_M_TXCSR_MODE | MGC_M_TXCSR_TXPKTRDY);
+ csr &= ~(MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY);
musb_writew(regs, MUSB_TXCSR, csr);
}
- csr = MGC_M_RXCSR_FLUSHFIFO | MGC_M_RXCSR_CLRDATATOG;
+ csr = MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_CLRDATATOG;
if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
- csr |= MGC_M_RXCSR_P_ISO;
+ csr |= MUSB_RXCSR_P_ISO;
else if (musb_ep->type == USB_ENDPOINT_XFER_INT)
- csr |= MGC_M_RXCSR_DISNYET;
+ csr |= MUSB_RXCSR_DISNYET;
/* set twice in case of double buffering */
musb_writew(regs, MUSB_RXCSR, csr);
@@ -1255,7 +1255,7 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
request = to_musb_request(next_request(musb_ep));
if (value && musb_ep->is_in) {
wCsr = musb_readw(epio, MUSB_TXCSR);
- if (wCsr & MGC_M_TXCSR_FIFONOTEMPTY) {
+ if (wCsr & MUSB_TXCSR_FIFONOTEMPTY) {
DBG(3, "%s fifo busy, cannot halt\n", ep->name);
spin_unlock_irqrestore(&musb->lock, flags);
return -EAGAIN;
@@ -1267,27 +1267,27 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
DBG(2, "%s: %s stall\n", ep->name, value ? "set" : "clear");
if (musb_ep->is_in) {
wCsr = musb_readw(epio, MUSB_TXCSR);
- if (wCsr & MGC_M_TXCSR_FIFONOTEMPTY)
- wCsr |= MGC_M_TXCSR_FLUSHFIFO;
- wCsr |= MGC_M_TXCSR_P_WZC_BITS
- | MGC_M_TXCSR_CLRDATATOG;
+ if (wCsr & MUSB_TXCSR_FIFONOTEMPTY)
+ wCsr |= MUSB_TXCSR_FLUSHFIFO;
+ wCsr |= MUSB_TXCSR_P_WZC_BITS
+ | MUSB_TXCSR_CLRDATATOG;
if (value)
- wCsr |= MGC_M_TXCSR_P_SENDSTALL;
+ wCsr |= MUSB_TXCSR_P_SENDSTALL;
else
- wCsr &= ~(MGC_M_TXCSR_P_SENDSTALL
- | MGC_M_TXCSR_P_SENTSTALL);
- wCsr &= ~MGC_M_TXCSR_TXPKTRDY;
+ wCsr &= ~(MUSB_TXCSR_P_SENDSTALL
+ | MUSB_TXCSR_P_SENTSTALL);
+ wCsr &= ~MUSB_TXCSR_TXPKTRDY;
musb_writew(epio, MUSB_TXCSR, wCsr);
} else {
wCsr = musb_readw(epio, MUSB_RXCSR);
- wCsr |= MGC_M_RXCSR_P_WZC_BITS
- | MGC_M_RXCSR_FLUSHFIFO
- | MGC_M_RXCSR_CLRDATATOG;
+ wCsr |= MUSB_RXCSR_P_WZC_BITS
+ | MUSB_RXCSR_FLUSHFIFO
+ | MUSB_RXCSR_CLRDATATOG;
if (value)
- wCsr |= MGC_M_RXCSR_P_SENDSTALL;
+ wCsr |= MUSB_RXCSR_P_SENDSTALL;
else
- wCsr &= ~(MGC_M_RXCSR_P_SENDSTALL
- | MGC_M_RXCSR_P_SENTSTALL);
+ wCsr &= ~(MUSB_RXCSR_P_SENDSTALL
+ | MUSB_RXCSR_P_SENTSTALL);
musb_writew(epio, MUSB_RXCSR, wCsr);
}
@@ -1347,15 +1347,15 @@ static void musb_gadget_fifo_flush(struct usb_ep *ep)
if (musb_ep->is_in) {
wCsr = musb_readw(epio, MUSB_TXCSR);
- if (wCsr & MGC_M_TXCSR_FIFONOTEMPTY) {
- wCsr |= MGC_M_TXCSR_FLUSHFIFO | MGC_M_TXCSR_P_WZC_BITS;
+ if (wCsr & MUSB_TXCSR_FIFONOTEMPTY) {
+ wCsr |= MUSB_TXCSR_FLUSHFIFO | MUSB_TXCSR_P_WZC_BITS;
musb_writew(epio, MUSB_TXCSR, wCsr);
/* REVISIT may be inappropriate w/o FIFONOTEMPTY ... */
musb_writew(epio, MUSB_TXCSR, wCsr);
}
} else {
wCsr = musb_readw(epio, MUSB_RXCSR);
- wCsr |= MGC_M_RXCSR_FLUSHFIFO | MGC_M_RXCSR_P_WZC_BITS;
+ wCsr |= MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_P_WZC_BITS;
musb_writew(epio, MUSB_RXCSR, wCsr);
musb_writew(epio, MUSB_RXCSR, wCsr);
}
@@ -1410,17 +1410,17 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
/* Start SRP ... OTG not required. */
devctl = musb_readb(mregs, MUSB_DEVCTL);
DBG(2, "Sending SRP: devctl: %02x\n", devctl);
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
musb_writeb(mregs, MUSB_DEVCTL, devctl);
devctl = musb_readb(mregs, MUSB_DEVCTL);
retries = 100;
- while (!(devctl & MGC_M_DEVCTL_SESSION)) {
+ while (!(devctl & MUSB_DEVCTL_SESSION)) {
devctl = musb_readb(mregs, MUSB_DEVCTL);
if (retries-- < 1)
break;
}
retries = 10000;
- while (devctl & MGC_M_DEVCTL_SESSION) {
+ while (devctl & MUSB_DEVCTL_SESSION) {
devctl = musb_readb(mregs, MUSB_DEVCTL);
if (retries-- < 1)
break;
@@ -1439,7 +1439,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
status = 0;
power = musb_readb(mregs, MUSB_POWER);
- power |= MGC_M_POWER_RESUME;
+ power |= MUSB_POWER_RESUME;
musb_writeb(mregs, MUSB_POWER, power);
DBG(2, "issue wakeup\n");
@@ -1447,7 +1447,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
mdelay(2);
power = musb_readb(mregs, MUSB_POWER);
- power &= ~MGC_M_POWER_RESUME;
+ power &= ~MUSB_POWER_RESUME;
musb_writeb(mregs, MUSB_POWER, power);
done:
spin_unlock_irqrestore(&musb->lock, flags);
@@ -1469,9 +1469,9 @@ static void musb_pullup(struct musb *musb, int is_on)
power = musb_readb(musb->mregs, MUSB_POWER);
if (is_on)
- power |= MGC_M_POWER_SOFTCONN;
+ power |= MUSB_POWER_SOFTCONN;
else
- power &= ~MGC_M_POWER_SOFTCONN;
+ power &= ~MUSB_POWER_SOFTCONN;
/* FIXME if on, HdrcStart; if off, HdrcStop */
@@ -1910,7 +1910,7 @@ void musb_g_suspend(struct musb *musb)
switch (musb->xceiv.state) {
case OTG_STATE_B_IDLE:
- if ((devctl & MGC_M_DEVCTL_VBUS) == MGC_M_DEVCTL_VBUS)
+ if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
musb->xceiv.state = OTG_STATE_B_PERIPHERAL;
break;
case OTG_STATE_B_PERIPHERAL:
@@ -1945,7 +1945,7 @@ void musb_g_disconnect(struct musb *musb)
DBG(3, "devctl %02x\n", devctl);
/* clear HR */
- musb_writeb(mregs, MUSB_DEVCTL, devctl & MGC_M_DEVCTL_SESSION);
+ musb_writeb(mregs, MUSB_DEVCTL, devctl & MUSB_DEVCTL_SESSION);
/* don't draw vbus until new b-default session */
(void) musb_gadget_vbus_draw(&musb->g, 0);
@@ -1987,7 +1987,7 @@ __acquires(musb->lock)
u8 power;
DBG(3, "<== %s addr=%x driver '%s'\n",
- (devctl & MGC_M_DEVCTL_BDEVICE)
+ (devctl & MUSB_DEVCTL_BDEVICE)
? "B-Device" : "A-Device",
musb_readb(mbase, MUSB_FADDR),
musb->gadget_driver
@@ -2000,13 +2000,13 @@ __acquires(musb->lock)
musb_g_disconnect(musb);
/* clear HR */
- else if (devctl & MGC_M_DEVCTL_HR)
- musb_writeb(mbase, MUSB_DEVCTL, MGC_M_DEVCTL_SESSION);
+ else if (devctl & MUSB_DEVCTL_HR)
+ musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
/* what speed did we negotiate? */
power = musb_readb(mbase, MUSB_POWER);
- musb->g.speed = (power & MGC_M_POWER_HSMODE)
+ musb->g.speed = (power & MUSB_POWER_HSMODE)
? USB_SPEED_HIGH : USB_SPEED_FULL;
/* start in USB_STATE_DEFAULT */
@@ -2024,7 +2024,7 @@ __acquires(musb->lock)
/* Normal reset, as B-Device;
* or else after HNP, as A-Device
*/
- if (devctl & MGC_M_DEVCTL_BDEVICE) {
+ if (devctl & MUSB_DEVCTL_BDEVICE) {
musb->xceiv.state = OTG_STATE_B_PERIPHERAL;
musb->g.is_a_peripheral = 0;
} else if (is_otg_enabled(musb)) {
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 7840f59..ea6db02 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -117,9 +117,9 @@ static inline void musb_h_tx_flush_fifo(struct musb_hw_ep *ep)
int retries = 1000;
csr = musb_readw(epio, MUSB_TXCSR);
- while (csr & MGC_M_TXCSR_FIFONOTEMPTY) {
+ while (csr & MUSB_TXCSR_FIFONOTEMPTY) {
DBG(5, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
- csr |= MGC_M_TXCSR_FLUSHFIFO;
+ csr |= MUSB_TXCSR_FLUSHFIFO;
musb_writew(epio, MUSB_TXCSR, csr);
csr = musb_readw(epio, MUSB_TXCSR);
if (retries-- < 1) {
@@ -141,10 +141,10 @@ static inline void musb_h_tx_start(struct musb_hw_ep *ep)
/* NOTE: no locks here; caller should lock and select EP */
if (ep->epnum) {
txcsr = musb_readw(ep->regs, MUSB_TXCSR);
- txcsr |= MGC_M_TXCSR_TXPKTRDY | MGC_M_TXCSR_H_WZC_BITS;
+ txcsr |= MUSB_TXCSR_TXPKTRDY | MUSB_TXCSR_H_WZC_BITS;
musb_writew(ep->regs, MUSB_TXCSR, txcsr);
} else {
- txcsr = MGC_M_CSR0_H_SETUPPKT | MGC_M_CSR0_TXPKTRDY;
+ txcsr = MUSB_CSR0_H_SETUPPKT | MUSB_CSR0_TXPKTRDY;
musb_writew(ep->regs, MUSB_CSR0, txcsr);
}
@@ -156,7 +156,7 @@ static inline void cppi_host_txdma_start(struct musb_hw_ep *ep)
/* NOTE: no locks here; caller should lock and select EP */
txcsr = musb_readw(ep->regs, MUSB_TXCSR);
- txcsr |= MGC_M_TXCSR_DMAENAB | MGC_M_TXCSR_H_WZC_BITS;
+ txcsr |= MUSB_TXCSR_DMAENAB | MUSB_TXCSR_H_WZC_BITS;
musb_writew(ep->regs, MUSB_TXCSR, txcsr);
}
@@ -330,12 +330,12 @@ static inline void musb_save_toggle(struct musb_hw_ep *ep, int is_in, struct urb
if (!is_in) {
csr = musb_readw(epio, MUSB_TXCSR);
usb_settoggle(udev, qh->epnum, 1,
- (csr & MGC_M_TXCSR_H_DATATOGGLE)
+ (csr & MUSB_TXCSR_H_DATATOGGLE)
? 1 : 0);
} else {
csr = musb_readw(epio, MUSB_RXCSR);
usb_settoggle(udev, qh->epnum, 0,
- (csr & MGC_M_RXCSR_H_DATATOGGLE)
+ (csr & MUSB_RXCSR_H_DATATOGGLE)
? 1 : 0);
}
}
@@ -449,10 +449,10 @@ static inline u16 musb_h_flush_rxfifo(struct musb_hw_ep *hw_ep, u16 csr)
* ignore dma (various models),
* leave toggle alone (may not have been saved yet)
*/
- csr |= MGC_M_RXCSR_FLUSHFIFO | MGC_M_RXCSR_RXPKTRDY;
- csr &= ~( MGC_M_RXCSR_H_REQPKT
- | MGC_M_RXCSR_H_AUTOREQ
- | MGC_M_RXCSR_AUTOCLEAR
+ csr |= MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_RXPKTRDY;
+ csr &= ~( MUSB_RXCSR_H_REQPKT
+ | MUSB_RXCSR_H_AUTOREQ
+ | MUSB_RXCSR_AUTOCLEAR
);
/* write 2x to allow double buffering */
@@ -545,14 +545,14 @@ static u8 musb_host_packet_rx(struct musb *musb, struct urb *pUrb,
musb_read_fifo(hw_ep, length, pBuffer);
wCsr = musb_readw(epio, MUSB_RXCSR);
- wCsr |= MGC_M_RXCSR_H_WZC_BITS;
+ wCsr |= MUSB_RXCSR_H_WZC_BITS;
if (unlikely(do_flush))
musb_h_flush_rxfifo(hw_ep, wCsr);
else {
/* REVISIT this assumes AUTOCLEAR is never set */
- wCsr &= ~(MGC_M_RXCSR_RXPKTRDY | MGC_M_RXCSR_H_REQPKT);
+ wCsr &= ~(MUSB_RXCSR_RXPKTRDY | MUSB_RXCSR_H_REQPKT);
if (!bDone)
- wCsr |= MGC_M_RXCSR_H_REQPKT;
+ wCsr |= MUSB_RXCSR_H_REQPKT;
musb_writew(epio, MUSB_RXCSR, wCsr);
}
@@ -580,10 +580,10 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
/* if programmed for Tx, put it in RX mode */
if (ep->is_shared_fifo) {
csr = musb_readw(ep->regs, MUSB_TXCSR);
- if (csr & MGC_M_TXCSR_MODE) {
+ if (csr & MUSB_TXCSR_MODE) {
musb_h_tx_flush_fifo(ep);
musb_writew(ep->regs, MUSB_TXCSR,
- MGC_M_TXCSR_FRCDATATOG);
+ MUSB_TXCSR_FRCDATATOG);
}
/* clear mode (and everything else) to enable Rx */
musb_writew(ep->regs, MUSB_TXCSR, 0);
@@ -591,11 +591,11 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
/* scrub all previous state, clearing toggle */
} else {
csr = musb_readw(ep->regs, MUSB_RXCSR);
- if (csr & MGC_M_RXCSR_RXPKTRDY)
+ if (csr & MUSB_RXCSR_RXPKTRDY)
WARN("rx%d, packet/%d ready?\n", ep->epnum,
musb_readw(ep->regs, MUSB_RXCOUNT));
- musb_h_flush_rxfifo(ep, MGC_M_RXCSR_CLRDATATOG);
+ musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG);
}
/* target addr and (for multipoint) hub addr/port */
@@ -690,21 +690,21 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
/* flush all old state, set default */
musb_h_tx_flush_fifo(hw_ep);
- csr &= ~(MGC_M_TXCSR_H_NAKTIMEOUT
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_FRCDATATOG
- | MGC_M_TXCSR_H_RXSTALL
- | MGC_M_TXCSR_H_ERROR
- | MGC_M_TXCSR_TXPKTRDY
+ csr &= ~(MUSB_TXCSR_H_NAKTIMEOUT
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_FRCDATATOG
+ | MUSB_TXCSR_H_RXSTALL
+ | MUSB_TXCSR_H_ERROR
+ | MUSB_TXCSR_TXPKTRDY
);
- csr |= MGC_M_TXCSR_MODE;
+ csr |= MUSB_TXCSR_MODE;
if (usb_gettoggle(pUrb->dev,
qh->epnum, 1))
- csr |= MGC_M_TXCSR_H_WR_DATATOGGLE
- | MGC_M_TXCSR_H_DATATOGGLE;
+ csr |= MUSB_TXCSR_H_WR_DATATOGGLE
+ | MUSB_TXCSR_H_DATATOGGLE;
else
- csr |= MGC_M_TXCSR_CLRDATATOG;
+ csr |= MUSB_TXCSR_CLRDATATOG;
/* twice in case of double packet buffering */
musb_writew(epio, MUSB_TXCSR, csr);
@@ -714,9 +714,9 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
} else {
/* endpoint 0: just flush */
musb_writew(epio, MUSB_CSR0,
- wCsr | MGC_M_CSR0_FLUSHFIFO);
+ wCsr | MUSB_CSR0_FLUSHFIFO);
musb_writew(epio, MUSB_CSR0,
- wCsr | MGC_M_CSR0_FLUSHFIFO);
+ wCsr | MUSB_CSR0_FLUSHFIFO);
}
/* target addr and (for multipoint) hub addr/port */
@@ -764,12 +764,12 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
/* clear previous state */
wCsr = musb_readw(epio, MUSB_TXCSR);
- wCsr &= ~(MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_DMAENAB);
- wCsr |= MGC_M_TXCSR_MODE;
+ wCsr &= ~(MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_DMAENAB);
+ wCsr |= MUSB_TXCSR_MODE;
musb_writew(epio, MUSB_TXCSR,
- wCsr | MGC_M_TXCSR_MODE);
+ wCsr | MUSB_TXCSR_MODE);
qh->segsize = min(dwLength, pDmaChannel->max_len);
@@ -780,14 +780,14 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
if (pDmaChannel->desired_mode == 0) {
- wCsr &= ~(MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAMODE);
- wCsr |= (MGC_M_TXCSR_DMAENAB);
+ wCsr &= ~(MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAMODE);
+ wCsr |= (MUSB_TXCSR_DMAENAB);
// against programming guide
} else
- wCsr |= (MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_DMAMODE);
+ wCsr |= (MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_DMAMODE);
musb_writew(epio, MUSB_TXCSR, wCsr);
@@ -817,12 +817,12 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
* defer enabling dma.
*/
wCsr = musb_readw(epio, MUSB_TXCSR);
- wCsr &= ~(MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_DMAENAB);
- wCsr |= MGC_M_TXCSR_MODE;
+ wCsr &= ~(MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_DMAENAB);
+ wCsr |= MUSB_TXCSR_MODE;
musb_writew(epio, MUSB_TXCSR,
- wCsr | MGC_M_TXCSR_MODE);
+ wCsr | MUSB_TXCSR_MODE);
pDmaChannel->actual_len = 0L;
qh->segsize = dwLength;
@@ -857,11 +857,11 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
qh->segsize = wLoadCount;
musb_write_fifo(hw_ep, wLoadCount, pBuffer);
wCsr = musb_readw(epio, MUSB_TXCSR);
- wCsr &= ~(MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_DMAMODE
- | MGC_M_TXCSR_AUTOSET);
+ wCsr &= ~(MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_DMAMODE
+ | MUSB_TXCSR_AUTOSET);
/* write CSR */
- wCsr |= MGC_M_TXCSR_MODE;
+ wCsr |= MUSB_TXCSR_MODE;
if (epnum)
musb_writew(epio, MUSB_TXCSR, wCsr);
@@ -879,24 +879,24 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
/* init new state: toggle and NYET, maybe DMA later */
if (usb_gettoggle(pUrb->dev, qh->epnum, 0))
- csr = MGC_M_RXCSR_H_WR_DATATOGGLE
- | MGC_M_RXCSR_H_DATATOGGLE;
+ csr = MUSB_RXCSR_H_WR_DATATOGGLE
+ | MUSB_RXCSR_H_DATATOGGLE;
else
csr = 0;
if (qh->type == USB_ENDPOINT_XFER_INT)
- csr |= MGC_M_RXCSR_DISNYET;
+ csr |= MUSB_RXCSR_DISNYET;
} else {
csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
- if (csr & (MGC_M_RXCSR_RXPKTRDY
- | MGC_M_RXCSR_DMAENAB
- | MGC_M_RXCSR_H_REQPKT))
+ 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);
/* scrub any stale state, leaving toggle alone */
- csr &= MGC_M_RXCSR_DISNYET;
+ csr &= MUSB_RXCSR_DISNYET;
}
/* kick things off */
@@ -926,11 +926,11 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
pDmaChannel);
pDmaChannel = hw_ep->rx_channel = NULL;
} else
- csr |= MGC_M_RXCSR_DMAENAB;
+ csr |= MUSB_RXCSR_DMAENAB;
}
}
- csr |= MGC_M_RXCSR_H_REQPKT;
+ csr |= MUSB_RXCSR_H_REQPKT;
DBG(7, "RXCSR%d := %04x\n", epnum, csr);
musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
@@ -1035,7 +1035,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
musb_ep_select(mbase, 0);
csr = musb_readw(epio, MUSB_CSR0);
- len = (csr & MGC_M_CSR0_RXPKTRDY)
+ len = (csr & MUSB_CSR0_RXPKTRDY)
? musb_readb(epio, MUSB_COUNT0)
: 0;
@@ -1049,15 +1049,15 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
}
/* prepare status */
- if (csr & MGC_M_CSR0_H_RXSTALL) {
+ if (csr & MUSB_CSR0_H_RXSTALL) {
DBG(6, "STALLING ENDPOINT\n");
status = -EPIPE;
- } else if (csr & MGC_M_CSR0_H_ERROR) {
+ } else if (csr & MUSB_CSR0_H_ERROR) {
DBG(2, "no response, csr0 %04x\n", csr);
status = -EPROTO;
- } else if (csr & MGC_M_CSR0_H_NAKTIMEOUT) {
+ } else if (csr & MUSB_CSR0_H_NAKTIMEOUT) {
DBG(2, "control NAK timeout\n");
/* NOTE: this code path would be a good place to PAUSE a
@@ -1079,16 +1079,16 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
bComplete = TRUE;
/* use the proper sequence to abort the transfer */
- if (csr & MGC_M_CSR0_H_REQPKT) {
- csr &= ~MGC_M_CSR0_H_REQPKT;
+ if (csr & MUSB_CSR0_H_REQPKT) {
+ csr &= ~MUSB_CSR0_H_REQPKT;
musb_writew(epio, MUSB_CSR0, csr);
- csr &= ~MGC_M_CSR0_H_NAKTIMEOUT;
+ csr &= ~MUSB_CSR0_H_NAKTIMEOUT;
musb_writew(epio, MUSB_CSR0, csr);
} else {
- csr |= MGC_M_CSR0_FLUSHFIFO;
+ csr |= MUSB_CSR0_FLUSHFIFO;
musb_writew(epio, MUSB_CSR0, csr);
musb_writew(epio, MUSB_CSR0, csr);
- csr &= ~MGC_M_CSR0_H_NAKTIMEOUT;
+ csr &= ~MUSB_CSR0_H_NAKTIMEOUT;
musb_writew(epio, MUSB_CSR0, csr);
}
@@ -1103,8 +1103,8 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
* SHOULD NEVER HAPPEN! */
ERR("no URB for end 0\n");
- musb_writew(epio, MUSB_CSR0, MGC_M_CSR0_FLUSHFIFO);
- musb_writew(epio, MUSB_CSR0, MGC_M_CSR0_FLUSHFIFO);
+ musb_writew(epio, MUSB_CSR0, MUSB_CSR0_FLUSHFIFO);
+ musb_writew(epio, MUSB_CSR0, MUSB_CSR0_FLUSHFIFO);
musb_writew(epio, MUSB_CSR0, 0);
goto done;
@@ -1115,16 +1115,16 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
if (musb_h_ep0_continue(musb, len, pUrb)) {
/* more packets required */
csr = (MGC_END0_IN == musb->ep0_stage)
- ? MGC_M_CSR0_H_REQPKT : MGC_M_CSR0_TXPKTRDY;
+ ? MUSB_CSR0_H_REQPKT : MUSB_CSR0_TXPKTRDY;
} else {
/* data transfer complete; perform status phase */
if (usb_pipeout(pUrb->pipe)
|| !pUrb->transfer_buffer_length)
- csr = MGC_M_CSR0_H_STATUSPKT
- | MGC_M_CSR0_H_REQPKT;
+ csr = MUSB_CSR0_H_STATUSPKT
+ | MUSB_CSR0_H_REQPKT;
else
- csr = MGC_M_CSR0_H_STATUSPKT
- | MGC_M_CSR0_TXPKTRDY;
+ csr = MUSB_CSR0_H_STATUSPKT
+ | MUSB_CSR0_TXPKTRDY;
/* flag status stage */
musb->ep0_stage = MGC_END0_STATUS;
@@ -1194,20 +1194,20 @@ void musb_host_tx(struct musb *musb, u8 epnum)
dma ? ", dma" : "");
/* check for errors */
- if (wTxCsrVal & MGC_M_TXCSR_H_RXSTALL) {
+ if (wTxCsrVal & MUSB_TXCSR_H_RXSTALL) {
/* dma was disabled, fifo flushed */
DBG(3, "TX end %d stall\n", epnum);
/* stall; record URB status */
status = -EPIPE;
- } else if (wTxCsrVal & MGC_M_TXCSR_H_ERROR) {
+ } else if (wTxCsrVal & MUSB_TXCSR_H_ERROR) {
/* (NON-ISO) dma was disabled, fifo flushed */
DBG(3, "TX 3strikes on ep=%d\n", epnum);
status = -ETIMEDOUT;
- } else if (wTxCsrVal & MGC_M_TXCSR_H_NAKTIMEOUT) {
+ } else if (wTxCsrVal & MUSB_TXCSR_H_NAKTIMEOUT) {
DBG(6, "TX end=%d device not responding\n", epnum);
/* NOTE: this code path would be a good place to PAUSE a
@@ -1219,8 +1219,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
*/
musb_ep_select(mbase, epnum);
musb_writew(epio, MUSB_CSR0,
- MGC_M_TXCSR_H_WZC_BITS
- | MGC_M_TXCSR_TXPKTRDY);
+ MUSB_TXCSR_H_WZC_BITS
+ | MUSB_TXCSR_TXPKTRDY);
goto finish;
}
@@ -1234,11 +1234,11 @@ void musb_host_tx(struct musb *musb, u8 epnum)
* usb core; the dma engine should already be stopped.
*/
musb_h_tx_flush_fifo(hw_ep);
- wTxCsrVal &= ~(MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_H_ERROR
- | MGC_M_TXCSR_H_RXSTALL
- | MGC_M_TXCSR_H_NAKTIMEOUT
+ wTxCsrVal &= ~(MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_H_ERROR
+ | MUSB_TXCSR_H_RXSTALL
+ | MUSB_TXCSR_H_NAKTIMEOUT
);
musb_ep_select(mbase, epnum);
@@ -1311,7 +1311,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
pUrb->actual_length = qh->offset;
musb_advance_schedule(musb, pUrb, hw_ep, USB_DIR_OUT);
- } else if (!(wTxCsrVal & MGC_M_TXCSR_DMAENAB)) {
+ } else if (!(wTxCsrVal & MUSB_TXCSR_DMAENAB)) {
// WARN_ON(!pBuffer);
/* REVISIT: some docs say that when hw_ep->tx_double_buffered,
@@ -1325,7 +1325,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
musb_ep_select(mbase, epnum);
musb_writew(epio, MUSB_TXCSR,
- MGC_M_TXCSR_H_WZC_BITS | MGC_M_TXCSR_TXPKTRDY);
+ MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY);
} else
DBG(1, "not complete, but dma enabled?\n");
@@ -1408,7 +1408,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
*/
DBG(3, "BOGUS RX%d ready, csr %04x, count %d\n", epnum, wVal,
musb_readw(epio, MUSB_RXCOUNT));
- musb_h_flush_rxfifo(hw_ep, MGC_M_RXCSR_CLRDATATOG);
+ musb_h_flush_rxfifo(hw_ep, MUSB_RXCSR_CLRDATATOG);
return;
}
@@ -1420,19 +1420,19 @@ void musb_host_rx(struct musb *musb, u8 epnum)
/* check for errors, concurrent stall & unlink is not really
* handled yet! */
- if (wRxCsrVal & MGC_M_RXCSR_H_RXSTALL) {
+ if (wRxCsrVal & MUSB_RXCSR_H_RXSTALL) {
DBG(3, "RX end %d STALL\n", epnum);
/* stall; record URB status */
status = -EPIPE;
- } else if (wRxCsrVal & MGC_M_RXCSR_H_ERROR) {
+ } else if (wRxCsrVal & MUSB_RXCSR_H_ERROR) {
DBG(3, "end %d RX proto error\n", epnum);
status = -EPROTO;
musb_writeb(epio, MUSB_RXINTERVAL, 0);
- } else if (wRxCsrVal & MGC_M_RXCSR_DATAERROR) {
+ } else if (wRxCsrVal & MUSB_RXCSR_DATAERROR) {
if (USB_ENDPOINT_XFER_ISOC != qh->type) {
/* NOTE this code path would be a good place to PAUSE a
@@ -1445,8 +1445,8 @@ void musb_host_rx(struct musb *musb, u8 epnum)
DBG(6, "RX end %d NAK timeout\n", epnum);
musb_ep_select(mbase, epnum);
musb_writew(epio, MUSB_RXCSR,
- MGC_M_RXCSR_H_WZC_BITS
- | MGC_M_RXCSR_H_REQPKT);
+ MUSB_RXCSR_H_WZC_BITS
+ | MUSB_RXCSR_H_REQPKT);
goto finish;
} else {
@@ -1484,7 +1484,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
/* FIXME this is _way_ too much in-line logic for Mentor DMA */
#ifndef CONFIG_USB_INVENTRA_DMA
- if (wRxCsrVal & MGC_M_RXCSR_H_REQPKT) {
+ if (wRxCsrVal & MUSB_RXCSR_H_REQPKT) {
/* REVISIT this happened for a while on some short reads...
* the cleanup still needs investigation... looks bad...
* and also duplicates dma cleanup code above ... plus,
@@ -1499,20 +1499,20 @@ void musb_host_rx(struct musb *musb, u8 epnum)
DBG(2, "RXCSR%d %04x, reqpkt, len %zd%s\n", epnum, wRxCsrVal,
xfer_len, dma ? ", dma" : "");
- wRxCsrVal &= ~MGC_M_RXCSR_H_REQPKT;
+ wRxCsrVal &= ~MUSB_RXCSR_H_REQPKT;
musb_ep_select(mbase, epnum);
musb_writew(epio, MUSB_RXCSR,
- MGC_M_RXCSR_H_WZC_BITS | wRxCsrVal);
+ MUSB_RXCSR_H_WZC_BITS | wRxCsrVal);
}
#endif
- if (dma && (wRxCsrVal & MGC_M_RXCSR_DMAENAB)) {
+ if (dma && (wRxCsrVal & MUSB_RXCSR_DMAENAB)) {
xfer_len = dma->actual_len;
- wVal &= ~(MGC_M_RXCSR_DMAENAB
- | MGC_M_RXCSR_H_AUTOREQ
- | MGC_M_RXCSR_AUTOCLEAR
- | MGC_M_RXCSR_RXPKTRDY);
+ wVal &= ~(MUSB_RXCSR_DMAENAB
+ | MUSB_RXCSR_H_AUTOREQ
+ | MUSB_RXCSR_AUTOCLEAR
+ | MUSB_RXCSR_RXPKTRDY);
musb_writew(hw_ep->regs, MUSB_RXCSR, wVal);
#ifdef CONFIG_USB_INVENTRA_DMA
@@ -1523,9 +1523,9 @@ void musb_host_rx(struct musb *musb, u8 epnum)
/* send IN token for next packet, without AUTOREQ */
if (!bDone) {
- wVal |= MGC_M_RXCSR_H_REQPKT;
+ wVal |= MUSB_RXCSR_H_REQPKT;
musb_writew(epio, MUSB_RXCSR,
- MGC_M_RXCSR_H_WZC_BITS | wVal);
+ MUSB_RXCSR_H_WZC_BITS | wVal);
}
DBG(4, "ep %d dma %s, rxcsr %04x, rxcount %d\n", epnum,
@@ -1537,7 +1537,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
#endif
} else if (pUrb->status == -EINPROGRESS) {
/* if no errors, be sure a packet is ready for unloading */
- if (unlikely(!(wRxCsrVal & MGC_M_RXCSR_RXPKTRDY))) {
+ if (unlikely(!(wRxCsrVal & MUSB_RXCSR_RXPKTRDY))) {
status = -EPROTO;
ERR("Rx interrupt with no errors or packet!\n");
@@ -1546,7 +1546,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
// SCRUB (RX)
/* do the proper sequence to abort the transfer */
musb_ep_select(mbase, epnum);
- wVal &= ~MGC_M_RXCSR_H_REQPKT;
+ wVal &= ~MUSB_RXCSR_H_REQPKT;
musb_writew(epio, MUSB_RXCSR, wVal);
goto finish;
}
@@ -1600,16 +1600,16 @@ void musb_host_rx(struct musb *musb, u8 epnum)
*/
wVal = musb_readw(epio, MUSB_RXCSR);
- wVal &= ~MGC_M_RXCSR_H_REQPKT;
+ wVal &= ~MUSB_RXCSR_H_REQPKT;
if (dma->desired_mode == 0)
- wVal &= ~MGC_M_RXCSR_H_AUTOREQ;
+ wVal &= ~MUSB_RXCSR_H_AUTOREQ;
else
- wVal |= MGC_M_RXCSR_H_AUTOREQ;
- wVal |= MGC_M_RXCSR_AUTOCLEAR | MGC_M_RXCSR_DMAENAB;
+ wVal |= MUSB_RXCSR_H_AUTOREQ;
+ wVal |= MUSB_RXCSR_AUTOCLEAR | MUSB_RXCSR_DMAENAB;
musb_writew(epio, MUSB_RXCSR,
- MGC_M_RXCSR_H_WZC_BITS | wVal);
+ MUSB_RXCSR_H_WZC_BITS | wVal);
/* REVISIT if when actual_length != 0,
* transfer_buffer_length needs to be
@@ -1936,12 +1936,12 @@ static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh, int is_in)
} else {
musb_h_tx_flush_fifo(ep);
csr = musb_readw(epio, MUSB_TXCSR);
- csr &= ~( MGC_M_TXCSR_AUTOSET
- | MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_H_RXSTALL
- | MGC_M_TXCSR_H_NAKTIMEOUT
- | MGC_M_TXCSR_H_ERROR
- | MGC_M_TXCSR_TXPKTRDY
+ csr &= ~( MUSB_TXCSR_AUTOSET
+ | MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_H_RXSTALL
+ | MUSB_TXCSR_H_NAKTIMEOUT
+ | MUSB_TXCSR_H_ERROR
+ | MUSB_TXCSR_TXPKTRDY
);
musb_writew(epio, MUSB_TXCSR, csr);
/* REVISIT may need to clear FLUSHFIFO ... */
diff --git a/drivers/usb/musb/musb_procfs.c b/drivers/usb/musb/musb_procfs.c
index ddb478f..1dbacf4 100644
--- a/drivers/usb/musb/musb_procfs.c
+++ b/drivers/usb/musb/musb_procfs.c
@@ -664,7 +664,7 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
case 'C':
if (mbase) {
bReg = musb_readb(mbase, MUSB_POWER)
- | MGC_M_POWER_SOFTCONN;
+ | MUSB_POWER_SOFTCONN;
musb_writeb(mbase, MUSB_POWER, bReg);
}
break;
@@ -672,7 +672,7 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
case 'c':
if (mbase) {
bReg = musb_readb(mbase, MUSB_POWER)
- & ~MGC_M_POWER_SOFTCONN;
+ & ~MUSB_POWER_SOFTCONN;
musb_writeb(mbase, MUSB_POWER, bReg);
}
break;
@@ -680,7 +680,7 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
case 'I':
if (mbase) {
bReg = musb_readb(mbase, MUSB_POWER)
- | MGC_M_POWER_HSENAB;
+ | MUSB_POWER_HSENAB;
musb_writeb(mbase, MUSB_POWER, bReg);
}
break;
@@ -688,21 +688,21 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
case 'i':
if (mbase) {
bReg = musb_readb(mbase, MUSB_POWER)
- & ~MGC_M_POWER_HSENAB;
+ & ~MUSB_POWER_HSENAB;
musb_writeb(mbase, MUSB_POWER, bReg);
}
break;
case 'F':
bReg = musb_readb(mbase, MUSB_DEVCTL);
- bReg |= MGC_M_DEVCTL_SESSION;
+ bReg |= MUSB_DEVCTL_SESSION;
musb_writeb(mbase, MUSB_DEVCTL, bReg);
break;
case 'H':
if (mbase) {
bReg = musb_readb(mbase, MUSB_DEVCTL);
- bReg |= MGC_M_DEVCTL_HR;
+ bReg |= MUSB_DEVCTL_HR;
musb_writeb(mbase, MUSB_DEVCTL, bReg);
//MUSB_HST_MODE( ((struct musb*)data) );
//WARN("Host Mode\n");
@@ -712,7 +712,7 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
case 'h':
if (mbase) {
bReg = musb_readb(mbase, MUSB_DEVCTL);
- bReg &= ~MGC_M_DEVCTL_HR;
+ bReg &= ~MUSB_DEVCTL_HR;
musb_writeb(mbase, MUSB_DEVCTL, bReg);
}
break;
@@ -721,7 +721,7 @@ static int musb_proc_write(struct file *file, const char __user *buffer,
if (mbase) {
musb_load_testpacket(musb);
musb_writeb(mbase, MUSB_TESTMODE,
- MGC_M_TEST_PACKET);
+ MUSB_TEST_PACKET);
}
break;
diff --git a/drivers/usb/musb/musbdefs.h b/drivers/usb/musb/musbdefs.h
index d4e8c3e..25dce14 100644
--- a/drivers/usb/musb/musbdefs.h
+++ b/drivers/usb/musb/musbdefs.h
@@ -242,7 +242,7 @@ enum musb_g_ep0_state {
{ (_musb)->is_host=FALSE; }
#define test_devctl_hst_mode(_x) \
- (musb_readb((_x)->mregs, MUSB_DEVCTL)&MGC_M_DEVCTL_HM)
+ (musb_readb((_x)->mregs, MUSB_DEVCTL)&MUSB_DEVCTL_HM)
#define MUSB_MODE(musb) ((musb)->is_host ? "Host" : "Peripheral")
diff --git a/drivers/usb/musb/musbhdrc.h b/drivers/usb/musb/musbhdrc.h
index 7762663..b1601a8 100644
--- a/drivers/usb/musb/musbhdrc.h
+++ b/drivers/usb/musb/musbhdrc.h
@@ -139,183 +139,183 @@
/* POWER */
-#define MGC_M_POWER_ISOUPDATE 0x80
-#define MGC_M_POWER_SOFTCONN 0x40
-#define MGC_M_POWER_HSENAB 0x20
-#define MGC_M_POWER_HSMODE 0x10
-#define MGC_M_POWER_RESET 0x08
-#define MGC_M_POWER_RESUME 0x04
-#define MGC_M_POWER_SUSPENDM 0x02
-#define MGC_M_POWER_ENSUSPEND 0x01
+#define MUSB_POWER_ISOUPDATE 0x80
+#define MUSB_POWER_SOFTCONN 0x40
+#define MUSB_POWER_HSENAB 0x20
+#define MUSB_POWER_HSMODE 0x10
+#define MUSB_POWER_RESET 0x08
+#define MUSB_POWER_RESUME 0x04
+#define MUSB_POWER_SUSPENDM 0x02
+#define MUSB_POWER_ENSUSPEND 0x01
/* INTRUSB */
-#define MGC_M_INTR_SUSPEND 0x01
-#define MGC_M_INTR_RESUME 0x02
-#define MGC_M_INTR_RESET 0x04
-#define MGC_M_INTR_BABBLE 0x04
-#define MGC_M_INTR_SOF 0x08
-#define MGC_M_INTR_CONNECT 0x10
-#define MGC_M_INTR_DISCONNECT 0x20
-#define MGC_M_INTR_SESSREQ 0x40
-#define MGC_M_INTR_VBUSERROR 0x80 /* FOR SESSION END */
+#define MUSB_INTR_SUSPEND 0x01
+#define MUSB_INTR_RESUME 0x02
+#define MUSB_INTR_RESET 0x04
+#define MUSB_INTR_BABBLE 0x04
+#define MUSB_INTR_SOF 0x08
+#define MUSB_INTR_CONNECT 0x10
+#define MUSB_INTR_DISCONNECT 0x20
+#define MUSB_INTR_SESSREQ 0x40
+#define MUSB_INTR_VBUSERROR 0x80 /* FOR SESSION END */
/* DEVCTL */
-#define MGC_M_DEVCTL_BDEVICE 0x80
-#define MGC_M_DEVCTL_FSDEV 0x40
-#define MGC_M_DEVCTL_LSDEV 0x20
-#define MGC_M_DEVCTL_VBUS 0x18
+#define MUSB_DEVCTL_BDEVICE 0x80
+#define MUSB_DEVCTL_FSDEV 0x40
+#define MUSB_DEVCTL_LSDEV 0x20
+#define MUSB_DEVCTL_VBUS 0x18
#define MGC_S_DEVCTL_VBUS 3
-#define MGC_M_DEVCTL_HM 0x04
-#define MGC_M_DEVCTL_HR 0x02
-#define MGC_M_DEVCTL_SESSION 0x01
+#define MUSB_DEVCTL_HM 0x04
+#define MUSB_DEVCTL_HR 0x02
+#define MUSB_DEVCTL_SESSION 0x01
/* TESTMODE */
-#define MGC_M_TEST_FORCE_HOST 0x80
-#define MGC_M_TEST_FIFO_ACCESS 0x40
-#define MGC_M_TEST_FORCE_FS 0x20
-#define MGC_M_TEST_FORCE_HS 0x10
-#define MGC_M_TEST_PACKET 0x08
-#define MGC_M_TEST_K 0x04
-#define MGC_M_TEST_J 0x02
-#define MGC_M_TEST_SE0_NAK 0x01
+#define MUSB_TEST_FORCE_HOST 0x80
+#define MUSB_TEST_FIFO_ACCESS 0x40
+#define MUSB_TEST_FORCE_FS 0x20
+#define MUSB_TEST_FORCE_HS 0x10
+#define MUSB_TEST_PACKET 0x08
+#define MUSB_TEST_K 0x04
+#define MUSB_TEST_J 0x02
+#define MUSB_TEST_SE0_NAK 0x01
/* allocate for double-packet buffering (effectively doubles assigned _SIZE) */
-#define MGC_M_FIFOSZ_DPB 0x10
+#define MUSB_FIFOSZ_DPB 0x10
/* allocation size (8, 16, 32, ... 4096) */
-#define MGC_M_FIFOSZ_SIZE 0x0f
+#define MUSB_FIFOSZ_SIZE 0x0f
/* CSR0 */
-#define MGC_M_CSR0_FLUSHFIFO 0x0100
-#define MGC_M_CSR0_TXPKTRDY 0x0002
-#define MGC_M_CSR0_RXPKTRDY 0x0001
+#define MUSB_CSR0_FLUSHFIFO 0x0100
+#define MUSB_CSR0_TXPKTRDY 0x0002
+#define MUSB_CSR0_RXPKTRDY 0x0001
/* CSR0 in Peripheral mode */
-#define MGC_M_CSR0_P_SVDSETUPEND 0x0080
-#define MGC_M_CSR0_P_SVDRXPKTRDY 0x0040
-#define MGC_M_CSR0_P_SENDSTALL 0x0020
-#define MGC_M_CSR0_P_SETUPEND 0x0010
-#define MGC_M_CSR0_P_DATAEND 0x0008
-#define MGC_M_CSR0_P_SENTSTALL 0x0004
+#define MUSB_CSR0_P_SVDSETUPEND 0x0080
+#define MUSB_CSR0_P_SVDRXPKTRDY 0x0040
+#define MUSB_CSR0_P_SENDSTALL 0x0020
+#define MUSB_CSR0_P_SETUPEND 0x0010
+#define MUSB_CSR0_P_DATAEND 0x0008
+#define MUSB_CSR0_P_SENTSTALL 0x0004
/* CSR0 in Host mode */
-#define MGC_M_CSR0_H_DIS_PING 0x0800
-#define MGC_M_CSR0_H_WR_DATATOGGLE 0x0400 /* set to allow setting: */
-#define MGC_M_CSR0_H_DATATOGGLE 0x0200 /* data toggle control */
-#define MGC_M_CSR0_H_NAKTIMEOUT 0x0080
-#define MGC_M_CSR0_H_STATUSPKT 0x0040
-#define MGC_M_CSR0_H_REQPKT 0x0020
-#define MGC_M_CSR0_H_ERROR 0x0010
-#define MGC_M_CSR0_H_SETUPPKT 0x0008
-#define MGC_M_CSR0_H_RXSTALL 0x0004
+#define MUSB_CSR0_H_DIS_PING 0x0800
+#define MUSB_CSR0_H_WR_DATATOGGLE 0x0400 /* set to allow setting: */
+#define MUSB_CSR0_H_DATATOGGLE 0x0200 /* data toggle control */
+#define MUSB_CSR0_H_NAKTIMEOUT 0x0080
+#define MUSB_CSR0_H_STATUSPKT 0x0040
+#define MUSB_CSR0_H_REQPKT 0x0020
+#define MUSB_CSR0_H_ERROR 0x0010
+#define MUSB_CSR0_H_SETUPPKT 0x0008
+#define MUSB_CSR0_H_RXSTALL 0x0004
/* CSR0 bits to avoid zeroing (write zero clears, write 1 ignored) */
-#define MGC_M_CSR0_P_WZC_BITS \
- ( MGC_M_CSR0_P_SENTSTALL )
-#define MGC_M_CSR0_H_WZC_BITS \
- ( MGC_M_CSR0_H_NAKTIMEOUT | MGC_M_CSR0_H_RXSTALL \
- | MGC_M_CSR0_RXPKTRDY )
+#define MUSB_CSR0_P_WZC_BITS \
+ ( MUSB_CSR0_P_SENTSTALL )
+#define MUSB_CSR0_H_WZC_BITS \
+ ( MUSB_CSR0_H_NAKTIMEOUT | MUSB_CSR0_H_RXSTALL \
+ | MUSB_CSR0_RXPKTRDY )
/* TxType/RxType */
-#define MGC_M_TYPE_SPEED 0xc0
+#define MUSB_TYPE_SPEED 0xc0
#define MGC_S_TYPE_SPEED 6
#define MGC_TYPE_SPEED_HIGH 1
#define MGC_TYPE_SPEED_FULL 2
#define MGC_TYPE_SPEED_LOW 3
-#define MGC_M_TYPE_PROTO 0x30 /* implicitly zero for ep0 */
+#define MUSB_TYPE_PROTO 0x30 /* implicitly zero for ep0 */
#define MGC_S_TYPE_PROTO 4
-#define MGC_M_TYPE_REMOTE_END 0xf /* implicitly zero for ep0 */
+#define MUSB_TYPE_REMOTE_END 0xf /* implicitly zero for ep0 */
/* CONFIGDATA */
-#define MGC_M_CONFIGDATA_MPRXE 0x80 /* auto bulk pkt combining */
-#define MGC_M_CONFIGDATA_MPTXE 0x40 /* auto bulk pkt splitting */
-#define MGC_M_CONFIGDATA_BIGENDIAN 0x20
-#define MGC_M_CONFIGDATA_HBRXE 0x10 /* HB-ISO for RX */
-#define MGC_M_CONFIGDATA_HBTXE 0x08 /* HB-ISO for TX */
-#define MGC_M_CONFIGDATA_DYNFIFO 0x04 /* dynamic FIFO sizing */
-#define MGC_M_CONFIGDATA_SOFTCONE 0x02 /* SoftConnect */
-#define MGC_M_CONFIGDATA_UTMIDW 0x01 /* data width 0/1 => 8/16bits */
+#define MUSB_CONFIGDATA_MPRXE 0x80 /* auto bulk pkt combining */
+#define MUSB_CONFIGDATA_MPTXE 0x40 /* auto bulk pkt splitting */
+#define MUSB_CONFIGDATA_BIGENDIAN 0x20
+#define MUSB_CONFIGDATA_HBRXE 0x10 /* HB-ISO for RX */
+#define MUSB_CONFIGDATA_HBTXE 0x08 /* HB-ISO for TX */
+#define MUSB_CONFIGDATA_DYNFIFO 0x04 /* dynamic FIFO sizing */
+#define MUSB_CONFIGDATA_SOFTCONE 0x02 /* SoftConnect */
+#define MUSB_CONFIGDATA_UTMIDW 0x01 /* data width 0/1 => 8/16bits */
/* TXCSR in Peripheral and Host mode */
-#define MGC_M_TXCSR_AUTOSET 0x8000
-#define MGC_M_TXCSR_MODE 0x2000
-#define MGC_M_TXCSR_DMAENAB 0x1000
-#define MGC_M_TXCSR_FRCDATATOG 0x0800
-#define MGC_M_TXCSR_DMAMODE 0x0400
-#define MGC_M_TXCSR_CLRDATATOG 0x0040
-#define MGC_M_TXCSR_FLUSHFIFO 0x0008
-#define MGC_M_TXCSR_FIFONOTEMPTY 0x0002
-#define MGC_M_TXCSR_TXPKTRDY 0x0001
+#define MUSB_TXCSR_AUTOSET 0x8000
+#define MUSB_TXCSR_MODE 0x2000
+#define MUSB_TXCSR_DMAENAB 0x1000
+#define MUSB_TXCSR_FRCDATATOG 0x0800
+#define MUSB_TXCSR_DMAMODE 0x0400
+#define MUSB_TXCSR_CLRDATATOG 0x0040
+#define MUSB_TXCSR_FLUSHFIFO 0x0008
+#define MUSB_TXCSR_FIFONOTEMPTY 0x0002
+#define MUSB_TXCSR_TXPKTRDY 0x0001
/* TXCSR in Peripheral mode */
-#define MGC_M_TXCSR_P_ISO 0x4000
-#define MGC_M_TXCSR_P_INCOMPTX 0x0080
-#define MGC_M_TXCSR_P_SENTSTALL 0x0020
-#define MGC_M_TXCSR_P_SENDSTALL 0x0010
-#define MGC_M_TXCSR_P_UNDERRUN 0x0004
+#define MUSB_TXCSR_P_ISO 0x4000
+#define MUSB_TXCSR_P_INCOMPTX 0x0080
+#define MUSB_TXCSR_P_SENTSTALL 0x0020
+#define MUSB_TXCSR_P_SENDSTALL 0x0010
+#define MUSB_TXCSR_P_UNDERRUN 0x0004
/* TXCSR in Host mode */
-#define MGC_M_TXCSR_H_WR_DATATOGGLE 0x0200
-#define MGC_M_TXCSR_H_DATATOGGLE 0x0100
-#define MGC_M_TXCSR_H_NAKTIMEOUT 0x0080
-#define MGC_M_TXCSR_H_RXSTALL 0x0020
-#define MGC_M_TXCSR_H_ERROR 0x0004
+#define MUSB_TXCSR_H_WR_DATATOGGLE 0x0200
+#define MUSB_TXCSR_H_DATATOGGLE 0x0100
+#define MUSB_TXCSR_H_NAKTIMEOUT 0x0080
+#define MUSB_TXCSR_H_RXSTALL 0x0020
+#define MUSB_TXCSR_H_ERROR 0x0004
/* TXCSR bits to avoid zeroing (write zero clears, write 1 ignored) */
-#define MGC_M_TXCSR_P_WZC_BITS \
- ( MGC_M_TXCSR_P_INCOMPTX | MGC_M_TXCSR_P_SENTSTALL \
- | MGC_M_TXCSR_P_UNDERRUN | MGC_M_TXCSR_FIFONOTEMPTY )
-#define MGC_M_TXCSR_H_WZC_BITS \
- ( MGC_M_TXCSR_H_NAKTIMEOUT | MGC_M_TXCSR_H_RXSTALL \
- | MGC_M_TXCSR_H_ERROR | MGC_M_TXCSR_FIFONOTEMPTY )
+#define MUSB_TXCSR_P_WZC_BITS \
+ ( MUSB_TXCSR_P_INCOMPTX | MUSB_TXCSR_P_SENTSTALL \
+ | MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_FIFONOTEMPTY )
+#define MUSB_TXCSR_H_WZC_BITS \
+ ( MUSB_TXCSR_H_NAKTIMEOUT | MUSB_TXCSR_H_RXSTALL \
+ | MUSB_TXCSR_H_ERROR | MUSB_TXCSR_FIFONOTEMPTY )
/* RXCSR in Peripheral and Host mode */
-#define MGC_M_RXCSR_AUTOCLEAR 0x8000
-#define MGC_M_RXCSR_DMAENAB 0x2000
-#define MGC_M_RXCSR_DISNYET 0x1000
-#define MGC_M_RXCSR_PID_ERR 0x1000
-#define MGC_M_RXCSR_DMAMODE 0x0800
-#define MGC_M_RXCSR_INCOMPRX 0x0100
-#define MGC_M_RXCSR_CLRDATATOG 0x0080
-#define MGC_M_RXCSR_FLUSHFIFO 0x0010
-#define MGC_M_RXCSR_DATAERROR 0x0008
-#define MGC_M_RXCSR_FIFOFULL 0x0002
-#define MGC_M_RXCSR_RXPKTRDY 0x0001
+#define MUSB_RXCSR_AUTOCLEAR 0x8000
+#define MUSB_RXCSR_DMAENAB 0x2000
+#define MUSB_RXCSR_DISNYET 0x1000
+#define MUSB_RXCSR_PID_ERR 0x1000
+#define MUSB_RXCSR_DMAMODE 0x0800
+#define MUSB_RXCSR_INCOMPRX 0x0100
+#define MUSB_RXCSR_CLRDATATOG 0x0080
+#define MUSB_RXCSR_FLUSHFIFO 0x0010
+#define MUSB_RXCSR_DATAERROR 0x0008
+#define MUSB_RXCSR_FIFOFULL 0x0002
+#define MUSB_RXCSR_RXPKTRDY 0x0001
/* RXCSR in Peripheral mode */
-#define MGC_M_RXCSR_P_ISO 0x4000
-#define MGC_M_RXCSR_P_SENTSTALL 0x0040
-#define MGC_M_RXCSR_P_SENDSTALL 0x0020
-#define MGC_M_RXCSR_P_OVERRUN 0x0004
+#define MUSB_RXCSR_P_ISO 0x4000
+#define MUSB_RXCSR_P_SENTSTALL 0x0040
+#define MUSB_RXCSR_P_SENDSTALL 0x0020
+#define MUSB_RXCSR_P_OVERRUN 0x0004
/* RXCSR in Host mode */
-#define MGC_M_RXCSR_H_AUTOREQ 0x4000
-#define MGC_M_RXCSR_H_WR_DATATOGGLE 0x0400
-#define MGC_M_RXCSR_H_DATATOGGLE 0x0200
-#define MGC_M_RXCSR_H_RXSTALL 0x0040
-#define MGC_M_RXCSR_H_REQPKT 0x0020
-#define MGC_M_RXCSR_H_ERROR 0x0004
+#define MUSB_RXCSR_H_AUTOREQ 0x4000
+#define MUSB_RXCSR_H_WR_DATATOGGLE 0x0400
+#define MUSB_RXCSR_H_DATATOGGLE 0x0200
+#define MUSB_RXCSR_H_RXSTALL 0x0040
+#define MUSB_RXCSR_H_REQPKT 0x0020
+#define MUSB_RXCSR_H_ERROR 0x0004
/* RXCSR bits to avoid zeroing (write zero clears, write 1 ignored) */
-#define MGC_M_RXCSR_P_WZC_BITS \
- ( MGC_M_RXCSR_P_SENTSTALL | MGC_M_RXCSR_P_OVERRUN \
- | MGC_M_RXCSR_RXPKTRDY )
-#define MGC_M_RXCSR_H_WZC_BITS \
- ( MGC_M_RXCSR_H_RXSTALL | MGC_M_RXCSR_H_ERROR \
- | MGC_M_RXCSR_DATAERROR | MGC_M_RXCSR_RXPKTRDY )
+#define MUSB_RXCSR_P_WZC_BITS \
+ ( MUSB_RXCSR_P_SENTSTALL | MUSB_RXCSR_P_OVERRUN \
+ | MUSB_RXCSR_RXPKTRDY )
+#define MUSB_RXCSR_H_WZC_BITS \
+ ( MUSB_RXCSR_H_RXSTALL | MUSB_RXCSR_H_ERROR \
+ | MUSB_RXCSR_DATAERROR | MUSB_RXCSR_RXPKTRDY )
/* HUBADDR */
-#define MGC_M_HUBADDR_MULTI_TT 0x80
+#define MUSB_HUBADDR_MULTI_TT 0x80
#endif /* __MUSB_HDRC_DEFS_H__ */
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index a1365c0..d25ae87 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -61,7 +61,7 @@
#define MGC_S_HSDMA_ENDPOINT 4
#define MGC_S_HSDMA_BUSERROR 8
#define MGC_S_HSDMA_BURSTMODE 9
-#define MGC_M_HSDMA_BURSTMODE (3 << MGC_S_HSDMA_BURSTMODE)
+#define MUSB_HSDMA_BURSTMODE (3 << MGC_S_HSDMA_BURSTMODE)
#define MGC_HSDMA_BURSTMODE_UNSPEC 0
#define MGC_HSDMA_BURSTMODE_INCR4 1
#define MGC_HSDMA_BURSTMODE_INCR8 2
@@ -264,9 +264,9 @@ static int dma_channel_abort(struct dma_channel *pChannel)
csr = musb_readw(mbase,
MGC_END_OFFSET(pImplChannel->epnum,MUSB_TXCSR));
- csr &= ~(MGC_M_TXCSR_AUTOSET |
- MGC_M_TXCSR_DMAENAB |
- MGC_M_TXCSR_DMAMODE);
+ csr &= ~(MUSB_TXCSR_AUTOSET |
+ MUSB_TXCSR_DMAENAB |
+ MUSB_TXCSR_DMAMODE);
musb_writew(mbase,
MGC_END_OFFSET(pImplChannel->epnum,MUSB_TXCSR),
csr);
@@ -274,9 +274,9 @@ static int dma_channel_abort(struct dma_channel *pChannel)
else {
csr = musb_readw(mbase,
MGC_END_OFFSET(pImplChannel->epnum,MUSB_RXCSR));
- csr &= ~(MGC_M_RXCSR_AUTOCLEAR |
- MGC_M_RXCSR_DMAENAB |
- MGC_M_RXCSR_DMAMODE);
+ csr &= ~(MUSB_RXCSR_AUTOCLEAR |
+ MUSB_RXCSR_DMAENAB |
+ MUSB_RXCSR_DMAMODE);
musb_writew(mbase,
MGC_END_OFFSET(pImplChannel->epnum,MUSB_RXCSR),
csr);
@@ -346,7 +346,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
pChannel->status = MGC_DMA_STATUS_FREE;
/* completed */
- if ((devctl & MGC_M_DEVCTL_HM)
+ if ((devctl & MUSB_DEVCTL_HM)
&& (pImplChannel->bTransmit)
&& ((pChannel->desired_mode == 0)
|| (pChannel->actual_len &
@@ -357,7 +357,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
pImplChannel->epnum);
musb_writew(mbase,
MGC_END_OFFSET(pImplChannel->epnum,MUSB_TXCSR),
- MGC_M_TXCSR_TXPKTRDY);
+ MUSB_TXCSR_TXPKTRDY);
} else
musb_dma_completion(
pController->pDmaPrivate,
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index e62bb76..3664ff8 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -65,7 +65,7 @@ static void omap_set_vbus(struct musb *musb, int is_on)
musb->is_active = 1;
musb->xceiv.default_a = 1;
musb->xceiv.state = OTG_STATE_A_WAIT_VRISE;
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
MUSB_HST_MODE(musb);
} else {
@@ -77,7 +77,7 @@ static void omap_set_vbus(struct musb *musb, int is_on)
musb->xceiv.default_a = 0;
musb->xceiv.state = OTG_STATE_B_IDLE;
- devctl &= ~MGC_M_DEVCTL_SESSION;
+ devctl &= ~MUSB_DEVCTL_SESSION;
MUSB_DEV_MODE(musb);
}
diff --git a/drivers/usb/musb/plat_uds.c b/drivers/usb/musb/plat_uds.c
index e2e1ab2..6e44909 100644
--- a/drivers/usb/musb/plat_uds.c
+++ b/drivers/usb/musb/plat_uds.c
@@ -276,7 +276,7 @@ void musb_load_testpacket(struct musb *musb)
musb_ep_select(musb->mregs, 0);
musb_write_fifo(musb->control_ep,
sizeof(musb_test_packet), musb_test_packet);
- musb_writew(regs, MUSB_CSR0, MGC_M_CSR0_TXPKTRDY);
+ musb_writew(regs, MUSB_CSR0, MUSB_CSR0_TXPKTRDY);
}
/*-------------------------------------------------------------------------*/
@@ -332,7 +332,7 @@ void musb_hnp_stop(struct musb *musb)
hcd->self.is_b_host = 0;
musb->xceiv.state = OTG_STATE_B_PERIPHERAL;
reg = musb_readb(mbase, MUSB_POWER);
- reg |= MGC_M_POWER_SUSPENDM;
+ reg |= MUSB_POWER_SUSPENDM;
musb_writeb(mbase, MUSB_POWER, reg);
/* REVISIT: Start SESSION_REQUEST here? */
break;
@@ -356,9 +356,9 @@ void musb_hnp_stop(struct musb *musb)
* @param power
*/
-#define STAGE0_MASK (MGC_M_INTR_RESUME | MGC_M_INTR_SESSREQ \
- | MGC_M_INTR_VBUSERROR | MGC_M_INTR_CONNECT \
- | MGC_M_INTR_RESET )
+#define STAGE0_MASK (MUSB_INTR_RESUME | MUSB_INTR_SESSREQ \
+ | MUSB_INTR_VBUSERROR | MUSB_INTR_CONNECT \
+ | MUSB_INTR_RESET )
static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
u8 devctl, u8 power)
@@ -375,11 +375,11 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
* in peripheral mode, the host may resume the link.
* spurious RESUME irqs happen too, paired with SUSPEND.
*/
- if (bIntrUSB & MGC_M_INTR_RESUME) {
+ if (bIntrUSB & MUSB_INTR_RESUME) {
handled = IRQ_HANDLED;
DBG(3, "RESUME (%s)\n", otg_state_string(musb));
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (devctl & MUSB_DEVCTL_HM) {
#ifdef CONFIG_USB_MUSB_HDRC_HCD
switch (musb->xceiv.state) {
case OTG_STATE_A_SUSPEND:
@@ -387,16 +387,16 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
* will stop RESUME signaling
*/
- if (power & MGC_M_POWER_SUSPENDM) {
+ if (power & MUSB_POWER_SUSPENDM) {
/* spurious */
- musb->int_usb &= ~MGC_M_INTR_SUSPEND;
+ musb->int_usb &= ~MUSB_INTR_SUSPEND;
DBG(2, "Spurious SUSPENDM\n");
break;
}
- power &= ~MGC_M_POWER_SUSPENDM;
+ power &= ~MUSB_POWER_SUSPENDM;
musb_writeb(mbase, MUSB_POWER,
- power | MGC_M_POWER_RESUME);
+ power | MUSB_POWER_RESUME);
musb->port1_status |=
(USB_PORT_STAT_C_SUSPEND << 16)
@@ -434,16 +434,16 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
/* disconnect while suspended? we may
* not get a disconnect irq...
*/
- if ((devctl & MGC_M_DEVCTL_VBUS)
+ if ((devctl & MUSB_DEVCTL_VBUS)
!= (3 << MGC_S_DEVCTL_VBUS)) {
- musb->int_usb |= MGC_M_INTR_DISCONNECT;
- musb->int_usb &= ~MGC_M_INTR_SUSPEND;
+ musb->int_usb |= MUSB_INTR_DISCONNECT;
+ musb->int_usb &= ~MUSB_INTR_SUSPEND;
break;
}
musb_g_resume(musb);
break;
case OTG_STATE_B_IDLE:
- musb->int_usb &= ~MGC_M_INTR_SUSPEND;
+ musb->int_usb &= ~MUSB_INTR_SUSPEND;
break;
#endif
default:
@@ -456,7 +456,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
#ifdef CONFIG_USB_MUSB_HDRC_HCD
/* see manual for the order of the tests */
- if (bIntrUSB & MGC_M_INTR_SESSREQ) {
+ if (bIntrUSB & MUSB_INTR_SESSREQ) {
DBG(1, "SESSION_REQUEST (%s)\n", otg_state_string(musb));
/* IRQ arrives from ID pin sense or (later, if VBUS power
@@ -466,7 +466,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
* - ... to A_WAIT_BCON.
* a_wait_vrise_tmout triggers VBUS_ERROR transitions
*/
- musb_writeb(mbase, MUSB_DEVCTL, MGC_M_DEVCTL_SESSION);
+ musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
musb->ep0_stage = MGC_END0_START;
musb->xceiv.state = OTG_STATE_A_IDLE;
MUSB_HST_MODE(musb);
@@ -475,7 +475,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
handled = IRQ_HANDLED;
}
- if (bIntrUSB & MGC_M_INTR_VBUSERROR) {
+ if (bIntrUSB & MUSB_INTR_VBUSERROR) {
int ignore = 0;
/* During connection as an A-Device, we may see a short
@@ -507,7 +507,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
if (musb->vbuserr_retry) {
musb->vbuserr_retry--;
ignore = 1;
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
musb_writeb(mbase, MUSB_DEVCTL, devctl);
} else {
musb->port1_status |=
@@ -523,7 +523,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
otg_state_string(musb),
devctl,
({ char *s;
- switch (devctl & MGC_M_DEVCTL_VBUS) {
+ switch (devctl & MUSB_DEVCTL_VBUS) {
case 0 << MGC_S_DEVCTL_VBUS:
s = "<SessEnd"; break;
case 1 << MGC_S_DEVCTL_VBUS:
@@ -543,7 +543,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
handled = IRQ_HANDLED;
}
- if (bIntrUSB & MGC_M_INTR_CONNECT) {
+ if (bIntrUSB & MUSB_INTR_CONNECT) {
struct usb_hcd *hcd = musb_to_hcd(musb);
handled = IRQ_HANDLED;
@@ -570,7 +570,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
|(USB_PORT_STAT_C_CONNECTION << 16);
/* high vs full speed is just a guess until after reset */
- if (devctl & MGC_M_DEVCTL_LSDEV)
+ if (devctl & MUSB_DEVCTL_LSDEV)
musb->port1_status |= USB_PORT_STAT_LOW_SPEED;
if (hcd->status_urb)
@@ -588,7 +588,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
hcd->self.is_b_host = 1;
break;
default:
- if ((devctl & MGC_M_DEVCTL_VBUS)
+ if ((devctl & MUSB_DEVCTL_VBUS)
== (3 << MGC_S_DEVCTL_VBUS)) {
musb->xceiv.state = OTG_STATE_A_HOST;
hcd->self.is_b_host = 0;
@@ -603,8 +603,8 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
/* mentor saves a bit: bus reset and babble share the same irq.
* only host sees babble; only peripheral sees bus reset.
*/
- if (bIntrUSB & MGC_M_INTR_RESET) {
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (bIntrUSB & MUSB_INTR_RESET) {
+ if (devctl & MUSB_DEVCTL_HM) {
/*
* Looks like non-HS BABBLE can be ignored, but
* HS BABBLE is an error condition. For HS the solution
@@ -612,7 +612,7 @@ static irqreturn_t musb_stage0_irq(struct musb * musb, u8 bIntrUSB,
* causes BABBLE. When HS BABBLE happens we can only stop
* the session.
*/
- if (devctl & (MGC_M_DEVCTL_FSDEV | MGC_M_DEVCTL_LSDEV))
+ if (devctl & (MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV))
DBG(1, "BABBLE devctl: %02x\n", devctl);
else {
ERR("Stopping host session because of babble\n");
@@ -659,7 +659,7 @@ static irqreturn_t musb_stage2_irq(struct musb * musb, u8 bIntrUSB,
* endpoints, relies on TX/RX interval registers, and isn't claimed
* to support ISO transfers yet.
*/
- if (bIntrUSB & MGC_M_INTR_SOF) {
+ if (bIntrUSB & MUSB_INTR_SOF) {
void __iomem *mbase = musb->mregs;
struct musb_hw_ep *ep;
u8 epnum;
@@ -690,7 +690,7 @@ static irqreturn_t musb_stage2_irq(struct musb * musb, u8 bIntrUSB,
}
#endif
- if ((bIntrUSB & MGC_M_INTR_DISCONNECT) && !musb->ignore_disconnect) {
+ if ((bIntrUSB & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
otg_state_string(musb),
MUSB_MODE(musb), devctl);
@@ -731,7 +731,7 @@ static irqreturn_t musb_stage2_irq(struct musb * musb, u8 bIntrUSB,
schedule_work(&musb->irq_work);
}
- if (bIntrUSB & MGC_M_INTR_SUSPEND) {
+ if (bIntrUSB & MUSB_INTR_SUSPEND) {
DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
otg_state_string(musb), devctl, power);
handled = IRQ_HANDLED;
@@ -799,16 +799,16 @@ void musb_start(struct musb *musb)
musb_writeb(regs, MUSB_TESTMODE, 0);
/* put into basic highspeed mode and start session */
- musb_writeb(regs, MUSB_POWER, MGC_M_POWER_ISOUPDATE
- | MGC_M_POWER_SOFTCONN
- | MGC_M_POWER_HSENAB
+ musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
+ | MUSB_POWER_SOFTCONN
+ | MUSB_POWER_HSENAB
/* ENSUSPEND wedges tusb */
- // | MGC_M_POWER_ENSUSPEND
+ // | MUSB_POWER_ENSUSPEND
);
musb->is_active = 0;
devctl = musb_readb(regs, MUSB_DEVCTL);
- devctl &= ~MGC_M_DEVCTL_SESSION;
+ devctl &= ~MUSB_DEVCTL_SESSION;
if (is_otg_enabled(musb)) {
/* session started after:
@@ -816,17 +816,17 @@ void musb_start(struct musb *musb)
* (b) vbus present/connect IRQ, peripheral mode;
* (c) peripheral initiates, using SRP
*/
- if ((devctl & MGC_M_DEVCTL_VBUS) == MGC_M_DEVCTL_VBUS)
+ if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
musb->is_active = 1;
else
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
} else if (is_host_enabled(musb)) {
/* assume ID pin is hard-wired to ground */
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
} else /* peripheral is enabled */ {
- if ((devctl & MGC_M_DEVCTL_VBUS) == MGC_M_DEVCTL_VBUS)
+ if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
musb->is_active = 1;
}
musb_platform_enable(musb);
@@ -1038,7 +1038,7 @@ fifo_setup(struct musb *musb, struct musb_hw_ep *hw_ep,
if (cfg->mode == BUF_DOUBLE) {
if ((offset + (maxpacket << 1)) > DYN_FIFO_SIZE)
return -EMSGSIZE;
- c_size |= MGC_M_FIFOSZ_DPB;
+ c_size |= MUSB_FIFOSZ_DPB;
} else {
if ((offset + maxpacket) > DYN_FIFO_SIZE)
return -EMSGSIZE;
@@ -1059,19 +1059,19 @@ fifo_setup(struct musb *musb, struct musb_hw_ep *hw_ep,
case FIFO_TX:
musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
musb_writew(mbase, MUSB_TXFIFOADD, c_off);
- hw_ep->tx_double_buffered = !!(c_size & MGC_M_FIFOSZ_DPB);
+ hw_ep->tx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
hw_ep->max_packet_sz_tx = maxpacket;
break;
case FIFO_RX:
musb_writeb(mbase, MUSB_RXFIFOSZ, c_size);
musb_writew(mbase, MUSB_RXFIFOADD, c_off);
- hw_ep->rx_double_buffered = !!(c_size & MGC_M_FIFOSZ_DPB);
+ hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
hw_ep->max_packet_sz_rx = maxpacket;
break;
case FIFO_RXTX:
musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
musb_writew(mbase, MUSB_TXFIFOADD, c_off);
- hw_ep->rx_double_buffered = !!(c_size & MGC_M_FIFOSZ_DPB);
+ hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
hw_ep->max_packet_sz_rx = maxpacket;
musb_writeb(mbase, MUSB_RXFIFOSZ, c_size);
@@ -1088,7 +1088,7 @@ fifo_setup(struct musb *musb, struct musb_hw_ep *hw_ep,
*/
musb->wEndMask |= (1 << hw_ep->epnum);
- return offset + (maxpacket << ((c_size & MGC_M_FIFOSZ_DPB) ? 1 : 0));
+ return offset + (maxpacket << ((c_size & MUSB_FIFOSZ_DPB) ? 1 : 0));
}
static struct fifo_cfg __initdata ep0_cfg = {
@@ -1261,11 +1261,11 @@ static int __init musb_core_init(u16 wType, struct musb *musb)
musb_ep_select(mbase, 0);
reg = musb_readb(mbase, 0x10 + MUSB_CONFIGDATA);
- strcpy(aInfo, (reg & MGC_M_CONFIGDATA_UTMIDW) ? "UTMI-16" : "UTMI-8");
- if (reg & MGC_M_CONFIGDATA_DYNFIFO) {
+ strcpy(aInfo, (reg & MUSB_CONFIGDATA_UTMIDW) ? "UTMI-16" : "UTMI-8");
+ if (reg & MUSB_CONFIGDATA_DYNFIFO) {
strcat(aInfo, ", dyn FIFOs");
}
- if (reg & MGC_M_CONFIGDATA_MPRXE) {
+ if (reg & MUSB_CONFIGDATA_MPRXE) {
strcat(aInfo, ", bulk combine");
#ifdef C_MP_RX
musb->bulk_combine = TRUE;
@@ -1273,7 +1273,7 @@ static int __init musb_core_init(u16 wType, struct musb *musb)
strcat(aInfo, " (X)"); /* no driver support */
#endif
}
- if (reg & MGC_M_CONFIGDATA_MPTXE) {
+ if (reg & MUSB_CONFIGDATA_MPTXE) {
strcat(aInfo, ", bulk split");
#ifdef C_MP_TX
musb->bulk_split = TRUE;
@@ -1281,15 +1281,15 @@ static int __init musb_core_init(u16 wType, struct musb *musb)
strcat(aInfo, " (X)"); /* no driver support */
#endif
}
- if (reg & MGC_M_CONFIGDATA_HBRXE) {
+ if (reg & MUSB_CONFIGDATA_HBRXE) {
strcat(aInfo, ", HB-ISO Rx");
strcat(aInfo, " (X)"); /* no driver support */
}
- if (reg & MGC_M_CONFIGDATA_HBTXE) {
+ if (reg & MUSB_CONFIGDATA_HBTXE) {
strcat(aInfo, ", HB-ISO Tx");
strcat(aInfo, " (X)"); /* no driver support */
}
- if (reg & MGC_M_CONFIGDATA_SOFTCONE) {
+ if (reg & MUSB_CONFIGDATA_SOFTCONE) {
strcat(aInfo, ", SoftConn");
}
@@ -1342,7 +1342,7 @@ static int __init musb_core_init(u16 wType, struct musb *musb)
musb->nr_endpoints = 1;
musb->wEndMask = 1;
- if (reg & MGC_M_CONFIGDATA_DYNFIFO) {
+ if (reg & MUSB_CONFIGDATA_DYNFIFO) {
if (can_dynfifo())
status = ep_config_from_table(musb);
else {
@@ -1462,7 +1462,7 @@ irqreturn_t musb_interrupt(struct musb *musb)
power = musb_readb(musb->mregs, MUSB_POWER);
DBG(4, "** IRQ %s usb%04x tx%04x rx%04x\n",
- (devctl & MGC_M_DEVCTL_HM) ? "host" : "peripheral",
+ (devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
musb->int_usb, musb->int_tx, musb->int_rx);
/* the core can interrupt us for multiple reasons; docs have
@@ -1476,7 +1476,7 @@ irqreturn_t musb_interrupt(struct musb *musb)
/* handle endpoint 0 first */
if (musb->int_tx & 1) {
- if (devctl & MGC_M_DEVCTL_HM)
+ if (devctl & MUSB_DEVCTL_HM)
retval |= musb_h_ep0_irq(musb);
else
retval |= musb_g_ep0_irq(musb);
@@ -1490,7 +1490,7 @@ irqreturn_t musb_interrupt(struct musb *musb)
// musb_ep_select(musb->mregs, ep_num);
/* REVISIT just retval = ep->rx_irq(...) */
retval = IRQ_HANDLED;
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (devctl & MUSB_DEVCTL_HM) {
if (is_host_capable())
musb_host_rx(musb, ep_num);
} else {
@@ -1511,7 +1511,7 @@ irqreturn_t musb_interrupt(struct musb *musb)
// musb_ep_select(musb->mregs, ep_num);
/* REVISIT just retval |= ep->tx_irq(...) */
retval = IRQ_HANDLED;
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (devctl & MUSB_DEVCTL_HM) {
if (is_host_capable())
musb_host_tx(musb, ep_num);
} else {
@@ -1549,7 +1549,7 @@ void musb_dma_completion(struct musb *musb, u8 epnum, u8 bTransmit)
#ifndef CONFIG_USB_TUSB_OMAP_DMA
if (!is_cppi_enabled()) {
/* endpoint 0 */
- if (devctl & MGC_M_DEVCTL_HM)
+ if (devctl & MUSB_DEVCTL_HM)
musb_h_ep0_irq(musb);
else
musb_g_ep0_irq(musb);
@@ -1558,7 +1558,7 @@ void musb_dma_completion(struct musb *musb, u8 epnum, u8 bTransmit)
} else {
/* endpoints 1..15 */
if (bTransmit) {
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (devctl & MUSB_DEVCTL_HM) {
if (is_host_capable())
musb_host_tx(musb, epnum);
} else {
@@ -1567,7 +1567,7 @@ void musb_dma_completion(struct musb *musb, u8 epnum, u8 bTransmit)
}
} else {
/* receive */
- if (devctl & MGC_M_DEVCTL_HM) {
+ if (devctl & MUSB_DEVCTL_HM) {
if (is_host_capable())
musb_host_rx(musb, epnum);
} else {
@@ -1653,7 +1653,7 @@ musb_cable_show(struct device *dev, struct device_attribute *attr, char *buf)
break;
case MUSB_OTG:
v1 = "Mini-";
- v2 = (vbus & MGC_M_DEVCTL_BDEVICE) ? "B" : "A";
+ v2 = (vbus & MUSB_DEVCTL_BDEVICE) ? "B" : "A";
break;
}
} else /* VBUS level below A-Valid */
@@ -1993,7 +1993,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
"HOST", status,
musb_readb(musb->mregs, MUSB_DEVCTL),
(musb_readb(musb->mregs, MUSB_DEVCTL)
- & MGC_M_DEVCTL_BDEVICE
+ & MUSB_DEVCTL_BDEVICE
? 'B' : 'A'));
} else /* peripheral is enabled */ {
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index fff2553..4b5a4dc 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -536,7 +536,7 @@ static void tusb_source_power(struct musb *musb, int is_on)
timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE);
musb->xceiv.default_a = 1;
musb->xceiv.state = OTG_STATE_A_WAIT_VRISE;
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
conf |= TUSB_DEV_CONF_USB_HOST_MODE;
MUSB_HST_MODE(musb);
@@ -550,7 +550,7 @@ static void tusb_source_power(struct musb *musb, int is_on)
musb->xceiv.default_a = 0;
musb->xceiv.state = OTG_STATE_B_IDLE;
- devctl &= ~MGC_M_DEVCTL_SESSION;
+ devctl &= ~MUSB_DEVCTL_SESSION;
conf &= ~TUSB_DEV_CONF_USB_HOST_MODE;
MUSB_DEV_MODE(musb);
@@ -688,7 +688,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *base)
if (musb->xceiv.state != OTG_STATE_B_IDLE) {
/* INTR_DISCONNECT can hide... */
musb->xceiv.state = OTG_STATE_B_IDLE;
- musb->int_usb |= MGC_M_INTR_DISCONNECT;
+ musb->int_usb |= MUSB_INTR_DISCONNECT;
}
musb->is_active = 0;
}
@@ -708,7 +708,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *base)
DBG(2, "Got SRP, turning on VBUS\n");
devctl = musb_readb(musb->mregs,
MUSB_DEVCTL);
- devctl |= MGC_M_DEVCTL_SESSION;
+ devctl |= MUSB_DEVCTL_SESSION;
musb_writeb(musb->mregs, MUSB_DEVCTL,
devctl);
musb->xceiv.state = OTG_STATE_A_WAIT_VRISE;
@@ -755,8 +755,8 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *base)
*/
devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
if (otg_stat & TUSB_DEV_OTG_STAT_VBUS_VALID) {
- if ((devctl & MGC_M_DEVCTL_VBUS)
- != MGC_M_DEVCTL_VBUS) {
+ if ((devctl & MUSB_DEVCTL_VBUS)
+ != MUSB_DEVCTL_VBUS) {
DBG(2, "devctl %02x\n", devctl);
break;
}
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index 4141c12..3a4db47 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -224,8 +224,8 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
DBG(2, "terminating short tx packet\n");
musb_ep_select(musb_base, chdat->epnum);
csr = musb_readw(hw_ep->regs, MUSB_TXCSR);
- csr |= MGC_M_TXCSR_MODE | MGC_M_TXCSR_TXPKTRDY
- | MGC_M_TXCSR_P_WZC_BITS;
+ csr |= MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY
+ | MUSB_TXCSR_P_WZC_BITS;
musb_writew(hw_ep->regs, MUSB_TXCSR, csr);
}
}
@@ -377,17 +377,17 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
if (chdat->tx) {
musb_ep_select(musb_base, chdat->epnum);
csr = musb_readw(hw_ep->regs, MUSB_TXCSR);
- csr |= (MGC_M_TXCSR_AUTOSET | MGC_M_TXCSR_DMAENAB
- | MGC_M_TXCSR_DMAMODE | MGC_M_TXCSR_MODE);
- csr &= ~MGC_M_TXCSR_P_UNDERRUN;
+ csr |= (MUSB_TXCSR_AUTOSET | MUSB_TXCSR_DMAENAB
+ | MUSB_TXCSR_DMAMODE | MUSB_TXCSR_MODE);
+ csr &= ~MUSB_TXCSR_P_UNDERRUN;
musb_writew(hw_ep->regs, MUSB_TXCSR, csr);
} else {
musb_ep_select(musb_base, chdat->epnum);
csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
- csr |= MGC_M_RXCSR_DMAENAB;
- csr &= ~(MGC_M_RXCSR_AUTOCLEAR | MGC_M_RXCSR_DMAMODE);
+ csr |= MUSB_RXCSR_DMAENAB;
+ csr &= ~(MUSB_RXCSR_AUTOCLEAR | MUSB_RXCSR_DMAMODE);
musb_writew(hw_ep->regs, MUSB_RXCSR,
- csr | MGC_M_RXCSR_P_WZC_BITS);
+ csr | MUSB_RXCSR_P_WZC_BITS);
}
/*
diff --git a/drivers/usb/musb/virthub.c b/drivers/usb/musb/virthub.c
index 41450c9..5cbce32 100644
--- a/drivers/usb/musb/virthub.c
+++ b/drivers/usb/musb/virthub.c
@@ -56,20 +56,20 @@ static void musb_port_suspend(struct musb *musb, u8 bSuspend)
/* NOTE: this doesn't necessarily put PHY into low power mode,
* turning off its clock; that's a function of PHY integration and
- * MGC_M_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect
+ * MUSB_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect
* SE0 changing to connect (J) or wakeup (K) states.
*/
power = musb_readb(mbase, MUSB_POWER);
if (bSuspend) {
int retries = 10000;
- power &= ~MGC_M_POWER_RESUME;
- power |= MGC_M_POWER_SUSPENDM;
+ power &= ~MUSB_POWER_RESUME;
+ power |= MUSB_POWER_SUSPENDM;
musb_writeb(mbase, MUSB_POWER, power);
/* Needed for OPT A tests */
power = musb_readb(mbase, MUSB_POWER);
- while (power & MGC_M_POWER_SUSPENDM) {
+ while (power & MUSB_POWER_SUSPENDM) {
power = musb_readb(mbase, MUSB_POWER);
if (retries-- < 1)
break;
@@ -88,15 +88,15 @@ static void musb_port_suspend(struct musb *musb, u8 bSuspend)
case OTG_STATE_B_HOST:
musb->xceiv.state = OTG_STATE_B_PERIPHERAL;
MUSB_DEV_MODE(musb);
- /* REVISIT restore setting of MGC_M_DEVCTL_HR */
+ /* REVISIT restore setting of MUSB_DEVCTL_HR */
break;
default:
DBG(1, "bogus rh suspend? %s\n",
otg_state_string(musb));
}
- } else if (power & MGC_M_POWER_SUSPENDM) {
- power &= ~MGC_M_POWER_SUSPENDM;
- power |= MGC_M_POWER_RESUME;
+ } else if (power & MUSB_POWER_SUSPENDM) {
+ power &= ~MUSB_POWER_SUSPENDM;
+ power |= MUSB_POWER_RESUME;
musb_writeb(mbase, MUSB_POWER, power);
DBG(3, "Root port resuming, power %02x\n", power);
@@ -116,7 +116,7 @@ static void musb_port_reset(struct musb *musb, u8 bReset)
/* REVISIT this looks wrong for HNP */
u8 devctl = musb_readb(mbase, MUSB_DEVCTL);
- if (musb->delay_port_power_off || !(devctl & MGC_M_DEVCTL_HM)) {
+ if (musb->delay_port_power_off || !(devctl & MUSB_DEVCTL_HM)) {
return;
}
#endif
@@ -137,18 +137,18 @@ static void musb_port_reset(struct musb *musb, u8 bReset)
* fail with "Error! Did not receive an SOF before suspend
* detected".
*/
- if (power & MGC_M_POWER_RESUME) {
+ if (power & MUSB_POWER_RESUME) {
while (time_before(jiffies, musb->rh_timer))
msleep(1);
musb_writeb(mbase, MUSB_POWER,
- power & ~MGC_M_POWER_RESUME);
+ power & ~MUSB_POWER_RESUME);
msleep(1);
}
musb->ignore_disconnect = TRUE;
power &= 0xf0;
musb_writeb(mbase, MUSB_POWER,
- power | MGC_M_POWER_RESET);
+ power | MUSB_POWER_RESET);
musb->port1_status |= USB_PORT_STAT_RESET;
musb->port1_status &= ~USB_PORT_STAT_ENABLE;
@@ -156,12 +156,12 @@ static void musb_port_reset(struct musb *musb, u8 bReset)
} else {
DBG(4, "root port reset stopped\n");
musb_writeb(mbase, MUSB_POWER,
- power & ~MGC_M_POWER_RESET);
+ power & ~MUSB_POWER_RESET);
musb->ignore_disconnect = FALSE;
power = musb_readb(mbase, MUSB_POWER);
- if (power & MGC_M_POWER_HSMODE) {
+ if (power & MUSB_POWER_HSMODE) {
DBG(4, "high-speed device connected\n");
musb->port1_status |= USB_PORT_STAT_HIGH_SPEED;
}
@@ -309,7 +309,7 @@ int musb_hub_control(
u8 power;
power = musb_readb(musb->mregs, MUSB_POWER);
- power &= ~MGC_M_POWER_RESUME;
+ power &= ~MUSB_POWER_RESUME;
DBG(4, "root port resume stopped, power %02x\n",
power);
musb_writeb(musb->mregs, MUSB_POWER, power);
@@ -368,31 +368,31 @@ int musb_hub_control(
switch (wIndex) {
case 1:
pr_debug("TEST_J\n");
- temp = MGC_M_TEST_J;
+ temp = MUSB_TEST_J;
break;
case 2:
pr_debug("TEST_K\n");
- temp = MGC_M_TEST_K;
+ temp = MUSB_TEST_K;
break;
case 3:
pr_debug("TEST_SE0_NAK\n");
- temp = MGC_M_TEST_SE0_NAK;
+ temp = MUSB_TEST_SE0_NAK;
break;
case 4:
pr_debug("TEST_PACKET\n");
- temp = MGC_M_TEST_PACKET;
+ temp = MUSB_TEST_PACKET;
musb_load_testpacket(musb);
break;
case 5:
pr_debug("TEST_FORCE_ENABLE\n");
- temp = MGC_M_TEST_FORCE_HOST
- | MGC_M_TEST_FORCE_HS;
+ temp = MUSB_TEST_FORCE_HOST
+ | MUSB_TEST_FORCE_HS;
- musb_writeb(musb->mregs, MUSB_DEVCTL, MGC_M_DEVCTL_SESSION);
+ musb_writeb(musb->mregs, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
break;
case 6:
pr_debug("TEST_FIFO_ACCESS\n");
- temp = MGC_M_TEST_FIFO_ACCESS;
+ temp = MUSB_TEST_FIFO_ACCESS;
break;
default:
goto error;
--
1.5.2.3
next prev parent reply other threads:[~2007-08-15 14:21 UTC|newest]
Thread overview: 13+ messages / expand[flat|nested] mbox.gz Atom feed top
2007-08-15 14:21 [PATCH 0/8] musb_hdrc: Series of patches to clean-up musbhdrc.h Tony Lindgren
2007-08-15 14:21 ` [PATCH 1/8] musb_hdrc: Search and replace MGC_O_HDRC_ with MUSB_ Tony Lindgren
2007-08-15 14:21 ` Tony Lindgren [this message]
2007-08-15 14:21 ` [PATCH 3/8] musb_hdrc: Search and replace MGC_S_XXX with MUSB_XXX_SHIFT Tony Lindgren
2007-08-15 14:21 ` [PATCH 4/8] musb_hdrc: Search and replace MGC_END0_FIFOSIZE with MUSB_EP0_FIFOSIZE, remove MGC_MAX_USB_ENDS Tony Lindgren
2007-08-15 14:21 ` [PATCH 5/8] musb_hdrc: Search and replace _bOffset with _offset Tony Lindgren
2007-08-15 14:21 ` [PATCH 6/8] musb_hdrc: Search and replace MGC_XXX_OFFSET with MUSB_XXX_OFFSET Tony Lindgren
2007-08-15 14:21 ` [PATCH 7/8] musb_hdrc: Remove old unsed MGC_TYPE_SPEED_XXX Tony Lindgren
2007-08-15 14:21 ` [PATCH 8/8] musb_hdrc: Tabify and clean-up musbhdrc.h Tony Lindgren
2007-08-15 16:20 ` David Brownell
2007-08-16 6:46 ` [PATCH] musb_hdrc: Add Nokia Copyright, Make GPLv2 text generic (Was: [PATCH 8/8] musb_hdrc: Tabify and clean-up musbhdrc.h) Tony Lindgren
2007-08-16 7:50 ` David Brownell
2007-08-16 9:13 ` Tony Lindgren
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1187187711983-git-send-email-tony@atomide.com \
--to=tony@atomide.com \
--cc=linux-omap-open-source@linux.omap.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.