#include "musbdefs.h"
-/* ep0 is always musb->aLocalEnd[0].ep_in */
-#define next_ep0_request(musb) next_in_request(&(musb)->aLocalEnd[0])
+/* ep0 is always musb->endpoints[0].ep_in */
+#define next_ep0_request(musb) next_in_request(&(musb)->endpoints[0])
/*
- * Locking note: we use only the controller lock, for simpler correctness.
+ * locking note: we use only the controller lock, for simpler correctness.
* It's always held with IRQs blocked.
*
* It protects the ep0 request queue as well as ep0_state, not just the
* Context: caller holds controller lock
*/
static int service_tx_status_request(
- struct musb *pThis,
- const struct usb_ctrlrequest *pControlRequest)
+ struct musb *musb,
+ const struct usb_ctrlrequest *ctrlrequest)
{
- void __iomem *pBase = pThis->pRegs;
+ void __iomem *mbase = musb->mregs;
int handled = 1;
- u8 bResult[2], bEnd = 0;
- const u8 bRecip = pControlRequest->bRequestType & USB_RECIP_MASK;
+ u8 result[2], epnum = 0;
+ const u8 recip = ctrlrequest->bRequestType & USB_RECIP_MASK;
- bResult[1] = 0;
+ result[1] = 0;
- switch (bRecip) {
+ switch (recip) {
case USB_RECIP_DEVICE:
- bResult[0] = pThis->bIsSelfPowered << USB_DEVICE_SELF_POWERED;
- bResult[0] |= pThis->bMayWakeup << USB_DEVICE_REMOTE_WAKEUP;
+ result[0] = musb->is_self_powered << USB_DEVICE_SELF_POWERED;
+ result[0] |= musb->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
#ifdef CONFIG_USB_MUSB_OTG
- if (pThis->g.is_otg) {
- bResult[0] |= pThis->g.b_hnp_enable
+ if (musb->g.is_otg) {
+ result[0] |= musb->g.b_hnp_enable
<< USB_DEVICE_B_HNP_ENABLE;
- bResult[0] |= pThis->g.a_alt_hnp_support
+ result[0] |= musb->g.a_alt_hnp_support
<< USB_DEVICE_A_ALT_HNP_SUPPORT;
- bResult[0] |= pThis->g.a_hnp_support
+ result[0] |= musb->g.a_hnp_support
<< USB_DEVICE_A_HNP_SUPPORT;
}
#endif
break;
case USB_RECIP_INTERFACE:
- bResult[0] = 0;
+ result[0] = 0;
break;
case USB_RECIP_ENDPOINT: {
u16 tmp;
void __iomem *regs;
- bEnd = (u8) pControlRequest->wIndex;
- if (!bEnd) {
- bResult[0] = 0;
+ epnum = (u8) ctrlrequest->wIndex;
+ if (!epnum) {
+ result[0] = 0;
break;
}
- is_in = bEnd & USB_DIR_IN;
+ is_in = epnum & USB_DIR_IN;
if (is_in) {
- bEnd &= 0x0f;
- ep = &pThis->aLocalEnd[bEnd].ep_in;
+ epnum &= 0x0f;
+ ep = &musb->endpoints[epnum].ep_in;
} else {
- ep = &pThis->aLocalEnd[bEnd].ep_out;
+ ep = &musb->endpoints[epnum].ep_out;
}
- regs = pThis->aLocalEnd[bEnd].regs;
+ regs = musb->endpoints[epnum].regs;
- if (bEnd >= MUSB_C_NUM_EPS || !ep->desc) {
+ if (epnum >= MUSB_C_NUM_EPS || !ep->desc) {
handled = -EINVAL;
break;
}
- MGC_SelectEnd(pBase, bEnd);
+ musb_ep_select(mbase, epnum);
if (is_in)
tmp = musb_readw(regs, MGC_O_HDRC_TXCSR)
& MGC_M_TXCSR_P_SENDSTALL;
else
tmp = musb_readw(regs, MGC_O_HDRC_RXCSR)
& MGC_M_RXCSR_P_SENDSTALL;
- MGC_SelectEnd(pBase, 0);
+ musb_ep_select(mbase, 0);
- bResult[0] = tmp ? 1 : 0;
+ result[0] = tmp ? 1 : 0;
} break;
default:
/* fill up the fifo; caller updates csr0 */
if (handled > 0) {
- u16 len = le16_to_cpu(pControlRequest->wLength);
+ u16 len = le16_to_cpu(ctrlrequest->wLength);
if (len > 2)
len = 2;
- musb_write_fifo(&pThis->aLocalEnd[0], len, bResult);
+ musb_write_fifo(&musb->endpoints[0], len, result);
}
return handled;
* Context: caller holds controller lock
*/
static int
-service_in_request(struct musb *pThis,
- const struct usb_ctrlrequest *pControlRequest)
+service_in_request(struct musb *musb,
+ const struct usb_ctrlrequest *ctrlrequest)
{
int handled = 0; /* not handled */
- if ((pControlRequest->bRequestType & USB_TYPE_MASK)
+ if ((ctrlrequest->bRequestType & USB_TYPE_MASK)
== USB_TYPE_STANDARD) {
- switch (pControlRequest->bRequest) {
+ switch (ctrlrequest->bRequest) {
case USB_REQ_GET_STATUS:
- handled = service_tx_status_request(pThis,
- pControlRequest);
+ handled = service_tx_status_request(musb,
+ ctrlrequest);
break;
/* case USB_REQ_SYNC_FRAME: */
/*
* Context: caller holds controller lock
*/
-static void musb_g_ep0_giveback(struct musb *pThis, struct usb_request *req)
+static void musb_g_ep0_giveback(struct musb *musb, struct usb_request *req)
{
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
- musb_g_giveback(&pThis->aLocalEnd[0].ep_in, req, 0);
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
+ musb_g_giveback(&musb->endpoints[0].ep_in, req, 0);
+}
+
+/*
+ * Tries to start B-device HNP negotiation if enabled via sysfs
+ */
+static inline void musb_try_b_hnp_enable(struct musb *musb)
+{
+ void __iomem *mbase = musb->mregs;
+ u8 devctl;
+
+ DBG(1, "HNP: Setting HR\n");
+ devctl = musb_readb(mbase, MGC_O_HDRC_DEVCTL);
+ musb_writeb(mbase, MGC_O_HDRC_DEVCTL, devctl | MGC_M_DEVCTL_HR);
}
/*
* Context: caller holds controller lock
*/
static int
-service_zero_data_request(struct musb *pThis,
- struct usb_ctrlrequest *pControlRequest)
-__releases(pThis->Lock)
-__acquires(pThis->Lock)
+service_zero_data_request(struct musb *musb,
+ struct usb_ctrlrequest *ctrlrequest)
+__releases(musb->lock)
+__acquires(musb->lock)
{
int handled = -EINVAL;
- void __iomem *pBase = pThis->pRegs;
- const u8 bRecip = pControlRequest->bRequestType & USB_RECIP_MASK;
+ void __iomem *mbase = musb->mregs;
+ const u8 recip = ctrlrequest->bRequestType & USB_RECIP_MASK;
/* the gadget driver handles everything except what we MUST handle */
- if ((pControlRequest->bRequestType & USB_TYPE_MASK)
+ if ((ctrlrequest->bRequestType & USB_TYPE_MASK)
== USB_TYPE_STANDARD) {
- switch (pControlRequest->bRequest) {
+ switch (ctrlrequest->bRequest) {
case USB_REQ_SET_ADDRESS:
/* change it after the status stage */
- pThis->bSetAddress = TRUE;
- pThis->bAddress = (u8) (pControlRequest->wValue & 0x7f);
+ musb->set_address = TRUE;
+ musb->address = (u8) (ctrlrequest->wValue & 0x7f);
handled = 1;
break;
case USB_REQ_CLEAR_FEATURE:
- switch (bRecip) {
+ switch (recip) {
case USB_RECIP_DEVICE:
- if (pControlRequest->wValue
+ if (ctrlrequest->wValue
!= USB_DEVICE_REMOTE_WAKEUP)
break;
- pThis->bMayWakeup = 0;
+ musb->may_wakeup = 0;
handled = 1;
break;
case USB_RECIP_INTERFACE:
break;
case USB_RECIP_ENDPOINT:{
- const u8 bEnd = pControlRequest->wIndex & 0x0f;
- struct musb_ep *pEnd;
+ const u8 epnum = ctrlrequest->wIndex & 0x0f;
+ struct musb_ep *musb_ep;
- if (bEnd == 0
- || bEnd >= MUSB_C_NUM_EPS
- || pControlRequest->wValue
+ if (epnum == 0
+ || epnum >= MUSB_C_NUM_EPS
+ || ctrlrequest->wValue
!= USB_ENDPOINT_HALT)
break;
- if (pControlRequest->wIndex & USB_DIR_IN)
- pEnd = &pThis->aLocalEnd[bEnd].ep_in;
+ if (ctrlrequest->wIndex & USB_DIR_IN)
+ musb_ep = &musb->endpoints[epnum].ep_in;
else
- pEnd = &pThis->aLocalEnd[bEnd].ep_out;
- if (!pEnd->desc)
+ musb_ep = &musb->endpoints[epnum].ep_out;
+ if (!musb_ep->desc)
break;
/* REVISIT do it directly, no locking games */
- spin_unlock(&pThis->Lock);
- musb_gadget_set_halt(&pEnd->end_point, 0);
- spin_lock(&pThis->Lock);
+ spin_unlock(&musb->lock);
+ musb_gadget_set_halt(&musb_ep->end_point, 0);
+ spin_lock(&musb->lock);
/* select ep0 again */
- MGC_SelectEnd(pBase, 0);
+ musb_ep_select(mbase, 0);
handled = 1;
} break;
default:
break;
case USB_REQ_SET_FEATURE:
- switch (bRecip) {
+ switch (recip) {
case USB_RECIP_DEVICE:
handled = 1;
- switch (pControlRequest->wValue) {
+ switch (ctrlrequest->wValue) {
case USB_DEVICE_REMOTE_WAKEUP:
- pThis->bMayWakeup = 1;
+ musb->may_wakeup = 1;
break;
case USB_DEVICE_TEST_MODE:
- if (pThis->g.speed != USB_SPEED_HIGH)
+ if (musb->g.speed != USB_SPEED_HIGH)
goto stall;
- if (pControlRequest->wIndex & 0xff)
+ if (ctrlrequest->wIndex & 0xff)
goto stall;
- switch (pControlRequest->wIndex >> 8) {
+ switch (ctrlrequest->wIndex >> 8) {
case 1:
pr_debug("TEST_J\n");
/* TEST_J */
- pThis->bTestModeValue =
+ musb->test_mode_nr =
MGC_M_TEST_J;
break;
case 2:
/* TEST_K */
pr_debug("TEST_K\n");
- pThis->bTestModeValue =
+ musb->test_mode_nr =
MGC_M_TEST_K;
break;
case 3:
/* TEST_SE0_NAK */
pr_debug("TEST_SE0_NAK\n");
- pThis->bTestModeValue =
+ musb->test_mode_nr =
MGC_M_TEST_SE0_NAK;
break;
case 4:
/* TEST_PACKET */
pr_debug("TEST_PACKET\n");
- pThis->bTestModeValue =
+ musb->test_mode_nr =
MGC_M_TEST_PACKET;
break;
default:
/* enter test mode after irq */
if (handled > 0)
- pThis->bTestMode = TRUE;
+ musb->test_mode = TRUE;
break;
#ifdef CONFIG_USB_MUSB_OTG
case USB_DEVICE_B_HNP_ENABLE:
- if (!pThis->g.is_otg)
+ if (!musb->g.is_otg)
goto stall;
- { u8 devctl;
- pThis->g.b_hnp_enable = 1;
- devctl = musb_readb(pBase,
- MGC_O_HDRC_DEVCTL);
- /* REVISIT after roleswitch, HR will
- * have been cleared ... reset it
- */
- musb_writeb(pBase, MGC_O_HDRC_DEVCTL,
- devctl | MGC_M_DEVCTL_HR);
- }
+ musb->g.b_hnp_enable = 1;
+ musb_try_b_hnp_enable(musb);
break;
case USB_DEVICE_A_HNP_SUPPORT:
- if (!pThis->g.is_otg)
+ if (!musb->g.is_otg)
goto stall;
- pThis->g.a_hnp_support = 1;
+ musb->g.a_hnp_support = 1;
break;
case USB_DEVICE_A_ALT_HNP_SUPPORT:
- if (!pThis->g.is_otg)
+ if (!musb->g.is_otg)
goto stall;
- pThis->g.a_alt_hnp_support = 1;
+ musb->g.a_alt_hnp_support = 1;
break;
#endif
stall:
break;
case USB_RECIP_ENDPOINT:{
- const u8 bEnd =
- pControlRequest->wIndex & 0x0f;
- struct musb_ep *pEnd;
+ const u8 epnum =
+ ctrlrequest->wIndex & 0x0f;
+ struct musb_ep *musb_ep;
struct musb_hw_ep *ep;
void __iomem *regs;
int is_in;
u16 csr;
- if (bEnd == 0
- || bEnd >= MUSB_C_NUM_EPS
- || pControlRequest->wValue
+ if (epnum == 0
+ || epnum >= MUSB_C_NUM_EPS
+ || ctrlrequest->wValue
!= USB_ENDPOINT_HALT)
break;
- ep = pThis->aLocalEnd + bEnd;
+ ep = musb->endpoints + epnum;
regs = ep->regs;
- is_in = pControlRequest->wIndex & USB_DIR_IN;
+ is_in = ctrlrequest->wIndex & USB_DIR_IN;
if (is_in)
- pEnd = &ep->ep_in;
+ musb_ep = &ep->ep_in;
else
- pEnd = &ep->ep_out;
- if (!pEnd->desc)
+ musb_ep = &ep->ep_out;
+ if (!musb_ep->desc)
break;
- MGC_SelectEnd(pBase, bEnd);
+ musb_ep_select(mbase, epnum);
if (is_in) {
csr = musb_readw(regs,
MGC_O_HDRC_TXCSR);
}
/* select ep0 again */
- MGC_SelectEnd(pBase, 0);
+ musb_ep_select(mbase, 0);
handled = 1;
} break;
req->status = -EOVERFLOW;
tmp = len;
}
- musb_read_fifo(&this->aLocalEnd[0], tmp, buf);
+ musb_read_fifo(&this->endpoints[0], tmp, buf);
req->actual += tmp;
tmp = MGC_M_CSR0_P_SVDRXPKTRDY;
if (tmp < 64 || req->actual == req->length) {
*
* Context: caller holds controller lock
*/
-static void ep0_txstate(struct musb *pThis)
+static void ep0_txstate(struct musb *musb)
{
- void __iomem *regs = pThis->control_ep->regs;
- struct usb_request *pRequest = next_ep0_request(pThis);
+ void __iomem *regs = musb->control_ep->regs;
+ struct usb_request *pRequest = next_ep0_request(musb);
u16 wCsrVal = MGC_M_CSR0_TXPKTRDY;
u8 *pFifoSource;
- u8 wFifoCount;
+ u8 fifo_count;
if (!pRequest) {
// WARN_ON(1);
/* load the data */
pFifoSource = (u8 *) pRequest->buf + pRequest->actual;
- wFifoCount = min((unsigned) MGC_END0_FIFOSIZE,
+ fifo_count = min((unsigned) MGC_END0_FIFOSIZE,
pRequest->length - pRequest->actual);
- musb_write_fifo(&pThis->aLocalEnd[0], wFifoCount, pFifoSource);
- pRequest->actual += wFifoCount;
+ musb_write_fifo(&musb->endpoints[0], fifo_count, pFifoSource);
+ pRequest->actual += fifo_count;
/* update the flags */
- if (wFifoCount < MUSB_MAX_END0_PACKET
+ if (fifo_count < MUSB_MAX_END0_PACKET
|| pRequest->actual == pRequest->length) {
- pThis->ep0_state = MGC_END0_STAGE_STATUSOUT;
+ musb->ep0_state = MGC_END0_STAGE_STATUSOUT;
wCsrVal |= MGC_M_CSR0_P_DATAEND;
} else
pRequest = NULL;
* this hardware, but not usable from portable gadget drivers.)
*/
if (pRequest)
- musb_g_ep0_giveback(pThis, pRequest);
+ musb_g_ep0_giveback(musb, pRequest);
}
/*
* Context: caller holds controller lock.
*/
static void
-musb_read_setup(struct musb *pThis, struct usb_ctrlrequest *req)
+musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
{
struct usb_request *r;
- void __iomem *regs = pThis->control_ep->regs;
+ void __iomem *regs = musb->control_ep->regs;
- musb_read_fifo(&pThis->aLocalEnd[0], sizeof *req, (u8 *)req);
+ musb_read_fifo(&musb->endpoints[0], sizeof *req, (u8 *)req);
/* NOTE: earlier 2.6 versions changed setup packets to host
* order, but now USB packets always stay in USB byte order.
le16_to_cpu(req->wLength));
/* clean up any leftover transfers */
- r = next_ep0_request(pThis);
+ r = next_ep0_request(musb);
if (r)
- musb_g_ep0_giveback(pThis, r);
+ musb_g_ep0_giveback(musb, r);
/* For zero-data requests we want to delay the STATUS stage to
* avoid SETUPEND errors. If we read data (OUT), delay accepting
* the TX FIFO right away, and give the controller a moment
* to switch modes...
*/
- pThis->bSetAddress = FALSE;
- pThis->ackpend = MGC_M_CSR0_P_SVDRXPKTRDY;
- if (req->wLength == 0)
- pThis->ep0_state = MGC_END0_STAGE_ACKWAIT;
- else if (req->bRequestType & USB_DIR_IN) {
- pThis->ep0_state = MGC_END0_STAGE_TX;
+ musb->set_address = FALSE;
+ musb->ackpend = MGC_M_CSR0_P_SVDRXPKTRDY;
+ if (req->wLength == 0) {
+ if (req->bRequestType & USB_DIR_IN)
+ musb->ackpend |= MGC_M_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, MGC_O_HDRC_CSR0, MGC_M_CSR0_P_SVDRXPKTRDY);
while ((musb_readw(regs, MGC_O_HDRC_CSR0)
& MGC_M_CSR0_RXPKTRDY) != 0)
cpu_relax();
- pThis->ackpend = 0;
+ musb->ackpend = 0;
} else
- pThis->ep0_state = MGC_END0_STAGE_RX;
+ musb->ep0_state = MGC_END0_STAGE_RX;
}
static int
forward_to_driver(struct musb *musb,
- const struct usb_ctrlrequest *pControlRequest)
-__releases(musb->Lock)
-__acquires(musb->Lock)
+ const struct usb_ctrlrequest *ctrlrequest)
+__releases(musb->lock)
+__acquires(musb->lock)
{
int retval;
- if (!musb->pGadgetDriver)
+ if (!musb->gadget_driver)
return -EOPNOTSUPP;
- spin_unlock(&musb->Lock);
- retval = musb->pGadgetDriver->setup(&musb->g, pControlRequest);
- spin_lock(&musb->Lock);
+ spin_unlock(&musb->lock);
+ retval = musb->gadget_driver->setup(&musb->g, ctrlrequest);
+ spin_lock(&musb->lock);
return retval;
}
/*
* Handle peripheral ep0 interrupt
- * @param pThis this
*
* Context: irq handler; we won't re-enter the driver that way.
*/
-irqreturn_t musb_g_ep0_irq(struct musb *pThis)
+irqreturn_t musb_g_ep0_irq(struct musb *musb)
{
u16 wCsrVal;
- u16 wCount;
- void __iomem *pBase = pThis->pRegs;
- void __iomem *regs = pThis->aLocalEnd[0].regs;
+ u16 len;
+ void __iomem *mbase = musb->mregs;
+ void __iomem *regs = musb->endpoints[0].regs;
irqreturn_t retval = IRQ_NONE;
- MGC_SelectEnd(pBase, 0); /* select ep0 */
+ musb_ep_select(mbase, 0); /* select ep0 */
wCsrVal = musb_readw(regs, MGC_O_HDRC_CSR0);
- wCount = musb_readb(regs, MGC_O_HDRC_COUNT0);
+ len = musb_readb(regs, MGC_O_HDRC_COUNT0);
DBG(4, "csr %04x, count %d, myaddr %d, ep0stage %s\n",
- wCsrVal, wCount,
- musb_readb(pBase, MGC_O_HDRC_FADDR),
- decode_ep0stage(pThis->ep0_state));
+ wCsrVal, len,
+ musb_readb(mbase, MGC_O_HDRC_FADDR),
+ decode_ep0stage(musb->ep0_state));
/* I sent a stall.. need to acknowledge it now.. */
if (wCsrVal & MGC_M_CSR0_P_SENTSTALL) {
musb_writew(regs, MGC_O_HDRC_CSR0,
wCsrVal & ~MGC_M_CSR0_P_SENTSTALL);
retval = IRQ_HANDLED;
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
wCsrVal = musb_readw(regs, MGC_O_HDRC_CSR0);
}
if (wCsrVal & MGC_M_CSR0_P_SETUPEND) {
musb_writew(regs, MGC_O_HDRC_CSR0, MGC_M_CSR0_P_SVDSETUPEND);
retval = IRQ_HANDLED;
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
wCsrVal = musb_readw(regs, MGC_O_HDRC_CSR0);
/* NOTE: request may need completion */
}
* we need to handle nuances around status stages, and also the
* case where status and setup stages come back-to-back ...
*/
- switch (pThis->ep0_state) {
+ switch (musb->ep0_state) {
case MGC_END0_STAGE_TX:
/* irq on clearing txpktrdy */
if ((wCsrVal & MGC_M_CSR0_TXPKTRDY) == 0) {
- ep0_txstate(pThis);
+ ep0_txstate(musb);
retval = IRQ_HANDLED;
}
break;
case MGC_END0_STAGE_RX:
/* irq on set rxpktrdy */
if (wCsrVal & MGC_M_CSR0_RXPKTRDY) {
- ep0_rxstate(pThis);
+ ep0_rxstate(musb);
retval = IRQ_HANDLED;
}
break;
* we get 10 msec to receive this irq... until this
* is done we won't see the next packet.
*/
- if (pThis->bSetAddress) {
- pThis->bSetAddress = FALSE;
- musb_writeb(pBase, MGC_O_HDRC_FADDR, pThis->bAddress);
+ if (musb->set_address) {
+ musb->set_address = FALSE;
+ musb_writeb(mbase, MGC_O_HDRC_FADDR, musb->address);
}
/* enter test mode if needed (exit by reset) */
- else if (pThis->bTestMode) {
+ else if (musb->test_mode) {
DBG(1, "entering TESTMODE\n");
- if (MGC_M_TEST_PACKET == pThis->bTestModeValue)
- musb_load_testpacket(pThis);
+ if (MGC_M_TEST_PACKET == musb->test_mode_nr)
+ musb_load_testpacket(musb);
- musb_writeb(pBase, MGC_O_HDRC_TESTMODE,
- pThis->bTestModeValue);
+ musb_writeb(mbase, MGC_O_HDRC_TESTMODE,
+ musb->test_mode_nr);
}
/* FALLTHROUGH */
{
struct usb_request *req;
- req = next_ep0_request(pThis);
+ req = next_ep0_request(musb);
if (req)
- musb_g_ep0_giveback(pThis, req);
+ musb_g_ep0_giveback(musb, req);
}
retval = IRQ_HANDLED;
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
/* FALLTHROUGH */
case MGC_END0_STAGE_SETUP:
struct usb_ctrlrequest setup;
int handled = 0;
- if (wCount != 8) {
- ERR("SETUP packet len %d != 8 ?\n", wCount);
+ if (len != 8) {
+ ERR("SETUP packet len %d != 8 ?\n", len);
break;
}
- musb_read_setup(pThis, &setup);
+ musb_read_setup(musb, &setup);
retval = IRQ_HANDLED;
/* sometimes the RESET won't be reported */
- if (unlikely(pThis->g.speed == USB_SPEED_UNKNOWN)) {
+ if (unlikely(musb->g.speed == USB_SPEED_UNKNOWN)) {
u8 power;
printk(KERN_NOTICE "%s: peripheral reset "
"irq lost!\n",
musb_driver_name);
- power = musb_readb(pBase, MGC_O_HDRC_POWER);
- pThis->g.speed = (power & MGC_M_POWER_HSMODE)
+ power = musb_readb(mbase, MGC_O_HDRC_POWER);
+ musb->g.speed = (power & MGC_M_POWER_HSMODE)
? USB_SPEED_HIGH : USB_SPEED_FULL;
}
- switch (pThis->ep0_state) {
+ switch (musb->ep0_state) {
/* sequence #3 (no data stage), includes requests
* we can't forward (notably SET_ADDRESS and the
*/
case MGC_END0_STAGE_ACKWAIT:
handled = service_zero_data_request(
- pThis, &setup);
+ musb, &setup);
/* status stage might be immediate */
if (handled > 0) {
- pThis->ackpend |= MGC_M_CSR0_P_DATAEND;
- pThis->ep0_state =
+ musb->ackpend |= MGC_M_CSR0_P_DATAEND;
+ musb->ep0_state =
MGC_END0_STAGE_STATUSIN;
}
break;
* and others that we must
*/
case MGC_END0_STAGE_TX:
- handled = service_in_request(pThis, &setup);
+ handled = service_in_request(musb, &setup);
if (handled > 0) {
- pThis->ackpend = MGC_M_CSR0_TXPKTRDY
+ musb->ackpend = MGC_M_CSR0_TXPKTRDY
| MGC_M_CSR0_P_DATAEND;
- pThis->ep0_state =
+ musb->ep0_state =
MGC_END0_STAGE_STATUSOUT;
}
break;
DBG(3, "handled %d, csr %04x, ep0stage %s\n",
handled, wCsrVal,
- decode_ep0stage(pThis->ep0_state));
+ decode_ep0stage(musb->ep0_state));
/* unless we need to delegate this to the gadget
* driver, we know how to wrap this up: csr0 has
else if (handled > 0)
goto finish;
- handled = forward_to_driver(pThis, &setup);
+ handled = forward_to_driver(musb, &setup);
if (handled < 0) {
- MGC_SelectEnd(pBase, 0);
+ musb_ep_select(mbase, 0);
stall:
DBG(3, "stall (%d)\n", handled);
- pThis->ackpend |= MGC_M_CSR0_P_SENDSTALL;
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
+ musb->ackpend |= MGC_M_CSR0_P_SENDSTALL;
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
finish:
musb_writew(regs, MGC_O_HDRC_CSR0,
- pThis->ackpend);
- pThis->ackpend = 0;
+ musb->ackpend);
+ musb->ackpend = 0;
}
}
break;
/* "can't happen" */
WARN_ON(1);
musb_writew(regs, MGC_O_HDRC_CSR0, MGC_M_CSR0_P_SENDSTALL);
- pThis->ep0_state = MGC_END0_STAGE_SETUP;
+ musb->ep0_state = MGC_END0_STAGE_SETUP;
break;
}
return -EINVAL;
}
-static void *musb_g_ep0_alloc_buffer(struct usb_ep *ep, unsigned bytes,
- dma_addr_t * dma, gfp_t gfp_flags)
-{
- *dma = DMA_ADDR_INVALID;
- return kmalloc(bytes, gfp_flags);
-}
-
-static void musb_g_ep0_free_buffer(struct usb_ep *ep, void *address,
- dma_addr_t dma, unsigned bytes)
-{
- kfree(address);
-}
-
static int
musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
{
return -EINVAL;
ep = to_musb_ep(e);
- musb = ep->pThis;
+ musb = ep->musb;
regs = musb->control_ep->regs;
req = to_musb_request(r);
req->request.status = -EINPROGRESS;
req->bTx = ep->is_in;
- spin_lock_irqsave(&musb->Lock, lockflags);
+ spin_lock_irqsave(&musb->lock, lockflags);
if (!list_empty(&ep->req_list)) {
status = -EBUSY;
ep->name, ep->is_in ? "IN/TX" : "OUT/RX",
req->request.length);
- MGC_SelectEnd(musb->pRegs, 0);
+ musb_ep_select(musb->mregs, 0);
/* sequence #1, IN ... start writing the data */
if (musb->ep0_state == MGC_END0_STAGE_TX)
musb_writew(regs, MGC_O_HDRC_CSR0,
musb->ackpend | MGC_M_CSR0_P_DATAEND);
musb->ackpend = 0;
- musb_g_ep0_giveback(ep->pThis, r);
+ musb_g_ep0_giveback(ep->musb, r);
}
/* else for sequence #2 (OUT), caller provides a buffer
}
cleanup:
- spin_unlock_irqrestore(&musb->Lock, lockflags);
+ spin_unlock_irqrestore(&musb->lock, lockflags);
return status;
}
return -EINVAL;
ep = to_musb_ep(e);
- musb = ep->pThis;
- base = musb->pRegs;
+ musb = ep->musb;
+ base = musb->mregs;
regs = musb->control_ep->regs;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (!list_empty(&ep->req_list)) {
status = -EBUSY;
case MGC_END0_STAGE_RX: /* control-OUT data */
status = 0;
- MGC_SelectEnd(base, 0);
+ musb_ep_select(base, 0);
csr = musb_readw(regs, MGC_O_HDRC_CSR0);
csr |= MGC_M_CSR0_P_SENDSTALL;
musb_writew(regs, MGC_O_HDRC_CSR0, csr);
}
cleanup:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
.disable = musb_g_ep0_disable,
.alloc_request = musb_alloc_request,
.free_request = musb_free_request,
- .alloc_buffer = musb_g_ep0_alloc_buffer,
- .free_buffer = musb_g_ep0_free_buffer,
.queue = musb_g_ep0_queue,
.dequeue = musb_g_ep0_dequeue,
.set_halt = musb_g_ep0_halt,
projects / linux-2.6-omap-h63xx.git / blobdiff