Skip to content

Commit

Permalink
cleanup #2
Browse files Browse the repository at this point in the history
  • Loading branch information
@Quarx2k
Quarx2k committed Feb 10, 2013
1 parent b9a32ab commit 049c34e
Show file tree
Hide file tree
Showing 4 changed files with 26 additions and 193 deletions.
154 changes: 25 additions & 129 deletions drivers/usb/musb/musb_gadget.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,7 +47,7 @@

#include "musb_core.h"

static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver);

/* MUSB PERIPHERAL status 3-mar-2006:
*
* - EP0 seems solid. It passes both USBCV and usbtest control cases.
Expand Down Expand Up @@ -765,6 +765,26 @@ static void rxstate(struct musb *musb, struct musb_request *req)

if (use_dma)
return;
else {
if (req->mapped) {
/* Unmap the buffer to use PIO*/
dma_unmap_single(musb->controller,
req->request.dma,
req->request.length,
req->tx
? DMA_TO_DEVICE
: DMA_FROM_DEVICE);

req->request.dma = DMA_ADDR_INVALID;
req->mapped = 0;
}

/* Need to clear DMAENAB for the
* backup PIO mode transfer to work
*/
csr &= ~MUSB_RXCSR_DMAENAB;
musb_writew(epio, MUSB_RXCSR, csr);
}
}
#elif defined(CONFIG_USB_UX500_DMA)
if ((is_buffer_mapped(req)) &&
Expand Down Expand Up @@ -1659,7 +1679,7 @@ musb_gadget_set_self_powered(struct usb_gadget *gadget, int is_selfpowered)
return 0;
}

void musb_pullup(struct musb *musb, int is_on)
static void musb_pullup(struct musb *musb, int is_on)
{
u8 power;

Expand Down Expand Up @@ -1712,55 +1732,24 @@ int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
* not pullup unless the B-session is active.
*/
spin_lock_irqsave(&musb->lock, flags);
#if defined(CONFIG_USB_MOT_ANDROID) && defined(CONFIG_USB_MUSB_OTG)
if (is_host_active(musb)) {
pr_info("musb is on dock, delay pull up\n");
spin_unlock_irqrestore(&musb->lock, flags);
pm_runtime_put(musb->controller);
return 0;
if (is_on != musb->softconnect) {
musb->softconnect = is_on;
musb_pullup(musb, is_on);
}
#endif
if (is_on) {
if (!musb->softconnect) {
musb_start(musb);
musb->softconnect = 1;
musb_pullup(musb, is_on);
}
} else
stop_activity(musb, musb->gadget_driver);

spin_unlock_irqrestore(&musb->lock, flags);

pm_runtime_put(musb->controller);

return 0;
}

static int musb_gadget_runtime_get(struct usb_gadget *gadget)
{
struct musb *musb = gadget_to_musb(gadget);

pm_runtime_get_sync(musb->controller);
return 0;
}

static int musb_gadget_runtime_put(struct usb_gadget *gadget)
{
struct musb *musb = gadget_to_musb(gadget);

pm_runtime_put(musb->controller);
return 0;
}

static const struct usb_gadget_ops musb_gadget_operations = {
.get_frame = musb_gadget_get_frame,
.wakeup = musb_gadget_wakeup,
.set_selfpowered = musb_gadget_set_self_powered,
/* .vbus_session = musb_gadget_vbus_session, */
.vbus_draw = musb_gadget_vbus_draw,
.pullup = musb_gadget_pullup,
.runtime_get = musb_gadget_runtime_get,
.runtime_put = musb_gadget_runtime_put,
};

/* ----------------------------------------------------------------------- */
Expand Down Expand Up @@ -1898,99 +1887,6 @@ void musb_gadget_cleanup(struct musb *musb)
the_gadget = NULL;
}

