/*
* inode.c -- user mode filesystem api for usb gadget controllers
*
- * Copyright (C) 2003 David Brownell
+ * Copyright (C) 2003-2004 David Brownell
* Copyright (C) 2003 Agilent Technologies
*
* This program is free software; you can redistribute it and/or modify
*/
#define DRIVER_DESC "USB Gadget filesystem"
-#define DRIVER_VERSION "18 Nov 2003"
+#define DRIVER_VERSION "24 Aug 2004"
static const char driver_desc [] = DRIVER_DESC;
static const char shortname [] = "gadgetfs";
/*----------------------------------------------------------------------*/
/* most "how to use the hardware" policy choices are in userspace:
- * mapping endpoint roles the driver needs to the capabilities that
- * the usb controller exposes.
+ * mapping endpoint roles (which the driver needs) to the capabilities
+ * which the usb controller has. most of those capabilities are exposed
+ * implicitly, starting with the driver name and then endpoint names.
*/
-#ifdef CONFIG_USB_GADGET_DUMMY_HCD
-/* act (mostly) like a net2280 */
-#define CONFIG_USB_GADGET_NET2280
-#endif
-
-#ifdef CONFIG_USB_GADGET_NET2280
-#define CHIP "net2280"
-#define HIGHSPEED
-#endif
-
-#ifdef CONFIG_USB_GADGET_PXA2XX
-#define CHIP "pxa2xx_udc"
-/* earlier hardware doesn't have UDCCFR, races set_{config,interface} */
-#warning works best with pxa255 or newer
-#endif
-
-#ifdef CONFIG_USB_GADGET_GOKU
-#define CHIP "goku_udc"
-#endif
-
-#ifdef CONFIG_USB_GADGET_OMAP
-#define CHIP "omap_udc"
-#endif
-
-#ifdef CONFIG_USB_GADGET_SA1100
-#define CHIP "sa1100"
-#endif
+static const char *CHIP;
/*----------------------------------------------------------------------*/
static int ep_aio_cancel(struct kiocb *iocb, struct io_event *e)
{
- struct kiocb_priv *priv = (void *) &iocb->private;
+ struct kiocb_priv *priv = iocb->private;
struct ep_data *epdata;
int value;
return value;
}
-static long ep_aio_read_retry(struct kiocb *iocb)
+static ssize_t ep_aio_read_retry(struct kiocb *iocb)
{
- struct kiocb_priv *priv = (void *) &iocb->private;
- int status = priv->actual;
+ struct kiocb_priv *priv = iocb->private;
+ ssize_t status = priv->actual;
/* we "retry" to get the right mm context for this: */
status = copy_to_user(priv->ubuf, priv->buf, priv->actual);
else
status = priv->actual;
kfree(priv->buf);
+ kfree(priv);
aio_put_req(iocb);
return status;
}
static void ep_aio_complete(struct usb_ep *ep, struct usb_request *req)
{
struct kiocb *iocb = req->context;
- struct kiocb_priv *priv = (void *) &iocb->private;
+ struct kiocb_priv *priv = iocb->private;
struct ep_data *epdata = priv->epdata;
/* lock against disconnect (and ideally, cancel) */
|| unlikely(0 == req->actual)
|| unlikely(kiocbIsCancelled(iocb))) {
kfree(req->buf);
+ kfree(priv);
+ iocb->private = NULL;
/* aio_complete() reports bytes-transferred _and_ faults */
if (unlikely(kiocbIsCancelled(iocb)))
aio_put_req(iocb);
}
static ssize_t
-ep_aio_rwtail(struct kiocb *iocb, char *buf, size_t len, struct ep_data *epdata)
+ep_aio_rwtail(
+ struct kiocb *iocb,
+ char *buf,
+ size_t len,
+ struct ep_data *epdata,
+ char __user *ubuf
+)
{
struct kiocb_priv *priv = (void *) &iocb->private;
struct usb_request *req;
ssize_t value;
- value = get_ready_ep(iocb->ki_filp->f_flags, epdata);
- if (unlikely(value < 0)) {
+ priv = kmalloc(sizeof *priv, GFP_KERNEL);
+ if (!priv) {
+ value = -ENOMEM;
+fail:
kfree(buf);
return value;
}
+ iocb->private = priv;
+ priv->ubuf = ubuf;
+
+ value = get_ready_ep(iocb->ki_filp->f_flags, epdata);
+ if (unlikely(value < 0)) {
+ kfree(priv);
+ goto fail;
+ }
iocb->ki_cancel = ep_aio_cancel;
get_ep(epdata);
up(&epdata->lock);
- if (unlikely(value))
+ if (unlikely(value)) {
+ kfree(priv);
put_ep(epdata);
- else
+ } else
value = -EIOCBQUEUED;
return value;
}
static ssize_t
ep_aio_read(struct kiocb *iocb, char __user *ubuf, size_t len, loff_t o)
{
- struct kiocb_priv *priv = (void *) &iocb->private;
struct ep_data *epdata = iocb->ki_filp->private_data;
char *buf;
if (unlikely(!buf))
return -ENOMEM;
iocb->ki_retry = ep_aio_read_retry;
- priv->ubuf = ubuf;
- return ep_aio_rwtail(iocb, buf, len, epdata);
+ return ep_aio_rwtail(iocb, buf, len, epdata, ubuf);
}
static ssize_t
kfree(buf);
return -EFAULT;
}
- return ep_aio_rwtail(iocb, buf, len, epdata);
+ return ep_aio_rwtail(iocb, buf, len, epdata, NULL);
}
/*----------------------------------------------------------------------*/
/* used after endpoint configuration */
static struct file_operations ep_io_operations = {
.owner = THIS_MODULE,
+ .llseek = no_llseek,
+
.read = ep_read,
.write = ep_write,
.ioctl = ep_ioctl,
/* used before endpoint configuration */
static struct file_operations ep_config_operations = {
.owner = THIS_MODULE,
+ .llseek = no_llseek,
+
.open = ep_open,
.write = ep_config,
.release = ep_release,
retval = usb_ep_queue (ep, req, GFP_ATOMIC);
dev->state = STATE_CONNECTED;
+ /* assume that was SET_CONFIGURATION */
+ if (dev->current_config) {
+ unsigned power;
+#ifdef HIGHSPEED
+ if (dev->gadget->speed == USB_SPEED_HIGH)
+ power = dev->hs_config->bMaxPower;
+ else
+#endif
+ power = dev->config->bMaxPower;
+ usb_gadget_vbus_draw(dev->gadget, 2 * power);
+ }
+
} else { /* collect OUT data */
if ((fd->f_flags & O_NONBLOCK) != 0
&& !dev->setup_out_ready) {
/* used after device configuration */
static struct file_operations ep0_io_operations = {
.owner = THIS_MODULE,
+ .llseek = no_llseek,
+
.read = ep0_read,
.write = ep0_write,
.fasync = ep0_fasync,
if (0 == (u8) ctrl->wValue) {
value = 0;
dev->current_config = 0;
+ usb_gadget_vbus_draw(gadget, 8 /* mA */ );
// user mode expected to disable endpoints
} else {
- u8 config;
+ u8 config, power;
#ifdef HIGHSPEED
- if (gadget->speed == USB_SPEED_HIGH)
+ if (gadget->speed == USB_SPEED_HIGH) {
config = dev->hs_config->bConfigurationValue;
- else
+ power = dev->hs_config->bMaxPower;
+ } else
#endif
+ {
config = dev->config->bConfigurationValue;
+ power = dev->config->bMaxPower;
+ }
if (config == (u8) ctrl->wValue) {
value = 0;
dev->current_config = config;
+ usb_gadget_vbus_draw(gadget, 2 * power);
}
}
if (!dev)
return -ESRCH;
if (0 != strcmp (CHIP, gadget->name)) {
- printk (KERN_ERR "%s expected " CHIP " controller not %s\n",
- shortname, gadget->name);
+ printk (KERN_ERR "%s expected %s controller not %s\n",
+ shortname, CHIP, gadget->name);
return -ENODEV;
}
/*----------------------------------------------------------------------*/
+static void gadgetfs_nop(struct usb_gadget *arg) { }
+
+static int gadgetfs_probe (struct usb_gadget *gadget)
+{
+ CHIP = gadget->name;
+ return -EISNAM;
+}
+
+static struct usb_gadget_driver probe_driver = {
+ .speed = USB_SPEED_HIGH,
+ .bind = gadgetfs_probe,
+ .unbind = gadgetfs_nop,
+ .setup = (void *)gadgetfs_nop,
+ .disconnect = gadgetfs_nop,
+ .driver = {
+ .name = "nop",
+ },
+};
+
+
/* DEVICE INITIALIZATION
*
* fd = open ("/dev/gadget/$CHIP", O_RDWR)
&& config->bConfigurationValue != 0
&& (config->bmAttributes & USB_CONFIG_ATT_ONE) != 0
&& (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0;
+ /* FIXME if gadget->is_otg, _must_ include an otg descriptor */
/* FIXME check lengths: walk to end */
}
static struct file_operations dev_init_operations = {
.owner = THIS_MODULE,
+ .llseek = no_llseek,
+
.open = dev_open,
.write = dev_config,
.fasync = ep0_fasync,
if (the_device)
return -ESRCH;
+ /* fake probe to determine $CHIP */
+ (void) usb_gadget_register_driver (&probe_driver);
+ if (!CHIP)
+ return -ENODEV;
+
/* superblock */
sb->s_blocksize = PAGE_CACHE_SIZE;
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;