devctl = musb_readb(mregs, MGC_O_HDRC_DEVCTL);
DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
switch (musb->xceiv.state) {
case OTG_STATE_A_WAIT_VFALL:
/* Wait till VBUS falls below SessionEnd (~0.2V); the 1.3 RTL
default:
break;
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
static irqreturn_t davinci_interrupt(int irq, void *__hci)
void *__iomem tibase = musb->ctrl_base;
u32 tmp;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
/* NOTE: DaVinci shadows the Mentor IRQs. Don't manage them through
* the Mentor registers (except for setup), use the TI ones and EOI.
&& musb->xceiv.state == OTG_STATE_B_IDLE)
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
/* REVISIT we sometimes get unhandled IRQs
* (e.g. ep0). not clear why...
#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
static int
service_zero_data_request(struct musb *musb,
struct usb_ctrlrequest *pControlRequest)
-__releases(musb->Lock)
-__acquires(musb->Lock)
+__releases(musb->lock)
+__acquires(musb->lock)
{
int handled = -EINVAL;
void __iomem *mbase = musb->mregs;
break;
/* REVISIT do it directly, no locking games */
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
musb_gadget_set_halt(&musb_ep->end_point, 0);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
/* select ep0 again */
MGC_SelectEnd(mbase, 0);
static int
forward_to_driver(struct musb *musb,
const struct usb_ctrlrequest *pControlRequest)
-__releases(musb->Lock)
-__acquires(musb->Lock)
+__releases(musb->lock)
+__acquires(musb->lock)
{
int retval;
if (!musb->pGadgetDriver)
return -EOPNOTSUPP;
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
retval = musb->pGadgetDriver->setup(&musb->g, pControlRequest);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
return retval;
}
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;
}
cleanup:
- spin_unlock_irqrestore(&musb->Lock, lockflags);
+ spin_unlock_irqrestore(&musb->lock, lockflags);
return status;
}
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;
}
cleanup:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
struct musb_ep *ep,
struct usb_request *pRequest,
int status)
-__releases(ep->musb->Lock)
-__acquires(ep->musb->Lock)
+__releases(ep->musb->lock)
+__acquires(ep->musb->lock)
{
struct musb_request *req;
struct musb *musb;
musb = req->musb;
ep->busy = 1;
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
if (is_dma_capable()) {
if (req->mapped) {
dma_unmap_single(musb->controller,
req->request.actual, req->request.length,
pRequest->status);
req->request.complete(&req->ep->end_point, &req->request);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
ep->busy = busy;
}
mbase = musb->mregs;
epnum = musb_ep->current_epnum;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (musb_ep->desc) {
status = -EBUSY;
schedule_work(&musb->irq_work);
fail:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
epnum = musb_ep->current_epnum;
epio = musb->endpoints[epnum].regs;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
MGC_SelectEnd(musb->mregs, epnum);
/* zero the endpoint sizes */
schedule_work(&musb->irq_work);
- spin_unlock_irqrestore(&(musb->Lock), flags);
+ spin_unlock_irqrestore(&(musb->lock), flags);
DBG(2, "%s\n", musb_ep->end_point.name);
} else
pRequest->mapped = 0;
- spin_lock_irqsave(&musb->Lock, lockflags);
+ spin_lock_irqsave(&musb->lock, lockflags);
/* don't queue if the ep is down */
if (!musb_ep->desc) {
musb_ep_restart(musb, pRequest);
cleanup:
- spin_unlock_irqrestore(&musb->Lock, lockflags);
+ spin_unlock_irqrestore(&musb->lock, lockflags);
return status;
}
if (!ep || !pRequest || to_musb_request(pRequest)->ep != musb_ep)
return -EINVAL;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
list_for_each_entry(r, &musb_ep->req_list, list) {
if (r == pRequest)
}
done:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
return -EINVAL;
mbase = musb->mregs;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if ((USB_ENDPOINT_XFER_ISOC == musb_ep->type)) {
status = -EINVAL;
wCsr = musb_readw(epio, MGC_O_HDRC_TXCSR);
if (wCsr & MGC_M_TXCSR_FIFONOTEMPTY) {
DBG(3, "%s fifo busy, cannot halt\n", ep->name);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return -EAGAIN;
}
musb_ep_restart(musb, pRequest);
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
void __iomem *mbase = musb->mregs;
unsigned long flags;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
MGC_SelectEnd(mbase, epnum);
/* FIXME return zero unless RXPKTRDY is set */
retval = musb_readw(epio, MGC_O_HDRC_RXCOUNT);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
return retval;
}
mbase = musb->mregs;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
MGC_SelectEnd(mbase, (u8) nEnd);
/* disable interrupts */
/* re-enable interrupt */
musb_writew(mbase, MGC_O_HDRC_INTRTXE, wIntrTxE);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
static const struct usb_ep_ops musb_ep_ops = {
u8 power, devctl;
int retries;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
switch (musb->xceiv.state) {
case OTG_STATE_B_PERIPHERAL:
power &= ~MGC_M_POWER_RESUME;
musb_writeb(mregs, MGC_O_HDRC_POWER, power);
done:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
/* NOTE: this assumes we are sensing vbus; we'd rather
* not pullup unless the B-session is active.
*/
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (is_on != musb->softconnect) {
musb->softconnect = is_on;
musb_pullup(musb, is_on);
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return 0;
}
}
DBG(3, "registering driver %s\n", driver->function);
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (musb->pGadgetDriver) {
DBG(1, "%s is already bound to %s\n",
retval = 0;
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
if (retval == 0)
retval = driver->bind(&musb->g);
/* start peripheral and/or OTG engines */
if (retval == 0) {
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
/* REVISIT always use otg_set_peripheral(), handling
* issues including the root hub one below ...
if (!is_otg_enabled(musb))
musb_start(musb);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
if (is_otg_enabled(musb)) {
DBG(3, "OTG startup...\n");
retval = usb_add_hcd(musb_to_hcd(musb), -1, 0);
if (retval < 0) {
DBG(1, "add_hcd failed, %d\n", retval);
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
musb->xceiv.gadget = NULL;
musb->xceiv.state = OTG_STATE_UNDEFINED;
musb->pGadgetDriver = NULL;
musb->g.dev.driver = NULL;
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
}
}
}
}
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
driver->disconnect (&musb->g);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
}
}
* this needs to shut down the OTG engine.
*/
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
#ifdef CONFIG_USB_MUSB_OTG
musb_hnp_stop(musb);
stop_activity(musb, driver);
DBG(3, "unregistering driver %s\n", driver->function);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
driver->unbind(&musb->g);
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
musb->pGadgetDriver = NULL;
musb->g.dev.driver = NULL;
musb_platform_try_idle(musb, 0);
} else
retval = -EINVAL;
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
if (is_otg_enabled(musb) && retval == 0) {
usb_remove_hcd(musb_to_hcd(musb));
case OTG_STATE_B_PERIPHERAL:
musb->is_active = 1;
if (musb->pGadgetDriver && musb->pGadgetDriver->resume) {
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
musb->pGadgetDriver->resume(&musb->g);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
}
break;
default:
case OTG_STATE_B_PERIPHERAL:
musb->is_suspended = 1;
if (musb->pGadgetDriver && musb->pGadgetDriver->suspend) {
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
musb->pGadgetDriver->suspend(&musb->g);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
}
break;
default:
musb->g.speed = USB_SPEED_UNKNOWN;
if (musb->pGadgetDriver && musb->pGadgetDriver->disconnect) {
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
musb->pGadgetDriver->disconnect(&musb->g);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
}
switch (musb->xceiv.state) {
}
void musb_g_reset(struct musb *musb)
-__releases(musb->Lock)
-__acquires(musb->Lock)
+__releases(musb->lock)
+__acquires(musb->lock)
{
void __iomem *mbase = musb->mregs;
u8 devctl = musb_readb(mbase, MGC_O_HDRC_DEVCTL);
/* caller owns controller lock, irqs are blocked */
static void
__musb_giveback(struct musb *musb, struct urb *urb, int status)
-__releases(musb->Lock)
-__acquires(musb->Lock)
+__releases(musb->lock)
+__acquires(musb->lock)
{
if ((urb->transfer_flags & URB_SHORT_NOT_OK)
&& (urb->actual_length < urb->transfer_buffer_length)
urb->actual_length, urb->transfer_buffer_length
);
- spin_unlock(&musb->Lock);
+ spin_unlock(&musb->lock);
usb_hcd_giveback_urb(musb_to_hcd(musb), urb);
- spin_lock(&musb->Lock);
+ spin_lock(&musb->lock);
}
/* for bulk/interrupt endpoints only */
* until we get real dma queues (with an entry for each urb/buffer),
* we only have work to do in the former case.
*/
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (hep->hcpriv) {
/* some concurrent activity submitted another urb to hep...
* odd, rare, error prone, but legal.
* musb_start_urb(), but otherwise only konicawc cares ...
*/
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
done:
if (status != 0)
usb_pipeendpoint(urb->pipe),
usb_pipein(urb->pipe) ? "in" : "out");
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
/* make sure the urb is still queued and not completed */
spin_lock(&urb->lock);
} else
status = musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN);
done:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return status;
}
if (!qh)
return;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
switch (qh->type) {
case USB_ENDPOINT_XFER_CONTROL:
list_for_each_entry_safe_from(urb, tmp, &hep->urb_list, urb_list)
musb_giveback(qh, urb, -ESHUTDOWN);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
static int musb_h_get_frame_number(struct usb_hcd *hcd)
if (count <= 0)
return -EINVAL;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
code = dump_header_stats(musb, buffer);
if (code > 0) {
musb_platform_try_idle(musb, 0);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
*eof = 1;
return buffer - page;
* struct musb - Driver instance data.
*/
struct musb {
- spinlock_t Lock;
+ spinlock_t lock;
struct clk *clock;
irqreturn_t (*isr)(int, void *);
struct work_struct irq_work;
struct musb *musb = (struct musb *)data;
unsigned long flags;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (musb->xceiv.state == OTG_STATE_B_WAIT_ACON) {
DBG(1, "HNP: B_WAIT_ACON timeout, going back to B_PERIPHERAL\n");
musb_g_disconnect(musb);
musb->xceiv.state = OTG_STATE_B_PERIPHERAL;
musb->is_active = 0;
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
static DEFINE_TIMER(musb_otg_timer, musb_otg_timer_func, 0, 0);
struct musb *musb = dev_to_musb(&pdev->dev);
unsigned long flags;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
musb_platform_disable(musb);
musb_generic_disable(musb);
if (musb->clock) {
clk_put(musb->clock);
musb->clock = NULL;
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
/* FIXME power down */
}
irqreturn_t retval = IRQ_NONE;
struct musb *musb = __hci;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
musb->int_usb = musb_readb(musb->mregs, MGC_O_HDRC_INTRUSB);
musb->int_tx = musb_readw(musb->mregs, MGC_O_HDRC_INTRTX);
if (musb->int_usb || musb->int_tx || musb->int_rx)
retval = musb_interrupt(musb);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
/* REVISIT we sometimes get spurious IRQs on g_ep0
* not clear why...
unsigned long flags;
int ret = -EINVAL;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
ret = sprintf(buf, "%s\n", otg_state_string(musb));
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return ret;
}
struct musb *musb = dev_to_musb(dev);
unsigned long flags;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (!strncmp(buf, "host", 4))
musb_platform_set_mode(musb, MUSB_HOST);
if (!strncmp(buf, "peripheral", 10))
musb_platform_set_mode(musb, MUSB_PERIPHERAL);
if (!strncmp(buf, "otg", 3))
musb_platform_set_mode(musb, MUSB_OTG);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return n;
}
unsigned long flags;
int vbus;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
#if defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_USB_MUSB_OTG)
/* REVISIT: connect-A != connect-B ... */
vbus = musb_platform_get_vbus_status(musb);
v2 = "disconnected";
#endif
musb_platform_try_idle(musb, 0);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return sprintf(buf, "%s%s\n", v1, v2);
}
unsigned long flags;
unsigned long val;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (sscanf(buf, "%lu", &val) < 1) {
printk(KERN_ERR "Invalid VBUS timeout ms value\n");
return -EINVAL;
if (musb->xceiv.state == OTG_STATE_A_WAIT_BCON)
musb->is_active = 0;
musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val));
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return n;
}
unsigned long flags;
unsigned long val;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
val = musb->a_wait_bcon;
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return sprintf(buf, "%lu\n", val);
}
return -EINVAL;
}
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (srp == 1)
musb_g_wakeup(musb);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return n;
}
if (!musb)
return -ENOMEM;
- spin_lock_init(&musb->Lock);
+ spin_lock_init(&musb->lock);
musb->board_mode = plat->mode;
musb->board_set_power = plat->set_power;
musb->set_clock = plat->set_clock;
if (!musb->clock)
return 0;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (is_peripheral_active(musb)) {
/* FIXME force disconnect unless we know USB will wake
musb->set_clock(musb->clock, 0);
else
clk_disable(musb->clock);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return 0;
}
if (!musb->clock)
return 0;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (musb->set_clock)
musb->set_clock(musb->clock, 1);
* unless for some reason the whole soc powered down and we're
* not treating that as a whole-system restart (e.g. swsusp)
*/
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return 0;
}
struct musb *musb = (void *)_musb;
unsigned long flags;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
switch (musb->xceiv.state) {
case OTG_STATE_A_WAIT_BCON:
tusb_allow_idle(musb, wakeups);
}
done:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
/*
unsigned long flags, idle_timeout = 0;
u32 int_mask, int_src;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
/* Mask all interrupts to allow using both edge and level GPIO irq */
int_mask = musb_readl(base, TUSB_INT_MASK);
musb_platform_try_idle(musb, idle_timeout);
musb_writel(base, TUSB_INT_MASK, int_mask);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return IRQ_HANDLED;
}
return ret;
}
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (musb_readl(base, TUSB_PROD_TEST_RESET) !=
TUSB_PROD_TEST_RESET_VAL) {
reg |= TUSB_PHY_OTG_CTRL_WRPROTECT | TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
musb_writel(base, TUSB_PHY_OTG_CTRL, reg);
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return 0;
err:
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
if (musb->board_set_power)
musb->board_set_power(0);
unsigned long remaining, flags, pio;
int ch;
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
if (dmareq_works())
ch = chdat->ch;
}
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
}
static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
* port features: reported, sometimes updated when host is active
* no indicators
*/
- spin_lock_irqsave(&musb->Lock, flags);
+ spin_lock_irqsave(&musb->lock, flags);
switch (typeReq) {
case ClearHubFeature:
case SetHubFeature:
/* "protocol stall" on error */
retval = -EPIPE;
}
- spin_unlock_irqrestore(&musb->Lock, flags);
+ spin_unlock_irqrestore(&musb->lock, flags);
return retval;
}
git.openpandora.org / pandora-kernel.git / commitdiff