int usb_gadget_register_driver(struct usb_gadget_driver *driver)
{
int retval;
unsigned long flags;
struct musb *musb = the_gadget;

if (!driver
|| driver->speed != USB_SPEED_HIGH
|| !driver->bind
|| !driver->setup){
return -EINVAL;
}
/* driver must be initialized to support peripheral mode */
if (!musb) {
dev_dbg((struct device *)1, "%s, no dev??\n", __func__);
return -ENODEV;
}

dev_dbg((struct device *)3,
"registering driver %s\n", driver->function);
spin_lock_irqsave(&musb->lock, flags);

if (musb->gadget_driver) {
dev_dbg((struct device *)1, "%s is already bound to %s\n",
musb_driver_name,
musb->gadget_driver->driver.name);
retval = -EBUSY;
} else {
musb->gadget_driver = driver;
musb->g.dev.driver = &driver->driver;
driver->driver.bus = NULL;
musb->softconnect = 0;
retval = 0;
}

spin_unlock_irqrestore(&musb->lock, flags);

if (retval == 0) {
retval = driver->bind(&musb->g);
if (retval != 0) {
dev_dbg((struct device *)3, "bind to driver %s failed --> %d\n",
driver->driver.name, retval);
musb->gadget_driver = NULL;
musb->g.dev.driver = NULL;
}

spin_lock_irqsave(&musb->lock, flags);

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
* allowed hold the peripheral inactive until for example
* userspace hooks up printer hardware or DSP codecs, so
* hosts only see fully functional devices.
*/

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)) {
struct usb_hcd *hcd = musb_to_hcd(musb);

dev_dbg((struct device *)3, "OTG startup...\n");

/* REVISIT: funcall to other code, which also
* handles power budgeting ... this way also
* ensures HdrcStart is indirectly called.
*/
retval = usb_add_hcd(musb_to_hcd(musb), -1, 0);
if (retval < 0) {
dev_dbg((struct device *)1,
"add_hcd failed, %d\n", retval);
spin_lock_irqsave(&musb->lock, flags);
otg_set_peripheral(musb->xceiv, NULL);
musb->gadget_driver = NULL;
musb->g.dev.driver = NULL;
spin_unlock_irqrestore(&musb->lock, flags);
} else {
hcd->self.uses_pio_for_control = 1;
}
}
}

return retval;
}
EXPORT_SYMBOL(usb_gadget_register_driver);

/*
* Register the gadget driver. Used by gadget drivers when
* registering themselves with the controller.
Expand Down
33 changes: 1 addition & 32 deletions drivers/usb/musb/omap2430.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@
#include "omap2430.h"

#define DEBUG
#define MUSB_WORKQUEUE
#undef MUSB_WORKQUEUE

static DEFINE_MUTEX(mpu_lat_mutex);
struct omap2430_glue {
Expand Down Expand Up @@ -265,61 +265,41 @@ void cpcap_musb_notifier_call(unsigned long event)
DBG(1, "VBUS Connect\n");
DBG(1, "MUSB - Hold L3 Bus and C State Constraint \n");
pm_runtime_get_sync(musb->controller);
printk("a\n");
/* Hold a c-state constraint */
printk("b\n");
mutex_lock(&mpu_lat_mutex);
printk("c\n");
pdata->musb_qos_request = kmalloc(sizeof(struct pm_qos_request_list), GFP_ATOMIC);
printk("d\n");
memset(pdata->musb_qos_request, 0, sizeof(struct pm_qos_request_list));
printk("e\n");
pm_qos_add_request(pdata->musb_qos_request, PM_QOS_CPU_DMA_LATENCY, 10);
printk("f\n");
mutex_unlock(&mpu_lat_mutex);
printk("g\n");
/* Hold a L3 constraint for better throughput */
if (pdata->set_min_bus_tput) {
printk("h\n");
pdata->set_min_bus_tput(musb->controller,
OCP_INITIATOR_AGENT, (200*1000*4));
}
printk("i\n");

/* configure musb into smartidle with wakeup enabled
* smart standby mode.
*/

printk("j\n");
musb_writel(musb->mregs, OTG_FORCESTDBY, 0);
printk("k\n");
val = musb_readl(musb->mregs, OTG_SYSCONFIG);
printk("l\n");
if (cpu_is_omap44xx())
val |= SMARTIDLEWKUP | SMARTSTDBY | ENABLEWAKEUP;
else
val |= SMARTIDLE | SMARTSTDBY | ENABLEWAKEUP;
musb_writel(musb->mregs, OTG_SYSCONFIG, val);
printk("m\n");

if (data->interface_type == MUSB_INTERFACE_UTMI) {
printk("n\n");
//phy_init();
printk("o\n");
otg_init(musb->xceiv);
printk("p\n");
if (!hostmode) {
/* Enable VBUS Valid, AValid. Clear SESSEND.*/
printk("q\n");
// __raw_writel(IDDIG | AVALID | VBUSVALID, ctrl_base + USBOTGHS_CONTROL);
printk("r\n");
}
}
printk("s\n");
musb->xceiv->last_event = USB_EVENT_VBUS;
printk("t\n");
musb->xceiv->state = OTG_STATE_B_IDLE;
printk("u\n");
break;

