15fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0+
28443f2d2SAndrzej Pietrasiewicz /*
38443f2d2SAndrzej Pietrasiewicz * inode.c -- user mode filesystem api for usb gadget controllers
48443f2d2SAndrzej Pietrasiewicz *
58443f2d2SAndrzej Pietrasiewicz * Copyright (C) 2003-2004 David Brownell
68443f2d2SAndrzej Pietrasiewicz * Copyright (C) 2003 Agilent Technologies
78443f2d2SAndrzej Pietrasiewicz */
88443f2d2SAndrzej Pietrasiewicz
98443f2d2SAndrzej Pietrasiewicz
108443f2d2SAndrzej Pietrasiewicz /* #define VERBOSE_DEBUG */
118443f2d2SAndrzej Pietrasiewicz
128443f2d2SAndrzej Pietrasiewicz #include <linux/init.h>
138443f2d2SAndrzej Pietrasiewicz #include <linux/module.h>
148443f2d2SAndrzej Pietrasiewicz #include <linux/fs.h>
15e5d82a73SDavid Howells #include <linux/fs_context.h>
168443f2d2SAndrzej Pietrasiewicz #include <linux/pagemap.h>
178443f2d2SAndrzej Pietrasiewicz #include <linux/uts.h>
188443f2d2SAndrzej Pietrasiewicz #include <linux/wait.h>
198443f2d2SAndrzej Pietrasiewicz #include <linux/compiler.h>
207c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
218443f2d2SAndrzej Pietrasiewicz #include <linux/sched.h>
228443f2d2SAndrzej Pietrasiewicz #include <linux/slab.h>
238443f2d2SAndrzej Pietrasiewicz #include <linux/poll.h>
249bf5b9ebSChristoph Hellwig #include <linux/kthread.h>
258443f2d2SAndrzej Pietrasiewicz #include <linux/aio.h>
26e2e40f2cSChristoph Hellwig #include <linux/uio.h>
27b7ddc981SElena Reshetova #include <linux/refcount.h>
28520b72fcSAlan Stern #include <linux/delay.h>
298443f2d2SAndrzej Pietrasiewicz #include <linux/device.h>
308443f2d2SAndrzej Pietrasiewicz #include <linux/moduleparam.h>
318443f2d2SAndrzej Pietrasiewicz
328443f2d2SAndrzej Pietrasiewicz #include <linux/usb/gadgetfs.h>
338443f2d2SAndrzej Pietrasiewicz #include <linux/usb/gadget.h>
348443f2d2SAndrzej Pietrasiewicz
358443f2d2SAndrzej Pietrasiewicz
368443f2d2SAndrzej Pietrasiewicz /*
378443f2d2SAndrzej Pietrasiewicz * The gadgetfs API maps each endpoint to a file descriptor so that you
388443f2d2SAndrzej Pietrasiewicz * can use standard synchronous read/write calls for I/O. There's some
398443f2d2SAndrzej Pietrasiewicz * O_NONBLOCK and O_ASYNC/FASYNC style i/o support. Example usermode
408443f2d2SAndrzej Pietrasiewicz * drivers show how this works in practice. You can also use AIO to
418443f2d2SAndrzej Pietrasiewicz * eliminate I/O gaps between requests, to help when streaming data.
428443f2d2SAndrzej Pietrasiewicz *
438443f2d2SAndrzej Pietrasiewicz * Key parts that must be USB-specific are protocols defining how the
448443f2d2SAndrzej Pietrasiewicz * read/write operations relate to the hardware state machines. There
458443f2d2SAndrzej Pietrasiewicz * are two types of files. One type is for the device, implementing ep0.
468443f2d2SAndrzej Pietrasiewicz * The other type is for each IN or OUT endpoint. In both cases, the
478443f2d2SAndrzej Pietrasiewicz * user mode driver must configure the hardware before using it.
488443f2d2SAndrzej Pietrasiewicz *
498443f2d2SAndrzej Pietrasiewicz * - First, dev_config() is called when /dev/gadget/$CHIP is configured
508443f2d2SAndrzej Pietrasiewicz * (by writing configuration and device descriptors). Afterwards it
518443f2d2SAndrzej Pietrasiewicz * may serve as a source of device events, used to handle all control
528443f2d2SAndrzej Pietrasiewicz * requests other than basic enumeration.
538443f2d2SAndrzej Pietrasiewicz *
548443f2d2SAndrzej Pietrasiewicz * - Then, after a SET_CONFIGURATION control request, ep_config() is
558443f2d2SAndrzej Pietrasiewicz * called when each /dev/gadget/ep* file is configured (by writing
568443f2d2SAndrzej Pietrasiewicz * endpoint descriptors). Afterwards these files are used to write()
578443f2d2SAndrzej Pietrasiewicz * IN data or to read() OUT data. To halt the endpoint, a "wrong
588443f2d2SAndrzej Pietrasiewicz * direction" request is issued (like reading an IN endpoint).
598443f2d2SAndrzej Pietrasiewicz *
608443f2d2SAndrzej Pietrasiewicz * Unlike "usbfs" the only ioctl()s are for things that are rare, and maybe
618443f2d2SAndrzej Pietrasiewicz * not possible on all hardware. For example, precise fault handling with
628443f2d2SAndrzej Pietrasiewicz * respect to data left in endpoint fifos after aborted operations; or
638443f2d2SAndrzej Pietrasiewicz * selective clearing of endpoint halts, to implement SET_INTERFACE.
648443f2d2SAndrzej Pietrasiewicz */
658443f2d2SAndrzej Pietrasiewicz
668443f2d2SAndrzej Pietrasiewicz #define DRIVER_DESC "USB Gadget filesystem"
678443f2d2SAndrzej Pietrasiewicz #define DRIVER_VERSION "24 Aug 2004"
688443f2d2SAndrzej Pietrasiewicz
698443f2d2SAndrzej Pietrasiewicz static const char driver_desc [] = DRIVER_DESC;
708443f2d2SAndrzej Pietrasiewicz static const char shortname [] = "gadgetfs";
718443f2d2SAndrzej Pietrasiewicz
728443f2d2SAndrzej Pietrasiewicz MODULE_DESCRIPTION (DRIVER_DESC);
738443f2d2SAndrzej Pietrasiewicz MODULE_AUTHOR ("David Brownell");
748443f2d2SAndrzej Pietrasiewicz MODULE_LICENSE ("GPL");
758443f2d2SAndrzej Pietrasiewicz
76d4461a60SAl Viro static int ep_open(struct inode *, struct file *);
77d4461a60SAl Viro
788443f2d2SAndrzej Pietrasiewicz
798443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
808443f2d2SAndrzej Pietrasiewicz
818443f2d2SAndrzej Pietrasiewicz #define GADGETFS_MAGIC 0xaee71ee7
828443f2d2SAndrzej Pietrasiewicz
838443f2d2SAndrzej Pietrasiewicz /* /dev/gadget/$CHIP represents ep0 and the whole device */
848443f2d2SAndrzej Pietrasiewicz enum ep0_state {
858a1115ffSMasahiro Yamada /* DISABLED is the initial state. */
868443f2d2SAndrzej Pietrasiewicz STATE_DEV_DISABLED = 0,
878443f2d2SAndrzej Pietrasiewicz
888443f2d2SAndrzej Pietrasiewicz /* Only one open() of /dev/gadget/$CHIP; only one file tracks
898443f2d2SAndrzej Pietrasiewicz * ep0/device i/o modes and binding to the controller. Driver
908443f2d2SAndrzej Pietrasiewicz * must always write descriptors to initialize the device, then
918443f2d2SAndrzej Pietrasiewicz * the device becomes UNCONNECTED until enumeration.
928443f2d2SAndrzej Pietrasiewicz */
938443f2d2SAndrzej Pietrasiewicz STATE_DEV_OPENED,
948443f2d2SAndrzej Pietrasiewicz
958443f2d2SAndrzej Pietrasiewicz /* From then on, ep0 fd is in either of two basic modes:
968443f2d2SAndrzej Pietrasiewicz * - (UN)CONNECTED: read usb_gadgetfs_event(s) from it
978443f2d2SAndrzej Pietrasiewicz * - SETUP: read/write will transfer control data and succeed;
988443f2d2SAndrzej Pietrasiewicz * or if "wrong direction", performs protocol stall
998443f2d2SAndrzej Pietrasiewicz */
1008443f2d2SAndrzej Pietrasiewicz STATE_DEV_UNCONNECTED,
1018443f2d2SAndrzej Pietrasiewicz STATE_DEV_CONNECTED,
1028443f2d2SAndrzej Pietrasiewicz STATE_DEV_SETUP,
1038443f2d2SAndrzej Pietrasiewicz
1048443f2d2SAndrzej Pietrasiewicz /* UNBOUND means the driver closed ep0, so the device won't be
1058443f2d2SAndrzej Pietrasiewicz * accessible again (DEV_DISABLED) until all fds are closed.
1068443f2d2SAndrzej Pietrasiewicz */
1078443f2d2SAndrzej Pietrasiewicz STATE_DEV_UNBOUND,
1088443f2d2SAndrzej Pietrasiewicz };
1098443f2d2SAndrzej Pietrasiewicz
1108443f2d2SAndrzej Pietrasiewicz /* enough for the whole queue: most events invalidate others */
1118443f2d2SAndrzej Pietrasiewicz #define N_EVENT 5
1128443f2d2SAndrzej Pietrasiewicz
113153a2d7eSGreg Kroah-Hartman #define RBUF_SIZE 256
114153a2d7eSGreg Kroah-Hartman
1158443f2d2SAndrzej Pietrasiewicz struct dev_data {
1168443f2d2SAndrzej Pietrasiewicz spinlock_t lock;
117b7ddc981SElena Reshetova refcount_t count;
118520b72fcSAlan Stern int udc_usage;
1198443f2d2SAndrzej Pietrasiewicz enum ep0_state state; /* P: lock */
1208443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event event [N_EVENT];
1218443f2d2SAndrzej Pietrasiewicz unsigned ev_next;
1228443f2d2SAndrzej Pietrasiewicz struct fasync_struct *fasync;
1238443f2d2SAndrzej Pietrasiewicz u8 current_config;
1248443f2d2SAndrzej Pietrasiewicz
1258443f2d2SAndrzej Pietrasiewicz /* drivers reading ep0 MUST handle control requests (SETUP)
1268443f2d2SAndrzej Pietrasiewicz * reported that way; else the host will time out.
1278443f2d2SAndrzej Pietrasiewicz */
1288443f2d2SAndrzej Pietrasiewicz unsigned usermode_setup : 1,
1298443f2d2SAndrzej Pietrasiewicz setup_in : 1,
1308443f2d2SAndrzej Pietrasiewicz setup_can_stall : 1,
1318443f2d2SAndrzej Pietrasiewicz setup_out_ready : 1,
1328443f2d2SAndrzej Pietrasiewicz setup_out_error : 1,
1337b0a271dSMarek Szyprowski setup_abort : 1,
1347b0a271dSMarek Szyprowski gadget_registered : 1;
1358443f2d2SAndrzej Pietrasiewicz unsigned setup_wLength;
1368443f2d2SAndrzej Pietrasiewicz
1378443f2d2SAndrzej Pietrasiewicz /* the rest is basically write-once */
1388443f2d2SAndrzej Pietrasiewicz struct usb_config_descriptor *config, *hs_config;
1398443f2d2SAndrzej Pietrasiewicz struct usb_device_descriptor *dev;
1408443f2d2SAndrzej Pietrasiewicz struct usb_request *req;
1418443f2d2SAndrzej Pietrasiewicz struct usb_gadget *gadget;
1428443f2d2SAndrzej Pietrasiewicz struct list_head epfiles;
1438443f2d2SAndrzej Pietrasiewicz void *buf;
1448443f2d2SAndrzej Pietrasiewicz wait_queue_head_t wait;
1458443f2d2SAndrzej Pietrasiewicz struct super_block *sb;
1468443f2d2SAndrzej Pietrasiewicz struct dentry *dentry;
1478443f2d2SAndrzej Pietrasiewicz
1488443f2d2SAndrzej Pietrasiewicz /* except this scratch i/o buffer for ep0 */
149153a2d7eSGreg Kroah-Hartman u8 rbuf[RBUF_SIZE];
1508443f2d2SAndrzej Pietrasiewicz };
1518443f2d2SAndrzej Pietrasiewicz
get_dev(struct dev_data * data)1528443f2d2SAndrzej Pietrasiewicz static inline void get_dev (struct dev_data *data)
1538443f2d2SAndrzej Pietrasiewicz {
154b7ddc981SElena Reshetova refcount_inc (&data->count);
1558443f2d2SAndrzej Pietrasiewicz }
1568443f2d2SAndrzej Pietrasiewicz
put_dev(struct dev_data * data)1578443f2d2SAndrzej Pietrasiewicz static void put_dev (struct dev_data *data)
1588443f2d2SAndrzej Pietrasiewicz {
159b7ddc981SElena Reshetova if (likely (!refcount_dec_and_test (&data->count)))
1608443f2d2SAndrzej Pietrasiewicz return;
1618443f2d2SAndrzej Pietrasiewicz /* needs no more cleanup */
1628443f2d2SAndrzej Pietrasiewicz BUG_ON (waitqueue_active (&data->wait));
1638443f2d2SAndrzej Pietrasiewicz kfree (data);
1648443f2d2SAndrzej Pietrasiewicz }
1658443f2d2SAndrzej Pietrasiewicz
dev_new(void)1668443f2d2SAndrzej Pietrasiewicz static struct dev_data *dev_new (void)
1678443f2d2SAndrzej Pietrasiewicz {
1688443f2d2SAndrzej Pietrasiewicz struct dev_data *dev;
1698443f2d2SAndrzej Pietrasiewicz
1708443f2d2SAndrzej Pietrasiewicz dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1718443f2d2SAndrzej Pietrasiewicz if (!dev)
1728443f2d2SAndrzej Pietrasiewicz return NULL;
1738443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_DISABLED;
174b7ddc981SElena Reshetova refcount_set (&dev->count, 1);
1758443f2d2SAndrzej Pietrasiewicz spin_lock_init (&dev->lock);
1768443f2d2SAndrzej Pietrasiewicz INIT_LIST_HEAD (&dev->epfiles);
1778443f2d2SAndrzej Pietrasiewicz init_waitqueue_head (&dev->wait);
1788443f2d2SAndrzej Pietrasiewicz return dev;
1798443f2d2SAndrzej Pietrasiewicz }
1808443f2d2SAndrzej Pietrasiewicz
1818443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
1828443f2d2SAndrzej Pietrasiewicz
1838443f2d2SAndrzej Pietrasiewicz /* other /dev/gadget/$ENDPOINT files represent endpoints */
1848443f2d2SAndrzej Pietrasiewicz enum ep_state {
1858443f2d2SAndrzej Pietrasiewicz STATE_EP_DISABLED = 0,
1868443f2d2SAndrzej Pietrasiewicz STATE_EP_READY,
1878443f2d2SAndrzej Pietrasiewicz STATE_EP_ENABLED,
1888443f2d2SAndrzej Pietrasiewicz STATE_EP_UNBOUND,
1898443f2d2SAndrzej Pietrasiewicz };
1908443f2d2SAndrzej Pietrasiewicz
1918443f2d2SAndrzej Pietrasiewicz struct ep_data {
1928443f2d2SAndrzej Pietrasiewicz struct mutex lock;
1938443f2d2SAndrzej Pietrasiewicz enum ep_state state;
1948d66db50SElena Reshetova refcount_t count;
1958443f2d2SAndrzej Pietrasiewicz struct dev_data *dev;
1968443f2d2SAndrzej Pietrasiewicz /* must hold dev->lock before accessing ep or req */
1978443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep;
1988443f2d2SAndrzej Pietrasiewicz struct usb_request *req;
1998443f2d2SAndrzej Pietrasiewicz ssize_t status;
2008443f2d2SAndrzej Pietrasiewicz char name [16];
2018443f2d2SAndrzej Pietrasiewicz struct usb_endpoint_descriptor desc, hs_desc;
2028443f2d2SAndrzej Pietrasiewicz struct list_head epfiles;
2038443f2d2SAndrzej Pietrasiewicz wait_queue_head_t wait;
2048443f2d2SAndrzej Pietrasiewicz struct dentry *dentry;
2058443f2d2SAndrzej Pietrasiewicz };
2068443f2d2SAndrzej Pietrasiewicz
get_ep(struct ep_data * data)2078443f2d2SAndrzej Pietrasiewicz static inline void get_ep (struct ep_data *data)
2088443f2d2SAndrzej Pietrasiewicz {
2098d66db50SElena Reshetova refcount_inc (&data->count);
2108443f2d2SAndrzej Pietrasiewicz }
2118443f2d2SAndrzej Pietrasiewicz
put_ep(struct ep_data * data)2128443f2d2SAndrzej Pietrasiewicz static void put_ep (struct ep_data *data)
2138443f2d2SAndrzej Pietrasiewicz {
2148d66db50SElena Reshetova if (likely (!refcount_dec_and_test (&data->count)))
2158443f2d2SAndrzej Pietrasiewicz return;
2168443f2d2SAndrzej Pietrasiewicz put_dev (data->dev);
2178443f2d2SAndrzej Pietrasiewicz /* needs no more cleanup */
2188443f2d2SAndrzej Pietrasiewicz BUG_ON (!list_empty (&data->epfiles));
2198443f2d2SAndrzej Pietrasiewicz BUG_ON (waitqueue_active (&data->wait));
2208443f2d2SAndrzej Pietrasiewicz kfree (data);
2218443f2d2SAndrzej Pietrasiewicz }
2228443f2d2SAndrzej Pietrasiewicz
2238443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
2248443f2d2SAndrzej Pietrasiewicz
2258443f2d2SAndrzej Pietrasiewicz /* most "how to use the hardware" policy choices are in userspace:
2268443f2d2SAndrzej Pietrasiewicz * mapping endpoint roles (which the driver needs) to the capabilities
2278443f2d2SAndrzej Pietrasiewicz * which the usb controller has. most of those capabilities are exposed
2288443f2d2SAndrzej Pietrasiewicz * implicitly, starting with the driver name and then endpoint names.
2298443f2d2SAndrzej Pietrasiewicz */
2308443f2d2SAndrzej Pietrasiewicz
2318443f2d2SAndrzej Pietrasiewicz static const char *CHIP;
232d18dcfe9SAlan Stern static DEFINE_MUTEX(sb_mutex); /* Serialize superblock operations */
2338443f2d2SAndrzej Pietrasiewicz
2348443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
2358443f2d2SAndrzej Pietrasiewicz
2368443f2d2SAndrzej Pietrasiewicz /* NOTE: don't use dev_printk calls before binding to the gadget
2378443f2d2SAndrzej Pietrasiewicz * at the end of ep0 configuration, or after unbind.
2388443f2d2SAndrzej Pietrasiewicz */
2398443f2d2SAndrzej Pietrasiewicz
2408443f2d2SAndrzej Pietrasiewicz /* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */
2418443f2d2SAndrzej Pietrasiewicz #define xprintk(d,level,fmt,args...) \
2428443f2d2SAndrzej Pietrasiewicz printk(level "%s: " fmt , shortname , ## args)
2438443f2d2SAndrzej Pietrasiewicz
2448443f2d2SAndrzej Pietrasiewicz #ifdef DEBUG
2458443f2d2SAndrzej Pietrasiewicz #define DBG(dev,fmt,args...) \
2468443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_DEBUG , fmt , ## args)
2478443f2d2SAndrzej Pietrasiewicz #else
2488443f2d2SAndrzej Pietrasiewicz #define DBG(dev,fmt,args...) \
2498443f2d2SAndrzej Pietrasiewicz do { } while (0)
2508443f2d2SAndrzej Pietrasiewicz #endif /* DEBUG */
2518443f2d2SAndrzej Pietrasiewicz
2528443f2d2SAndrzej Pietrasiewicz #ifdef VERBOSE_DEBUG
2538443f2d2SAndrzej Pietrasiewicz #define VDEBUG DBG
2548443f2d2SAndrzej Pietrasiewicz #else
2558443f2d2SAndrzej Pietrasiewicz #define VDEBUG(dev,fmt,args...) \
2568443f2d2SAndrzej Pietrasiewicz do { } while (0)
2578443f2d2SAndrzej Pietrasiewicz #endif /* DEBUG */
2588443f2d2SAndrzej Pietrasiewicz
2598443f2d2SAndrzej Pietrasiewicz #define ERROR(dev,fmt,args...) \
2608443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_ERR , fmt , ## args)
2618443f2d2SAndrzej Pietrasiewicz #define INFO(dev,fmt,args...) \
2628443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_INFO , fmt , ## args)
2638443f2d2SAndrzej Pietrasiewicz
2648443f2d2SAndrzej Pietrasiewicz
2658443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
2668443f2d2SAndrzej Pietrasiewicz
2678443f2d2SAndrzej Pietrasiewicz /* SYNCHRONOUS ENDPOINT OPERATIONS (bulk/intr/iso)
2688443f2d2SAndrzej Pietrasiewicz *
2698443f2d2SAndrzej Pietrasiewicz * After opening, configure non-control endpoints. Then use normal
2708443f2d2SAndrzej Pietrasiewicz * stream read() and write() requests; and maybe ioctl() to get more
2718443f2d2SAndrzej Pietrasiewicz * precise FIFO status when recovering from cancellation.
2728443f2d2SAndrzej Pietrasiewicz */
2738443f2d2SAndrzej Pietrasiewicz
epio_complete(struct usb_ep * ep,struct usb_request * req)2748443f2d2SAndrzej Pietrasiewicz static void epio_complete (struct usb_ep *ep, struct usb_request *req)
2758443f2d2SAndrzej Pietrasiewicz {
2768443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = ep->driver_data;
2778443f2d2SAndrzej Pietrasiewicz
2788443f2d2SAndrzej Pietrasiewicz if (!req->context)
2798443f2d2SAndrzej Pietrasiewicz return;
2808443f2d2SAndrzej Pietrasiewicz if (req->status)
2818443f2d2SAndrzej Pietrasiewicz epdata->status = req->status;
2828443f2d2SAndrzej Pietrasiewicz else
2838443f2d2SAndrzej Pietrasiewicz epdata->status = req->actual;
2848443f2d2SAndrzej Pietrasiewicz complete ((struct completion *)req->context);
2858443f2d2SAndrzej Pietrasiewicz }
2868443f2d2SAndrzej Pietrasiewicz
2878443f2d2SAndrzej Pietrasiewicz /* tasklock endpoint, returning when it's connected.
2888443f2d2SAndrzej Pietrasiewicz * still need dev->lock to use epdata->ep.
2898443f2d2SAndrzej Pietrasiewicz */
2908443f2d2SAndrzej Pietrasiewicz static int
get_ready_ep(unsigned f_flags,struct ep_data * epdata,bool is_write)291d4461a60SAl Viro get_ready_ep (unsigned f_flags, struct ep_data *epdata, bool is_write)
2928443f2d2SAndrzej Pietrasiewicz {
2938443f2d2SAndrzej Pietrasiewicz int val;
2948443f2d2SAndrzej Pietrasiewicz
2958443f2d2SAndrzej Pietrasiewicz if (f_flags & O_NONBLOCK) {
2968443f2d2SAndrzej Pietrasiewicz if (!mutex_trylock(&epdata->lock))
2978443f2d2SAndrzej Pietrasiewicz goto nonblock;
298d4461a60SAl Viro if (epdata->state != STATE_EP_ENABLED &&
299d4461a60SAl Viro (!is_write || epdata->state != STATE_EP_READY)) {
3008443f2d2SAndrzej Pietrasiewicz mutex_unlock(&epdata->lock);
3018443f2d2SAndrzej Pietrasiewicz nonblock:
3028443f2d2SAndrzej Pietrasiewicz val = -EAGAIN;
3038443f2d2SAndrzej Pietrasiewicz } else
3048443f2d2SAndrzej Pietrasiewicz val = 0;
3058443f2d2SAndrzej Pietrasiewicz return val;
3068443f2d2SAndrzej Pietrasiewicz }
3078443f2d2SAndrzej Pietrasiewicz
3088443f2d2SAndrzej Pietrasiewicz val = mutex_lock_interruptible(&epdata->lock);
3098443f2d2SAndrzej Pietrasiewicz if (val < 0)
3108443f2d2SAndrzej Pietrasiewicz return val;
3118443f2d2SAndrzej Pietrasiewicz
3128443f2d2SAndrzej Pietrasiewicz switch (epdata->state) {
3138443f2d2SAndrzej Pietrasiewicz case STATE_EP_ENABLED:
314d4461a60SAl Viro return 0;
315d4461a60SAl Viro case STATE_EP_READY: /* not configured yet */
316d4461a60SAl Viro if (is_write)
317d4461a60SAl Viro return 0;
318a74005abSGustavo A. R. Silva fallthrough;
319d4461a60SAl Viro case STATE_EP_UNBOUND: /* clean disconnect */
3208443f2d2SAndrzej Pietrasiewicz break;
3218443f2d2SAndrzej Pietrasiewicz // case STATE_EP_DISABLED: /* "can't happen" */
3228443f2d2SAndrzej Pietrasiewicz default: /* error! */
3238443f2d2SAndrzej Pietrasiewicz pr_debug ("%s: ep %p not available, state %d\n",
3248443f2d2SAndrzej Pietrasiewicz shortname, epdata, epdata->state);
3258443f2d2SAndrzej Pietrasiewicz }
326d4461a60SAl Viro mutex_unlock(&epdata->lock);
327d4461a60SAl Viro return -ENODEV;
3288443f2d2SAndrzej Pietrasiewicz }
3298443f2d2SAndrzej Pietrasiewicz
3308443f2d2SAndrzej Pietrasiewicz static ssize_t
ep_io(struct ep_data * epdata,void * buf,unsigned len)3318443f2d2SAndrzej Pietrasiewicz ep_io (struct ep_data *epdata, void *buf, unsigned len)
3328443f2d2SAndrzej Pietrasiewicz {
3338443f2d2SAndrzej Pietrasiewicz DECLARE_COMPLETION_ONSTACK (done);
3348443f2d2SAndrzej Pietrasiewicz int value;
3358443f2d2SAndrzej Pietrasiewicz
3368443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&epdata->dev->lock);
3378443f2d2SAndrzej Pietrasiewicz if (likely (epdata->ep != NULL)) {
3388443f2d2SAndrzej Pietrasiewicz struct usb_request *req = epdata->req;
3398443f2d2SAndrzej Pietrasiewicz
3408443f2d2SAndrzej Pietrasiewicz req->context = &done;
3418443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete;
3428443f2d2SAndrzej Pietrasiewicz req->buf = buf;
3438443f2d2SAndrzej Pietrasiewicz req->length = len;
3448443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
3458443f2d2SAndrzej Pietrasiewicz } else
3468443f2d2SAndrzej Pietrasiewicz value = -ENODEV;
3478443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock);
3488443f2d2SAndrzej Pietrasiewicz
3498443f2d2SAndrzej Pietrasiewicz if (likely (value == 0)) {
350c1d51dd5SThomas Gleixner value = wait_for_completion_interruptible(&done);
3518443f2d2SAndrzej Pietrasiewicz if (value != 0) {
3528443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&epdata->dev->lock);
3538443f2d2SAndrzej Pietrasiewicz if (likely (epdata->ep != NULL)) {
3548443f2d2SAndrzej Pietrasiewicz DBG (epdata->dev, "%s i/o interrupted\n",
3558443f2d2SAndrzej Pietrasiewicz epdata->name);
3568443f2d2SAndrzej Pietrasiewicz usb_ep_dequeue (epdata->ep, epdata->req);
3578443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock);
3588443f2d2SAndrzej Pietrasiewicz
359c1d51dd5SThomas Gleixner wait_for_completion(&done);
3608443f2d2SAndrzej Pietrasiewicz if (epdata->status == -ECONNRESET)
3618443f2d2SAndrzej Pietrasiewicz epdata->status = -EINTR;
3628443f2d2SAndrzej Pietrasiewicz } else {
3638443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock);
3648443f2d2SAndrzej Pietrasiewicz
3658443f2d2SAndrzej Pietrasiewicz DBG (epdata->dev, "endpoint gone\n");
36604cb742dSJozef Martiniak wait_for_completion(&done);
3678443f2d2SAndrzej Pietrasiewicz epdata->status = -ENODEV;
3688443f2d2SAndrzej Pietrasiewicz }
3698443f2d2SAndrzej Pietrasiewicz }
3708443f2d2SAndrzej Pietrasiewicz return epdata->status;
3718443f2d2SAndrzej Pietrasiewicz }
3728443f2d2SAndrzej Pietrasiewicz return value;
3738443f2d2SAndrzej Pietrasiewicz }
3748443f2d2SAndrzej Pietrasiewicz
3758443f2d2SAndrzej Pietrasiewicz static int
ep_release(struct inode * inode,struct file * fd)3768443f2d2SAndrzej Pietrasiewicz ep_release (struct inode *inode, struct file *fd)
3778443f2d2SAndrzej Pietrasiewicz {
3788443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data;
3798443f2d2SAndrzej Pietrasiewicz int value;
3808443f2d2SAndrzej Pietrasiewicz
3818443f2d2SAndrzej Pietrasiewicz value = mutex_lock_interruptible(&data->lock);
3828443f2d2SAndrzej Pietrasiewicz if (value < 0)
3838443f2d2SAndrzej Pietrasiewicz return value;
3848443f2d2SAndrzej Pietrasiewicz
3858443f2d2SAndrzej Pietrasiewicz /* clean up if this can be reopened */
3868443f2d2SAndrzej Pietrasiewicz if (data->state != STATE_EP_UNBOUND) {
3878443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_DISABLED;
3888443f2d2SAndrzej Pietrasiewicz data->desc.bDescriptorType = 0;
3898443f2d2SAndrzej Pietrasiewicz data->hs_desc.bDescriptorType = 0;
3908443f2d2SAndrzej Pietrasiewicz usb_ep_disable(data->ep);
3918443f2d2SAndrzej Pietrasiewicz }
3928443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock);
3938443f2d2SAndrzej Pietrasiewicz put_ep (data);
3948443f2d2SAndrzej Pietrasiewicz return 0;
3958443f2d2SAndrzej Pietrasiewicz }
3968443f2d2SAndrzej Pietrasiewicz
ep_ioctl(struct file * fd,unsigned code,unsigned long value)3978443f2d2SAndrzej Pietrasiewicz static long ep_ioctl(struct file *fd, unsigned code, unsigned long value)
3988443f2d2SAndrzej Pietrasiewicz {
3998443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data;
4008443f2d2SAndrzej Pietrasiewicz int status;
4018443f2d2SAndrzej Pietrasiewicz
402d4461a60SAl Viro if ((status = get_ready_ep (fd->f_flags, data, false)) < 0)
4038443f2d2SAndrzej Pietrasiewicz return status;
4048443f2d2SAndrzej Pietrasiewicz
4058443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock);
4068443f2d2SAndrzej Pietrasiewicz if (likely (data->ep != NULL)) {
4078443f2d2SAndrzej Pietrasiewicz switch (code) {
4088443f2d2SAndrzej Pietrasiewicz case GADGETFS_FIFO_STATUS:
4098443f2d2SAndrzej Pietrasiewicz status = usb_ep_fifo_status (data->ep);
4108443f2d2SAndrzej Pietrasiewicz break;
4118443f2d2SAndrzej Pietrasiewicz case GADGETFS_FIFO_FLUSH:
4128443f2d2SAndrzej Pietrasiewicz usb_ep_fifo_flush (data->ep);
4138443f2d2SAndrzej Pietrasiewicz break;
4148443f2d2SAndrzej Pietrasiewicz case GADGETFS_CLEAR_HALT:
4158443f2d2SAndrzej Pietrasiewicz status = usb_ep_clear_halt (data->ep);
4168443f2d2SAndrzej Pietrasiewicz break;
4178443f2d2SAndrzej Pietrasiewicz default:
4188443f2d2SAndrzej Pietrasiewicz status = -ENOTTY;
4198443f2d2SAndrzej Pietrasiewicz }
4208443f2d2SAndrzej Pietrasiewicz } else
4218443f2d2SAndrzej Pietrasiewicz status = -ENODEV;
4228443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock);
4238443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock);
4248443f2d2SAndrzej Pietrasiewicz return status;
4258443f2d2SAndrzej Pietrasiewicz }
4268443f2d2SAndrzej Pietrasiewicz
4278443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
4288443f2d2SAndrzej Pietrasiewicz
4298443f2d2SAndrzej Pietrasiewicz /* ASYNCHRONOUS ENDPOINT I/O OPERATIONS (bulk/intr/iso) */
4308443f2d2SAndrzej Pietrasiewicz
4318443f2d2SAndrzej Pietrasiewicz struct kiocb_priv {
4328443f2d2SAndrzej Pietrasiewicz struct usb_request *req;
4338443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata;
4348443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb;
4358443f2d2SAndrzej Pietrasiewicz struct mm_struct *mm;
4368443f2d2SAndrzej Pietrasiewicz struct work_struct work;
4378443f2d2SAndrzej Pietrasiewicz void *buf;
4387fe3976eSAl Viro struct iov_iter to;
4397fe3976eSAl Viro const void *to_free;
4408443f2d2SAndrzej Pietrasiewicz unsigned actual;
4418443f2d2SAndrzej Pietrasiewicz };
4428443f2d2SAndrzej Pietrasiewicz
ep_aio_cancel(struct kiocb * iocb)4438443f2d2SAndrzej Pietrasiewicz static int ep_aio_cancel(struct kiocb *iocb)
4448443f2d2SAndrzej Pietrasiewicz {
4458443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = iocb->private;
4468443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata;
4478443f2d2SAndrzej Pietrasiewicz int value;
4488443f2d2SAndrzej Pietrasiewicz
4498443f2d2SAndrzej Pietrasiewicz local_irq_disable();
4508443f2d2SAndrzej Pietrasiewicz epdata = priv->epdata;
4518443f2d2SAndrzej Pietrasiewicz // spin_lock(&epdata->dev->lock);
4528443f2d2SAndrzej Pietrasiewicz if (likely(epdata && epdata->ep && priv->req))
4538443f2d2SAndrzej Pietrasiewicz value = usb_ep_dequeue (epdata->ep, priv->req);
4548443f2d2SAndrzej Pietrasiewicz else
4558443f2d2SAndrzej Pietrasiewicz value = -EINVAL;
4568443f2d2SAndrzej Pietrasiewicz // spin_unlock(&epdata->dev->lock);
4578443f2d2SAndrzej Pietrasiewicz local_irq_enable();
4588443f2d2SAndrzej Pietrasiewicz
4598443f2d2SAndrzej Pietrasiewicz return value;
4608443f2d2SAndrzej Pietrasiewicz }
4618443f2d2SAndrzej Pietrasiewicz
ep_user_copy_worker(struct work_struct * work)4628443f2d2SAndrzej Pietrasiewicz static void ep_user_copy_worker(struct work_struct *work)
4638443f2d2SAndrzej Pietrasiewicz {
4648443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = container_of(work, struct kiocb_priv, work);
4658443f2d2SAndrzej Pietrasiewicz struct mm_struct *mm = priv->mm;
4668443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb = priv->iocb;
4678443f2d2SAndrzej Pietrasiewicz size_t ret;
4688443f2d2SAndrzej Pietrasiewicz
469f5678e7fSChristoph Hellwig kthread_use_mm(mm);
4707fe3976eSAl Viro ret = copy_to_iter(priv->buf, priv->actual, &priv->to);
471f5678e7fSChristoph Hellwig kthread_unuse_mm(mm);
4727fe3976eSAl Viro if (!ret)
4737fe3976eSAl Viro ret = -EFAULT;
4748443f2d2SAndrzej Pietrasiewicz
4758443f2d2SAndrzej Pietrasiewicz /* completing the iocb can drop the ctx and mm, don't touch mm after */
4766b19b766SJens Axboe iocb->ki_complete(iocb, ret);
4778443f2d2SAndrzej Pietrasiewicz
4788443f2d2SAndrzej Pietrasiewicz kfree(priv->buf);
4797fe3976eSAl Viro kfree(priv->to_free);
4808443f2d2SAndrzej Pietrasiewicz kfree(priv);
4818443f2d2SAndrzej Pietrasiewicz }
4828443f2d2SAndrzej Pietrasiewicz
ep_aio_complete(struct usb_ep * ep,struct usb_request * req)4838443f2d2SAndrzej Pietrasiewicz static void ep_aio_complete(struct usb_ep *ep, struct usb_request *req)
4848443f2d2SAndrzej Pietrasiewicz {
4858443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb = req->context;
4868443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = iocb->private;
4878443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = priv->epdata;
4888443f2d2SAndrzej Pietrasiewicz
4898443f2d2SAndrzej Pietrasiewicz /* lock against disconnect (and ideally, cancel) */
4908443f2d2SAndrzej Pietrasiewicz spin_lock(&epdata->dev->lock);
4918443f2d2SAndrzej Pietrasiewicz priv->req = NULL;
4928443f2d2SAndrzej Pietrasiewicz priv->epdata = NULL;
4938443f2d2SAndrzej Pietrasiewicz
4948443f2d2SAndrzej Pietrasiewicz /* if this was a write or a read returning no data then we
4958443f2d2SAndrzej Pietrasiewicz * don't need to copy anything to userspace, so we can
4968443f2d2SAndrzej Pietrasiewicz * complete the aio request immediately.
4978443f2d2SAndrzej Pietrasiewicz */
4987fe3976eSAl Viro if (priv->to_free == NULL || unlikely(req->actual == 0)) {
4998443f2d2SAndrzej Pietrasiewicz kfree(req->buf);
5007fe3976eSAl Viro kfree(priv->to_free);
5018443f2d2SAndrzej Pietrasiewicz kfree(priv);
5028443f2d2SAndrzej Pietrasiewicz iocb->private = NULL;
5033343f376SDan Carpenter iocb->ki_complete(iocb,
5046b19b766SJens Axboe req->actual ? req->actual : (long)req->status);
5058443f2d2SAndrzej Pietrasiewicz } else {
5068443f2d2SAndrzej Pietrasiewicz /* ep_copy_to_user() won't report both; we hide some faults */
5078443f2d2SAndrzej Pietrasiewicz if (unlikely(0 != req->status))
5088443f2d2SAndrzej Pietrasiewicz DBG(epdata->dev, "%s fault %d len %d\n",
5098443f2d2SAndrzej Pietrasiewicz ep->name, req->status, req->actual);
5108443f2d2SAndrzej Pietrasiewicz
5118443f2d2SAndrzej Pietrasiewicz priv->buf = req->buf;
5128443f2d2SAndrzej Pietrasiewicz priv->actual = req->actual;
5137fe3976eSAl Viro INIT_WORK(&priv->work, ep_user_copy_worker);
5148443f2d2SAndrzej Pietrasiewicz schedule_work(&priv->work);
5158443f2d2SAndrzej Pietrasiewicz }
5168443f2d2SAndrzej Pietrasiewicz
5178443f2d2SAndrzej Pietrasiewicz usb_ep_free_request(ep, req);
518520b72fcSAlan Stern spin_unlock(&epdata->dev->lock);
5198443f2d2SAndrzej Pietrasiewicz put_ep(epdata);
5208443f2d2SAndrzej Pietrasiewicz }
5218443f2d2SAndrzej Pietrasiewicz
ep_aio(struct kiocb * iocb,struct kiocb_priv * priv,struct ep_data * epdata,char * buf,size_t len)5227fe3976eSAl Viro static ssize_t ep_aio(struct kiocb *iocb,
5237fe3976eSAl Viro struct kiocb_priv *priv,
5248443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata,
5257fe3976eSAl Viro char *buf,
5267fe3976eSAl Viro size_t len)
5278443f2d2SAndrzej Pietrasiewicz {
5288443f2d2SAndrzej Pietrasiewicz struct usb_request *req;
5298443f2d2SAndrzej Pietrasiewicz ssize_t value;
5308443f2d2SAndrzej Pietrasiewicz
5318443f2d2SAndrzej Pietrasiewicz iocb->private = priv;
5328443f2d2SAndrzej Pietrasiewicz priv->iocb = iocb;
5338443f2d2SAndrzej Pietrasiewicz
5348443f2d2SAndrzej Pietrasiewicz kiocb_set_cancel_fn(iocb, ep_aio_cancel);
5358443f2d2SAndrzej Pietrasiewicz get_ep(epdata);
5368443f2d2SAndrzej Pietrasiewicz priv->epdata = epdata;
5378443f2d2SAndrzej Pietrasiewicz priv->actual = 0;
5388443f2d2SAndrzej Pietrasiewicz priv->mm = current->mm; /* mm teardown waits for iocbs in exit_aio() */
5398443f2d2SAndrzej Pietrasiewicz
5408443f2d2SAndrzej Pietrasiewicz /* each kiocb is coupled to one usb_request, but we can't
5418443f2d2SAndrzej Pietrasiewicz * allocate or submit those if the host disconnected.
5428443f2d2SAndrzej Pietrasiewicz */
5438443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&epdata->dev->lock);
5447fe3976eSAl Viro value = -ENODEV;
545327b21daSMathieu Laurendeau if (unlikely(epdata->ep == NULL))
5467fe3976eSAl Viro goto fail;
5477fe3976eSAl Viro
5488443f2d2SAndrzej Pietrasiewicz req = usb_ep_alloc_request(epdata->ep, GFP_ATOMIC);
5497fe3976eSAl Viro value = -ENOMEM;
5507fe3976eSAl Viro if (unlikely(!req))
5517fe3976eSAl Viro goto fail;
5527fe3976eSAl Viro
5538443f2d2SAndrzej Pietrasiewicz priv->req = req;
5548443f2d2SAndrzej Pietrasiewicz req->buf = buf;
5558443f2d2SAndrzej Pietrasiewicz req->length = len;
5568443f2d2SAndrzej Pietrasiewicz req->complete = ep_aio_complete;
5578443f2d2SAndrzej Pietrasiewicz req->context = iocb;
5588443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue(epdata->ep, req, GFP_ATOMIC);
5597fe3976eSAl Viro if (unlikely(0 != value)) {
5608443f2d2SAndrzej Pietrasiewicz usb_ep_free_request(epdata->ep, req);
5617fe3976eSAl Viro goto fail;
5627fe3976eSAl Viro }
5638443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&epdata->dev->lock);
5647fe3976eSAl Viro return -EIOCBQUEUED;
5658443f2d2SAndrzej Pietrasiewicz
5667fe3976eSAl Viro fail:
5677fe3976eSAl Viro spin_unlock_irq(&epdata->dev->lock);
5687fe3976eSAl Viro kfree(priv->to_free);
5698443f2d2SAndrzej Pietrasiewicz kfree(priv);
5708443f2d2SAndrzej Pietrasiewicz put_ep(epdata);
5718443f2d2SAndrzej Pietrasiewicz return value;
5728443f2d2SAndrzej Pietrasiewicz }
5738443f2d2SAndrzej Pietrasiewicz
5748443f2d2SAndrzej Pietrasiewicz static ssize_t
ep_read_iter(struct kiocb * iocb,struct iov_iter * to)5757fe3976eSAl Viro ep_read_iter(struct kiocb *iocb, struct iov_iter *to)
5768443f2d2SAndrzej Pietrasiewicz {
5777fe3976eSAl Viro struct file *file = iocb->ki_filp;
5787fe3976eSAl Viro struct ep_data *epdata = file->private_data;
5797fe3976eSAl Viro size_t len = iov_iter_count(to);
5807fe3976eSAl Viro ssize_t value;
5818443f2d2SAndrzej Pietrasiewicz char *buf;
5828443f2d2SAndrzej Pietrasiewicz
583d4461a60SAl Viro if ((value = get_ready_ep(file->f_flags, epdata, false)) < 0)
5847fe3976eSAl Viro return value;
5857fe3976eSAl Viro
5867fe3976eSAl Viro /* halt any endpoint by doing a "wrong direction" i/o call */
5877fe3976eSAl Viro if (usb_endpoint_dir_in(&epdata->desc)) {
5887fe3976eSAl Viro if (usb_endpoint_xfer_isoc(&epdata->desc) ||
5897fe3976eSAl Viro !is_sync_kiocb(iocb)) {
5907fe3976eSAl Viro mutex_unlock(&epdata->lock);
5918443f2d2SAndrzej Pietrasiewicz return -EINVAL;
5927fe3976eSAl Viro }
5937fe3976eSAl Viro DBG (epdata->dev, "%s halt\n", epdata->name);
5947fe3976eSAl Viro spin_lock_irq(&epdata->dev->lock);
5957fe3976eSAl Viro if (likely(epdata->ep != NULL))
5967fe3976eSAl Viro usb_ep_set_halt(epdata->ep);
5977fe3976eSAl Viro spin_unlock_irq(&epdata->dev->lock);
5987fe3976eSAl Viro mutex_unlock(&epdata->lock);
5997fe3976eSAl Viro return -EBADMSG;
6007fe3976eSAl Viro }
6018443f2d2SAndrzej Pietrasiewicz
6027fe3976eSAl Viro buf = kmalloc(len, GFP_KERNEL);
6037fe3976eSAl Viro if (unlikely(!buf)) {
6047fe3976eSAl Viro mutex_unlock(&epdata->lock);
6058443f2d2SAndrzej Pietrasiewicz return -ENOMEM;
6067fe3976eSAl Viro }
6077fe3976eSAl Viro if (is_sync_kiocb(iocb)) {
6087fe3976eSAl Viro value = ep_io(epdata, buf, len);
60963196e98SBinyamin Sharet if (value >= 0 && (copy_to_iter(buf, value, to) != value))
6107fe3976eSAl Viro value = -EFAULT;
6117fe3976eSAl Viro } else {
6127fe3976eSAl Viro struct kiocb_priv *priv = kzalloc(sizeof *priv, GFP_KERNEL);
6137fe3976eSAl Viro value = -ENOMEM;
6147fe3976eSAl Viro if (!priv)
6157fe3976eSAl Viro goto fail;
6167fe3976eSAl Viro priv->to_free = dup_iter(&priv->to, to, GFP_KERNEL);
617e07fec47SSandeep Dhavale if (!iter_is_ubuf(&priv->to) && !priv->to_free) {
6187fe3976eSAl Viro kfree(priv);
6197fe3976eSAl Viro goto fail;
6207fe3976eSAl Viro }
6217fe3976eSAl Viro value = ep_aio(iocb, priv, epdata, buf, len);
6227fe3976eSAl Viro if (value == -EIOCBQUEUED)
6237fe3976eSAl Viro buf = NULL;
6247fe3976eSAl Viro }
6257fe3976eSAl Viro fail:
6267fe3976eSAl Viro kfree(buf);
6277fe3976eSAl Viro mutex_unlock(&epdata->lock);
6287fe3976eSAl Viro return value;
6298443f2d2SAndrzej Pietrasiewicz }
6308443f2d2SAndrzej Pietrasiewicz
631d4461a60SAl Viro static ssize_t ep_config(struct ep_data *, const char *, size_t);
632d4461a60SAl Viro
6338443f2d2SAndrzej Pietrasiewicz static ssize_t
ep_write_iter(struct kiocb * iocb,struct iov_iter * from)6347fe3976eSAl Viro ep_write_iter(struct kiocb *iocb, struct iov_iter *from)
6358443f2d2SAndrzej Pietrasiewicz {
6367fe3976eSAl Viro struct file *file = iocb->ki_filp;
6377fe3976eSAl Viro struct ep_data *epdata = file->private_data;
6387fe3976eSAl Viro size_t len = iov_iter_count(from);
639d4461a60SAl Viro bool configured;
6407fe3976eSAl Viro ssize_t value;
6418443f2d2SAndrzej Pietrasiewicz char *buf;
6428443f2d2SAndrzej Pietrasiewicz
643d4461a60SAl Viro if ((value = get_ready_ep(file->f_flags, epdata, true)) < 0)
6447fe3976eSAl Viro return value;
6457fe3976eSAl Viro
646d4461a60SAl Viro configured = epdata->state == STATE_EP_ENABLED;
647d4461a60SAl Viro
6487fe3976eSAl Viro /* halt any endpoint by doing a "wrong direction" i/o call */
649d4461a60SAl Viro if (configured && !usb_endpoint_dir_in(&epdata->desc)) {
6507fe3976eSAl Viro if (usb_endpoint_xfer_isoc(&epdata->desc) ||
6517fe3976eSAl Viro !is_sync_kiocb(iocb)) {
6527fe3976eSAl Viro mutex_unlock(&epdata->lock);
6538443f2d2SAndrzej Pietrasiewicz return -EINVAL;
6547fe3976eSAl Viro }
6557fe3976eSAl Viro DBG (epdata->dev, "%s halt\n", epdata->name);
6567fe3976eSAl Viro spin_lock_irq(&epdata->dev->lock);
6577fe3976eSAl Viro if (likely(epdata->ep != NULL))
6587fe3976eSAl Viro usb_ep_set_halt(epdata->ep);
6597fe3976eSAl Viro spin_unlock_irq(&epdata->dev->lock);
6607fe3976eSAl Viro mutex_unlock(&epdata->lock);
6617fe3976eSAl Viro return -EBADMSG;
6627fe3976eSAl Viro }
6638443f2d2SAndrzej Pietrasiewicz
6647fe3976eSAl Viro buf = kmalloc(len, GFP_KERNEL);
6657fe3976eSAl Viro if (unlikely(!buf)) {
6667fe3976eSAl Viro mutex_unlock(&epdata->lock);
6678443f2d2SAndrzej Pietrasiewicz return -ENOMEM;
6687fe3976eSAl Viro }
6698443f2d2SAndrzej Pietrasiewicz
670cbbd26b8SAl Viro if (unlikely(!copy_from_iter_full(buf, len, from))) {
6717fe3976eSAl Viro value = -EFAULT;
6727fe3976eSAl Viro goto out;
6737fe3976eSAl Viro }
6747fe3976eSAl Viro
675d4461a60SAl Viro if (unlikely(!configured)) {
676d4461a60SAl Viro value = ep_config(epdata, buf, len);
677d4461a60SAl Viro } else if (is_sync_kiocb(iocb)) {
6787fe3976eSAl Viro value = ep_io(epdata, buf, len);
6797fe3976eSAl Viro } else {
6807fe3976eSAl Viro struct kiocb_priv *priv = kzalloc(sizeof *priv, GFP_KERNEL);
6817fe3976eSAl Viro value = -ENOMEM;
6827fe3976eSAl Viro if (priv) {
6837fe3976eSAl Viro value = ep_aio(iocb, priv, epdata, buf, len);
6847fe3976eSAl Viro if (value == -EIOCBQUEUED)
6857fe3976eSAl Viro buf = NULL;
6867fe3976eSAl Viro }
6877fe3976eSAl Viro }
6887fe3976eSAl Viro out:
6898443f2d2SAndrzej Pietrasiewicz kfree(buf);
6907fe3976eSAl Viro mutex_unlock(&epdata->lock);
6917fe3976eSAl Viro return value;
6928443f2d2SAndrzej Pietrasiewicz }
6938443f2d2SAndrzej Pietrasiewicz
6948443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
6958443f2d2SAndrzej Pietrasiewicz
6968443f2d2SAndrzej Pietrasiewicz /* used after endpoint configuration */
6978443f2d2SAndrzej Pietrasiewicz static const struct file_operations ep_io_operations = {
6988443f2d2SAndrzej Pietrasiewicz .owner = THIS_MODULE,
6998443f2d2SAndrzej Pietrasiewicz
700d4461a60SAl Viro .open = ep_open,
701d4461a60SAl Viro .release = ep_release,
702d4461a60SAl Viro .llseek = no_llseek,
7038443f2d2SAndrzej Pietrasiewicz .unlocked_ioctl = ep_ioctl,
7047fe3976eSAl Viro .read_iter = ep_read_iter,
7057fe3976eSAl Viro .write_iter = ep_write_iter,
7068443f2d2SAndrzej Pietrasiewicz };
7078443f2d2SAndrzej Pietrasiewicz
7088443f2d2SAndrzej Pietrasiewicz /* ENDPOINT INITIALIZATION
7098443f2d2SAndrzej Pietrasiewicz *
7108443f2d2SAndrzej Pietrasiewicz * fd = open ("/dev/gadget/$ENDPOINT", O_RDWR)
7118443f2d2SAndrzej Pietrasiewicz * status = write (fd, descriptors, sizeof descriptors)
7128443f2d2SAndrzej Pietrasiewicz *
7138443f2d2SAndrzej Pietrasiewicz * That write establishes the endpoint configuration, configuring
7148443f2d2SAndrzej Pietrasiewicz * the controller to process bulk, interrupt, or isochronous transfers
7158443f2d2SAndrzej Pietrasiewicz * at the right maxpacket size, and so on.
7168443f2d2SAndrzej Pietrasiewicz *
7178443f2d2SAndrzej Pietrasiewicz * The descriptors are message type 1, identified by a host order u32
7188443f2d2SAndrzej Pietrasiewicz * at the beginning of what's written. Descriptor order is: full/low
7198443f2d2SAndrzej Pietrasiewicz * speed descriptor, then optional high speed descriptor.
7208443f2d2SAndrzej Pietrasiewicz */
7218443f2d2SAndrzej Pietrasiewicz static ssize_t
ep_config(struct ep_data * data,const char * buf,size_t len)722d4461a60SAl Viro ep_config (struct ep_data *data, const char *buf, size_t len)
7238443f2d2SAndrzej Pietrasiewicz {
7248443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep;
7258443f2d2SAndrzej Pietrasiewicz u32 tag;
7268443f2d2SAndrzej Pietrasiewicz int value, length = len;
7278443f2d2SAndrzej Pietrasiewicz
7288443f2d2SAndrzej Pietrasiewicz if (data->state != STATE_EP_READY) {
7298443f2d2SAndrzej Pietrasiewicz value = -EL2HLT;
7308443f2d2SAndrzej Pietrasiewicz goto fail;
7318443f2d2SAndrzej Pietrasiewicz }
7328443f2d2SAndrzej Pietrasiewicz
7338443f2d2SAndrzej Pietrasiewicz value = len;
7348443f2d2SAndrzej Pietrasiewicz if (len < USB_DT_ENDPOINT_SIZE + 4)
7358443f2d2SAndrzej Pietrasiewicz goto fail0;
7368443f2d2SAndrzej Pietrasiewicz
7378443f2d2SAndrzej Pietrasiewicz /* we might need to change message format someday */
738d4461a60SAl Viro memcpy(&tag, buf, 4);
7398443f2d2SAndrzej Pietrasiewicz if (tag != 1) {
7408443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "config %s, bad tag %d\n", data->name, tag);
7418443f2d2SAndrzej Pietrasiewicz goto fail0;
7428443f2d2SAndrzej Pietrasiewicz }
7438443f2d2SAndrzej Pietrasiewicz buf += 4;
7448443f2d2SAndrzej Pietrasiewicz len -= 4;
7458443f2d2SAndrzej Pietrasiewicz
7468443f2d2SAndrzej Pietrasiewicz /* NOTE: audio endpoint extensions not accepted here;
7478443f2d2SAndrzej Pietrasiewicz * just don't include the extra bytes.
7488443f2d2SAndrzej Pietrasiewicz */
7498443f2d2SAndrzej Pietrasiewicz
7508443f2d2SAndrzej Pietrasiewicz /* full/low speed descriptor, then high speed */
751d4461a60SAl Viro memcpy(&data->desc, buf, USB_DT_ENDPOINT_SIZE);
7528443f2d2SAndrzej Pietrasiewicz if (data->desc.bLength != USB_DT_ENDPOINT_SIZE
7538443f2d2SAndrzej Pietrasiewicz || data->desc.bDescriptorType != USB_DT_ENDPOINT)
7548443f2d2SAndrzej Pietrasiewicz goto fail0;
7558443f2d2SAndrzej Pietrasiewicz if (len != USB_DT_ENDPOINT_SIZE) {
7568443f2d2SAndrzej Pietrasiewicz if (len != 2 * USB_DT_ENDPOINT_SIZE)
7578443f2d2SAndrzej Pietrasiewicz goto fail0;
758d4461a60SAl Viro memcpy(&data->hs_desc, buf + USB_DT_ENDPOINT_SIZE,
759d4461a60SAl Viro USB_DT_ENDPOINT_SIZE);
7608443f2d2SAndrzej Pietrasiewicz if (data->hs_desc.bLength != USB_DT_ENDPOINT_SIZE
7618443f2d2SAndrzej Pietrasiewicz || data->hs_desc.bDescriptorType
7628443f2d2SAndrzej Pietrasiewicz != USB_DT_ENDPOINT) {
7638443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "config %s, bad hs length or type\n",
7648443f2d2SAndrzej Pietrasiewicz data->name);
7658443f2d2SAndrzej Pietrasiewicz goto fail0;
7668443f2d2SAndrzej Pietrasiewicz }
7678443f2d2SAndrzej Pietrasiewicz }
7688443f2d2SAndrzej Pietrasiewicz
7698443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock);
7708443f2d2SAndrzej Pietrasiewicz if (data->dev->state == STATE_DEV_UNBOUND) {
7718443f2d2SAndrzej Pietrasiewicz value = -ENOENT;
7728443f2d2SAndrzej Pietrasiewicz goto gone;
7731ee7eeadSGreg Kroah-Hartman } else {
7741ee7eeadSGreg Kroah-Hartman ep = data->ep;
7751ee7eeadSGreg Kroah-Hartman if (ep == NULL) {
7768443f2d2SAndrzej Pietrasiewicz value = -ENODEV;
7778443f2d2SAndrzej Pietrasiewicz goto gone;
7788443f2d2SAndrzej Pietrasiewicz }
7791ee7eeadSGreg Kroah-Hartman }
7808443f2d2SAndrzej Pietrasiewicz switch (data->dev->gadget->speed) {
7818443f2d2SAndrzej Pietrasiewicz case USB_SPEED_LOW:
7828443f2d2SAndrzej Pietrasiewicz case USB_SPEED_FULL:
7838443f2d2SAndrzej Pietrasiewicz ep->desc = &data->desc;
7848443f2d2SAndrzej Pietrasiewicz break;
7858443f2d2SAndrzej Pietrasiewicz case USB_SPEED_HIGH:
7868443f2d2SAndrzej Pietrasiewicz /* fails if caller didn't provide that descriptor... */
7878443f2d2SAndrzej Pietrasiewicz ep->desc = &data->hs_desc;
7888443f2d2SAndrzej Pietrasiewicz break;
7898443f2d2SAndrzej Pietrasiewicz default:
7908443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "unconnected, %s init abandoned\n",
7918443f2d2SAndrzej Pietrasiewicz data->name);
7928443f2d2SAndrzej Pietrasiewicz value = -EINVAL;
793d4461a60SAl Viro goto gone;
7948443f2d2SAndrzej Pietrasiewicz }
795d4461a60SAl Viro value = usb_ep_enable(ep);
7968443f2d2SAndrzej Pietrasiewicz if (value == 0) {
797d4461a60SAl Viro data->state = STATE_EP_ENABLED;
7988443f2d2SAndrzej Pietrasiewicz value = length;
7998443f2d2SAndrzej Pietrasiewicz }
8008443f2d2SAndrzej Pietrasiewicz gone:
8018443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock);
8028443f2d2SAndrzej Pietrasiewicz if (value < 0) {
8038443f2d2SAndrzej Pietrasiewicz fail:
8048443f2d2SAndrzej Pietrasiewicz data->desc.bDescriptorType = 0;
8058443f2d2SAndrzej Pietrasiewicz data->hs_desc.bDescriptorType = 0;
8068443f2d2SAndrzej Pietrasiewicz }
8078443f2d2SAndrzej Pietrasiewicz return value;
8088443f2d2SAndrzej Pietrasiewicz fail0:
8098443f2d2SAndrzej Pietrasiewicz value = -EINVAL;
8108443f2d2SAndrzej Pietrasiewicz goto fail;
8118443f2d2SAndrzej Pietrasiewicz }
8128443f2d2SAndrzej Pietrasiewicz
8138443f2d2SAndrzej Pietrasiewicz static int
ep_open(struct inode * inode,struct file * fd)8148443f2d2SAndrzej Pietrasiewicz ep_open (struct inode *inode, struct file *fd)
8158443f2d2SAndrzej Pietrasiewicz {
8168443f2d2SAndrzej Pietrasiewicz struct ep_data *data = inode->i_private;
8178443f2d2SAndrzej Pietrasiewicz int value = -EBUSY;
8188443f2d2SAndrzej Pietrasiewicz
8198443f2d2SAndrzej Pietrasiewicz if (mutex_lock_interruptible(&data->lock) != 0)
8208443f2d2SAndrzej Pietrasiewicz return -EINTR;
8218443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock);
8228443f2d2SAndrzej Pietrasiewicz if (data->dev->state == STATE_DEV_UNBOUND)
8238443f2d2SAndrzej Pietrasiewicz value = -ENOENT;
8248443f2d2SAndrzej Pietrasiewicz else if (data->state == STATE_EP_DISABLED) {
8258443f2d2SAndrzej Pietrasiewicz value = 0;
8268443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_READY;
8278443f2d2SAndrzej Pietrasiewicz get_ep (data);
8288443f2d2SAndrzej Pietrasiewicz fd->private_data = data;
8298443f2d2SAndrzej Pietrasiewicz VDEBUG (data->dev, "%s ready\n", data->name);
8308443f2d2SAndrzej Pietrasiewicz } else
8318443f2d2SAndrzej Pietrasiewicz DBG (data->dev, "%s state %d\n",
8328443f2d2SAndrzej Pietrasiewicz data->name, data->state);
8338443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock);
8348443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock);
8358443f2d2SAndrzej Pietrasiewicz return value;
8368443f2d2SAndrzej Pietrasiewicz }
8378443f2d2SAndrzej Pietrasiewicz
8388443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
8398443f2d2SAndrzej Pietrasiewicz
8408443f2d2SAndrzej Pietrasiewicz /* EP0 IMPLEMENTATION can be partly in userspace.
8418443f2d2SAndrzej Pietrasiewicz *
8428443f2d2SAndrzej Pietrasiewicz * Drivers that use this facility receive various events, including
8438443f2d2SAndrzej Pietrasiewicz * control requests the kernel doesn't handle. Drivers that don't
8448443f2d2SAndrzej Pietrasiewicz * use this facility may be too simple-minded for real applications.
8458443f2d2SAndrzej Pietrasiewicz */
8468443f2d2SAndrzej Pietrasiewicz
ep0_readable(struct dev_data * dev)8478443f2d2SAndrzej Pietrasiewicz static inline void ep0_readable (struct dev_data *dev)
8488443f2d2SAndrzej Pietrasiewicz {
8498443f2d2SAndrzej Pietrasiewicz wake_up (&dev->wait);
8508443f2d2SAndrzej Pietrasiewicz kill_fasync (&dev->fasync, SIGIO, POLL_IN);
8518443f2d2SAndrzej Pietrasiewicz }
8528443f2d2SAndrzej Pietrasiewicz
clean_req(struct usb_ep * ep,struct usb_request * req)8538443f2d2SAndrzej Pietrasiewicz static void clean_req (struct usb_ep *ep, struct usb_request *req)
8548443f2d2SAndrzej Pietrasiewicz {
8558443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data;
8568443f2d2SAndrzej Pietrasiewicz
8578443f2d2SAndrzej Pietrasiewicz if (req->buf != dev->rbuf) {
8588443f2d2SAndrzej Pietrasiewicz kfree(req->buf);
8598443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf;
8608443f2d2SAndrzej Pietrasiewicz }
8618443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete;
8628443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 0;
8638443f2d2SAndrzej Pietrasiewicz }
8648443f2d2SAndrzej Pietrasiewicz
ep0_complete(struct usb_ep * ep,struct usb_request * req)8658443f2d2SAndrzej Pietrasiewicz static void ep0_complete (struct usb_ep *ep, struct usb_request *req)
8668443f2d2SAndrzej Pietrasiewicz {
8678443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data;
8688443f2d2SAndrzej Pietrasiewicz unsigned long flags;
8698443f2d2SAndrzej Pietrasiewicz int free = 1;
8708443f2d2SAndrzej Pietrasiewicz
8718443f2d2SAndrzej Pietrasiewicz /* for control OUT, data must still get to userspace */
8728443f2d2SAndrzej Pietrasiewicz spin_lock_irqsave(&dev->lock, flags);
8738443f2d2SAndrzej Pietrasiewicz if (!dev->setup_in) {
8748443f2d2SAndrzej Pietrasiewicz dev->setup_out_error = (req->status != 0);
8758443f2d2SAndrzej Pietrasiewicz if (!dev->setup_out_error)
8768443f2d2SAndrzej Pietrasiewicz free = 0;
8778443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 1;
8788443f2d2SAndrzej Pietrasiewicz ep0_readable (dev);
8798443f2d2SAndrzej Pietrasiewicz }
8808443f2d2SAndrzej Pietrasiewicz
8818443f2d2SAndrzej Pietrasiewicz /* clean up as appropriate */
8828443f2d2SAndrzej Pietrasiewicz if (free && req->buf != &dev->rbuf)
8838443f2d2SAndrzej Pietrasiewicz clean_req (ep, req);
8848443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete;
8858443f2d2SAndrzej Pietrasiewicz spin_unlock_irqrestore(&dev->lock, flags);
8868443f2d2SAndrzej Pietrasiewicz }
8878443f2d2SAndrzej Pietrasiewicz
setup_req(struct usb_ep * ep,struct usb_request * req,u16 len)8888443f2d2SAndrzej Pietrasiewicz static int setup_req (struct usb_ep *ep, struct usb_request *req, u16 len)
8898443f2d2SAndrzej Pietrasiewicz {
8908443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data;
8918443f2d2SAndrzej Pietrasiewicz
8928443f2d2SAndrzej Pietrasiewicz if (dev->setup_out_ready) {
8938443f2d2SAndrzej Pietrasiewicz DBG (dev, "ep0 request busy!\n");
8948443f2d2SAndrzej Pietrasiewicz return -EBUSY;
8958443f2d2SAndrzej Pietrasiewicz }
8968443f2d2SAndrzej Pietrasiewicz if (len > sizeof (dev->rbuf))
8978443f2d2SAndrzej Pietrasiewicz req->buf = kmalloc(len, GFP_ATOMIC);
8988443f2d2SAndrzej Pietrasiewicz if (req->buf == NULL) {
8998443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf;
9008443f2d2SAndrzej Pietrasiewicz return -ENOMEM;
9018443f2d2SAndrzej Pietrasiewicz }
9028443f2d2SAndrzej Pietrasiewicz req->complete = ep0_complete;
9038443f2d2SAndrzej Pietrasiewicz req->length = len;
9048443f2d2SAndrzej Pietrasiewicz req->zero = 0;
9058443f2d2SAndrzej Pietrasiewicz return 0;
9068443f2d2SAndrzej Pietrasiewicz }
9078443f2d2SAndrzej Pietrasiewicz
9088443f2d2SAndrzej Pietrasiewicz static ssize_t
ep0_read(struct file * fd,char __user * buf,size_t len,loff_t * ptr)9098443f2d2SAndrzej Pietrasiewicz ep0_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
9108443f2d2SAndrzej Pietrasiewicz {
9118443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
9128443f2d2SAndrzej Pietrasiewicz ssize_t retval;
9138443f2d2SAndrzej Pietrasiewicz enum ep0_state state;
9148443f2d2SAndrzej Pietrasiewicz
9158443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
91696b62a57SAlan Stern if (dev->state <= STATE_DEV_OPENED) {
91796b62a57SAlan Stern retval = -EINVAL;
91896b62a57SAlan Stern goto done;
91996b62a57SAlan Stern }
9208443f2d2SAndrzej Pietrasiewicz
9218443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */
9228443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) {
9238443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0;
9248443f2d2SAndrzej Pietrasiewicz retval = -EIDRM;
9258443f2d2SAndrzej Pietrasiewicz goto done;
9268443f2d2SAndrzej Pietrasiewicz }
9278443f2d2SAndrzej Pietrasiewicz
9288443f2d2SAndrzej Pietrasiewicz /* control DATA stage */
9298443f2d2SAndrzej Pietrasiewicz if ((state = dev->state) == STATE_DEV_SETUP) {
9308443f2d2SAndrzej Pietrasiewicz
9318443f2d2SAndrzej Pietrasiewicz if (dev->setup_in) { /* stall IN */
9328443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "ep0in stall\n");
9338443f2d2SAndrzej Pietrasiewicz (void) usb_ep_set_halt (dev->gadget->ep0);
9348443f2d2SAndrzej Pietrasiewicz retval = -EL2HLT;
9358443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
9368443f2d2SAndrzej Pietrasiewicz
9378443f2d2SAndrzej Pietrasiewicz } else if (len == 0) { /* ack SET_CONFIGURATION etc */
9388443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep = dev->gadget->ep0;
9398443f2d2SAndrzej Pietrasiewicz struct usb_request *req = dev->req;
9408443f2d2SAndrzej Pietrasiewicz
941d246dcb2SBin Liu if ((retval = setup_req (ep, req, 0)) == 0) {
942520b72fcSAlan Stern ++dev->udc_usage;
943d246dcb2SBin Liu spin_unlock_irq (&dev->lock);
944d246dcb2SBin Liu retval = usb_ep_queue (ep, req, GFP_KERNEL);
945d246dcb2SBin Liu spin_lock_irq (&dev->lock);
946520b72fcSAlan Stern --dev->udc_usage;
947d246dcb2SBin Liu }
9488443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
9498443f2d2SAndrzej Pietrasiewicz
9508443f2d2SAndrzej Pietrasiewicz /* assume that was SET_CONFIGURATION */
9518443f2d2SAndrzej Pietrasiewicz if (dev->current_config) {
9528443f2d2SAndrzej Pietrasiewicz unsigned power;
9538443f2d2SAndrzej Pietrasiewicz
9548443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(dev->gadget)
9558443f2d2SAndrzej Pietrasiewicz && (dev->gadget->speed
9568443f2d2SAndrzej Pietrasiewicz == USB_SPEED_HIGH))
9578443f2d2SAndrzej Pietrasiewicz power = dev->hs_config->bMaxPower;
9588443f2d2SAndrzej Pietrasiewicz else
9598443f2d2SAndrzej Pietrasiewicz power = dev->config->bMaxPower;
9608443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(dev->gadget, 2 * power);
9618443f2d2SAndrzej Pietrasiewicz }
9628443f2d2SAndrzej Pietrasiewicz
9638443f2d2SAndrzej Pietrasiewicz } else { /* collect OUT data */
9648443f2d2SAndrzej Pietrasiewicz if ((fd->f_flags & O_NONBLOCK) != 0
9658443f2d2SAndrzej Pietrasiewicz && !dev->setup_out_ready) {
9668443f2d2SAndrzej Pietrasiewicz retval = -EAGAIN;
9678443f2d2SAndrzej Pietrasiewicz goto done;
9688443f2d2SAndrzej Pietrasiewicz }
9698443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
9708443f2d2SAndrzej Pietrasiewicz retval = wait_event_interruptible (dev->wait,
9718443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready != 0);
9728443f2d2SAndrzej Pietrasiewicz
9738443f2d2SAndrzej Pietrasiewicz /* FIXME state could change from under us */
9748443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
9758443f2d2SAndrzej Pietrasiewicz if (retval)
9768443f2d2SAndrzej Pietrasiewicz goto done;
9778443f2d2SAndrzej Pietrasiewicz
9788443f2d2SAndrzej Pietrasiewicz if (dev->state != STATE_DEV_SETUP) {
9798443f2d2SAndrzej Pietrasiewicz retval = -ECANCELED;
9808443f2d2SAndrzej Pietrasiewicz goto done;
9818443f2d2SAndrzej Pietrasiewicz }
9828443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
9838443f2d2SAndrzej Pietrasiewicz
9848443f2d2SAndrzej Pietrasiewicz if (dev->setup_out_error)
9858443f2d2SAndrzej Pietrasiewicz retval = -EIO;
9868443f2d2SAndrzej Pietrasiewicz else {
9878443f2d2SAndrzej Pietrasiewicz len = min (len, (size_t)dev->req->actual);
9886e76c01eSAlan Stern ++dev->udc_usage;
9896e76c01eSAlan Stern spin_unlock_irq(&dev->lock);
9908443f2d2SAndrzej Pietrasiewicz if (copy_to_user (buf, dev->req->buf, len))
9918443f2d2SAndrzej Pietrasiewicz retval = -EFAULT;
9928443f2d2SAndrzej Pietrasiewicz else
9938443f2d2SAndrzej Pietrasiewicz retval = len;
9946e76c01eSAlan Stern spin_lock_irq(&dev->lock);
9956e76c01eSAlan Stern --dev->udc_usage;
9968443f2d2SAndrzej Pietrasiewicz clean_req (dev->gadget->ep0, dev->req);
9978443f2d2SAndrzej Pietrasiewicz /* NOTE userspace can't yet choose to stall */
9988443f2d2SAndrzej Pietrasiewicz }
9998443f2d2SAndrzej Pietrasiewicz }
10008443f2d2SAndrzej Pietrasiewicz goto done;
10018443f2d2SAndrzej Pietrasiewicz }
10028443f2d2SAndrzej Pietrasiewicz
10038443f2d2SAndrzej Pietrasiewicz /* else normal: return event data */
10048443f2d2SAndrzej Pietrasiewicz if (len < sizeof dev->event [0]) {
10058443f2d2SAndrzej Pietrasiewicz retval = -EINVAL;
10068443f2d2SAndrzej Pietrasiewicz goto done;
10078443f2d2SAndrzej Pietrasiewicz }
10088443f2d2SAndrzej Pietrasiewicz len -= len % sizeof (struct usb_gadgetfs_event);
10098443f2d2SAndrzej Pietrasiewicz dev->usermode_setup = 1;
10108443f2d2SAndrzej Pietrasiewicz
10118443f2d2SAndrzej Pietrasiewicz scan:
10128443f2d2SAndrzej Pietrasiewicz /* return queued events right away */
10138443f2d2SAndrzej Pietrasiewicz if (dev->ev_next != 0) {
10148443f2d2SAndrzej Pietrasiewicz unsigned i, n;
10158443f2d2SAndrzej Pietrasiewicz
10168443f2d2SAndrzej Pietrasiewicz n = len / sizeof (struct usb_gadgetfs_event);
10178443f2d2SAndrzej Pietrasiewicz if (dev->ev_next < n)
10188443f2d2SAndrzej Pietrasiewicz n = dev->ev_next;
10198443f2d2SAndrzej Pietrasiewicz
10208443f2d2SAndrzej Pietrasiewicz /* ep0 i/o has special semantics during STATE_DEV_SETUP */
10218443f2d2SAndrzej Pietrasiewicz for (i = 0; i < n; i++) {
10228443f2d2SAndrzej Pietrasiewicz if (dev->event [i].type == GADGETFS_SETUP) {
10238443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_SETUP;
10248443f2d2SAndrzej Pietrasiewicz n = i + 1;
10258443f2d2SAndrzej Pietrasiewicz break;
10268443f2d2SAndrzej Pietrasiewicz }
10278443f2d2SAndrzej Pietrasiewicz }
10288443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
10298443f2d2SAndrzej Pietrasiewicz len = n * sizeof (struct usb_gadgetfs_event);
10308443f2d2SAndrzej Pietrasiewicz if (copy_to_user (buf, &dev->event, len))
10318443f2d2SAndrzej Pietrasiewicz retval = -EFAULT;
10328443f2d2SAndrzej Pietrasiewicz else
10338443f2d2SAndrzej Pietrasiewicz retval = len;
10348443f2d2SAndrzej Pietrasiewicz if (len > 0) {
10358443f2d2SAndrzej Pietrasiewicz /* NOTE this doesn't guard against broken drivers;
10368443f2d2SAndrzej Pietrasiewicz * concurrent ep0 readers may lose events.
10378443f2d2SAndrzej Pietrasiewicz */
10388443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
10398443f2d2SAndrzej Pietrasiewicz if (dev->ev_next > n) {
10408443f2d2SAndrzej Pietrasiewicz memmove(&dev->event[0], &dev->event[n],
10418443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_gadgetfs_event)
10428443f2d2SAndrzej Pietrasiewicz * (dev->ev_next - n));
10438443f2d2SAndrzej Pietrasiewicz }
10448443f2d2SAndrzej Pietrasiewicz dev->ev_next -= n;
10458443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
10468443f2d2SAndrzej Pietrasiewicz }
10478443f2d2SAndrzej Pietrasiewicz return retval;
10488443f2d2SAndrzej Pietrasiewicz }
10498443f2d2SAndrzej Pietrasiewicz if (fd->f_flags & O_NONBLOCK) {
10508443f2d2SAndrzej Pietrasiewicz retval = -EAGAIN;
10518443f2d2SAndrzej Pietrasiewicz goto done;
10528443f2d2SAndrzej Pietrasiewicz }
10538443f2d2SAndrzej Pietrasiewicz
10548443f2d2SAndrzej Pietrasiewicz switch (state) {
10558443f2d2SAndrzej Pietrasiewicz default:
10568443f2d2SAndrzej Pietrasiewicz DBG (dev, "fail %s, state %d\n", __func__, state);
10578443f2d2SAndrzej Pietrasiewicz retval = -ESRCH;
10588443f2d2SAndrzej Pietrasiewicz break;
10598443f2d2SAndrzej Pietrasiewicz case STATE_DEV_UNCONNECTED:
10608443f2d2SAndrzej Pietrasiewicz case STATE_DEV_CONNECTED:
10618443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
10628443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s wait\n", __func__);
10638443f2d2SAndrzej Pietrasiewicz
10648443f2d2SAndrzej Pietrasiewicz /* wait for events */
10658443f2d2SAndrzej Pietrasiewicz retval = wait_event_interruptible (dev->wait,
10668443f2d2SAndrzej Pietrasiewicz dev->ev_next != 0);
10678443f2d2SAndrzej Pietrasiewicz if (retval < 0)
10688443f2d2SAndrzej Pietrasiewicz return retval;
10698443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
10708443f2d2SAndrzej Pietrasiewicz goto scan;
10718443f2d2SAndrzej Pietrasiewicz }
10728443f2d2SAndrzej Pietrasiewicz
10738443f2d2SAndrzej Pietrasiewicz done:
10748443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
10758443f2d2SAndrzej Pietrasiewicz return retval;
10768443f2d2SAndrzej Pietrasiewicz }
10778443f2d2SAndrzej Pietrasiewicz
10788443f2d2SAndrzej Pietrasiewicz static struct usb_gadgetfs_event *
next_event(struct dev_data * dev,enum usb_gadgetfs_event_type type)10798443f2d2SAndrzej Pietrasiewicz next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type)
10808443f2d2SAndrzej Pietrasiewicz {
10818443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event *event;
10828443f2d2SAndrzej Pietrasiewicz unsigned i;
10838443f2d2SAndrzej Pietrasiewicz
10848443f2d2SAndrzej Pietrasiewicz switch (type) {
10858443f2d2SAndrzej Pietrasiewicz /* these events purge the queue */
10868443f2d2SAndrzej Pietrasiewicz case GADGETFS_DISCONNECT:
10878443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_SETUP)
10888443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 1;
1089a74005abSGustavo A. R. Silva fallthrough;
10908443f2d2SAndrzej Pietrasiewicz case GADGETFS_CONNECT:
10918443f2d2SAndrzej Pietrasiewicz dev->ev_next = 0;
10928443f2d2SAndrzej Pietrasiewicz break;
10938443f2d2SAndrzej Pietrasiewicz case GADGETFS_SETUP: /* previous request timed out */
10948443f2d2SAndrzej Pietrasiewicz case GADGETFS_SUSPEND: /* same effect */
10958443f2d2SAndrzej Pietrasiewicz /* these events can't be repeated */
10968443f2d2SAndrzej Pietrasiewicz for (i = 0; i != dev->ev_next; i++) {
10978443f2d2SAndrzej Pietrasiewicz if (dev->event [i].type != type)
10988443f2d2SAndrzej Pietrasiewicz continue;
10998443f2d2SAndrzej Pietrasiewicz DBG(dev, "discard old event[%d] %d\n", i, type);
11008443f2d2SAndrzej Pietrasiewicz dev->ev_next--;
11018443f2d2SAndrzej Pietrasiewicz if (i == dev->ev_next)
11028443f2d2SAndrzej Pietrasiewicz break;
11038443f2d2SAndrzej Pietrasiewicz /* indices start at zero, for simplicity */
11048443f2d2SAndrzej Pietrasiewicz memmove (&dev->event [i], &dev->event [i + 1],
11058443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_gadgetfs_event)
11068443f2d2SAndrzej Pietrasiewicz * (dev->ev_next - i));
11078443f2d2SAndrzej Pietrasiewicz }
11088443f2d2SAndrzej Pietrasiewicz break;
11098443f2d2SAndrzej Pietrasiewicz default:
11108443f2d2SAndrzej Pietrasiewicz BUG ();
11118443f2d2SAndrzej Pietrasiewicz }
11128443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "event[%d] = %d\n", dev->ev_next, type);
11138443f2d2SAndrzej Pietrasiewicz event = &dev->event [dev->ev_next++];
11148443f2d2SAndrzej Pietrasiewicz BUG_ON (dev->ev_next > N_EVENT);
11158443f2d2SAndrzej Pietrasiewicz memset (event, 0, sizeof *event);
11168443f2d2SAndrzej Pietrasiewicz event->type = type;
11178443f2d2SAndrzej Pietrasiewicz return event;
11188443f2d2SAndrzej Pietrasiewicz }
11198443f2d2SAndrzej Pietrasiewicz
11208443f2d2SAndrzej Pietrasiewicz static ssize_t
ep0_write(struct file * fd,const char __user * buf,size_t len,loff_t * ptr)11218443f2d2SAndrzej Pietrasiewicz ep0_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
11228443f2d2SAndrzej Pietrasiewicz {
11238443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
11248443f2d2SAndrzej Pietrasiewicz ssize_t retval = -ESRCH;
11258443f2d2SAndrzej Pietrasiewicz
11268443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */
11278443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) {
11288443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0;
11298443f2d2SAndrzej Pietrasiewicz retval = -EIDRM;
11308443f2d2SAndrzej Pietrasiewicz
11318443f2d2SAndrzej Pietrasiewicz /* data and/or status stage for control request */
11328443f2d2SAndrzej Pietrasiewicz } else if (dev->state == STATE_DEV_SETUP) {
11338443f2d2SAndrzej Pietrasiewicz
1134faab5098SAlan Stern len = min_t(size_t, len, dev->setup_wLength);
11358443f2d2SAndrzej Pietrasiewicz if (dev->setup_in) {
11368443f2d2SAndrzej Pietrasiewicz retval = setup_req (dev->gadget->ep0, dev->req, len);
11378443f2d2SAndrzej Pietrasiewicz if (retval == 0) {
11388443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
1139520b72fcSAlan Stern ++dev->udc_usage;
11408443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
11418443f2d2SAndrzej Pietrasiewicz if (copy_from_user (dev->req->buf, buf, len))
11428443f2d2SAndrzej Pietrasiewicz retval = -EFAULT;
11438443f2d2SAndrzej Pietrasiewicz else {
11448443f2d2SAndrzej Pietrasiewicz if (len < dev->setup_wLength)
11458443f2d2SAndrzej Pietrasiewicz dev->req->zero = 1;
11468443f2d2SAndrzej Pietrasiewicz retval = usb_ep_queue (
11478443f2d2SAndrzej Pietrasiewicz dev->gadget->ep0, dev->req,
11488443f2d2SAndrzej Pietrasiewicz GFP_KERNEL);
11498443f2d2SAndrzej Pietrasiewicz }
11508443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock);
1151520b72fcSAlan Stern --dev->udc_usage;
1152b7bd98b7SDavid Eccher if (retval < 0) {
11538443f2d2SAndrzej Pietrasiewicz clean_req (dev->gadget->ep0, dev->req);
11548443f2d2SAndrzej Pietrasiewicz } else
11558443f2d2SAndrzej Pietrasiewicz retval = len;
11568443f2d2SAndrzej Pietrasiewicz
11578443f2d2SAndrzej Pietrasiewicz return retval;
11588443f2d2SAndrzej Pietrasiewicz }
11598443f2d2SAndrzej Pietrasiewicz
11608443f2d2SAndrzej Pietrasiewicz /* can stall some OUT transfers */
11618443f2d2SAndrzej Pietrasiewicz } else if (dev->setup_can_stall) {
11628443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "ep0out stall\n");
11638443f2d2SAndrzej Pietrasiewicz (void) usb_ep_set_halt (dev->gadget->ep0);
11648443f2d2SAndrzej Pietrasiewicz retval = -EL2HLT;
11658443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
11668443f2d2SAndrzej Pietrasiewicz } else {
11678443f2d2SAndrzej Pietrasiewicz DBG(dev, "bogus ep0out stall!\n");
11688443f2d2SAndrzej Pietrasiewicz }
11698443f2d2SAndrzej Pietrasiewicz } else
11708443f2d2SAndrzej Pietrasiewicz DBG (dev, "fail %s, state %d\n", __func__, dev->state);
11718443f2d2SAndrzej Pietrasiewicz
11728443f2d2SAndrzej Pietrasiewicz return retval;
11738443f2d2SAndrzej Pietrasiewicz }
11748443f2d2SAndrzej Pietrasiewicz
11758443f2d2SAndrzej Pietrasiewicz static int
ep0_fasync(int f,struct file * fd,int on)11768443f2d2SAndrzej Pietrasiewicz ep0_fasync (int f, struct file *fd, int on)
11778443f2d2SAndrzej Pietrasiewicz {
11788443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
11798443f2d2SAndrzej Pietrasiewicz // caller must F_SETOWN before signal delivery happens
11808443f2d2SAndrzej Pietrasiewicz VDEBUG (dev, "%s %s\n", __func__, on ? "on" : "off");
11818443f2d2SAndrzej Pietrasiewicz return fasync_helper (f, fd, on, &dev->fasync);
11828443f2d2SAndrzej Pietrasiewicz }
11838443f2d2SAndrzej Pietrasiewicz
11848443f2d2SAndrzej Pietrasiewicz static struct usb_gadget_driver gadgetfs_driver;
11858443f2d2SAndrzej Pietrasiewicz
11868443f2d2SAndrzej Pietrasiewicz static int
dev_release(struct inode * inode,struct file * fd)11878443f2d2SAndrzej Pietrasiewicz dev_release (struct inode *inode, struct file *fd)
11888443f2d2SAndrzej Pietrasiewicz {
11898443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
11908443f2d2SAndrzej Pietrasiewicz
11918443f2d2SAndrzej Pietrasiewicz /* closing ep0 === shutdown all */
11928443f2d2SAndrzej Pietrasiewicz
1193f50b878fSAlan Stern if (dev->gadget_registered) {
11948443f2d2SAndrzej Pietrasiewicz usb_gadget_unregister_driver (&gadgetfs_driver);
1195f50b878fSAlan Stern dev->gadget_registered = false;
1196f50b878fSAlan Stern }
11978443f2d2SAndrzej Pietrasiewicz
11988443f2d2SAndrzej Pietrasiewicz /* at this point "good" hardware has disconnected the
11998443f2d2SAndrzej Pietrasiewicz * device from USB; the host won't see it any more.
12008443f2d2SAndrzej Pietrasiewicz * alternatively, all host requests will time out.
12018443f2d2SAndrzej Pietrasiewicz */
12028443f2d2SAndrzej Pietrasiewicz
12038443f2d2SAndrzej Pietrasiewicz kfree (dev->buf);
12048443f2d2SAndrzej Pietrasiewicz dev->buf = NULL;
12058443f2d2SAndrzej Pietrasiewicz
120661fe2d75SGreg Kroah-Hartman /* other endpoints were all decoupled from this device */
120761fe2d75SGreg Kroah-Hartman spin_lock_irq(&dev->lock);
120861fe2d75SGreg Kroah-Hartman dev->state = STATE_DEV_DISABLED;
120961fe2d75SGreg Kroah-Hartman spin_unlock_irq(&dev->lock);
121061fe2d75SGreg Kroah-Hartman
121161fe2d75SGreg Kroah-Hartman put_dev (dev);
12128443f2d2SAndrzej Pietrasiewicz return 0;
12138443f2d2SAndrzej Pietrasiewicz }
12148443f2d2SAndrzej Pietrasiewicz
1215afc9a42bSAl Viro static __poll_t
ep0_poll(struct file * fd,poll_table * wait)12168443f2d2SAndrzej Pietrasiewicz ep0_poll (struct file *fd, poll_table *wait)
12178443f2d2SAndrzej Pietrasiewicz {
12188443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
1219afc9a42bSAl Viro __poll_t mask = 0;
12208443f2d2SAndrzej Pietrasiewicz
122196b62a57SAlan Stern if (dev->state <= STATE_DEV_OPENED)
122296b62a57SAlan Stern return DEFAULT_POLLMASK;
122396b62a57SAlan Stern
12248443f2d2SAndrzej Pietrasiewicz poll_wait(fd, &dev->wait, wait);
12258443f2d2SAndrzej Pietrasiewicz
12268443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock);
12278443f2d2SAndrzej Pietrasiewicz
12288443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */
12298443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) {
12308443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0;
1231a9a08845SLinus Torvalds mask = EPOLLHUP;
12328443f2d2SAndrzej Pietrasiewicz goto out;
12338443f2d2SAndrzej Pietrasiewicz }
12348443f2d2SAndrzej Pietrasiewicz
12358443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_SETUP) {
12368443f2d2SAndrzej Pietrasiewicz if (dev->setup_in || dev->setup_can_stall)
1237a9a08845SLinus Torvalds mask = EPOLLOUT;
12388443f2d2SAndrzej Pietrasiewicz } else {
12398443f2d2SAndrzej Pietrasiewicz if (dev->ev_next != 0)
1240a9a08845SLinus Torvalds mask = EPOLLIN;
12418443f2d2SAndrzej Pietrasiewicz }
12428443f2d2SAndrzej Pietrasiewicz out:
12438443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock);
12448443f2d2SAndrzej Pietrasiewicz return mask;
12458443f2d2SAndrzej Pietrasiewicz }
12468443f2d2SAndrzej Pietrasiewicz
gadget_dev_ioctl(struct file * fd,unsigned code,unsigned long value)1247452785d0SIngo Molnar static long gadget_dev_ioctl (struct file *fd, unsigned code, unsigned long value)
12488443f2d2SAndrzej Pietrasiewicz {
12498443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
12508443f2d2SAndrzej Pietrasiewicz struct usb_gadget *gadget = dev->gadget;
12518443f2d2SAndrzej Pietrasiewicz long ret = -ENOTTY;
12528443f2d2SAndrzej Pietrasiewicz
1253520b72fcSAlan Stern spin_lock_irq(&dev->lock);
1254520b72fcSAlan Stern if (dev->state == STATE_DEV_OPENED ||
1255520b72fcSAlan Stern dev->state == STATE_DEV_UNBOUND) {
1256520b72fcSAlan Stern /* Not bound to a UDC */
1257520b72fcSAlan Stern } else if (gadget->ops->ioctl) {
1258520b72fcSAlan Stern ++dev->udc_usage;
1259520b72fcSAlan Stern spin_unlock_irq(&dev->lock);
1260520b72fcSAlan Stern
12618443f2d2SAndrzej Pietrasiewicz ret = gadget->ops->ioctl (gadget, code, value);
12628443f2d2SAndrzej Pietrasiewicz
1263520b72fcSAlan Stern spin_lock_irq(&dev->lock);
1264520b72fcSAlan Stern --dev->udc_usage;
1265520b72fcSAlan Stern }
1266520b72fcSAlan Stern spin_unlock_irq(&dev->lock);
1267520b72fcSAlan Stern
12688443f2d2SAndrzej Pietrasiewicz return ret;
12698443f2d2SAndrzej Pietrasiewicz }
12708443f2d2SAndrzej Pietrasiewicz
12718443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
12728443f2d2SAndrzej Pietrasiewicz
12738443f2d2SAndrzej Pietrasiewicz /* The in-kernel gadget driver handles most ep0 issues, in particular
12748443f2d2SAndrzej Pietrasiewicz * enumerating the single configuration (as provided from user space).
12758443f2d2SAndrzej Pietrasiewicz *
12768443f2d2SAndrzej Pietrasiewicz * Unrecognized ep0 requests may be handled in user space.
12778443f2d2SAndrzej Pietrasiewicz */
12788443f2d2SAndrzej Pietrasiewicz
make_qualifier(struct dev_data * dev)12798443f2d2SAndrzej Pietrasiewicz static void make_qualifier (struct dev_data *dev)
12808443f2d2SAndrzej Pietrasiewicz {
12818443f2d2SAndrzej Pietrasiewicz struct usb_qualifier_descriptor qual;
12828443f2d2SAndrzej Pietrasiewicz struct usb_device_descriptor *desc;
12838443f2d2SAndrzej Pietrasiewicz
12848443f2d2SAndrzej Pietrasiewicz qual.bLength = sizeof qual;
12858443f2d2SAndrzej Pietrasiewicz qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
12868443f2d2SAndrzej Pietrasiewicz qual.bcdUSB = cpu_to_le16 (0x0200);
12878443f2d2SAndrzej Pietrasiewicz
12888443f2d2SAndrzej Pietrasiewicz desc = dev->dev;
12898443f2d2SAndrzej Pietrasiewicz qual.bDeviceClass = desc->bDeviceClass;
12908443f2d2SAndrzej Pietrasiewicz qual.bDeviceSubClass = desc->bDeviceSubClass;
12918443f2d2SAndrzej Pietrasiewicz qual.bDeviceProtocol = desc->bDeviceProtocol;
12928443f2d2SAndrzej Pietrasiewicz
12938443f2d2SAndrzej Pietrasiewicz /* assumes ep0 uses the same value for both speeds ... */
12948443f2d2SAndrzej Pietrasiewicz qual.bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
12958443f2d2SAndrzej Pietrasiewicz
12968443f2d2SAndrzej Pietrasiewicz qual.bNumConfigurations = 1;
12978443f2d2SAndrzej Pietrasiewicz qual.bRESERVED = 0;
12988443f2d2SAndrzej Pietrasiewicz
12998443f2d2SAndrzej Pietrasiewicz memcpy (dev->rbuf, &qual, sizeof qual);
13008443f2d2SAndrzej Pietrasiewicz }
13018443f2d2SAndrzej Pietrasiewicz
13028443f2d2SAndrzej Pietrasiewicz static int
config_buf(struct dev_data * dev,u8 type,unsigned index)13038443f2d2SAndrzej Pietrasiewicz config_buf (struct dev_data *dev, u8 type, unsigned index)
13048443f2d2SAndrzej Pietrasiewicz {
13058443f2d2SAndrzej Pietrasiewicz int len;
13068443f2d2SAndrzej Pietrasiewicz int hs = 0;
13078443f2d2SAndrzej Pietrasiewicz
13088443f2d2SAndrzej Pietrasiewicz /* only one configuration */
13098443f2d2SAndrzej Pietrasiewicz if (index > 0)
13108443f2d2SAndrzej Pietrasiewicz return -EINVAL;
13118443f2d2SAndrzej Pietrasiewicz
13128443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(dev->gadget)) {
13138443f2d2SAndrzej Pietrasiewicz hs = (dev->gadget->speed == USB_SPEED_HIGH);
13148443f2d2SAndrzej Pietrasiewicz if (type == USB_DT_OTHER_SPEED_CONFIG)
13158443f2d2SAndrzej Pietrasiewicz hs = !hs;
13168443f2d2SAndrzej Pietrasiewicz }
13178443f2d2SAndrzej Pietrasiewicz if (hs) {
13188443f2d2SAndrzej Pietrasiewicz dev->req->buf = dev->hs_config;
13198443f2d2SAndrzej Pietrasiewicz len = le16_to_cpu(dev->hs_config->wTotalLength);
13208443f2d2SAndrzej Pietrasiewicz } else {
13218443f2d2SAndrzej Pietrasiewicz dev->req->buf = dev->config;
13228443f2d2SAndrzej Pietrasiewicz len = le16_to_cpu(dev->config->wTotalLength);
13238443f2d2SAndrzej Pietrasiewicz }
13248443f2d2SAndrzej Pietrasiewicz ((u8 *)dev->req->buf) [1] = type;
13258443f2d2SAndrzej Pietrasiewicz return len;
13268443f2d2SAndrzej Pietrasiewicz }
13278443f2d2SAndrzej Pietrasiewicz
13288443f2d2SAndrzej Pietrasiewicz static int
gadgetfs_setup(struct usb_gadget * gadget,const struct usb_ctrlrequest * ctrl)13298443f2d2SAndrzej Pietrasiewicz gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
13308443f2d2SAndrzej Pietrasiewicz {
13318443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget);
13328443f2d2SAndrzej Pietrasiewicz struct usb_request *req = dev->req;
13338443f2d2SAndrzej Pietrasiewicz int value = -EOPNOTSUPP;
13348443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event *event;
13358443f2d2SAndrzej Pietrasiewicz u16 w_value = le16_to_cpu(ctrl->wValue);
13368443f2d2SAndrzej Pietrasiewicz u16 w_length = le16_to_cpu(ctrl->wLength);
13378443f2d2SAndrzej Pietrasiewicz
1338153a2d7eSGreg Kroah-Hartman if (w_length > RBUF_SIZE) {
1339f08adf5aSGreg Kroah-Hartman if (ctrl->bRequestType & USB_DIR_IN) {
1340153a2d7eSGreg Kroah-Hartman /* Cast away the const, we are going to overwrite on purpose. */
1341153a2d7eSGreg Kroah-Hartman __le16 *temp = (__le16 *)&ctrl->wLength;
1342153a2d7eSGreg Kroah-Hartman
1343153a2d7eSGreg Kroah-Hartman *temp = cpu_to_le16(RBUF_SIZE);
1344153a2d7eSGreg Kroah-Hartman w_length = RBUF_SIZE;
1345f08adf5aSGreg Kroah-Hartman } else {
1346f08adf5aSGreg Kroah-Hartman return value;
1347153a2d7eSGreg Kroah-Hartman }
1348153a2d7eSGreg Kroah-Hartman }
1349153a2d7eSGreg Kroah-Hartman
13508443f2d2SAndrzej Pietrasiewicz spin_lock (&dev->lock);
13518443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0;
13528443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_UNCONNECTED) {
13538443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(gadget)
13548443f2d2SAndrzej Pietrasiewicz && gadget->speed == USB_SPEED_HIGH
13558443f2d2SAndrzej Pietrasiewicz && dev->hs_config == NULL) {
13568443f2d2SAndrzej Pietrasiewicz spin_unlock(&dev->lock);
13578443f2d2SAndrzej Pietrasiewicz ERROR (dev, "no high speed config??\n");
13588443f2d2SAndrzej Pietrasiewicz return -EINVAL;
13598443f2d2SAndrzej Pietrasiewicz }
13608443f2d2SAndrzej Pietrasiewicz
13618443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED;
13628443f2d2SAndrzej Pietrasiewicz
13638443f2d2SAndrzej Pietrasiewicz INFO (dev, "connected\n");
13648443f2d2SAndrzej Pietrasiewicz event = next_event (dev, GADGETFS_CONNECT);
13658443f2d2SAndrzej Pietrasiewicz event->u.speed = gadget->speed;
13668443f2d2SAndrzej Pietrasiewicz ep0_readable (dev);
13678443f2d2SAndrzej Pietrasiewicz
13688443f2d2SAndrzej Pietrasiewicz /* host may have given up waiting for response. we can miss control
13698443f2d2SAndrzej Pietrasiewicz * requests handled lower down (device/endpoint status and features);
13708443f2d2SAndrzej Pietrasiewicz * then ep0_{read,write} will report the wrong status. controller
13718443f2d2SAndrzej Pietrasiewicz * driver will have aborted pending i/o.
13728443f2d2SAndrzej Pietrasiewicz */
13738443f2d2SAndrzej Pietrasiewicz } else if (dev->state == STATE_DEV_SETUP)
13748443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 1;
13758443f2d2SAndrzej Pietrasiewicz
13768443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf;
13778443f2d2SAndrzej Pietrasiewicz req->context = NULL;
13788443f2d2SAndrzej Pietrasiewicz switch (ctrl->bRequest) {
13798443f2d2SAndrzej Pietrasiewicz
13808443f2d2SAndrzej Pietrasiewicz case USB_REQ_GET_DESCRIPTOR:
13818443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != USB_DIR_IN)
13828443f2d2SAndrzej Pietrasiewicz goto unrecognized;
13838443f2d2SAndrzej Pietrasiewicz switch (w_value >> 8) {
13848443f2d2SAndrzej Pietrasiewicz
13858443f2d2SAndrzej Pietrasiewicz case USB_DT_DEVICE:
13868443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) sizeof *dev->dev);
13878443f2d2SAndrzej Pietrasiewicz dev->dev->bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
13888443f2d2SAndrzej Pietrasiewicz req->buf = dev->dev;
13898443f2d2SAndrzej Pietrasiewicz break;
13908443f2d2SAndrzej Pietrasiewicz case USB_DT_DEVICE_QUALIFIER:
13918443f2d2SAndrzej Pietrasiewicz if (!dev->hs_config)
13928443f2d2SAndrzej Pietrasiewicz break;
13938443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16)
13948443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_qualifier_descriptor));
13958443f2d2SAndrzej Pietrasiewicz make_qualifier (dev);
13968443f2d2SAndrzej Pietrasiewicz break;
13978443f2d2SAndrzej Pietrasiewicz case USB_DT_OTHER_SPEED_CONFIG:
13988443f2d2SAndrzej Pietrasiewicz case USB_DT_CONFIG:
13998443f2d2SAndrzej Pietrasiewicz value = config_buf (dev,
14008443f2d2SAndrzej Pietrasiewicz w_value >> 8,
14018443f2d2SAndrzej Pietrasiewicz w_value & 0xff);
14028443f2d2SAndrzej Pietrasiewicz if (value >= 0)
14038443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) value);
14048443f2d2SAndrzej Pietrasiewicz break;
14058443f2d2SAndrzej Pietrasiewicz case USB_DT_STRING:
14068443f2d2SAndrzej Pietrasiewicz goto unrecognized;
14078443f2d2SAndrzej Pietrasiewicz
14088443f2d2SAndrzej Pietrasiewicz default: // all others are errors
14098443f2d2SAndrzej Pietrasiewicz break;
14108443f2d2SAndrzej Pietrasiewicz }
14118443f2d2SAndrzej Pietrasiewicz break;
14128443f2d2SAndrzej Pietrasiewicz
14138443f2d2SAndrzej Pietrasiewicz /* currently one config, two speeds */
14148443f2d2SAndrzej Pietrasiewicz case USB_REQ_SET_CONFIGURATION:
14158443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != 0)
14168443f2d2SAndrzej Pietrasiewicz goto unrecognized;
14178443f2d2SAndrzej Pietrasiewicz if (0 == (u8) w_value) {
14188443f2d2SAndrzej Pietrasiewicz value = 0;
14198443f2d2SAndrzej Pietrasiewicz dev->current_config = 0;
14208443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(gadget, 8 /* mA */ );
14218443f2d2SAndrzej Pietrasiewicz // user mode expected to disable endpoints
14228443f2d2SAndrzej Pietrasiewicz } else {
14238443f2d2SAndrzej Pietrasiewicz u8 config, power;
14248443f2d2SAndrzej Pietrasiewicz
14258443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(gadget)
14268443f2d2SAndrzej Pietrasiewicz && gadget->speed == USB_SPEED_HIGH) {
14278443f2d2SAndrzej Pietrasiewicz config = dev->hs_config->bConfigurationValue;
14288443f2d2SAndrzej Pietrasiewicz power = dev->hs_config->bMaxPower;
14298443f2d2SAndrzej Pietrasiewicz } else {
14308443f2d2SAndrzej Pietrasiewicz config = dev->config->bConfigurationValue;
14318443f2d2SAndrzej Pietrasiewicz power = dev->config->bMaxPower;
14328443f2d2SAndrzej Pietrasiewicz }
14338443f2d2SAndrzej Pietrasiewicz
14348443f2d2SAndrzej Pietrasiewicz if (config == (u8) w_value) {
14358443f2d2SAndrzej Pietrasiewicz value = 0;
14368443f2d2SAndrzej Pietrasiewicz dev->current_config = config;
14378443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(gadget, 2 * power);
14388443f2d2SAndrzej Pietrasiewicz }
14398443f2d2SAndrzej Pietrasiewicz }
14408443f2d2SAndrzej Pietrasiewicz
14418443f2d2SAndrzej Pietrasiewicz /* report SET_CONFIGURATION like any other control request,
14428443f2d2SAndrzej Pietrasiewicz * except that usermode may not stall this. the next
14438443f2d2SAndrzej Pietrasiewicz * request mustn't be allowed start until this finishes:
14448443f2d2SAndrzej Pietrasiewicz * endpoints and threads set up, etc.
14458443f2d2SAndrzej Pietrasiewicz *
14468443f2d2SAndrzej Pietrasiewicz * NOTE: older PXA hardware (before PXA 255: without UDCCFR)
14478443f2d2SAndrzej Pietrasiewicz * has bad/racey automagic that prevents synchronizing here.
14488443f2d2SAndrzej Pietrasiewicz * even kernel mode drivers often miss them.
14498443f2d2SAndrzej Pietrasiewicz */
14508443f2d2SAndrzej Pietrasiewicz if (value == 0) {
14518443f2d2SAndrzej Pietrasiewicz INFO (dev, "configuration #%d\n", dev->current_config);
14528443f2d2SAndrzej Pietrasiewicz usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
14538443f2d2SAndrzej Pietrasiewicz if (dev->usermode_setup) {
14548443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 0;
14558443f2d2SAndrzej Pietrasiewicz goto delegate;
14568443f2d2SAndrzej Pietrasiewicz }
14578443f2d2SAndrzej Pietrasiewicz }
14588443f2d2SAndrzej Pietrasiewicz break;
14598443f2d2SAndrzej Pietrasiewicz
14608443f2d2SAndrzej Pietrasiewicz #ifndef CONFIG_USB_PXA25X
14618443f2d2SAndrzej Pietrasiewicz /* PXA automagically handles this request too */
14628443f2d2SAndrzej Pietrasiewicz case USB_REQ_GET_CONFIGURATION:
14638443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != 0x80)
14648443f2d2SAndrzej Pietrasiewicz goto unrecognized;
14658443f2d2SAndrzej Pietrasiewicz *(u8 *)req->buf = dev->current_config;
14668443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) 1);
14678443f2d2SAndrzej Pietrasiewicz break;
14688443f2d2SAndrzej Pietrasiewicz #endif
14698443f2d2SAndrzej Pietrasiewicz
14708443f2d2SAndrzej Pietrasiewicz default:
14718443f2d2SAndrzej Pietrasiewicz unrecognized:
14728443f2d2SAndrzej Pietrasiewicz VDEBUG (dev, "%s req%02x.%02x v%04x i%04x l%d\n",
14738443f2d2SAndrzej Pietrasiewicz dev->usermode_setup ? "delegate" : "fail",
14748443f2d2SAndrzej Pietrasiewicz ctrl->bRequestType, ctrl->bRequest,
14758443f2d2SAndrzej Pietrasiewicz w_value, le16_to_cpu(ctrl->wIndex), w_length);
14768443f2d2SAndrzej Pietrasiewicz
14778443f2d2SAndrzej Pietrasiewicz /* if there's an ep0 reader, don't stall */
14788443f2d2SAndrzej Pietrasiewicz if (dev->usermode_setup) {
14798443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 1;
14808443f2d2SAndrzej Pietrasiewicz delegate:
14818443f2d2SAndrzej Pietrasiewicz dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
14828443f2d2SAndrzej Pietrasiewicz ? 1 : 0;
14838443f2d2SAndrzej Pietrasiewicz dev->setup_wLength = w_length;
14848443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 0;
14858443f2d2SAndrzej Pietrasiewicz dev->setup_out_error = 0;
14868443f2d2SAndrzej Pietrasiewicz
14878443f2d2SAndrzej Pietrasiewicz /* read DATA stage for OUT right away */
14888443f2d2SAndrzej Pietrasiewicz if (unlikely (!dev->setup_in && w_length)) {
14898443f2d2SAndrzej Pietrasiewicz value = setup_req (gadget->ep0, dev->req,
14908443f2d2SAndrzej Pietrasiewicz w_length);
14918443f2d2SAndrzej Pietrasiewicz if (value < 0)
14928443f2d2SAndrzej Pietrasiewicz break;
1493d246dcb2SBin Liu
1494520b72fcSAlan Stern ++dev->udc_usage;
1495d246dcb2SBin Liu spin_unlock (&dev->lock);
14968443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue (gadget->ep0, dev->req,
1497d246dcb2SBin Liu GFP_KERNEL);
1498d246dcb2SBin Liu spin_lock (&dev->lock);
1499520b72fcSAlan Stern --dev->udc_usage;
15008443f2d2SAndrzej Pietrasiewicz if (value < 0) {
15018443f2d2SAndrzej Pietrasiewicz clean_req (gadget->ep0, dev->req);
15028443f2d2SAndrzej Pietrasiewicz break;
15038443f2d2SAndrzej Pietrasiewicz }
15048443f2d2SAndrzej Pietrasiewicz
15058443f2d2SAndrzej Pietrasiewicz /* we can't currently stall these */
15068443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 0;
15078443f2d2SAndrzej Pietrasiewicz }
15088443f2d2SAndrzej Pietrasiewicz
15098443f2d2SAndrzej Pietrasiewicz /* state changes when reader collects event */
15108443f2d2SAndrzej Pietrasiewicz event = next_event (dev, GADGETFS_SETUP);
15118443f2d2SAndrzej Pietrasiewicz event->u.setup = *ctrl;
15128443f2d2SAndrzej Pietrasiewicz ep0_readable (dev);
15138443f2d2SAndrzej Pietrasiewicz spin_unlock (&dev->lock);
15148443f2d2SAndrzej Pietrasiewicz return 0;
15158443f2d2SAndrzej Pietrasiewicz }
15168443f2d2SAndrzej Pietrasiewicz }
15178443f2d2SAndrzej Pietrasiewicz
15188443f2d2SAndrzej Pietrasiewicz /* proceed with data transfer and status phases? */
15198443f2d2SAndrzej Pietrasiewicz if (value >= 0 && dev->state != STATE_DEV_SETUP) {
15208443f2d2SAndrzej Pietrasiewicz req->length = value;
15218443f2d2SAndrzej Pietrasiewicz req->zero = value < w_length;
1522d246dcb2SBin Liu
1523520b72fcSAlan Stern ++dev->udc_usage;
1524d246dcb2SBin Liu spin_unlock (&dev->lock);
1525d246dcb2SBin Liu value = usb_ep_queue (gadget->ep0, req, GFP_KERNEL);
1526520b72fcSAlan Stern spin_lock(&dev->lock);
1527520b72fcSAlan Stern --dev->udc_usage;
1528520b72fcSAlan Stern spin_unlock(&dev->lock);
15298443f2d2SAndrzej Pietrasiewicz if (value < 0) {
15308443f2d2SAndrzej Pietrasiewicz DBG (dev, "ep_queue --> %d\n", value);
15318443f2d2SAndrzej Pietrasiewicz req->status = 0;
15328443f2d2SAndrzej Pietrasiewicz }
1533d246dcb2SBin Liu return value;
15348443f2d2SAndrzej Pietrasiewicz }
15358443f2d2SAndrzej Pietrasiewicz
15368443f2d2SAndrzej Pietrasiewicz /* device stalls when value < 0 */
15378443f2d2SAndrzej Pietrasiewicz spin_unlock (&dev->lock);
15388443f2d2SAndrzej Pietrasiewicz return value;
15398443f2d2SAndrzej Pietrasiewicz }
15408443f2d2SAndrzej Pietrasiewicz
destroy_ep_files(struct dev_data * dev)15418443f2d2SAndrzej Pietrasiewicz static void destroy_ep_files (struct dev_data *dev)
15428443f2d2SAndrzej Pietrasiewicz {
15438443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s %d\n", __func__, dev->state);
15448443f2d2SAndrzej Pietrasiewicz
15458443f2d2SAndrzej Pietrasiewicz /* dev->state must prevent interference */
15468443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
15478443f2d2SAndrzej Pietrasiewicz while (!list_empty(&dev->epfiles)) {
15488443f2d2SAndrzej Pietrasiewicz struct ep_data *ep;
15498443f2d2SAndrzej Pietrasiewicz struct inode *parent;
15508443f2d2SAndrzej Pietrasiewicz struct dentry *dentry;
15518443f2d2SAndrzej Pietrasiewicz
15528443f2d2SAndrzej Pietrasiewicz /* break link to FS */
15538443f2d2SAndrzej Pietrasiewicz ep = list_first_entry (&dev->epfiles, struct ep_data, epfiles);
15548443f2d2SAndrzej Pietrasiewicz list_del_init (&ep->epfiles);
1555520b72fcSAlan Stern spin_unlock_irq (&dev->lock);
1556520b72fcSAlan Stern
15578443f2d2SAndrzej Pietrasiewicz dentry = ep->dentry;
15588443f2d2SAndrzej Pietrasiewicz ep->dentry = NULL;
155975c3cfa8SDavid Howells parent = d_inode(dentry->d_parent);
15608443f2d2SAndrzej Pietrasiewicz
15618443f2d2SAndrzej Pietrasiewicz /* break link to controller */
1562520b72fcSAlan Stern mutex_lock(&ep->lock);
15638443f2d2SAndrzej Pietrasiewicz if (ep->state == STATE_EP_ENABLED)
15648443f2d2SAndrzej Pietrasiewicz (void) usb_ep_disable (ep->ep);
15658443f2d2SAndrzej Pietrasiewicz ep->state = STATE_EP_UNBOUND;
15668443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (ep->ep, ep->req);
15678443f2d2SAndrzej Pietrasiewicz ep->ep = NULL;
1568520b72fcSAlan Stern mutex_unlock(&ep->lock);
1569520b72fcSAlan Stern
15708443f2d2SAndrzej Pietrasiewicz wake_up (&ep->wait);
15718443f2d2SAndrzej Pietrasiewicz put_ep (ep);
15728443f2d2SAndrzej Pietrasiewicz
15738443f2d2SAndrzej Pietrasiewicz /* break link to dcache */
15745955102cSAl Viro inode_lock(parent);
15758443f2d2SAndrzej Pietrasiewicz d_delete (dentry);
15768443f2d2SAndrzej Pietrasiewicz dput (dentry);
15775955102cSAl Viro inode_unlock(parent);
15788443f2d2SAndrzej Pietrasiewicz
15798443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
15808443f2d2SAndrzej Pietrasiewicz }
15818443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
15828443f2d2SAndrzej Pietrasiewicz }
15838443f2d2SAndrzej Pietrasiewicz
15848443f2d2SAndrzej Pietrasiewicz
1585fb6c3225SAl Viro static struct dentry *
15868443f2d2SAndrzej Pietrasiewicz gadgetfs_create_file (struct super_block *sb, char const *name,
1587fb6c3225SAl Viro void *data, const struct file_operations *fops);
15888443f2d2SAndrzej Pietrasiewicz
activate_ep_files(struct dev_data * dev)15898443f2d2SAndrzej Pietrasiewicz static int activate_ep_files (struct dev_data *dev)
15908443f2d2SAndrzej Pietrasiewicz {
15918443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep;
15928443f2d2SAndrzej Pietrasiewicz struct ep_data *data;
15938443f2d2SAndrzej Pietrasiewicz
15948443f2d2SAndrzej Pietrasiewicz gadget_for_each_ep (ep, dev->gadget) {
15958443f2d2SAndrzej Pietrasiewicz
15968443f2d2SAndrzej Pietrasiewicz data = kzalloc(sizeof(*data), GFP_KERNEL);
15978443f2d2SAndrzej Pietrasiewicz if (!data)
15988443f2d2SAndrzej Pietrasiewicz goto enomem0;
15998443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_DISABLED;
16008443f2d2SAndrzej Pietrasiewicz mutex_init(&data->lock);
16018443f2d2SAndrzej Pietrasiewicz init_waitqueue_head (&data->wait);
16028443f2d2SAndrzej Pietrasiewicz
16038443f2d2SAndrzej Pietrasiewicz strncpy (data->name, ep->name, sizeof (data->name) - 1);
16048d66db50SElena Reshetova refcount_set (&data->count, 1);
16058443f2d2SAndrzej Pietrasiewicz data->dev = dev;
16068443f2d2SAndrzej Pietrasiewicz get_dev (dev);
16078443f2d2SAndrzej Pietrasiewicz
16088443f2d2SAndrzej Pietrasiewicz data->ep = ep;
16098443f2d2SAndrzej Pietrasiewicz ep->driver_data = data;
16108443f2d2SAndrzej Pietrasiewicz
16118443f2d2SAndrzej Pietrasiewicz data->req = usb_ep_alloc_request (ep, GFP_KERNEL);
16128443f2d2SAndrzej Pietrasiewicz if (!data->req)
16138443f2d2SAndrzej Pietrasiewicz goto enomem1;
16148443f2d2SAndrzej Pietrasiewicz
1615fb6c3225SAl Viro data->dentry = gadgetfs_create_file (dev->sb, data->name,
1616d4461a60SAl Viro data, &ep_io_operations);
1617fb6c3225SAl Viro if (!data->dentry)
16188443f2d2SAndrzej Pietrasiewicz goto enomem2;
16198443f2d2SAndrzej Pietrasiewicz list_add_tail (&data->epfiles, &dev->epfiles);
16208443f2d2SAndrzej Pietrasiewicz }
16218443f2d2SAndrzej Pietrasiewicz return 0;
16228443f2d2SAndrzej Pietrasiewicz
16238443f2d2SAndrzej Pietrasiewicz enomem2:
16248443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (ep, data->req);
16258443f2d2SAndrzej Pietrasiewicz enomem1:
16268443f2d2SAndrzej Pietrasiewicz put_dev (dev);
16278443f2d2SAndrzej Pietrasiewicz kfree (data);
16288443f2d2SAndrzej Pietrasiewicz enomem0:
16298443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s enomem\n", __func__);
16308443f2d2SAndrzej Pietrasiewicz destroy_ep_files (dev);
16318443f2d2SAndrzej Pietrasiewicz return -ENOMEM;
16328443f2d2SAndrzej Pietrasiewicz }
16338443f2d2SAndrzej Pietrasiewicz
16348443f2d2SAndrzej Pietrasiewicz static void
gadgetfs_unbind(struct usb_gadget * gadget)16358443f2d2SAndrzej Pietrasiewicz gadgetfs_unbind (struct usb_gadget *gadget)
16368443f2d2SAndrzej Pietrasiewicz {
16378443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget);
16388443f2d2SAndrzej Pietrasiewicz
16398443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s\n", __func__);
16408443f2d2SAndrzej Pietrasiewicz
16418443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
16428443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNBOUND;
1643520b72fcSAlan Stern while (dev->udc_usage > 0) {
1644520b72fcSAlan Stern spin_unlock_irq(&dev->lock);
1645520b72fcSAlan Stern usleep_range(1000, 2000);
1646520b72fcSAlan Stern spin_lock_irq(&dev->lock);
1647520b72fcSAlan Stern }
16488443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
16498443f2d2SAndrzej Pietrasiewicz
16508443f2d2SAndrzej Pietrasiewicz destroy_ep_files (dev);
16518443f2d2SAndrzej Pietrasiewicz gadget->ep0->driver_data = NULL;
16528443f2d2SAndrzej Pietrasiewicz set_gadget_data (gadget, NULL);
16538443f2d2SAndrzej Pietrasiewicz
16548443f2d2SAndrzej Pietrasiewicz /* we've already been disconnected ... no i/o is active */
16558443f2d2SAndrzej Pietrasiewicz if (dev->req)
16568443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (gadget->ep0, dev->req);
16578443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s done\n", __func__);
16588443f2d2SAndrzej Pietrasiewicz put_dev (dev);
16598443f2d2SAndrzej Pietrasiewicz }
16608443f2d2SAndrzej Pietrasiewicz
16618443f2d2SAndrzej Pietrasiewicz static struct dev_data *the_device;
16628443f2d2SAndrzej Pietrasiewicz
gadgetfs_bind(struct usb_gadget * gadget,struct usb_gadget_driver * driver)16638443f2d2SAndrzej Pietrasiewicz static int gadgetfs_bind(struct usb_gadget *gadget,
16648443f2d2SAndrzej Pietrasiewicz struct usb_gadget_driver *driver)
16658443f2d2SAndrzej Pietrasiewicz {
16668443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = the_device;
16678443f2d2SAndrzej Pietrasiewicz
16688443f2d2SAndrzej Pietrasiewicz if (!dev)
16698443f2d2SAndrzej Pietrasiewicz return -ESRCH;
16708443f2d2SAndrzej Pietrasiewicz if (0 != strcmp (CHIP, gadget->name)) {
16718443f2d2SAndrzej Pietrasiewicz pr_err("%s expected %s controller not %s\n",
16728443f2d2SAndrzej Pietrasiewicz shortname, CHIP, gadget->name);
16738443f2d2SAndrzej Pietrasiewicz return -ENODEV;
16748443f2d2SAndrzej Pietrasiewicz }
16758443f2d2SAndrzej Pietrasiewicz
16768443f2d2SAndrzej Pietrasiewicz set_gadget_data (gadget, dev);
16778443f2d2SAndrzej Pietrasiewicz dev->gadget = gadget;
16788443f2d2SAndrzej Pietrasiewicz gadget->ep0->driver_data = dev;
16798443f2d2SAndrzej Pietrasiewicz
16808443f2d2SAndrzej Pietrasiewicz /* preallocate control response and buffer */
16818443f2d2SAndrzej Pietrasiewicz dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
16828443f2d2SAndrzej Pietrasiewicz if (!dev->req)
16838443f2d2SAndrzej Pietrasiewicz goto enomem;
16848443f2d2SAndrzej Pietrasiewicz dev->req->context = NULL;
16858443f2d2SAndrzej Pietrasiewicz dev->req->complete = epio_complete;
16868443f2d2SAndrzej Pietrasiewicz
16878443f2d2SAndrzej Pietrasiewicz if (activate_ep_files (dev) < 0)
16888443f2d2SAndrzej Pietrasiewicz goto enomem;
16898443f2d2SAndrzej Pietrasiewicz
16908443f2d2SAndrzej Pietrasiewicz INFO (dev, "bound to %s driver\n", gadget->name);
16918443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock);
16928443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNCONNECTED;
16938443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock);
16948443f2d2SAndrzej Pietrasiewicz get_dev (dev);
16958443f2d2SAndrzej Pietrasiewicz return 0;
16968443f2d2SAndrzej Pietrasiewicz
16978443f2d2SAndrzej Pietrasiewicz enomem:
16988443f2d2SAndrzej Pietrasiewicz gadgetfs_unbind (gadget);
16998443f2d2SAndrzej Pietrasiewicz return -ENOMEM;
17008443f2d2SAndrzej Pietrasiewicz }
17018443f2d2SAndrzej Pietrasiewicz
17028443f2d2SAndrzej Pietrasiewicz static void
gadgetfs_disconnect(struct usb_gadget * gadget)17038443f2d2SAndrzej Pietrasiewicz gadgetfs_disconnect (struct usb_gadget *gadget)
17048443f2d2SAndrzej Pietrasiewicz {
17058443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget);
17068443f2d2SAndrzej Pietrasiewicz unsigned long flags;
17078443f2d2SAndrzej Pietrasiewicz
17088443f2d2SAndrzej Pietrasiewicz spin_lock_irqsave (&dev->lock, flags);
17098443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_UNCONNECTED)
17108443f2d2SAndrzej Pietrasiewicz goto exit;
17118443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNCONNECTED;
17128443f2d2SAndrzej Pietrasiewicz
17138443f2d2SAndrzej Pietrasiewicz INFO (dev, "disconnected\n");
17148443f2d2SAndrzej Pietrasiewicz next_event (dev, GADGETFS_DISCONNECT);
17158443f2d2SAndrzej Pietrasiewicz ep0_readable (dev);
17168443f2d2SAndrzej Pietrasiewicz exit:
17178443f2d2SAndrzej Pietrasiewicz spin_unlock_irqrestore (&dev->lock, flags);
17188443f2d2SAndrzej Pietrasiewicz }
17198443f2d2SAndrzej Pietrasiewicz
17208443f2d2SAndrzej Pietrasiewicz static void
gadgetfs_suspend(struct usb_gadget * gadget)17218443f2d2SAndrzej Pietrasiewicz gadgetfs_suspend (struct usb_gadget *gadget)
17228443f2d2SAndrzej Pietrasiewicz {
17238443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget);
1724f16443a0SAlan Stern unsigned long flags;
17258443f2d2SAndrzej Pietrasiewicz
17268443f2d2SAndrzej Pietrasiewicz INFO (dev, "suspended from state %d\n", dev->state);
1727f16443a0SAlan Stern spin_lock_irqsave(&dev->lock, flags);
17288443f2d2SAndrzej Pietrasiewicz switch (dev->state) {
17298443f2d2SAndrzej Pietrasiewicz case STATE_DEV_SETUP: // VERY odd... host died??
17308443f2d2SAndrzej Pietrasiewicz case STATE_DEV_CONNECTED:
17318443f2d2SAndrzej Pietrasiewicz case STATE_DEV_UNCONNECTED:
17328443f2d2SAndrzej Pietrasiewicz next_event (dev, GADGETFS_SUSPEND);
17338443f2d2SAndrzej Pietrasiewicz ep0_readable (dev);
1734a74005abSGustavo A. R. Silva fallthrough;
17358443f2d2SAndrzej Pietrasiewicz default:
17368443f2d2SAndrzej Pietrasiewicz break;
17378443f2d2SAndrzej Pietrasiewicz }
1738f16443a0SAlan Stern spin_unlock_irqrestore(&dev->lock, flags);
17398443f2d2SAndrzej Pietrasiewicz }
17408443f2d2SAndrzej Pietrasiewicz
17418443f2d2SAndrzej Pietrasiewicz static struct usb_gadget_driver gadgetfs_driver = {
17428443f2d2SAndrzej Pietrasiewicz .function = (char *) driver_desc,
17438443f2d2SAndrzej Pietrasiewicz .bind = gadgetfs_bind,
17448443f2d2SAndrzej Pietrasiewicz .unbind = gadgetfs_unbind,
17458443f2d2SAndrzej Pietrasiewicz .setup = gadgetfs_setup,
17460eba4550SPeter Chen .reset = gadgetfs_disconnect,
17478443f2d2SAndrzej Pietrasiewicz .disconnect = gadgetfs_disconnect,
17488443f2d2SAndrzej Pietrasiewicz .suspend = gadgetfs_suspend,
17498443f2d2SAndrzej Pietrasiewicz
17508443f2d2SAndrzej Pietrasiewicz .driver = {
1751bab6bac2SCorentin Labbe .name = shortname,
17528443f2d2SAndrzej Pietrasiewicz },
17538443f2d2SAndrzej Pietrasiewicz };
17548443f2d2SAndrzej Pietrasiewicz
17558443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
17568443f2d2SAndrzej Pietrasiewicz /* DEVICE INITIALIZATION
17578443f2d2SAndrzej Pietrasiewicz *
17588443f2d2SAndrzej Pietrasiewicz * fd = open ("/dev/gadget/$CHIP", O_RDWR)
17598443f2d2SAndrzej Pietrasiewicz * status = write (fd, descriptors, sizeof descriptors)
17608443f2d2SAndrzej Pietrasiewicz *
17618443f2d2SAndrzej Pietrasiewicz * That write establishes the device configuration, so the kernel can
17628443f2d2SAndrzej Pietrasiewicz * bind to the controller ... guaranteeing it can handle enumeration
17638443f2d2SAndrzej Pietrasiewicz * at all necessary speeds. Descriptor order is:
17648443f2d2SAndrzej Pietrasiewicz *
17658443f2d2SAndrzej Pietrasiewicz * . message tag (u32, host order) ... for now, must be zero; it
17668443f2d2SAndrzej Pietrasiewicz * would change to support features like multi-config devices
17678443f2d2SAndrzej Pietrasiewicz * . full/low speed config ... all wTotalLength bytes (with interface,
17688443f2d2SAndrzej Pietrasiewicz * class, altsetting, endpoint, and other descriptors)
17698443f2d2SAndrzej Pietrasiewicz * . high speed config ... all descriptors, for high speed operation;
17708443f2d2SAndrzej Pietrasiewicz * this one's optional except for high-speed hardware
17718443f2d2SAndrzej Pietrasiewicz * . device descriptor
17728443f2d2SAndrzej Pietrasiewicz *
17738443f2d2SAndrzej Pietrasiewicz * Endpoints are not yet enabled. Drivers must wait until device
17748443f2d2SAndrzej Pietrasiewicz * configuration and interface altsetting changes create
17758443f2d2SAndrzej Pietrasiewicz * the need to configure (or unconfigure) them.
17768443f2d2SAndrzej Pietrasiewicz *
17778443f2d2SAndrzej Pietrasiewicz * After initialization, the device stays active for as long as that
17788443f2d2SAndrzej Pietrasiewicz * $CHIP file is open. Events must then be read from that descriptor,
17798443f2d2SAndrzej Pietrasiewicz * such as configuration notifications.
17808443f2d2SAndrzej Pietrasiewicz */
17818443f2d2SAndrzej Pietrasiewicz
is_valid_config(struct usb_config_descriptor * config,unsigned int total)17821c069b05SAlan Stern static int is_valid_config(struct usb_config_descriptor *config,
17831c069b05SAlan Stern unsigned int total)
17848443f2d2SAndrzej Pietrasiewicz {
17858443f2d2SAndrzej Pietrasiewicz return config->bDescriptorType == USB_DT_CONFIG
17868443f2d2SAndrzej Pietrasiewicz && config->bLength == USB_DT_CONFIG_SIZE
17871c069b05SAlan Stern && total >= USB_DT_CONFIG_SIZE
17888443f2d2SAndrzej Pietrasiewicz && config->bConfigurationValue != 0
17898443f2d2SAndrzej Pietrasiewicz && (config->bmAttributes & USB_CONFIG_ATT_ONE) != 0
17908443f2d2SAndrzej Pietrasiewicz && (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0;
17918443f2d2SAndrzej Pietrasiewicz /* FIXME if gadget->is_otg, _must_ include an otg descriptor */
17928443f2d2SAndrzej Pietrasiewicz /* FIXME check lengths: walk to end */
17938443f2d2SAndrzej Pietrasiewicz }
17948443f2d2SAndrzej Pietrasiewicz
17958443f2d2SAndrzej Pietrasiewicz static ssize_t
dev_config(struct file * fd,const char __user * buf,size_t len,loff_t * ptr)17968443f2d2SAndrzej Pietrasiewicz dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
17978443f2d2SAndrzej Pietrasiewicz {
17988443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data;
1799d13cce75SMasahiro Yamada ssize_t value, length = len;
18008443f2d2SAndrzej Pietrasiewicz unsigned total;
18018443f2d2SAndrzej Pietrasiewicz u32 tag;
18028443f2d2SAndrzej Pietrasiewicz char *kbuf;
18038443f2d2SAndrzej Pietrasiewicz
180496b62a57SAlan Stern spin_lock_irq(&dev->lock);
180596b62a57SAlan Stern if (dev->state > STATE_DEV_OPENED) {
180696b62a57SAlan Stern value = ep0_write(fd, buf, len, ptr);
180796b62a57SAlan Stern spin_unlock_irq(&dev->lock);
180896b62a57SAlan Stern return value;
180996b62a57SAlan Stern }
181096b62a57SAlan Stern spin_unlock_irq(&dev->lock);
181196b62a57SAlan Stern
18120994b0a2SGreg Kroah-Hartman if ((len < (USB_DT_CONFIG_SIZE + USB_DT_DEVICE_SIZE + 4)) ||
18130994b0a2SGreg Kroah-Hartman (len > PAGE_SIZE * 4))
18148443f2d2SAndrzej Pietrasiewicz return -EINVAL;
18158443f2d2SAndrzej Pietrasiewicz
18168443f2d2SAndrzej Pietrasiewicz /* we might need to change message format someday */
18178443f2d2SAndrzej Pietrasiewicz if (copy_from_user (&tag, buf, 4))
18188443f2d2SAndrzej Pietrasiewicz return -EFAULT;
18198443f2d2SAndrzej Pietrasiewicz if (tag != 0)
18208443f2d2SAndrzej Pietrasiewicz return -EINVAL;
18218443f2d2SAndrzej Pietrasiewicz buf += 4;
18228443f2d2SAndrzej Pietrasiewicz length -= 4;
18238443f2d2SAndrzej Pietrasiewicz
18248443f2d2SAndrzej Pietrasiewicz kbuf = memdup_user(buf, length);
18258443f2d2SAndrzej Pietrasiewicz if (IS_ERR(kbuf))
18268443f2d2SAndrzej Pietrasiewicz return PTR_ERR(kbuf);
18278443f2d2SAndrzej Pietrasiewicz
18288443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock);
18298443f2d2SAndrzej Pietrasiewicz value = -EINVAL;
1830b6e7aeeaSChristophe JAILLET if (dev->buf) {
183189f3594dSHangyu Hua spin_unlock_irq(&dev->lock);
1832b6e7aeeaSChristophe JAILLET kfree(kbuf);
183389f3594dSHangyu Hua return value;
1834b6e7aeeaSChristophe JAILLET }
18358443f2d2SAndrzej Pietrasiewicz dev->buf = kbuf;
18368443f2d2SAndrzej Pietrasiewicz
18378443f2d2SAndrzej Pietrasiewicz /* full or low speed config */
18388443f2d2SAndrzej Pietrasiewicz dev->config = (void *) kbuf;
18398443f2d2SAndrzej Pietrasiewicz total = le16_to_cpu(dev->config->wTotalLength);
18401c069b05SAlan Stern if (!is_valid_config(dev->config, total) ||
18411c069b05SAlan Stern total > length - USB_DT_DEVICE_SIZE)
18428443f2d2SAndrzej Pietrasiewicz goto fail;
18438443f2d2SAndrzej Pietrasiewicz kbuf += total;
18448443f2d2SAndrzej Pietrasiewicz length -= total;
18458443f2d2SAndrzej Pietrasiewicz
18468443f2d2SAndrzej Pietrasiewicz /* optional high speed config */
18478443f2d2SAndrzej Pietrasiewicz if (kbuf [1] == USB_DT_CONFIG) {
18488443f2d2SAndrzej Pietrasiewicz dev->hs_config = (void *) kbuf;
18498443f2d2SAndrzej Pietrasiewicz total = le16_to_cpu(dev->hs_config->wTotalLength);
18501c069b05SAlan Stern if (!is_valid_config(dev->hs_config, total) ||
18511c069b05SAlan Stern total > length - USB_DT_DEVICE_SIZE)
18528443f2d2SAndrzej Pietrasiewicz goto fail;
18538443f2d2SAndrzej Pietrasiewicz kbuf += total;
18548443f2d2SAndrzej Pietrasiewicz length -= total;
1855add333a8SAlan Stern } else {
1856add333a8SAlan Stern dev->hs_config = NULL;
18578443f2d2SAndrzej Pietrasiewicz }
18588443f2d2SAndrzej Pietrasiewicz
18598443f2d2SAndrzej Pietrasiewicz /* could support multiple configs, using another encoding! */
18608443f2d2SAndrzej Pietrasiewicz
18618443f2d2SAndrzej Pietrasiewicz /* device descriptor (tweaked for paranoia) */
18628443f2d2SAndrzej Pietrasiewicz if (length != USB_DT_DEVICE_SIZE)
18638443f2d2SAndrzej Pietrasiewicz goto fail;
18648443f2d2SAndrzej Pietrasiewicz dev->dev = (void *)kbuf;
18658443f2d2SAndrzej Pietrasiewicz if (dev->dev->bLength != USB_DT_DEVICE_SIZE
18668443f2d2SAndrzej Pietrasiewicz || dev->dev->bDescriptorType != USB_DT_DEVICE
18678443f2d2SAndrzej Pietrasiewicz || dev->dev->bNumConfigurations != 1)
18688443f2d2SAndrzej Pietrasiewicz goto fail;
18698443f2d2SAndrzej Pietrasiewicz dev->dev->bcdUSB = cpu_to_le16 (0x0200);
18708443f2d2SAndrzej Pietrasiewicz
18718443f2d2SAndrzej Pietrasiewicz /* triggers gadgetfs_bind(); then we can enumerate. */
18728443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
18738443f2d2SAndrzej Pietrasiewicz if (dev->hs_config)
18748443f2d2SAndrzej Pietrasiewicz gadgetfs_driver.max_speed = USB_SPEED_HIGH;
18758443f2d2SAndrzej Pietrasiewicz else
18768443f2d2SAndrzej Pietrasiewicz gadgetfs_driver.max_speed = USB_SPEED_FULL;
18778443f2d2SAndrzej Pietrasiewicz
1878af1969a2SAlan Stern value = usb_gadget_register_driver(&gadgetfs_driver);
18798443f2d2SAndrzej Pietrasiewicz if (value != 0) {
1880501e38a5SHangyu Hua spin_lock_irq(&dev->lock);
1881501e38a5SHangyu Hua goto fail;
18828443f2d2SAndrzej Pietrasiewicz } else {
18838443f2d2SAndrzej Pietrasiewicz /* at this point "good" hardware has for the first time
18848443f2d2SAndrzej Pietrasiewicz * let the USB the host see us. alternatively, if users
18858443f2d2SAndrzej Pietrasiewicz * unplug/replug that will clear all the error state.
18868443f2d2SAndrzej Pietrasiewicz *
18878443f2d2SAndrzej Pietrasiewicz * note: everything running before here was guaranteed
18888443f2d2SAndrzej Pietrasiewicz * to choke driver model style diagnostics. from here
18898443f2d2SAndrzej Pietrasiewicz * on, they can work ... except in cleanup paths that
18908443f2d2SAndrzej Pietrasiewicz * kick in after the ep0 descriptor is closed.
18918443f2d2SAndrzej Pietrasiewicz */
18928443f2d2SAndrzej Pietrasiewicz value = len;
18937b0a271dSMarek Szyprowski dev->gadget_registered = true;
18948443f2d2SAndrzej Pietrasiewicz }
18958443f2d2SAndrzej Pietrasiewicz return value;
18968443f2d2SAndrzej Pietrasiewicz
18978443f2d2SAndrzej Pietrasiewicz fail:
1898501e38a5SHangyu Hua dev->config = NULL;
1899501e38a5SHangyu Hua dev->hs_config = NULL;
1900501e38a5SHangyu Hua dev->dev = NULL;
19018443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock);
19025b5e0928SAlexey Dobriyan pr_debug ("%s: %s fail %zd, %p\n", shortname, __func__, value, dev);
19038443f2d2SAndrzej Pietrasiewicz kfree (dev->buf);
19048443f2d2SAndrzej Pietrasiewicz dev->buf = NULL;
19058443f2d2SAndrzej Pietrasiewicz return value;
19068443f2d2SAndrzej Pietrasiewicz }
19078443f2d2SAndrzej Pietrasiewicz
19088443f2d2SAndrzej Pietrasiewicz static int
gadget_dev_open(struct inode * inode,struct file * fd)1909452785d0SIngo Molnar gadget_dev_open (struct inode *inode, struct file *fd)
19108443f2d2SAndrzej Pietrasiewicz {
19118443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = inode->i_private;
19128443f2d2SAndrzej Pietrasiewicz int value = -EBUSY;
19138443f2d2SAndrzej Pietrasiewicz
19148443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock);
19158443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_DISABLED) {
19168443f2d2SAndrzej Pietrasiewicz dev->ev_next = 0;
19178443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_OPENED;
19188443f2d2SAndrzej Pietrasiewicz fd->private_data = dev;
19198443f2d2SAndrzej Pietrasiewicz get_dev (dev);
19208443f2d2SAndrzej Pietrasiewicz value = 0;
19218443f2d2SAndrzej Pietrasiewicz }
19228443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock);
19238443f2d2SAndrzej Pietrasiewicz return value;
19248443f2d2SAndrzej Pietrasiewicz }
19258443f2d2SAndrzej Pietrasiewicz
192696b62a57SAlan Stern static const struct file_operations ep0_operations = {
19278443f2d2SAndrzej Pietrasiewicz .llseek = no_llseek,
19288443f2d2SAndrzej Pietrasiewicz
1929452785d0SIngo Molnar .open = gadget_dev_open,
193096b62a57SAlan Stern .read = ep0_read,
19318443f2d2SAndrzej Pietrasiewicz .write = dev_config,
19328443f2d2SAndrzej Pietrasiewicz .fasync = ep0_fasync,
193396b62a57SAlan Stern .poll = ep0_poll,
1934452785d0SIngo Molnar .unlocked_ioctl = gadget_dev_ioctl,
19358443f2d2SAndrzej Pietrasiewicz .release = dev_release,
19368443f2d2SAndrzej Pietrasiewicz };
19378443f2d2SAndrzej Pietrasiewicz
19388443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
19398443f2d2SAndrzej Pietrasiewicz
19408443f2d2SAndrzej Pietrasiewicz /* FILESYSTEM AND SUPERBLOCK OPERATIONS
19418443f2d2SAndrzej Pietrasiewicz *
19428443f2d2SAndrzej Pietrasiewicz * Mounting the filesystem creates a controller file, used first for
19438443f2d2SAndrzej Pietrasiewicz * device configuration then later for event monitoring.
19448443f2d2SAndrzej Pietrasiewicz */
19458443f2d2SAndrzej Pietrasiewicz
19468443f2d2SAndrzej Pietrasiewicz
19478443f2d2SAndrzej Pietrasiewicz /* FIXME PAM etc could set this security policy without mount options
19488443f2d2SAndrzej Pietrasiewicz * if epfiles inherited ownership and permissons from ep0 ...
19498443f2d2SAndrzej Pietrasiewicz */
19508443f2d2SAndrzej Pietrasiewicz
19518443f2d2SAndrzej Pietrasiewicz static unsigned default_uid;
19528443f2d2SAndrzej Pietrasiewicz static unsigned default_gid;
19538443f2d2SAndrzej Pietrasiewicz static unsigned default_perm = S_IRUSR | S_IWUSR;
19548443f2d2SAndrzej Pietrasiewicz
19558443f2d2SAndrzej Pietrasiewicz module_param (default_uid, uint, 0644);
19568443f2d2SAndrzej Pietrasiewicz module_param (default_gid, uint, 0644);
19578443f2d2SAndrzej Pietrasiewicz module_param (default_perm, uint, 0644);
19588443f2d2SAndrzej Pietrasiewicz
19598443f2d2SAndrzej Pietrasiewicz
19608443f2d2SAndrzej Pietrasiewicz static struct inode *
gadgetfs_make_inode(struct super_block * sb,void * data,const struct file_operations * fops,int mode)19618443f2d2SAndrzej Pietrasiewicz gadgetfs_make_inode (struct super_block *sb,
19628443f2d2SAndrzej Pietrasiewicz void *data, const struct file_operations *fops,
19638443f2d2SAndrzej Pietrasiewicz int mode)
19648443f2d2SAndrzej Pietrasiewicz {
19658443f2d2SAndrzej Pietrasiewicz struct inode *inode = new_inode (sb);
19668443f2d2SAndrzej Pietrasiewicz
19678443f2d2SAndrzej Pietrasiewicz if (inode) {
19688443f2d2SAndrzej Pietrasiewicz inode->i_ino = get_next_ino();
19698443f2d2SAndrzej Pietrasiewicz inode->i_mode = mode;
19708443f2d2SAndrzej Pietrasiewicz inode->i_uid = make_kuid(&init_user_ns, default_uid);
19718443f2d2SAndrzej Pietrasiewicz inode->i_gid = make_kgid(&init_user_ns, default_gid);
1972*c7603adcSJeff Layton inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
19738443f2d2SAndrzej Pietrasiewicz inode->i_private = data;
19748443f2d2SAndrzej Pietrasiewicz inode->i_fop = fops;
19758443f2d2SAndrzej Pietrasiewicz }
19768443f2d2SAndrzej Pietrasiewicz return inode;
19778443f2d2SAndrzej Pietrasiewicz }
19788443f2d2SAndrzej Pietrasiewicz
19798443f2d2SAndrzej Pietrasiewicz /* creates in fs root directory, so non-renamable and non-linkable.
19808443f2d2SAndrzej Pietrasiewicz * so inode and dentry are paired, until device reconfig.
19818443f2d2SAndrzej Pietrasiewicz */
1982fb6c3225SAl Viro static struct dentry *
gadgetfs_create_file(struct super_block * sb,char const * name,void * data,const struct file_operations * fops)19838443f2d2SAndrzej Pietrasiewicz gadgetfs_create_file (struct super_block *sb, char const *name,
1984fb6c3225SAl Viro void *data, const struct file_operations *fops)
19858443f2d2SAndrzej Pietrasiewicz {
19868443f2d2SAndrzej Pietrasiewicz struct dentry *dentry;
19878443f2d2SAndrzej Pietrasiewicz struct inode *inode;
19888443f2d2SAndrzej Pietrasiewicz
19898443f2d2SAndrzej Pietrasiewicz dentry = d_alloc_name(sb->s_root, name);
19908443f2d2SAndrzej Pietrasiewicz if (!dentry)
19918443f2d2SAndrzej Pietrasiewicz return NULL;
19928443f2d2SAndrzej Pietrasiewicz
19938443f2d2SAndrzej Pietrasiewicz inode = gadgetfs_make_inode (sb, data, fops,
19948443f2d2SAndrzej Pietrasiewicz S_IFREG | (default_perm & S_IRWXUGO));
19958443f2d2SAndrzej Pietrasiewicz if (!inode) {
19968443f2d2SAndrzej Pietrasiewicz dput(dentry);
19978443f2d2SAndrzej Pietrasiewicz return NULL;
19988443f2d2SAndrzej Pietrasiewicz }
19998443f2d2SAndrzej Pietrasiewicz d_add (dentry, inode);
2000fb6c3225SAl Viro return dentry;
20018443f2d2SAndrzej Pietrasiewicz }
20028443f2d2SAndrzej Pietrasiewicz
20038443f2d2SAndrzej Pietrasiewicz static const struct super_operations gadget_fs_operations = {
20048443f2d2SAndrzej Pietrasiewicz .statfs = simple_statfs,
20058443f2d2SAndrzej Pietrasiewicz .drop_inode = generic_delete_inode,
20068443f2d2SAndrzej Pietrasiewicz };
20078443f2d2SAndrzej Pietrasiewicz
20088443f2d2SAndrzej Pietrasiewicz static int
gadgetfs_fill_super(struct super_block * sb,struct fs_context * fc)2009e5d82a73SDavid Howells gadgetfs_fill_super (struct super_block *sb, struct fs_context *fc)
20108443f2d2SAndrzej Pietrasiewicz {
20118443f2d2SAndrzej Pietrasiewicz struct inode *inode;
20128443f2d2SAndrzej Pietrasiewicz struct dev_data *dev;
2013d18dcfe9SAlan Stern int rc;
20148443f2d2SAndrzej Pietrasiewicz
2015d18dcfe9SAlan Stern mutex_lock(&sb_mutex);
2016d18dcfe9SAlan Stern
2017d18dcfe9SAlan Stern if (the_device) {
2018d18dcfe9SAlan Stern rc = -ESRCH;
2019d18dcfe9SAlan Stern goto Done;
2020d18dcfe9SAlan Stern }
20218443f2d2SAndrzej Pietrasiewicz
2022175f7121SMarek Szyprowski CHIP = usb_get_gadget_udc_name();
2023d18dcfe9SAlan Stern if (!CHIP) {
2024d18dcfe9SAlan Stern rc = -ENODEV;
2025d18dcfe9SAlan Stern goto Done;
2026d18dcfe9SAlan Stern }
20278443f2d2SAndrzej Pietrasiewicz
20288443f2d2SAndrzej Pietrasiewicz /* superblock */
202909cbfeafSKirill A. Shutemov sb->s_blocksize = PAGE_SIZE;
203009cbfeafSKirill A. Shutemov sb->s_blocksize_bits = PAGE_SHIFT;
20318443f2d2SAndrzej Pietrasiewicz sb->s_magic = GADGETFS_MAGIC;
20328443f2d2SAndrzej Pietrasiewicz sb->s_op = &gadget_fs_operations;
20338443f2d2SAndrzej Pietrasiewicz sb->s_time_gran = 1;
20348443f2d2SAndrzej Pietrasiewicz
20358443f2d2SAndrzej Pietrasiewicz /* root inode */
20368443f2d2SAndrzej Pietrasiewicz inode = gadgetfs_make_inode (sb,
20378443f2d2SAndrzej Pietrasiewicz NULL, &simple_dir_operations,
20388443f2d2SAndrzej Pietrasiewicz S_IFDIR | S_IRUGO | S_IXUGO);
20398443f2d2SAndrzej Pietrasiewicz if (!inode)
20408443f2d2SAndrzej Pietrasiewicz goto Enomem;
20418443f2d2SAndrzej Pietrasiewicz inode->i_op = &simple_dir_inode_operations;
20428443f2d2SAndrzej Pietrasiewicz if (!(sb->s_root = d_make_root (inode)))
20438443f2d2SAndrzej Pietrasiewicz goto Enomem;
20448443f2d2SAndrzej Pietrasiewicz
20458443f2d2SAndrzej Pietrasiewicz /* the ep0 file is named after the controller we expect;
20468443f2d2SAndrzej Pietrasiewicz * user mode code can use it for sanity checks, like we do.
20478443f2d2SAndrzej Pietrasiewicz */
20488443f2d2SAndrzej Pietrasiewicz dev = dev_new ();
20498443f2d2SAndrzej Pietrasiewicz if (!dev)
20508443f2d2SAndrzej Pietrasiewicz goto Enomem;
20518443f2d2SAndrzej Pietrasiewicz
20528443f2d2SAndrzej Pietrasiewicz dev->sb = sb;
205396b62a57SAlan Stern dev->dentry = gadgetfs_create_file(sb, CHIP, dev, &ep0_operations);
2054fb6c3225SAl Viro if (!dev->dentry) {
20558443f2d2SAndrzej Pietrasiewicz put_dev(dev);
20568443f2d2SAndrzej Pietrasiewicz goto Enomem;
20578443f2d2SAndrzej Pietrasiewicz }
20588443f2d2SAndrzej Pietrasiewicz
20598443f2d2SAndrzej Pietrasiewicz /* other endpoint files are available after hardware setup,
20608443f2d2SAndrzej Pietrasiewicz * from binding to a controller.
20618443f2d2SAndrzej Pietrasiewicz */
20628443f2d2SAndrzej Pietrasiewicz the_device = dev;
2063d18dcfe9SAlan Stern rc = 0;
2064d18dcfe9SAlan Stern goto Done;
20658443f2d2SAndrzej Pietrasiewicz
20668443f2d2SAndrzej Pietrasiewicz Enomem:
206787bed3d7SZhang Qilong kfree(CHIP);
206887bed3d7SZhang Qilong CHIP = NULL;
2069d18dcfe9SAlan Stern rc = -ENOMEM;
207087bed3d7SZhang Qilong
2071d18dcfe9SAlan Stern Done:
2072d18dcfe9SAlan Stern mutex_unlock(&sb_mutex);
2073d18dcfe9SAlan Stern return rc;
20748443f2d2SAndrzej Pietrasiewicz }
20758443f2d2SAndrzej Pietrasiewicz
20768443f2d2SAndrzej Pietrasiewicz /* "mount -t gadgetfs path /dev/gadget" ends up here */
gadgetfs_get_tree(struct fs_context * fc)2077e5d82a73SDavid Howells static int gadgetfs_get_tree(struct fs_context *fc)
20788443f2d2SAndrzej Pietrasiewicz {
2079e5d82a73SDavid Howells return get_tree_single(fc, gadgetfs_fill_super);
2080e5d82a73SDavid Howells }
2081e5d82a73SDavid Howells
2082e5d82a73SDavid Howells static const struct fs_context_operations gadgetfs_context_ops = {
2083e5d82a73SDavid Howells .get_tree = gadgetfs_get_tree,
2084e5d82a73SDavid Howells };
2085e5d82a73SDavid Howells
gadgetfs_init_fs_context(struct fs_context * fc)2086e5d82a73SDavid Howells static int gadgetfs_init_fs_context(struct fs_context *fc)
2087e5d82a73SDavid Howells {
2088e5d82a73SDavid Howells fc->ops = &gadgetfs_context_ops;
2089e5d82a73SDavid Howells return 0;
20908443f2d2SAndrzej Pietrasiewicz }
20918443f2d2SAndrzej Pietrasiewicz
20928443f2d2SAndrzej Pietrasiewicz static void
gadgetfs_kill_sb(struct super_block * sb)20938443f2d2SAndrzej Pietrasiewicz gadgetfs_kill_sb (struct super_block *sb)
20948443f2d2SAndrzej Pietrasiewicz {
2095d18dcfe9SAlan Stern mutex_lock(&sb_mutex);
20968443f2d2SAndrzej Pietrasiewicz kill_litter_super (sb);
20978443f2d2SAndrzej Pietrasiewicz if (the_device) {
20988443f2d2SAndrzej Pietrasiewicz put_dev (the_device);
20998443f2d2SAndrzej Pietrasiewicz the_device = NULL;
21008443f2d2SAndrzej Pietrasiewicz }
2101175f7121SMarek Szyprowski kfree(CHIP);
2102175f7121SMarek Szyprowski CHIP = NULL;
2103d18dcfe9SAlan Stern mutex_unlock(&sb_mutex);
21048443f2d2SAndrzej Pietrasiewicz }
21058443f2d2SAndrzej Pietrasiewicz
21068443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
21078443f2d2SAndrzej Pietrasiewicz
21088443f2d2SAndrzej Pietrasiewicz static struct file_system_type gadgetfs_type = {
21098443f2d2SAndrzej Pietrasiewicz .owner = THIS_MODULE,
21108443f2d2SAndrzej Pietrasiewicz .name = shortname,
2111e5d82a73SDavid Howells .init_fs_context = gadgetfs_init_fs_context,
21128443f2d2SAndrzej Pietrasiewicz .kill_sb = gadgetfs_kill_sb,
21138443f2d2SAndrzej Pietrasiewicz };
21148443f2d2SAndrzej Pietrasiewicz MODULE_ALIAS_FS("gadgetfs");
21158443f2d2SAndrzej Pietrasiewicz
21168443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/
21178443f2d2SAndrzej Pietrasiewicz
gadgetfs_init(void)21186653b827SRandy Dunlap static int __init gadgetfs_init (void)
21198443f2d2SAndrzej Pietrasiewicz {
21208443f2d2SAndrzej Pietrasiewicz int status;
21218443f2d2SAndrzej Pietrasiewicz
21228443f2d2SAndrzej Pietrasiewicz status = register_filesystem (&gadgetfs_type);
21238443f2d2SAndrzej Pietrasiewicz if (status == 0)
21248443f2d2SAndrzej Pietrasiewicz pr_info ("%s: %s, version " DRIVER_VERSION "\n",
21258443f2d2SAndrzej Pietrasiewicz shortname, driver_desc);
21268443f2d2SAndrzej Pietrasiewicz return status;
21278443f2d2SAndrzej Pietrasiewicz }
21286653b827SRandy Dunlap module_init (gadgetfs_init);
21298443f2d2SAndrzej Pietrasiewicz
gadgetfs_cleanup(void)21306653b827SRandy Dunlap static void __exit gadgetfs_cleanup (void)
21318443f2d2SAndrzej Pietrasiewicz {
21328443f2d2SAndrzej Pietrasiewicz pr_debug ("unregister %s\n", shortname);
21338443f2d2SAndrzej Pietrasiewicz unregister_filesystem (&gadgetfs_type);
21348443f2d2SAndrzej Pietrasiewicz }
21356653b827SRandy Dunlap module_exit (gadgetfs_cleanup);
21368443f2d2SAndrzej Pietrasiewicz
2137