Skip to content

Commit

Permalink
usb: musb: convert musb to new style bind
Browse files Browse the repository at this point in the history 
udc-core checks for valid callbacks so there is no need for the driver
to do so. Also "can-be-bound-once" is verified by udc-core. The pull-up
callback is called by udc-core afterwords.

[ balbi@ti.com : keep holding gadget_driver pointer for now
		 remove the stupid check for gadget_driver otherwise
		  we don't handle IRQs ]

Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  • Loading branch information
Sebastian Andrzej Siewior authored and Greg Kroah-Hartman committed Jul 1, 2011
1 parent 352c2dc commit e71eb39
Show file tree
Hide file tree
Showing 2 changed files with 17 additions and 81 deletions.
7 changes: 0 additions & 7 deletions drivers/usb/musb/musb_core.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -899,7 +899,6 @@ void musb_start(struct musb *musb)

/* put into basic highspeed mode and start session */
musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
| MUSB_POWER_SOFTCONN
| MUSB_POWER_HSENAB
/* ENSUSPEND wedges tusb */
/* | MUSB_POWER_ENSUSPEND */
Expand Down Expand Up @@ -1526,12 +1525,6 @@ irqreturn_t musb_interrupt(struct musb *musb)
(devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
musb->int_usb, musb->int_tx, musb->int_rx);

if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
if (!musb->gadget_driver) {
dev_dbg(musb->controller, "No gadget driver loaded\n");
return IRQ_HANDLED;
}

/* the core can interrupt us for multiple reasons; docs have
* a generic interrupt flowchart to follow
*/
Expand Down
91 changes: 17 additions & 74 deletions drivers/usb/musb/musb_gadget.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1657,8 +1657,8 @@ static void musb_pullup(struct musb *musb, int is_on)

/* FIXME if on, HdrcStart; if off, HdrcStop */

dev_dbg(musb->controller, "gadget %s D+ pullup %s\n",
musb->gadget_driver->function, is_on ? "on" : "off");
dev_dbg(musb->controller, "gadget D+ pullup %s\n",
is_on ? "on" : "off");
musb_writeb(musb->mregs, MUSB_POWER, power);
}

Expand Down Expand Up @@ -1704,9 +1704,10 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
return 0;
}

static int musb_gadget_start(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *));
static int musb_gadget_stop(struct usb_gadget_driver *driver);
static int musb_gadget_start(struct usb_gadget *g,
struct usb_gadget_driver *driver);
static int musb_gadget_stop(struct usb_gadget *g,
struct usb_gadget_driver *driver);