case USB_EVENT_NONE:
Expand All @@ -332,34 +312,25 @@ void cpcap_musb_notifier_call(unsigned long event)
* not enabled then DISCONNECT interrupt will not be
* reached to mentor
*/
printk("a");
otg_set_clk(musb->xceiv, 1);
__raw_writel(SESSEND | IDDIG, ctrl_base +
USBOTGHS_CONTROL);
printk("b");
if (musb->xceiv->set_vbus) {
printk("c");
otg_set_vbus(musb->xceiv, 0);
}
printk("d");
otg_shutdown(musb->xceiv);
printk("e");
//phy_shutdown();
printk("f");
}
/* configure in force idle/ standby */
printk("g");
musb_writel(musb->mregs, OTG_FORCESTDBY, 1);
val = musb_readl(musb->mregs, OTG_SYSCONFIG);
val &= ~(SMARTIDLEWKUP | SMARTSTDBY | ENABLEWAKEUP);
val |= FORCEIDLE | FORCESTDBY;
printk("h");
musb_writel(musb->mregs, OTG_SYSCONFIG, val);

DBG(1, "MUSB - Release L3 Bus and C State Constraint \n");
/* Release c-state constraint */
mutex_lock(&mpu_lat_mutex);
printk("i");
pm_qos_remove_request(pdata->musb_qos_request);
kfree(pdata->musb_qos_request);
mutex_unlock(&mpu_lat_mutex);
Expand All @@ -369,11 +340,9 @@ printk("b");
OCP_INITIATOR_AGENT, -1);

if (data->interface_type == MUSB_INTERFACE_UTMI) {
printk("j");
val = __raw_readl(phymux_base +
USBA0_OTG_CE_PAD1_USBA0_OTG_DP);

printk("k");
val &= ~DP_WAKEUPENABLE;
__raw_writel(val, phymux_base +
USBA0_OTG_CE_PAD1_USBA0_OTG_DP);
Expand Down
29 changes: 0 additions & 29 deletions include/linux/usb/gadget.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -430,8 +430,6 @@ struct usb_gadget_ops {
int (*pullup) (struct usb_gadget *, int is_on);
int (*ioctl)(struct usb_gadget *,
unsigned code, unsigned long param);
int (*runtime_get)(struct usb_gadget *);
int (*runtime_put)(struct usb_gadget *);
};

/**
Expand Down Expand Up @@ -700,19 +698,6 @@ static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
return gadget->ops->pullup(gadget, 0);
}

static inline int usb_gadget_runtime_get(struct usb_gadget *gadget)
{
if (!gadget->ops->runtime_get)
return -EOPNOTSUPP;
return gadget->ops->runtime_get(gadget);
}

static inline int usb_gadget_runtime_put(struct usb_gadget *gadget)
{
if (!gadget->ops->runtime_put)
return -EOPNOTSUPP;
return gadget->ops->runtime_put(gadget);
}

/*-------------------------------------------------------------------------*/

Expand Down Expand Up @@ -784,7 +769,6 @@ static inline int usb_gadget_runtime_put(struct usb_gadget *gadget)
struct usb_gadget_driver {
char *function;
enum usb_device_speed speed;
int (*bind)(struct usb_gadget *);
void (*unbind)(struct usb_gadget *);
int (*setup)(struct usb_gadget *,
const struct usb_ctrlrequest *);
Expand Down Expand Up @@ -822,19 +806,6 @@ struct usb_gadget_driver {
int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *));

/**
* usb_gadget_register_driver - register a gadget driver
* @driver:the driver being registered
* Context: can sleep
*
* Call this in your gadget driver's module initialization function,
* to tell the underlying usb controller driver about your driver.
* The driver's bind() function will be called to bind it to a
* gadget before this registration call returns. It's expected that
* the bind() functions will be in init sections.
*/
int usb_gadget_register_driver(struct usb_gadget_driver *driver);

/**
* usb_gadget_unregister_driver - unregister a gadget driver
* @driver:the driver being unregistered
Expand Down
3 changes: 0 additions & 3 deletions include/linux/usb/quirks.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,4 @@
/* device does not support reset-resume */
#define USB_QUIRK_NO_RESET_RESUME 0x00000080

/* device needs multiple reset-resumes */
#define USB_QUIRK_RETRY_RESET_RESUME 0x00000100

#endif /* __LINUX_USB_QUIRKS_H */

0 comments on commit 049c34e

Please sign in to comment.