static const struct usb_gadget_ops musb_gadget_operations = {
.get_frame = musb_gadget_get_frame,
Expand All @@ -1715,8 +1716,8 @@ static const struct usb_gadget_ops musb_gadget_operations = {
/* .vbus_session = musb_gadget_vbus_session, */
.vbus_draw = musb_gadget_vbus_draw,
.pullup = musb_gadget_pullup,
.start = musb_gadget_start,
.stop = musb_gadget_stop,
.udc_start = musb_gadget_start,
.udc_stop = musb_gadget_stop,
};

/* ----------------------------------------------------------------------- */
Expand All @@ -1727,7 +1728,6 @@ static const struct usb_gadget_ops musb_gadget_operations = {
* about there being only one external upstream port. It assumes
* all peripheral ports are external...
*/
static struct musb *the_gadget;

static void musb_gadget_release(struct device *dev)
{
Expand Down Expand Up @@ -1814,9 +1814,6 @@ int __init musb_gadget_setup(struct musb *musb)
* musb peripherals at the same time, only the bus lock
* is probably held.
*/
if (the_gadget)
return -EBUSY;
the_gadget = musb;

musb->g.ops = &musb_gadget_operations;
musb->g.is_dualspeed = 1;
Expand All @@ -1840,7 +1837,6 @@ int __init musb_gadget_setup(struct musb *musb)
status = device_register(&musb->g.dev);
if (status != 0) {
put_device(&musb->g.dev);
the_gadget = NULL;
return status;
}
status = usb_add_gadget_udc(musb->controller, &musb->g);
Expand All @@ -1850,18 +1846,13 @@ int __init musb_gadget_setup(struct musb *musb)
return 0;
err:
device_unregister(&musb->g.dev);
the_gadget = NULL;
return status;
}

void musb_gadget_cleanup(struct musb *musb)
{
if (musb != the_gadget)
return;

usb_del_gadget_udc(&musb->g);
device_unregister(&musb->g.dev);
the_gadget = NULL;
}

/*
Expand All @@ -1873,59 +1864,30 @@ void musb_gadget_cleanup(struct musb *musb)
* -ENOMEM no memory to perform the operation
*
* @param driver the gadget driver
* @param bind the driver's bind function
* @return <0 if error, 0 if everything is fine
*/
static int musb_gadget_start(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *))
static int musb_gadget_start(struct usb_gadget *g,
struct usb_gadget_driver *driver)
{
struct musb *musb = the_gadget;
struct musb *musb = gadget_to_musb(g);
unsigned long flags;
int retval = -EINVAL;

if (!driver
|| driver->speed != USB_SPEED_HIGH
|| !bind || !driver->setup)
if (driver->speed != USB_SPEED_HIGH)
goto err0;

/* driver must be initialized to support peripheral mode */
if (!musb) {
dev_dbg(musb->controller, "no dev??\n");
retval = -ENODEV;
goto err0;
}

pm_runtime_get_sync(musb->controller);

dev_dbg(musb->controller, "registering driver %s\n", driver->function);

if (musb->gadget_driver) {
dev_dbg(musb->controller, "%s is already bound to %s\n",
musb_driver_name,
musb->gadget_driver->driver.name);
retval = -EBUSY;
goto err0;
}

spin_lock_irqsave(&musb->lock, flags);
musb->softconnect = 0;
musb->gadget_driver = driver;
musb->g.dev.driver = &driver->driver;
driver->driver.bus = NULL;
musb->softconnect = 1;
spin_unlock_irqrestore(&musb->lock, flags);

retval = bind(&musb->g);
if (retval) {
dev_dbg(musb->controller, "bind to driver %s failed --> %d\n",
driver->driver.name, retval);
goto err1;
}

spin_lock_irqsave(&musb->lock, flags);
musb->is_active = 1;

otg_set_peripheral(musb->xceiv, &musb->g);
musb->xceiv->state = OTG_STATE_B_IDLE;
musb->is_active = 1;

/*
* FIXME this ignores the softconnect flag. Drivers are
Expand All @@ -1937,8 +1899,6 @@ static int musb_gadget_start(struct usb_gadget_driver *driver,
if (!is_otg_enabled(musb))
musb_start(musb);

otg_set_peripheral(musb->xceiv, &musb->g);

spin_unlock_irqrestore(&musb->lock, flags);

if (is_otg_enabled(musb)) {
Expand Down Expand Up @@ -1970,11 +1930,6 @@ static int musb_gadget_start(struct usb_gadget_driver *driver,
err2:
if (!is_otg_enabled(musb))
musb_stop(musb);

err1:
musb->gadget_driver = NULL;
musb->g.dev.driver = NULL;

err0:
return retval;
}
Expand Down Expand Up @@ -2027,17 +1982,12 @@ static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
*
* @param driver the gadget driver to unregister
*/
static int musb_gadget_stop(struct usb_gadget_driver *driver)
static int musb_gadget_stop(struct usb_gadget *g,
struct usb_gadget_driver *driver)
{
struct musb *musb = the_gadget;
struct musb *musb = gadget_to_musb(g);
unsigned long flags;

if (!driver || !driver->unbind || !musb)
return -EINVAL;

if (!musb->gadget_driver)
return -EINVAL;

if (musb->xceiv->last_event == USB_EVENT_NONE)
pm_runtime_get_sync(musb->controller);

Expand All @@ -2058,13 +2008,6 @@ static int musb_gadget_stop(struct usb_gadget_driver *driver)

dev_dbg(musb->controller, "unregistering driver %s\n", driver->function);

spin_unlock_irqrestore(&musb->lock, flags);
driver->unbind(&musb->g);
spin_lock_irqsave(&musb->lock, flags);

musb->gadget_driver = NULL;
musb->g.dev.driver = NULL;

musb->is_active = 0;
musb_platform_try_idle(musb, 0);
spin_unlock_irqrestore(&musb->lock, flags);
Expand Down

0 comments on commit e71eb39

Please sign in to comment.