18443f2d2SAndrzej Pietrasiewicz /* 28443f2d2SAndrzej Pietrasiewicz * inode.c -- user mode filesystem api for usb gadget controllers 38443f2d2SAndrzej Pietrasiewicz * 48443f2d2SAndrzej Pietrasiewicz * Copyright (C) 2003-2004 David Brownell 58443f2d2SAndrzej Pietrasiewicz * Copyright (C) 2003 Agilent Technologies 68443f2d2SAndrzej Pietrasiewicz * 78443f2d2SAndrzej Pietrasiewicz * This program is free software; you can redistribute it and/or modify 88443f2d2SAndrzej Pietrasiewicz * it under the terms of the GNU General Public License as published by 98443f2d2SAndrzej Pietrasiewicz * the Free Software Foundation; either version 2 of the License, or 108443f2d2SAndrzej Pietrasiewicz * (at your option) any later version. 118443f2d2SAndrzej Pietrasiewicz */ 128443f2d2SAndrzej Pietrasiewicz 138443f2d2SAndrzej Pietrasiewicz 148443f2d2SAndrzej Pietrasiewicz /* #define VERBOSE_DEBUG */ 158443f2d2SAndrzej Pietrasiewicz 168443f2d2SAndrzej Pietrasiewicz #include <linux/init.h> 178443f2d2SAndrzej Pietrasiewicz #include <linux/module.h> 188443f2d2SAndrzej Pietrasiewicz #include <linux/fs.h> 198443f2d2SAndrzej Pietrasiewicz #include <linux/pagemap.h> 208443f2d2SAndrzej Pietrasiewicz #include <linux/uts.h> 218443f2d2SAndrzej Pietrasiewicz #include <linux/wait.h> 228443f2d2SAndrzej Pietrasiewicz #include <linux/compiler.h> 238443f2d2SAndrzej Pietrasiewicz #include <asm/uaccess.h> 248443f2d2SAndrzej Pietrasiewicz #include <linux/sched.h> 258443f2d2SAndrzej Pietrasiewicz #include <linux/slab.h> 268443f2d2SAndrzej Pietrasiewicz #include <linux/poll.h> 278443f2d2SAndrzej Pietrasiewicz #include <linux/mmu_context.h> 288443f2d2SAndrzej Pietrasiewicz #include <linux/aio.h> 298443f2d2SAndrzej Pietrasiewicz 308443f2d2SAndrzej Pietrasiewicz #include <linux/device.h> 318443f2d2SAndrzej Pietrasiewicz #include <linux/moduleparam.h> 328443f2d2SAndrzej Pietrasiewicz 338443f2d2SAndrzej Pietrasiewicz #include <linux/usb/gadgetfs.h> 348443f2d2SAndrzej Pietrasiewicz #include <linux/usb/gadget.h> 358443f2d2SAndrzej Pietrasiewicz 368443f2d2SAndrzej Pietrasiewicz 378443f2d2SAndrzej Pietrasiewicz /* 388443f2d2SAndrzej Pietrasiewicz * The gadgetfs API maps each endpoint to a file descriptor so that you 398443f2d2SAndrzej Pietrasiewicz * can use standard synchronous read/write calls for I/O. There's some 408443f2d2SAndrzej Pietrasiewicz * O_NONBLOCK and O_ASYNC/FASYNC style i/o support. Example usermode 418443f2d2SAndrzej Pietrasiewicz * drivers show how this works in practice. You can also use AIO to 428443f2d2SAndrzej Pietrasiewicz * eliminate I/O gaps between requests, to help when streaming data. 438443f2d2SAndrzej Pietrasiewicz * 448443f2d2SAndrzej Pietrasiewicz * Key parts that must be USB-specific are protocols defining how the 458443f2d2SAndrzej Pietrasiewicz * read/write operations relate to the hardware state machines. There 468443f2d2SAndrzej Pietrasiewicz * are two types of files. One type is for the device, implementing ep0. 478443f2d2SAndrzej Pietrasiewicz * The other type is for each IN or OUT endpoint. In both cases, the 488443f2d2SAndrzej Pietrasiewicz * user mode driver must configure the hardware before using it. 498443f2d2SAndrzej Pietrasiewicz * 508443f2d2SAndrzej Pietrasiewicz * - First, dev_config() is called when /dev/gadget/$CHIP is configured 518443f2d2SAndrzej Pietrasiewicz * (by writing configuration and device descriptors). Afterwards it 528443f2d2SAndrzej Pietrasiewicz * may serve as a source of device events, used to handle all control 538443f2d2SAndrzej Pietrasiewicz * requests other than basic enumeration. 548443f2d2SAndrzej Pietrasiewicz * 558443f2d2SAndrzej Pietrasiewicz * - Then, after a SET_CONFIGURATION control request, ep_config() is 568443f2d2SAndrzej Pietrasiewicz * called when each /dev/gadget/ep* file is configured (by writing 578443f2d2SAndrzej Pietrasiewicz * endpoint descriptors). Afterwards these files are used to write() 588443f2d2SAndrzej Pietrasiewicz * IN data or to read() OUT data. To halt the endpoint, a "wrong 598443f2d2SAndrzej Pietrasiewicz * direction" request is issued (like reading an IN endpoint). 608443f2d2SAndrzej Pietrasiewicz * 618443f2d2SAndrzej Pietrasiewicz * Unlike "usbfs" the only ioctl()s are for things that are rare, and maybe 628443f2d2SAndrzej Pietrasiewicz * not possible on all hardware. For example, precise fault handling with 638443f2d2SAndrzej Pietrasiewicz * respect to data left in endpoint fifos after aborted operations; or 648443f2d2SAndrzej Pietrasiewicz * selective clearing of endpoint halts, to implement SET_INTERFACE. 658443f2d2SAndrzej Pietrasiewicz */ 668443f2d2SAndrzej Pietrasiewicz 678443f2d2SAndrzej Pietrasiewicz #define DRIVER_DESC "USB Gadget filesystem" 688443f2d2SAndrzej Pietrasiewicz #define DRIVER_VERSION "24 Aug 2004" 698443f2d2SAndrzej Pietrasiewicz 708443f2d2SAndrzej Pietrasiewicz static const char driver_desc [] = DRIVER_DESC; 718443f2d2SAndrzej Pietrasiewicz static const char shortname [] = "gadgetfs"; 728443f2d2SAndrzej Pietrasiewicz 738443f2d2SAndrzej Pietrasiewicz MODULE_DESCRIPTION (DRIVER_DESC); 748443f2d2SAndrzej Pietrasiewicz MODULE_AUTHOR ("David Brownell"); 758443f2d2SAndrzej Pietrasiewicz MODULE_LICENSE ("GPL"); 768443f2d2SAndrzej Pietrasiewicz 778443f2d2SAndrzej Pietrasiewicz 788443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 798443f2d2SAndrzej Pietrasiewicz 808443f2d2SAndrzej Pietrasiewicz #define GADGETFS_MAGIC 0xaee71ee7 818443f2d2SAndrzej Pietrasiewicz 828443f2d2SAndrzej Pietrasiewicz /* /dev/gadget/$CHIP represents ep0 and the whole device */ 838443f2d2SAndrzej Pietrasiewicz enum ep0_state { 848443f2d2SAndrzej Pietrasiewicz /* DISBLED is the initial state. 858443f2d2SAndrzej Pietrasiewicz */ 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 1138443f2d2SAndrzej Pietrasiewicz struct dev_data { 1148443f2d2SAndrzej Pietrasiewicz spinlock_t lock; 1158443f2d2SAndrzej Pietrasiewicz atomic_t count; 1168443f2d2SAndrzej Pietrasiewicz enum ep0_state state; /* P: lock */ 1178443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event event [N_EVENT]; 1188443f2d2SAndrzej Pietrasiewicz unsigned ev_next; 1198443f2d2SAndrzej Pietrasiewicz struct fasync_struct *fasync; 1208443f2d2SAndrzej Pietrasiewicz u8 current_config; 1218443f2d2SAndrzej Pietrasiewicz 1228443f2d2SAndrzej Pietrasiewicz /* drivers reading ep0 MUST handle control requests (SETUP) 1238443f2d2SAndrzej Pietrasiewicz * reported that way; else the host will time out. 1248443f2d2SAndrzej Pietrasiewicz */ 1258443f2d2SAndrzej Pietrasiewicz unsigned usermode_setup : 1, 1268443f2d2SAndrzej Pietrasiewicz setup_in : 1, 1278443f2d2SAndrzej Pietrasiewicz setup_can_stall : 1, 1288443f2d2SAndrzej Pietrasiewicz setup_out_ready : 1, 1298443f2d2SAndrzej Pietrasiewicz setup_out_error : 1, 1308443f2d2SAndrzej Pietrasiewicz setup_abort : 1; 1318443f2d2SAndrzej Pietrasiewicz unsigned setup_wLength; 1328443f2d2SAndrzej Pietrasiewicz 1338443f2d2SAndrzej Pietrasiewicz /* the rest is basically write-once */ 1348443f2d2SAndrzej Pietrasiewicz struct usb_config_descriptor *config, *hs_config; 1358443f2d2SAndrzej Pietrasiewicz struct usb_device_descriptor *dev; 1368443f2d2SAndrzej Pietrasiewicz struct usb_request *req; 1378443f2d2SAndrzej Pietrasiewicz struct usb_gadget *gadget; 1388443f2d2SAndrzej Pietrasiewicz struct list_head epfiles; 1398443f2d2SAndrzej Pietrasiewicz void *buf; 1408443f2d2SAndrzej Pietrasiewicz wait_queue_head_t wait; 1418443f2d2SAndrzej Pietrasiewicz struct super_block *sb; 1428443f2d2SAndrzej Pietrasiewicz struct dentry *dentry; 1438443f2d2SAndrzej Pietrasiewicz 1448443f2d2SAndrzej Pietrasiewicz /* except this scratch i/o buffer for ep0 */ 1458443f2d2SAndrzej Pietrasiewicz u8 rbuf [256]; 1468443f2d2SAndrzej Pietrasiewicz }; 1478443f2d2SAndrzej Pietrasiewicz 1488443f2d2SAndrzej Pietrasiewicz static inline void get_dev (struct dev_data *data) 1498443f2d2SAndrzej Pietrasiewicz { 1508443f2d2SAndrzej Pietrasiewicz atomic_inc (&data->count); 1518443f2d2SAndrzej Pietrasiewicz } 1528443f2d2SAndrzej Pietrasiewicz 1538443f2d2SAndrzej Pietrasiewicz static void put_dev (struct dev_data *data) 1548443f2d2SAndrzej Pietrasiewicz { 1558443f2d2SAndrzej Pietrasiewicz if (likely (!atomic_dec_and_test (&data->count))) 1568443f2d2SAndrzej Pietrasiewicz return; 1578443f2d2SAndrzej Pietrasiewicz /* needs no more cleanup */ 1588443f2d2SAndrzej Pietrasiewicz BUG_ON (waitqueue_active (&data->wait)); 1598443f2d2SAndrzej Pietrasiewicz kfree (data); 1608443f2d2SAndrzej Pietrasiewicz } 1618443f2d2SAndrzej Pietrasiewicz 1628443f2d2SAndrzej Pietrasiewicz static struct dev_data *dev_new (void) 1638443f2d2SAndrzej Pietrasiewicz { 1648443f2d2SAndrzej Pietrasiewicz struct dev_data *dev; 1658443f2d2SAndrzej Pietrasiewicz 1668443f2d2SAndrzej Pietrasiewicz dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1678443f2d2SAndrzej Pietrasiewicz if (!dev) 1688443f2d2SAndrzej Pietrasiewicz return NULL; 1698443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_DISABLED; 1708443f2d2SAndrzej Pietrasiewicz atomic_set (&dev->count, 1); 1718443f2d2SAndrzej Pietrasiewicz spin_lock_init (&dev->lock); 1728443f2d2SAndrzej Pietrasiewicz INIT_LIST_HEAD (&dev->epfiles); 1738443f2d2SAndrzej Pietrasiewicz init_waitqueue_head (&dev->wait); 1748443f2d2SAndrzej Pietrasiewicz return dev; 1758443f2d2SAndrzej Pietrasiewicz } 1768443f2d2SAndrzej Pietrasiewicz 1778443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 1788443f2d2SAndrzej Pietrasiewicz 1798443f2d2SAndrzej Pietrasiewicz /* other /dev/gadget/$ENDPOINT files represent endpoints */ 1808443f2d2SAndrzej Pietrasiewicz enum ep_state { 1818443f2d2SAndrzej Pietrasiewicz STATE_EP_DISABLED = 0, 1828443f2d2SAndrzej Pietrasiewicz STATE_EP_READY, 1838443f2d2SAndrzej Pietrasiewicz STATE_EP_ENABLED, 1848443f2d2SAndrzej Pietrasiewicz STATE_EP_UNBOUND, 1858443f2d2SAndrzej Pietrasiewicz }; 1868443f2d2SAndrzej Pietrasiewicz 1878443f2d2SAndrzej Pietrasiewicz struct ep_data { 1888443f2d2SAndrzej Pietrasiewicz struct mutex lock; 1898443f2d2SAndrzej Pietrasiewicz enum ep_state state; 1908443f2d2SAndrzej Pietrasiewicz atomic_t count; 1918443f2d2SAndrzej Pietrasiewicz struct dev_data *dev; 1928443f2d2SAndrzej Pietrasiewicz /* must hold dev->lock before accessing ep or req */ 1938443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep; 1948443f2d2SAndrzej Pietrasiewicz struct usb_request *req; 1958443f2d2SAndrzej Pietrasiewicz ssize_t status; 1968443f2d2SAndrzej Pietrasiewicz char name [16]; 1978443f2d2SAndrzej Pietrasiewicz struct usb_endpoint_descriptor desc, hs_desc; 1988443f2d2SAndrzej Pietrasiewicz struct list_head epfiles; 1998443f2d2SAndrzej Pietrasiewicz wait_queue_head_t wait; 2008443f2d2SAndrzej Pietrasiewicz struct dentry *dentry; 2018443f2d2SAndrzej Pietrasiewicz struct inode *inode; 2028443f2d2SAndrzej Pietrasiewicz }; 2038443f2d2SAndrzej Pietrasiewicz 2048443f2d2SAndrzej Pietrasiewicz static inline void get_ep (struct ep_data *data) 2058443f2d2SAndrzej Pietrasiewicz { 2068443f2d2SAndrzej Pietrasiewicz atomic_inc (&data->count); 2078443f2d2SAndrzej Pietrasiewicz } 2088443f2d2SAndrzej Pietrasiewicz 2098443f2d2SAndrzej Pietrasiewicz static void put_ep (struct ep_data *data) 2108443f2d2SAndrzej Pietrasiewicz { 2118443f2d2SAndrzej Pietrasiewicz if (likely (!atomic_dec_and_test (&data->count))) 2128443f2d2SAndrzej Pietrasiewicz return; 2138443f2d2SAndrzej Pietrasiewicz put_dev (data->dev); 2148443f2d2SAndrzej Pietrasiewicz /* needs no more cleanup */ 2158443f2d2SAndrzej Pietrasiewicz BUG_ON (!list_empty (&data->epfiles)); 2168443f2d2SAndrzej Pietrasiewicz BUG_ON (waitqueue_active (&data->wait)); 2178443f2d2SAndrzej Pietrasiewicz kfree (data); 2188443f2d2SAndrzej Pietrasiewicz } 2198443f2d2SAndrzej Pietrasiewicz 2208443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 2218443f2d2SAndrzej Pietrasiewicz 2228443f2d2SAndrzej Pietrasiewicz /* most "how to use the hardware" policy choices are in userspace: 2238443f2d2SAndrzej Pietrasiewicz * mapping endpoint roles (which the driver needs) to the capabilities 2248443f2d2SAndrzej Pietrasiewicz * which the usb controller has. most of those capabilities are exposed 2258443f2d2SAndrzej Pietrasiewicz * implicitly, starting with the driver name and then endpoint names. 2268443f2d2SAndrzej Pietrasiewicz */ 2278443f2d2SAndrzej Pietrasiewicz 2288443f2d2SAndrzej Pietrasiewicz static const char *CHIP; 2298443f2d2SAndrzej Pietrasiewicz 2308443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 2318443f2d2SAndrzej Pietrasiewicz 2328443f2d2SAndrzej Pietrasiewicz /* NOTE: don't use dev_printk calls before binding to the gadget 2338443f2d2SAndrzej Pietrasiewicz * at the end of ep0 configuration, or after unbind. 2348443f2d2SAndrzej Pietrasiewicz */ 2358443f2d2SAndrzej Pietrasiewicz 2368443f2d2SAndrzej Pietrasiewicz /* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */ 2378443f2d2SAndrzej Pietrasiewicz #define xprintk(d,level,fmt,args...) \ 2388443f2d2SAndrzej Pietrasiewicz printk(level "%s: " fmt , shortname , ## args) 2398443f2d2SAndrzej Pietrasiewicz 2408443f2d2SAndrzej Pietrasiewicz #ifdef DEBUG 2418443f2d2SAndrzej Pietrasiewicz #define DBG(dev,fmt,args...) \ 2428443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_DEBUG , fmt , ## args) 2438443f2d2SAndrzej Pietrasiewicz #else 2448443f2d2SAndrzej Pietrasiewicz #define DBG(dev,fmt,args...) \ 2458443f2d2SAndrzej Pietrasiewicz do { } while (0) 2468443f2d2SAndrzej Pietrasiewicz #endif /* DEBUG */ 2478443f2d2SAndrzej Pietrasiewicz 2488443f2d2SAndrzej Pietrasiewicz #ifdef VERBOSE_DEBUG 2498443f2d2SAndrzej Pietrasiewicz #define VDEBUG DBG 2508443f2d2SAndrzej Pietrasiewicz #else 2518443f2d2SAndrzej Pietrasiewicz #define VDEBUG(dev,fmt,args...) \ 2528443f2d2SAndrzej Pietrasiewicz do { } while (0) 2538443f2d2SAndrzej Pietrasiewicz #endif /* DEBUG */ 2548443f2d2SAndrzej Pietrasiewicz 2558443f2d2SAndrzej Pietrasiewicz #define ERROR(dev,fmt,args...) \ 2568443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_ERR , fmt , ## args) 2578443f2d2SAndrzej Pietrasiewicz #define INFO(dev,fmt,args...) \ 2588443f2d2SAndrzej Pietrasiewicz xprintk(dev , KERN_INFO , fmt , ## args) 2598443f2d2SAndrzej Pietrasiewicz 2608443f2d2SAndrzej Pietrasiewicz 2618443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 2628443f2d2SAndrzej Pietrasiewicz 2638443f2d2SAndrzej Pietrasiewicz /* SYNCHRONOUS ENDPOINT OPERATIONS (bulk/intr/iso) 2648443f2d2SAndrzej Pietrasiewicz * 2658443f2d2SAndrzej Pietrasiewicz * After opening, configure non-control endpoints. Then use normal 2668443f2d2SAndrzej Pietrasiewicz * stream read() and write() requests; and maybe ioctl() to get more 2678443f2d2SAndrzej Pietrasiewicz * precise FIFO status when recovering from cancellation. 2688443f2d2SAndrzej Pietrasiewicz */ 2698443f2d2SAndrzej Pietrasiewicz 2708443f2d2SAndrzej Pietrasiewicz static void epio_complete (struct usb_ep *ep, struct usb_request *req) 2718443f2d2SAndrzej Pietrasiewicz { 2728443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = ep->driver_data; 2738443f2d2SAndrzej Pietrasiewicz 2748443f2d2SAndrzej Pietrasiewicz if (!req->context) 2758443f2d2SAndrzej Pietrasiewicz return; 2768443f2d2SAndrzej Pietrasiewicz if (req->status) 2778443f2d2SAndrzej Pietrasiewicz epdata->status = req->status; 2788443f2d2SAndrzej Pietrasiewicz else 2798443f2d2SAndrzej Pietrasiewicz epdata->status = req->actual; 2808443f2d2SAndrzej Pietrasiewicz complete ((struct completion *)req->context); 2818443f2d2SAndrzej Pietrasiewicz } 2828443f2d2SAndrzej Pietrasiewicz 2838443f2d2SAndrzej Pietrasiewicz /* tasklock endpoint, returning when it's connected. 2848443f2d2SAndrzej Pietrasiewicz * still need dev->lock to use epdata->ep. 2858443f2d2SAndrzej Pietrasiewicz */ 2868443f2d2SAndrzej Pietrasiewicz static int 2878443f2d2SAndrzej Pietrasiewicz get_ready_ep (unsigned f_flags, struct ep_data *epdata) 2888443f2d2SAndrzej Pietrasiewicz { 2898443f2d2SAndrzej Pietrasiewicz int val; 2908443f2d2SAndrzej Pietrasiewicz 2918443f2d2SAndrzej Pietrasiewicz if (f_flags & O_NONBLOCK) { 2928443f2d2SAndrzej Pietrasiewicz if (!mutex_trylock(&epdata->lock)) 2938443f2d2SAndrzej Pietrasiewicz goto nonblock; 2948443f2d2SAndrzej Pietrasiewicz if (epdata->state != STATE_EP_ENABLED) { 2958443f2d2SAndrzej Pietrasiewicz mutex_unlock(&epdata->lock); 2968443f2d2SAndrzej Pietrasiewicz nonblock: 2978443f2d2SAndrzej Pietrasiewicz val = -EAGAIN; 2988443f2d2SAndrzej Pietrasiewicz } else 2998443f2d2SAndrzej Pietrasiewicz val = 0; 3008443f2d2SAndrzej Pietrasiewicz return val; 3018443f2d2SAndrzej Pietrasiewicz } 3028443f2d2SAndrzej Pietrasiewicz 3038443f2d2SAndrzej Pietrasiewicz val = mutex_lock_interruptible(&epdata->lock); 3048443f2d2SAndrzej Pietrasiewicz if (val < 0) 3058443f2d2SAndrzej Pietrasiewicz return val; 3068443f2d2SAndrzej Pietrasiewicz 3078443f2d2SAndrzej Pietrasiewicz switch (epdata->state) { 3088443f2d2SAndrzej Pietrasiewicz case STATE_EP_ENABLED: 3098443f2d2SAndrzej Pietrasiewicz break; 3108443f2d2SAndrzej Pietrasiewicz // case STATE_EP_DISABLED: /* "can't happen" */ 3118443f2d2SAndrzej Pietrasiewicz // case STATE_EP_READY: /* "can't happen" */ 3128443f2d2SAndrzej Pietrasiewicz default: /* error! */ 3138443f2d2SAndrzej Pietrasiewicz pr_debug ("%s: ep %p not available, state %d\n", 3148443f2d2SAndrzej Pietrasiewicz shortname, epdata, epdata->state); 3158443f2d2SAndrzej Pietrasiewicz // FALLTHROUGH 3168443f2d2SAndrzej Pietrasiewicz case STATE_EP_UNBOUND: /* clean disconnect */ 3178443f2d2SAndrzej Pietrasiewicz val = -ENODEV; 3188443f2d2SAndrzej Pietrasiewicz mutex_unlock(&epdata->lock); 3198443f2d2SAndrzej Pietrasiewicz } 3208443f2d2SAndrzej Pietrasiewicz return val; 3218443f2d2SAndrzej Pietrasiewicz } 3228443f2d2SAndrzej Pietrasiewicz 3238443f2d2SAndrzej Pietrasiewicz static ssize_t 3248443f2d2SAndrzej Pietrasiewicz ep_io (struct ep_data *epdata, void *buf, unsigned len) 3258443f2d2SAndrzej Pietrasiewicz { 3268443f2d2SAndrzej Pietrasiewicz DECLARE_COMPLETION_ONSTACK (done); 3278443f2d2SAndrzej Pietrasiewicz int value; 3288443f2d2SAndrzej Pietrasiewicz 3298443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&epdata->dev->lock); 3308443f2d2SAndrzej Pietrasiewicz if (likely (epdata->ep != NULL)) { 3318443f2d2SAndrzej Pietrasiewicz struct usb_request *req = epdata->req; 3328443f2d2SAndrzej Pietrasiewicz 3338443f2d2SAndrzej Pietrasiewicz req->context = &done; 3348443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete; 3358443f2d2SAndrzej Pietrasiewicz req->buf = buf; 3368443f2d2SAndrzej Pietrasiewicz req->length = len; 3378443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC); 3388443f2d2SAndrzej Pietrasiewicz } else 3398443f2d2SAndrzej Pietrasiewicz value = -ENODEV; 3408443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock); 3418443f2d2SAndrzej Pietrasiewicz 3428443f2d2SAndrzej Pietrasiewicz if (likely (value == 0)) { 3438443f2d2SAndrzej Pietrasiewicz value = wait_event_interruptible (done.wait, done.done); 3448443f2d2SAndrzej Pietrasiewicz if (value != 0) { 3458443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&epdata->dev->lock); 3468443f2d2SAndrzej Pietrasiewicz if (likely (epdata->ep != NULL)) { 3478443f2d2SAndrzej Pietrasiewicz DBG (epdata->dev, "%s i/o interrupted\n", 3488443f2d2SAndrzej Pietrasiewicz epdata->name); 3498443f2d2SAndrzej Pietrasiewicz usb_ep_dequeue (epdata->ep, epdata->req); 3508443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock); 3518443f2d2SAndrzej Pietrasiewicz 3528443f2d2SAndrzej Pietrasiewicz wait_event (done.wait, done.done); 3538443f2d2SAndrzej Pietrasiewicz if (epdata->status == -ECONNRESET) 3548443f2d2SAndrzej Pietrasiewicz epdata->status = -EINTR; 3558443f2d2SAndrzej Pietrasiewicz } else { 3568443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&epdata->dev->lock); 3578443f2d2SAndrzej Pietrasiewicz 3588443f2d2SAndrzej Pietrasiewicz DBG (epdata->dev, "endpoint gone\n"); 3598443f2d2SAndrzej Pietrasiewicz epdata->status = -ENODEV; 3608443f2d2SAndrzej Pietrasiewicz } 3618443f2d2SAndrzej Pietrasiewicz } 3628443f2d2SAndrzej Pietrasiewicz return epdata->status; 3638443f2d2SAndrzej Pietrasiewicz } 3648443f2d2SAndrzej Pietrasiewicz return value; 3658443f2d2SAndrzej Pietrasiewicz } 3668443f2d2SAndrzej Pietrasiewicz 3678443f2d2SAndrzej Pietrasiewicz 3688443f2d2SAndrzej Pietrasiewicz /* handle a synchronous OUT bulk/intr/iso transfer */ 3698443f2d2SAndrzej Pietrasiewicz static ssize_t 3708443f2d2SAndrzej Pietrasiewicz ep_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr) 3718443f2d2SAndrzej Pietrasiewicz { 3728443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data; 3738443f2d2SAndrzej Pietrasiewicz void *kbuf; 3748443f2d2SAndrzej Pietrasiewicz ssize_t value; 3758443f2d2SAndrzej Pietrasiewicz 3768443f2d2SAndrzej Pietrasiewicz if ((value = get_ready_ep (fd->f_flags, data)) < 0) 3778443f2d2SAndrzej Pietrasiewicz return value; 3788443f2d2SAndrzej Pietrasiewicz 3798443f2d2SAndrzej Pietrasiewicz /* halt any endpoint by doing a "wrong direction" i/o call */ 3808443f2d2SAndrzej Pietrasiewicz if (usb_endpoint_dir_in(&data->desc)) { 3818443f2d2SAndrzej Pietrasiewicz if (usb_endpoint_xfer_isoc(&data->desc)) { 3828443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 3838443f2d2SAndrzej Pietrasiewicz return -EINVAL; 3848443f2d2SAndrzej Pietrasiewicz } 3858443f2d2SAndrzej Pietrasiewicz DBG (data->dev, "%s halt\n", data->name); 3868443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock); 3878443f2d2SAndrzej Pietrasiewicz if (likely (data->ep != NULL)) 3888443f2d2SAndrzej Pietrasiewicz usb_ep_set_halt (data->ep); 3898443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock); 3908443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 3918443f2d2SAndrzej Pietrasiewicz return -EBADMSG; 3928443f2d2SAndrzej Pietrasiewicz } 3938443f2d2SAndrzej Pietrasiewicz 3948443f2d2SAndrzej Pietrasiewicz /* FIXME readahead for O_NONBLOCK and poll(); careful with ZLPs */ 3958443f2d2SAndrzej Pietrasiewicz 3968443f2d2SAndrzej Pietrasiewicz value = -ENOMEM; 3978443f2d2SAndrzej Pietrasiewicz kbuf = kmalloc (len, GFP_KERNEL); 3988443f2d2SAndrzej Pietrasiewicz if (unlikely (!kbuf)) 3998443f2d2SAndrzej Pietrasiewicz goto free1; 4008443f2d2SAndrzej Pietrasiewicz 4018443f2d2SAndrzej Pietrasiewicz value = ep_io (data, kbuf, len); 4028443f2d2SAndrzej Pietrasiewicz VDEBUG (data->dev, "%s read %zu OUT, status %d\n", 4038443f2d2SAndrzej Pietrasiewicz data->name, len, (int) value); 4048443f2d2SAndrzej Pietrasiewicz if (value >= 0 && copy_to_user (buf, kbuf, value)) 4058443f2d2SAndrzej Pietrasiewicz value = -EFAULT; 4068443f2d2SAndrzej Pietrasiewicz 4078443f2d2SAndrzej Pietrasiewicz free1: 4088443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 4098443f2d2SAndrzej Pietrasiewicz kfree (kbuf); 4108443f2d2SAndrzej Pietrasiewicz return value; 4118443f2d2SAndrzej Pietrasiewicz } 4128443f2d2SAndrzej Pietrasiewicz 4138443f2d2SAndrzej Pietrasiewicz /* handle a synchronous IN bulk/intr/iso transfer */ 4148443f2d2SAndrzej Pietrasiewicz static ssize_t 4158443f2d2SAndrzej Pietrasiewicz ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr) 4168443f2d2SAndrzej Pietrasiewicz { 4178443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data; 4188443f2d2SAndrzej Pietrasiewicz void *kbuf; 4198443f2d2SAndrzej Pietrasiewicz ssize_t value; 4208443f2d2SAndrzej Pietrasiewicz 4218443f2d2SAndrzej Pietrasiewicz if ((value = get_ready_ep (fd->f_flags, data)) < 0) 4228443f2d2SAndrzej Pietrasiewicz return value; 4238443f2d2SAndrzej Pietrasiewicz 4248443f2d2SAndrzej Pietrasiewicz /* halt any endpoint by doing a "wrong direction" i/o call */ 4258443f2d2SAndrzej Pietrasiewicz if (!usb_endpoint_dir_in(&data->desc)) { 4268443f2d2SAndrzej Pietrasiewicz if (usb_endpoint_xfer_isoc(&data->desc)) { 4278443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 4288443f2d2SAndrzej Pietrasiewicz return -EINVAL; 4298443f2d2SAndrzej Pietrasiewicz } 4308443f2d2SAndrzej Pietrasiewicz DBG (data->dev, "%s halt\n", data->name); 4318443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock); 4328443f2d2SAndrzej Pietrasiewicz if (likely (data->ep != NULL)) 4338443f2d2SAndrzej Pietrasiewicz usb_ep_set_halt (data->ep); 4348443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock); 4358443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 4368443f2d2SAndrzej Pietrasiewicz return -EBADMSG; 4378443f2d2SAndrzej Pietrasiewicz } 4388443f2d2SAndrzej Pietrasiewicz 4398443f2d2SAndrzej Pietrasiewicz /* FIXME writebehind for O_NONBLOCK and poll(), qlen = 1 */ 4408443f2d2SAndrzej Pietrasiewicz 4418443f2d2SAndrzej Pietrasiewicz value = -ENOMEM; 4428443f2d2SAndrzej Pietrasiewicz kbuf = memdup_user(buf, len); 4437042e8f2SWei Yongjun if (IS_ERR(kbuf)) { 4448443f2d2SAndrzej Pietrasiewicz value = PTR_ERR(kbuf); 4458443f2d2SAndrzej Pietrasiewicz goto free1; 4468443f2d2SAndrzej Pietrasiewicz } 4478443f2d2SAndrzej Pietrasiewicz 4488443f2d2SAndrzej Pietrasiewicz value = ep_io (data, kbuf, len); 4498443f2d2SAndrzej Pietrasiewicz VDEBUG (data->dev, "%s write %zu IN, status %d\n", 4508443f2d2SAndrzej Pietrasiewicz data->name, len, (int) value); 4518443f2d2SAndrzej Pietrasiewicz free1: 4528443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 4538443f2d2SAndrzej Pietrasiewicz return value; 4548443f2d2SAndrzej Pietrasiewicz } 4558443f2d2SAndrzej Pietrasiewicz 4568443f2d2SAndrzej Pietrasiewicz static int 4578443f2d2SAndrzej Pietrasiewicz ep_release (struct inode *inode, struct file *fd) 4588443f2d2SAndrzej Pietrasiewicz { 4598443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data; 4608443f2d2SAndrzej Pietrasiewicz int value; 4618443f2d2SAndrzej Pietrasiewicz 4628443f2d2SAndrzej Pietrasiewicz value = mutex_lock_interruptible(&data->lock); 4638443f2d2SAndrzej Pietrasiewicz if (value < 0) 4648443f2d2SAndrzej Pietrasiewicz return value; 4658443f2d2SAndrzej Pietrasiewicz 4668443f2d2SAndrzej Pietrasiewicz /* clean up if this can be reopened */ 4678443f2d2SAndrzej Pietrasiewicz if (data->state != STATE_EP_UNBOUND) { 4688443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_DISABLED; 4698443f2d2SAndrzej Pietrasiewicz data->desc.bDescriptorType = 0; 4708443f2d2SAndrzej Pietrasiewicz data->hs_desc.bDescriptorType = 0; 4718443f2d2SAndrzej Pietrasiewicz usb_ep_disable(data->ep); 4728443f2d2SAndrzej Pietrasiewicz } 4738443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 4748443f2d2SAndrzej Pietrasiewicz put_ep (data); 4758443f2d2SAndrzej Pietrasiewicz return 0; 4768443f2d2SAndrzej Pietrasiewicz } 4778443f2d2SAndrzej Pietrasiewicz 4788443f2d2SAndrzej Pietrasiewicz static long ep_ioctl(struct file *fd, unsigned code, unsigned long value) 4798443f2d2SAndrzej Pietrasiewicz { 4808443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data; 4818443f2d2SAndrzej Pietrasiewicz int status; 4828443f2d2SAndrzej Pietrasiewicz 4838443f2d2SAndrzej Pietrasiewicz if ((status = get_ready_ep (fd->f_flags, data)) < 0) 4848443f2d2SAndrzej Pietrasiewicz return status; 4858443f2d2SAndrzej Pietrasiewicz 4868443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock); 4878443f2d2SAndrzej Pietrasiewicz if (likely (data->ep != NULL)) { 4888443f2d2SAndrzej Pietrasiewicz switch (code) { 4898443f2d2SAndrzej Pietrasiewicz case GADGETFS_FIFO_STATUS: 4908443f2d2SAndrzej Pietrasiewicz status = usb_ep_fifo_status (data->ep); 4918443f2d2SAndrzej Pietrasiewicz break; 4928443f2d2SAndrzej Pietrasiewicz case GADGETFS_FIFO_FLUSH: 4938443f2d2SAndrzej Pietrasiewicz usb_ep_fifo_flush (data->ep); 4948443f2d2SAndrzej Pietrasiewicz break; 4958443f2d2SAndrzej Pietrasiewicz case GADGETFS_CLEAR_HALT: 4968443f2d2SAndrzej Pietrasiewicz status = usb_ep_clear_halt (data->ep); 4978443f2d2SAndrzej Pietrasiewicz break; 4988443f2d2SAndrzej Pietrasiewicz default: 4998443f2d2SAndrzej Pietrasiewicz status = -ENOTTY; 5008443f2d2SAndrzej Pietrasiewicz } 5018443f2d2SAndrzej Pietrasiewicz } else 5028443f2d2SAndrzej Pietrasiewicz status = -ENODEV; 5038443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock); 5048443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 5058443f2d2SAndrzej Pietrasiewicz return status; 5068443f2d2SAndrzej Pietrasiewicz } 5078443f2d2SAndrzej Pietrasiewicz 5088443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 5098443f2d2SAndrzej Pietrasiewicz 5108443f2d2SAndrzej Pietrasiewicz /* ASYNCHRONOUS ENDPOINT I/O OPERATIONS (bulk/intr/iso) */ 5118443f2d2SAndrzej Pietrasiewicz 5128443f2d2SAndrzej Pietrasiewicz struct kiocb_priv { 5138443f2d2SAndrzej Pietrasiewicz struct usb_request *req; 5148443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata; 5158443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb; 5168443f2d2SAndrzej Pietrasiewicz struct mm_struct *mm; 5178443f2d2SAndrzej Pietrasiewicz struct work_struct work; 5188443f2d2SAndrzej Pietrasiewicz void *buf; 5198443f2d2SAndrzej Pietrasiewicz const struct iovec *iv; 5208443f2d2SAndrzej Pietrasiewicz unsigned long nr_segs; 5218443f2d2SAndrzej Pietrasiewicz unsigned actual; 5228443f2d2SAndrzej Pietrasiewicz }; 5238443f2d2SAndrzej Pietrasiewicz 5248443f2d2SAndrzej Pietrasiewicz static int ep_aio_cancel(struct kiocb *iocb) 5258443f2d2SAndrzej Pietrasiewicz { 5268443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = iocb->private; 5278443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata; 5288443f2d2SAndrzej Pietrasiewicz int value; 5298443f2d2SAndrzej Pietrasiewicz 5308443f2d2SAndrzej Pietrasiewicz local_irq_disable(); 5318443f2d2SAndrzej Pietrasiewicz epdata = priv->epdata; 5328443f2d2SAndrzej Pietrasiewicz // spin_lock(&epdata->dev->lock); 5338443f2d2SAndrzej Pietrasiewicz if (likely(epdata && epdata->ep && priv->req)) 5348443f2d2SAndrzej Pietrasiewicz value = usb_ep_dequeue (epdata->ep, priv->req); 5358443f2d2SAndrzej Pietrasiewicz else 5368443f2d2SAndrzej Pietrasiewicz value = -EINVAL; 5378443f2d2SAndrzej Pietrasiewicz // spin_unlock(&epdata->dev->lock); 5388443f2d2SAndrzej Pietrasiewicz local_irq_enable(); 5398443f2d2SAndrzej Pietrasiewicz 5408443f2d2SAndrzej Pietrasiewicz return value; 5418443f2d2SAndrzej Pietrasiewicz } 5428443f2d2SAndrzej Pietrasiewicz 5438443f2d2SAndrzej Pietrasiewicz static ssize_t ep_copy_to_user(struct kiocb_priv *priv) 5448443f2d2SAndrzej Pietrasiewicz { 5458443f2d2SAndrzej Pietrasiewicz ssize_t len, total; 5468443f2d2SAndrzej Pietrasiewicz void *to_copy; 5478443f2d2SAndrzej Pietrasiewicz int i; 5488443f2d2SAndrzej Pietrasiewicz 5498443f2d2SAndrzej Pietrasiewicz /* copy stuff into user buffers */ 5508443f2d2SAndrzej Pietrasiewicz total = priv->actual; 5518443f2d2SAndrzej Pietrasiewicz len = 0; 5528443f2d2SAndrzej Pietrasiewicz to_copy = priv->buf; 5538443f2d2SAndrzej Pietrasiewicz for (i=0; i < priv->nr_segs; i++) { 5548443f2d2SAndrzej Pietrasiewicz ssize_t this = min((ssize_t)(priv->iv[i].iov_len), total); 5558443f2d2SAndrzej Pietrasiewicz 5568443f2d2SAndrzej Pietrasiewicz if (copy_to_user(priv->iv[i].iov_base, to_copy, this)) { 5578443f2d2SAndrzej Pietrasiewicz if (len == 0) 5588443f2d2SAndrzej Pietrasiewicz len = -EFAULT; 5598443f2d2SAndrzej Pietrasiewicz break; 5608443f2d2SAndrzej Pietrasiewicz } 5618443f2d2SAndrzej Pietrasiewicz 5628443f2d2SAndrzej Pietrasiewicz total -= this; 5638443f2d2SAndrzej Pietrasiewicz len += this; 5648443f2d2SAndrzej Pietrasiewicz to_copy += this; 5658443f2d2SAndrzej Pietrasiewicz if (total == 0) 5668443f2d2SAndrzej Pietrasiewicz break; 5678443f2d2SAndrzej Pietrasiewicz } 5688443f2d2SAndrzej Pietrasiewicz 5698443f2d2SAndrzej Pietrasiewicz return len; 5708443f2d2SAndrzej Pietrasiewicz } 5718443f2d2SAndrzej Pietrasiewicz 5728443f2d2SAndrzej Pietrasiewicz static void ep_user_copy_worker(struct work_struct *work) 5738443f2d2SAndrzej Pietrasiewicz { 5748443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = container_of(work, struct kiocb_priv, work); 5758443f2d2SAndrzej Pietrasiewicz struct mm_struct *mm = priv->mm; 5768443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb = priv->iocb; 5778443f2d2SAndrzej Pietrasiewicz size_t ret; 5788443f2d2SAndrzej Pietrasiewicz 5798443f2d2SAndrzej Pietrasiewicz use_mm(mm); 5808443f2d2SAndrzej Pietrasiewicz ret = ep_copy_to_user(priv); 5818443f2d2SAndrzej Pietrasiewicz unuse_mm(mm); 5828443f2d2SAndrzej Pietrasiewicz 5838443f2d2SAndrzej Pietrasiewicz /* completing the iocb can drop the ctx and mm, don't touch mm after */ 5848443f2d2SAndrzej Pietrasiewicz aio_complete(iocb, ret, ret); 5858443f2d2SAndrzej Pietrasiewicz 5868443f2d2SAndrzej Pietrasiewicz kfree(priv->buf); 5878443f2d2SAndrzej Pietrasiewicz kfree(priv); 5888443f2d2SAndrzej Pietrasiewicz } 5898443f2d2SAndrzej Pietrasiewicz 5908443f2d2SAndrzej Pietrasiewicz static void ep_aio_complete(struct usb_ep *ep, struct usb_request *req) 5918443f2d2SAndrzej Pietrasiewicz { 5928443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb = req->context; 5938443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv = iocb->private; 5948443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = priv->epdata; 5958443f2d2SAndrzej Pietrasiewicz 5968443f2d2SAndrzej Pietrasiewicz /* lock against disconnect (and ideally, cancel) */ 5978443f2d2SAndrzej Pietrasiewicz spin_lock(&epdata->dev->lock); 5988443f2d2SAndrzej Pietrasiewicz priv->req = NULL; 5998443f2d2SAndrzej Pietrasiewicz priv->epdata = NULL; 6008443f2d2SAndrzej Pietrasiewicz 6018443f2d2SAndrzej Pietrasiewicz /* if this was a write or a read returning no data then we 6028443f2d2SAndrzej Pietrasiewicz * don't need to copy anything to userspace, so we can 6038443f2d2SAndrzej Pietrasiewicz * complete the aio request immediately. 6048443f2d2SAndrzej Pietrasiewicz */ 6058443f2d2SAndrzej Pietrasiewicz if (priv->iv == NULL || unlikely(req->actual == 0)) { 6068443f2d2SAndrzej Pietrasiewicz kfree(req->buf); 6078443f2d2SAndrzej Pietrasiewicz kfree(priv); 6088443f2d2SAndrzej Pietrasiewicz iocb->private = NULL; 6098443f2d2SAndrzej Pietrasiewicz /* aio_complete() reports bytes-transferred _and_ faults */ 6108443f2d2SAndrzej Pietrasiewicz aio_complete(iocb, req->actual ? req->actual : req->status, 6118443f2d2SAndrzej Pietrasiewicz req->status); 6128443f2d2SAndrzej Pietrasiewicz } else { 6138443f2d2SAndrzej Pietrasiewicz /* ep_copy_to_user() won't report both; we hide some faults */ 6148443f2d2SAndrzej Pietrasiewicz if (unlikely(0 != req->status)) 6158443f2d2SAndrzej Pietrasiewicz DBG(epdata->dev, "%s fault %d len %d\n", 6168443f2d2SAndrzej Pietrasiewicz ep->name, req->status, req->actual); 6178443f2d2SAndrzej Pietrasiewicz 6188443f2d2SAndrzej Pietrasiewicz priv->buf = req->buf; 6198443f2d2SAndrzej Pietrasiewicz priv->actual = req->actual; 6208443f2d2SAndrzej Pietrasiewicz schedule_work(&priv->work); 6218443f2d2SAndrzej Pietrasiewicz } 6228443f2d2SAndrzej Pietrasiewicz spin_unlock(&epdata->dev->lock); 6238443f2d2SAndrzej Pietrasiewicz 6248443f2d2SAndrzej Pietrasiewicz usb_ep_free_request(ep, req); 6258443f2d2SAndrzej Pietrasiewicz put_ep(epdata); 6268443f2d2SAndrzej Pietrasiewicz } 6278443f2d2SAndrzej Pietrasiewicz 6288443f2d2SAndrzej Pietrasiewicz static ssize_t 6298443f2d2SAndrzej Pietrasiewicz ep_aio_rwtail( 6308443f2d2SAndrzej Pietrasiewicz struct kiocb *iocb, 6318443f2d2SAndrzej Pietrasiewicz char *buf, 6328443f2d2SAndrzej Pietrasiewicz size_t len, 6338443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata, 6348443f2d2SAndrzej Pietrasiewicz const struct iovec *iv, 6358443f2d2SAndrzej Pietrasiewicz unsigned long nr_segs 6368443f2d2SAndrzej Pietrasiewicz ) 6378443f2d2SAndrzej Pietrasiewicz { 6388443f2d2SAndrzej Pietrasiewicz struct kiocb_priv *priv; 6398443f2d2SAndrzej Pietrasiewicz struct usb_request *req; 6408443f2d2SAndrzej Pietrasiewicz ssize_t value; 6418443f2d2SAndrzej Pietrasiewicz 6428443f2d2SAndrzej Pietrasiewicz priv = kmalloc(sizeof *priv, GFP_KERNEL); 6438443f2d2SAndrzej Pietrasiewicz if (!priv) { 6448443f2d2SAndrzej Pietrasiewicz value = -ENOMEM; 6458443f2d2SAndrzej Pietrasiewicz fail: 6468443f2d2SAndrzej Pietrasiewicz kfree(buf); 6478443f2d2SAndrzej Pietrasiewicz return value; 6488443f2d2SAndrzej Pietrasiewicz } 6498443f2d2SAndrzej Pietrasiewicz iocb->private = priv; 6508443f2d2SAndrzej Pietrasiewicz priv->iocb = iocb; 6518443f2d2SAndrzej Pietrasiewicz priv->iv = iv; 6528443f2d2SAndrzej Pietrasiewicz priv->nr_segs = nr_segs; 6538443f2d2SAndrzej Pietrasiewicz INIT_WORK(&priv->work, ep_user_copy_worker); 6548443f2d2SAndrzej Pietrasiewicz 6558443f2d2SAndrzej Pietrasiewicz value = get_ready_ep(iocb->ki_filp->f_flags, epdata); 6568443f2d2SAndrzej Pietrasiewicz if (unlikely(value < 0)) { 6578443f2d2SAndrzej Pietrasiewicz kfree(priv); 6588443f2d2SAndrzej Pietrasiewicz goto fail; 6598443f2d2SAndrzej Pietrasiewicz } 6608443f2d2SAndrzej Pietrasiewicz 6618443f2d2SAndrzej Pietrasiewicz kiocb_set_cancel_fn(iocb, ep_aio_cancel); 6628443f2d2SAndrzej Pietrasiewicz get_ep(epdata); 6638443f2d2SAndrzej Pietrasiewicz priv->epdata = epdata; 6648443f2d2SAndrzej Pietrasiewicz priv->actual = 0; 6658443f2d2SAndrzej Pietrasiewicz priv->mm = current->mm; /* mm teardown waits for iocbs in exit_aio() */ 6668443f2d2SAndrzej Pietrasiewicz 6678443f2d2SAndrzej Pietrasiewicz /* each kiocb is coupled to one usb_request, but we can't 6688443f2d2SAndrzej Pietrasiewicz * allocate or submit those if the host disconnected. 6698443f2d2SAndrzej Pietrasiewicz */ 6708443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&epdata->dev->lock); 6718443f2d2SAndrzej Pietrasiewicz if (likely(epdata->ep)) { 6728443f2d2SAndrzej Pietrasiewicz req = usb_ep_alloc_request(epdata->ep, GFP_ATOMIC); 6738443f2d2SAndrzej Pietrasiewicz if (likely(req)) { 6748443f2d2SAndrzej Pietrasiewicz priv->req = req; 6758443f2d2SAndrzej Pietrasiewicz req->buf = buf; 6768443f2d2SAndrzej Pietrasiewicz req->length = len; 6778443f2d2SAndrzej Pietrasiewicz req->complete = ep_aio_complete; 6788443f2d2SAndrzej Pietrasiewicz req->context = iocb; 6798443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue(epdata->ep, req, GFP_ATOMIC); 6808443f2d2SAndrzej Pietrasiewicz if (unlikely(0 != value)) 6818443f2d2SAndrzej Pietrasiewicz usb_ep_free_request(epdata->ep, req); 6828443f2d2SAndrzej Pietrasiewicz } else 6838443f2d2SAndrzej Pietrasiewicz value = -EAGAIN; 6848443f2d2SAndrzej Pietrasiewicz } else 6858443f2d2SAndrzej Pietrasiewicz value = -ENODEV; 6868443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&epdata->dev->lock); 6878443f2d2SAndrzej Pietrasiewicz 6888443f2d2SAndrzej Pietrasiewicz mutex_unlock(&epdata->lock); 6898443f2d2SAndrzej Pietrasiewicz 6908443f2d2SAndrzej Pietrasiewicz if (unlikely(value)) { 6918443f2d2SAndrzej Pietrasiewicz kfree(priv); 6928443f2d2SAndrzej Pietrasiewicz put_ep(epdata); 6938443f2d2SAndrzej Pietrasiewicz } else 6948443f2d2SAndrzej Pietrasiewicz value = -EIOCBQUEUED; 6958443f2d2SAndrzej Pietrasiewicz return value; 6968443f2d2SAndrzej Pietrasiewicz } 6978443f2d2SAndrzej Pietrasiewicz 6988443f2d2SAndrzej Pietrasiewicz static ssize_t 6998443f2d2SAndrzej Pietrasiewicz ep_aio_read(struct kiocb *iocb, const struct iovec *iov, 7008443f2d2SAndrzej Pietrasiewicz unsigned long nr_segs, loff_t o) 7018443f2d2SAndrzej Pietrasiewicz { 7028443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = iocb->ki_filp->private_data; 7038443f2d2SAndrzej Pietrasiewicz char *buf; 7048443f2d2SAndrzej Pietrasiewicz 7058443f2d2SAndrzej Pietrasiewicz if (unlikely(usb_endpoint_dir_in(&epdata->desc))) 7068443f2d2SAndrzej Pietrasiewicz return -EINVAL; 7078443f2d2SAndrzej Pietrasiewicz 7088443f2d2SAndrzej Pietrasiewicz buf = kmalloc(iocb->ki_nbytes, GFP_KERNEL); 7098443f2d2SAndrzej Pietrasiewicz if (unlikely(!buf)) 7108443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 7118443f2d2SAndrzej Pietrasiewicz 7128443f2d2SAndrzej Pietrasiewicz return ep_aio_rwtail(iocb, buf, iocb->ki_nbytes, epdata, iov, nr_segs); 7138443f2d2SAndrzej Pietrasiewicz } 7148443f2d2SAndrzej Pietrasiewicz 7158443f2d2SAndrzej Pietrasiewicz static ssize_t 7168443f2d2SAndrzej Pietrasiewicz ep_aio_write(struct kiocb *iocb, const struct iovec *iov, 7178443f2d2SAndrzej Pietrasiewicz unsigned long nr_segs, loff_t o) 7188443f2d2SAndrzej Pietrasiewicz { 7198443f2d2SAndrzej Pietrasiewicz struct ep_data *epdata = iocb->ki_filp->private_data; 7208443f2d2SAndrzej Pietrasiewicz char *buf; 7218443f2d2SAndrzej Pietrasiewicz size_t len = 0; 7228443f2d2SAndrzej Pietrasiewicz int i = 0; 7238443f2d2SAndrzej Pietrasiewicz 7248443f2d2SAndrzej Pietrasiewicz if (unlikely(!usb_endpoint_dir_in(&epdata->desc))) 7258443f2d2SAndrzej Pietrasiewicz return -EINVAL; 7268443f2d2SAndrzej Pietrasiewicz 7278443f2d2SAndrzej Pietrasiewicz buf = kmalloc(iocb->ki_nbytes, GFP_KERNEL); 7288443f2d2SAndrzej Pietrasiewicz if (unlikely(!buf)) 7298443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 7308443f2d2SAndrzej Pietrasiewicz 7318443f2d2SAndrzej Pietrasiewicz for (i=0; i < nr_segs; i++) { 7328443f2d2SAndrzej Pietrasiewicz if (unlikely(copy_from_user(&buf[len], iov[i].iov_base, 7338443f2d2SAndrzej Pietrasiewicz iov[i].iov_len) != 0)) { 7348443f2d2SAndrzej Pietrasiewicz kfree(buf); 7358443f2d2SAndrzej Pietrasiewicz return -EFAULT; 7368443f2d2SAndrzej Pietrasiewicz } 7378443f2d2SAndrzej Pietrasiewicz len += iov[i].iov_len; 7388443f2d2SAndrzej Pietrasiewicz } 7398443f2d2SAndrzej Pietrasiewicz return ep_aio_rwtail(iocb, buf, len, epdata, NULL, 0); 7408443f2d2SAndrzej Pietrasiewicz } 7418443f2d2SAndrzej Pietrasiewicz 7428443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 7438443f2d2SAndrzej Pietrasiewicz 7448443f2d2SAndrzej Pietrasiewicz /* used after endpoint configuration */ 7458443f2d2SAndrzej Pietrasiewicz static const struct file_operations ep_io_operations = { 7468443f2d2SAndrzej Pietrasiewicz .owner = THIS_MODULE, 7478443f2d2SAndrzej Pietrasiewicz .llseek = no_llseek, 7488443f2d2SAndrzej Pietrasiewicz 7498443f2d2SAndrzej Pietrasiewicz .read = ep_read, 7508443f2d2SAndrzej Pietrasiewicz .write = ep_write, 7518443f2d2SAndrzej Pietrasiewicz .unlocked_ioctl = ep_ioctl, 7528443f2d2SAndrzej Pietrasiewicz .release = ep_release, 7538443f2d2SAndrzej Pietrasiewicz 7548443f2d2SAndrzej Pietrasiewicz .aio_read = ep_aio_read, 7558443f2d2SAndrzej Pietrasiewicz .aio_write = ep_aio_write, 7568443f2d2SAndrzej Pietrasiewicz }; 7578443f2d2SAndrzej Pietrasiewicz 7588443f2d2SAndrzej Pietrasiewicz /* ENDPOINT INITIALIZATION 7598443f2d2SAndrzej Pietrasiewicz * 7608443f2d2SAndrzej Pietrasiewicz * fd = open ("/dev/gadget/$ENDPOINT", O_RDWR) 7618443f2d2SAndrzej Pietrasiewicz * status = write (fd, descriptors, sizeof descriptors) 7628443f2d2SAndrzej Pietrasiewicz * 7638443f2d2SAndrzej Pietrasiewicz * That write establishes the endpoint configuration, configuring 7648443f2d2SAndrzej Pietrasiewicz * the controller to process bulk, interrupt, or isochronous transfers 7658443f2d2SAndrzej Pietrasiewicz * at the right maxpacket size, and so on. 7668443f2d2SAndrzej Pietrasiewicz * 7678443f2d2SAndrzej Pietrasiewicz * The descriptors are message type 1, identified by a host order u32 7688443f2d2SAndrzej Pietrasiewicz * at the beginning of what's written. Descriptor order is: full/low 7698443f2d2SAndrzej Pietrasiewicz * speed descriptor, then optional high speed descriptor. 7708443f2d2SAndrzej Pietrasiewicz */ 7718443f2d2SAndrzej Pietrasiewicz static ssize_t 7728443f2d2SAndrzej Pietrasiewicz ep_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr) 7738443f2d2SAndrzej Pietrasiewicz { 7748443f2d2SAndrzej Pietrasiewicz struct ep_data *data = fd->private_data; 7758443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep; 7768443f2d2SAndrzej Pietrasiewicz u32 tag; 7778443f2d2SAndrzej Pietrasiewicz int value, length = len; 7788443f2d2SAndrzej Pietrasiewicz 7798443f2d2SAndrzej Pietrasiewicz value = mutex_lock_interruptible(&data->lock); 7808443f2d2SAndrzej Pietrasiewicz if (value < 0) 7818443f2d2SAndrzej Pietrasiewicz return value; 7828443f2d2SAndrzej Pietrasiewicz 7838443f2d2SAndrzej Pietrasiewicz if (data->state != STATE_EP_READY) { 7848443f2d2SAndrzej Pietrasiewicz value = -EL2HLT; 7858443f2d2SAndrzej Pietrasiewicz goto fail; 7868443f2d2SAndrzej Pietrasiewicz } 7878443f2d2SAndrzej Pietrasiewicz 7888443f2d2SAndrzej Pietrasiewicz value = len; 7898443f2d2SAndrzej Pietrasiewicz if (len < USB_DT_ENDPOINT_SIZE + 4) 7908443f2d2SAndrzej Pietrasiewicz goto fail0; 7918443f2d2SAndrzej Pietrasiewicz 7928443f2d2SAndrzej Pietrasiewicz /* we might need to change message format someday */ 7938443f2d2SAndrzej Pietrasiewicz if (copy_from_user (&tag, buf, 4)) { 7948443f2d2SAndrzej Pietrasiewicz goto fail1; 7958443f2d2SAndrzej Pietrasiewicz } 7968443f2d2SAndrzej Pietrasiewicz if (tag != 1) { 7978443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "config %s, bad tag %d\n", data->name, tag); 7988443f2d2SAndrzej Pietrasiewicz goto fail0; 7998443f2d2SAndrzej Pietrasiewicz } 8008443f2d2SAndrzej Pietrasiewicz buf += 4; 8018443f2d2SAndrzej Pietrasiewicz len -= 4; 8028443f2d2SAndrzej Pietrasiewicz 8038443f2d2SAndrzej Pietrasiewicz /* NOTE: audio endpoint extensions not accepted here; 8048443f2d2SAndrzej Pietrasiewicz * just don't include the extra bytes. 8058443f2d2SAndrzej Pietrasiewicz */ 8068443f2d2SAndrzej Pietrasiewicz 8078443f2d2SAndrzej Pietrasiewicz /* full/low speed descriptor, then high speed */ 8088443f2d2SAndrzej Pietrasiewicz if (copy_from_user (&data->desc, buf, USB_DT_ENDPOINT_SIZE)) { 8098443f2d2SAndrzej Pietrasiewicz goto fail1; 8108443f2d2SAndrzej Pietrasiewicz } 8118443f2d2SAndrzej Pietrasiewicz if (data->desc.bLength != USB_DT_ENDPOINT_SIZE 8128443f2d2SAndrzej Pietrasiewicz || data->desc.bDescriptorType != USB_DT_ENDPOINT) 8138443f2d2SAndrzej Pietrasiewicz goto fail0; 8148443f2d2SAndrzej Pietrasiewicz if (len != USB_DT_ENDPOINT_SIZE) { 8158443f2d2SAndrzej Pietrasiewicz if (len != 2 * USB_DT_ENDPOINT_SIZE) 8168443f2d2SAndrzej Pietrasiewicz goto fail0; 8178443f2d2SAndrzej Pietrasiewicz if (copy_from_user (&data->hs_desc, buf + USB_DT_ENDPOINT_SIZE, 8188443f2d2SAndrzej Pietrasiewicz USB_DT_ENDPOINT_SIZE)) { 8198443f2d2SAndrzej Pietrasiewicz goto fail1; 8208443f2d2SAndrzej Pietrasiewicz } 8218443f2d2SAndrzej Pietrasiewicz if (data->hs_desc.bLength != USB_DT_ENDPOINT_SIZE 8228443f2d2SAndrzej Pietrasiewicz || data->hs_desc.bDescriptorType 8238443f2d2SAndrzej Pietrasiewicz != USB_DT_ENDPOINT) { 8248443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "config %s, bad hs length or type\n", 8258443f2d2SAndrzej Pietrasiewicz data->name); 8268443f2d2SAndrzej Pietrasiewicz goto fail0; 8278443f2d2SAndrzej Pietrasiewicz } 8288443f2d2SAndrzej Pietrasiewicz } 8298443f2d2SAndrzej Pietrasiewicz 8308443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock); 8318443f2d2SAndrzej Pietrasiewicz if (data->dev->state == STATE_DEV_UNBOUND) { 8328443f2d2SAndrzej Pietrasiewicz value = -ENOENT; 8338443f2d2SAndrzej Pietrasiewicz goto gone; 8348443f2d2SAndrzej Pietrasiewicz } else if ((ep = data->ep) == NULL) { 8358443f2d2SAndrzej Pietrasiewicz value = -ENODEV; 8368443f2d2SAndrzej Pietrasiewicz goto gone; 8378443f2d2SAndrzej Pietrasiewicz } 8388443f2d2SAndrzej Pietrasiewicz switch (data->dev->gadget->speed) { 8398443f2d2SAndrzej Pietrasiewicz case USB_SPEED_LOW: 8408443f2d2SAndrzej Pietrasiewicz case USB_SPEED_FULL: 8418443f2d2SAndrzej Pietrasiewicz ep->desc = &data->desc; 8428443f2d2SAndrzej Pietrasiewicz value = usb_ep_enable(ep); 8438443f2d2SAndrzej Pietrasiewicz if (value == 0) 8448443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_ENABLED; 8458443f2d2SAndrzej Pietrasiewicz break; 8468443f2d2SAndrzej Pietrasiewicz case USB_SPEED_HIGH: 8478443f2d2SAndrzej Pietrasiewicz /* fails if caller didn't provide that descriptor... */ 8488443f2d2SAndrzej Pietrasiewicz ep->desc = &data->hs_desc; 8498443f2d2SAndrzej Pietrasiewicz value = usb_ep_enable(ep); 8508443f2d2SAndrzej Pietrasiewicz if (value == 0) 8518443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_ENABLED; 8528443f2d2SAndrzej Pietrasiewicz break; 8538443f2d2SAndrzej Pietrasiewicz default: 8548443f2d2SAndrzej Pietrasiewicz DBG(data->dev, "unconnected, %s init abandoned\n", 8558443f2d2SAndrzej Pietrasiewicz data->name); 8568443f2d2SAndrzej Pietrasiewicz value = -EINVAL; 8578443f2d2SAndrzej Pietrasiewicz } 8588443f2d2SAndrzej Pietrasiewicz if (value == 0) { 8598443f2d2SAndrzej Pietrasiewicz fd->f_op = &ep_io_operations; 8608443f2d2SAndrzej Pietrasiewicz value = length; 8618443f2d2SAndrzej Pietrasiewicz } 8628443f2d2SAndrzej Pietrasiewicz gone: 8638443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock); 8648443f2d2SAndrzej Pietrasiewicz if (value < 0) { 8658443f2d2SAndrzej Pietrasiewicz fail: 8668443f2d2SAndrzej Pietrasiewicz data->desc.bDescriptorType = 0; 8678443f2d2SAndrzej Pietrasiewicz data->hs_desc.bDescriptorType = 0; 8688443f2d2SAndrzej Pietrasiewicz } 8698443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 8708443f2d2SAndrzej Pietrasiewicz return value; 8718443f2d2SAndrzej Pietrasiewicz fail0: 8728443f2d2SAndrzej Pietrasiewicz value = -EINVAL; 8738443f2d2SAndrzej Pietrasiewicz goto fail; 8748443f2d2SAndrzej Pietrasiewicz fail1: 8758443f2d2SAndrzej Pietrasiewicz value = -EFAULT; 8768443f2d2SAndrzej Pietrasiewicz goto fail; 8778443f2d2SAndrzej Pietrasiewicz } 8788443f2d2SAndrzej Pietrasiewicz 8798443f2d2SAndrzej Pietrasiewicz static int 8808443f2d2SAndrzej Pietrasiewicz ep_open (struct inode *inode, struct file *fd) 8818443f2d2SAndrzej Pietrasiewicz { 8828443f2d2SAndrzej Pietrasiewicz struct ep_data *data = inode->i_private; 8838443f2d2SAndrzej Pietrasiewicz int value = -EBUSY; 8848443f2d2SAndrzej Pietrasiewicz 8858443f2d2SAndrzej Pietrasiewicz if (mutex_lock_interruptible(&data->lock) != 0) 8868443f2d2SAndrzej Pietrasiewicz return -EINTR; 8878443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&data->dev->lock); 8888443f2d2SAndrzej Pietrasiewicz if (data->dev->state == STATE_DEV_UNBOUND) 8898443f2d2SAndrzej Pietrasiewicz value = -ENOENT; 8908443f2d2SAndrzej Pietrasiewicz else if (data->state == STATE_EP_DISABLED) { 8918443f2d2SAndrzej Pietrasiewicz value = 0; 8928443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_READY; 8938443f2d2SAndrzej Pietrasiewicz get_ep (data); 8948443f2d2SAndrzej Pietrasiewicz fd->private_data = data; 8958443f2d2SAndrzej Pietrasiewicz VDEBUG (data->dev, "%s ready\n", data->name); 8968443f2d2SAndrzej Pietrasiewicz } else 8978443f2d2SAndrzej Pietrasiewicz DBG (data->dev, "%s state %d\n", 8988443f2d2SAndrzej Pietrasiewicz data->name, data->state); 8998443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&data->dev->lock); 9008443f2d2SAndrzej Pietrasiewicz mutex_unlock(&data->lock); 9018443f2d2SAndrzej Pietrasiewicz return value; 9028443f2d2SAndrzej Pietrasiewicz } 9038443f2d2SAndrzej Pietrasiewicz 9048443f2d2SAndrzej Pietrasiewicz /* used before endpoint configuration */ 9058443f2d2SAndrzej Pietrasiewicz static const struct file_operations ep_config_operations = { 9068443f2d2SAndrzej Pietrasiewicz .llseek = no_llseek, 9078443f2d2SAndrzej Pietrasiewicz 9088443f2d2SAndrzej Pietrasiewicz .open = ep_open, 9098443f2d2SAndrzej Pietrasiewicz .write = ep_config, 9108443f2d2SAndrzej Pietrasiewicz .release = ep_release, 9118443f2d2SAndrzej Pietrasiewicz }; 9128443f2d2SAndrzej Pietrasiewicz 9138443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 9148443f2d2SAndrzej Pietrasiewicz 9158443f2d2SAndrzej Pietrasiewicz /* EP0 IMPLEMENTATION can be partly in userspace. 9168443f2d2SAndrzej Pietrasiewicz * 9178443f2d2SAndrzej Pietrasiewicz * Drivers that use this facility receive various events, including 9188443f2d2SAndrzej Pietrasiewicz * control requests the kernel doesn't handle. Drivers that don't 9198443f2d2SAndrzej Pietrasiewicz * use this facility may be too simple-minded for real applications. 9208443f2d2SAndrzej Pietrasiewicz */ 9218443f2d2SAndrzej Pietrasiewicz 9228443f2d2SAndrzej Pietrasiewicz static inline void ep0_readable (struct dev_data *dev) 9238443f2d2SAndrzej Pietrasiewicz { 9248443f2d2SAndrzej Pietrasiewicz wake_up (&dev->wait); 9258443f2d2SAndrzej Pietrasiewicz kill_fasync (&dev->fasync, SIGIO, POLL_IN); 9268443f2d2SAndrzej Pietrasiewicz } 9278443f2d2SAndrzej Pietrasiewicz 9288443f2d2SAndrzej Pietrasiewicz static void clean_req (struct usb_ep *ep, struct usb_request *req) 9298443f2d2SAndrzej Pietrasiewicz { 9308443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data; 9318443f2d2SAndrzej Pietrasiewicz 9328443f2d2SAndrzej Pietrasiewicz if (req->buf != dev->rbuf) { 9338443f2d2SAndrzej Pietrasiewicz kfree(req->buf); 9348443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf; 9358443f2d2SAndrzej Pietrasiewicz } 9368443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete; 9378443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 0; 9388443f2d2SAndrzej Pietrasiewicz } 9398443f2d2SAndrzej Pietrasiewicz 9408443f2d2SAndrzej Pietrasiewicz static void ep0_complete (struct usb_ep *ep, struct usb_request *req) 9418443f2d2SAndrzej Pietrasiewicz { 9428443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data; 9438443f2d2SAndrzej Pietrasiewicz unsigned long flags; 9448443f2d2SAndrzej Pietrasiewicz int free = 1; 9458443f2d2SAndrzej Pietrasiewicz 9468443f2d2SAndrzej Pietrasiewicz /* for control OUT, data must still get to userspace */ 9478443f2d2SAndrzej Pietrasiewicz spin_lock_irqsave(&dev->lock, flags); 9488443f2d2SAndrzej Pietrasiewicz if (!dev->setup_in) { 9498443f2d2SAndrzej Pietrasiewicz dev->setup_out_error = (req->status != 0); 9508443f2d2SAndrzej Pietrasiewicz if (!dev->setup_out_error) 9518443f2d2SAndrzej Pietrasiewicz free = 0; 9528443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 1; 9538443f2d2SAndrzej Pietrasiewicz ep0_readable (dev); 9548443f2d2SAndrzej Pietrasiewicz } 9558443f2d2SAndrzej Pietrasiewicz 9568443f2d2SAndrzej Pietrasiewicz /* clean up as appropriate */ 9578443f2d2SAndrzej Pietrasiewicz if (free && req->buf != &dev->rbuf) 9588443f2d2SAndrzej Pietrasiewicz clean_req (ep, req); 9598443f2d2SAndrzej Pietrasiewicz req->complete = epio_complete; 9608443f2d2SAndrzej Pietrasiewicz spin_unlock_irqrestore(&dev->lock, flags); 9618443f2d2SAndrzej Pietrasiewicz } 9628443f2d2SAndrzej Pietrasiewicz 9638443f2d2SAndrzej Pietrasiewicz static int setup_req (struct usb_ep *ep, struct usb_request *req, u16 len) 9648443f2d2SAndrzej Pietrasiewicz { 9658443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = ep->driver_data; 9668443f2d2SAndrzej Pietrasiewicz 9678443f2d2SAndrzej Pietrasiewicz if (dev->setup_out_ready) { 9688443f2d2SAndrzej Pietrasiewicz DBG (dev, "ep0 request busy!\n"); 9698443f2d2SAndrzej Pietrasiewicz return -EBUSY; 9708443f2d2SAndrzej Pietrasiewicz } 9718443f2d2SAndrzej Pietrasiewicz if (len > sizeof (dev->rbuf)) 9728443f2d2SAndrzej Pietrasiewicz req->buf = kmalloc(len, GFP_ATOMIC); 9738443f2d2SAndrzej Pietrasiewicz if (req->buf == NULL) { 9748443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf; 9758443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 9768443f2d2SAndrzej Pietrasiewicz } 9778443f2d2SAndrzej Pietrasiewicz req->complete = ep0_complete; 9788443f2d2SAndrzej Pietrasiewicz req->length = len; 9798443f2d2SAndrzej Pietrasiewicz req->zero = 0; 9808443f2d2SAndrzej Pietrasiewicz return 0; 9818443f2d2SAndrzej Pietrasiewicz } 9828443f2d2SAndrzej Pietrasiewicz 9838443f2d2SAndrzej Pietrasiewicz static ssize_t 9848443f2d2SAndrzej Pietrasiewicz ep0_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr) 9858443f2d2SAndrzej Pietrasiewicz { 9868443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 9878443f2d2SAndrzej Pietrasiewicz ssize_t retval; 9888443f2d2SAndrzej Pietrasiewicz enum ep0_state state; 9898443f2d2SAndrzej Pietrasiewicz 9908443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 9918443f2d2SAndrzej Pietrasiewicz 9928443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */ 9938443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) { 9948443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0; 9958443f2d2SAndrzej Pietrasiewicz retval = -EIDRM; 9968443f2d2SAndrzej Pietrasiewicz goto done; 9978443f2d2SAndrzej Pietrasiewicz } 9988443f2d2SAndrzej Pietrasiewicz 9998443f2d2SAndrzej Pietrasiewicz /* control DATA stage */ 10008443f2d2SAndrzej Pietrasiewicz if ((state = dev->state) == STATE_DEV_SETUP) { 10018443f2d2SAndrzej Pietrasiewicz 10028443f2d2SAndrzej Pietrasiewicz if (dev->setup_in) { /* stall IN */ 10038443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "ep0in stall\n"); 10048443f2d2SAndrzej Pietrasiewicz (void) usb_ep_set_halt (dev->gadget->ep0); 10058443f2d2SAndrzej Pietrasiewicz retval = -EL2HLT; 10068443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 10078443f2d2SAndrzej Pietrasiewicz 10088443f2d2SAndrzej Pietrasiewicz } else if (len == 0) { /* ack SET_CONFIGURATION etc */ 10098443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep = dev->gadget->ep0; 10108443f2d2SAndrzej Pietrasiewicz struct usb_request *req = dev->req; 10118443f2d2SAndrzej Pietrasiewicz 10128443f2d2SAndrzej Pietrasiewicz if ((retval = setup_req (ep, req, 0)) == 0) 10138443f2d2SAndrzej Pietrasiewicz retval = usb_ep_queue (ep, req, GFP_ATOMIC); 10148443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 10158443f2d2SAndrzej Pietrasiewicz 10168443f2d2SAndrzej Pietrasiewicz /* assume that was SET_CONFIGURATION */ 10178443f2d2SAndrzej Pietrasiewicz if (dev->current_config) { 10188443f2d2SAndrzej Pietrasiewicz unsigned power; 10198443f2d2SAndrzej Pietrasiewicz 10208443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(dev->gadget) 10218443f2d2SAndrzej Pietrasiewicz && (dev->gadget->speed 10228443f2d2SAndrzej Pietrasiewicz == USB_SPEED_HIGH)) 10238443f2d2SAndrzej Pietrasiewicz power = dev->hs_config->bMaxPower; 10248443f2d2SAndrzej Pietrasiewicz else 10258443f2d2SAndrzej Pietrasiewicz power = dev->config->bMaxPower; 10268443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(dev->gadget, 2 * power); 10278443f2d2SAndrzej Pietrasiewicz } 10288443f2d2SAndrzej Pietrasiewicz 10298443f2d2SAndrzej Pietrasiewicz } else { /* collect OUT data */ 10308443f2d2SAndrzej Pietrasiewicz if ((fd->f_flags & O_NONBLOCK) != 0 10318443f2d2SAndrzej Pietrasiewicz && !dev->setup_out_ready) { 10328443f2d2SAndrzej Pietrasiewicz retval = -EAGAIN; 10338443f2d2SAndrzej Pietrasiewicz goto done; 10348443f2d2SAndrzej Pietrasiewicz } 10358443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 10368443f2d2SAndrzej Pietrasiewicz retval = wait_event_interruptible (dev->wait, 10378443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready != 0); 10388443f2d2SAndrzej Pietrasiewicz 10398443f2d2SAndrzej Pietrasiewicz /* FIXME state could change from under us */ 10408443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 10418443f2d2SAndrzej Pietrasiewicz if (retval) 10428443f2d2SAndrzej Pietrasiewicz goto done; 10438443f2d2SAndrzej Pietrasiewicz 10448443f2d2SAndrzej Pietrasiewicz if (dev->state != STATE_DEV_SETUP) { 10458443f2d2SAndrzej Pietrasiewicz retval = -ECANCELED; 10468443f2d2SAndrzej Pietrasiewicz goto done; 10478443f2d2SAndrzej Pietrasiewicz } 10488443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 10498443f2d2SAndrzej Pietrasiewicz 10508443f2d2SAndrzej Pietrasiewicz if (dev->setup_out_error) 10518443f2d2SAndrzej Pietrasiewicz retval = -EIO; 10528443f2d2SAndrzej Pietrasiewicz else { 10538443f2d2SAndrzej Pietrasiewicz len = min (len, (size_t)dev->req->actual); 10548443f2d2SAndrzej Pietrasiewicz // FIXME don't call this with the spinlock held ... 10558443f2d2SAndrzej Pietrasiewicz if (copy_to_user (buf, dev->req->buf, len)) 10568443f2d2SAndrzej Pietrasiewicz retval = -EFAULT; 10578443f2d2SAndrzej Pietrasiewicz else 10588443f2d2SAndrzej Pietrasiewicz retval = len; 10598443f2d2SAndrzej Pietrasiewicz clean_req (dev->gadget->ep0, dev->req); 10608443f2d2SAndrzej Pietrasiewicz /* NOTE userspace can't yet choose to stall */ 10618443f2d2SAndrzej Pietrasiewicz } 10628443f2d2SAndrzej Pietrasiewicz } 10638443f2d2SAndrzej Pietrasiewicz goto done; 10648443f2d2SAndrzej Pietrasiewicz } 10658443f2d2SAndrzej Pietrasiewicz 10668443f2d2SAndrzej Pietrasiewicz /* else normal: return event data */ 10678443f2d2SAndrzej Pietrasiewicz if (len < sizeof dev->event [0]) { 10688443f2d2SAndrzej Pietrasiewicz retval = -EINVAL; 10698443f2d2SAndrzej Pietrasiewicz goto done; 10708443f2d2SAndrzej Pietrasiewicz } 10718443f2d2SAndrzej Pietrasiewicz len -= len % sizeof (struct usb_gadgetfs_event); 10728443f2d2SAndrzej Pietrasiewicz dev->usermode_setup = 1; 10738443f2d2SAndrzej Pietrasiewicz 10748443f2d2SAndrzej Pietrasiewicz scan: 10758443f2d2SAndrzej Pietrasiewicz /* return queued events right away */ 10768443f2d2SAndrzej Pietrasiewicz if (dev->ev_next != 0) { 10778443f2d2SAndrzej Pietrasiewicz unsigned i, n; 10788443f2d2SAndrzej Pietrasiewicz 10798443f2d2SAndrzej Pietrasiewicz n = len / sizeof (struct usb_gadgetfs_event); 10808443f2d2SAndrzej Pietrasiewicz if (dev->ev_next < n) 10818443f2d2SAndrzej Pietrasiewicz n = dev->ev_next; 10828443f2d2SAndrzej Pietrasiewicz 10838443f2d2SAndrzej Pietrasiewicz /* ep0 i/o has special semantics during STATE_DEV_SETUP */ 10848443f2d2SAndrzej Pietrasiewicz for (i = 0; i < n; i++) { 10858443f2d2SAndrzej Pietrasiewicz if (dev->event [i].type == GADGETFS_SETUP) { 10868443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_SETUP; 10878443f2d2SAndrzej Pietrasiewicz n = i + 1; 10888443f2d2SAndrzej Pietrasiewicz break; 10898443f2d2SAndrzej Pietrasiewicz } 10908443f2d2SAndrzej Pietrasiewicz } 10918443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 10928443f2d2SAndrzej Pietrasiewicz len = n * sizeof (struct usb_gadgetfs_event); 10938443f2d2SAndrzej Pietrasiewicz if (copy_to_user (buf, &dev->event, len)) 10948443f2d2SAndrzej Pietrasiewicz retval = -EFAULT; 10958443f2d2SAndrzej Pietrasiewicz else 10968443f2d2SAndrzej Pietrasiewicz retval = len; 10978443f2d2SAndrzej Pietrasiewicz if (len > 0) { 10988443f2d2SAndrzej Pietrasiewicz /* NOTE this doesn't guard against broken drivers; 10998443f2d2SAndrzej Pietrasiewicz * concurrent ep0 readers may lose events. 11008443f2d2SAndrzej Pietrasiewicz */ 11018443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 11028443f2d2SAndrzej Pietrasiewicz if (dev->ev_next > n) { 11038443f2d2SAndrzej Pietrasiewicz memmove(&dev->event[0], &dev->event[n], 11048443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_gadgetfs_event) 11058443f2d2SAndrzej Pietrasiewicz * (dev->ev_next - n)); 11068443f2d2SAndrzej Pietrasiewicz } 11078443f2d2SAndrzej Pietrasiewicz dev->ev_next -= n; 11088443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 11098443f2d2SAndrzej Pietrasiewicz } 11108443f2d2SAndrzej Pietrasiewicz return retval; 11118443f2d2SAndrzej Pietrasiewicz } 11128443f2d2SAndrzej Pietrasiewicz if (fd->f_flags & O_NONBLOCK) { 11138443f2d2SAndrzej Pietrasiewicz retval = -EAGAIN; 11148443f2d2SAndrzej Pietrasiewicz goto done; 11158443f2d2SAndrzej Pietrasiewicz } 11168443f2d2SAndrzej Pietrasiewicz 11178443f2d2SAndrzej Pietrasiewicz switch (state) { 11188443f2d2SAndrzej Pietrasiewicz default: 11198443f2d2SAndrzej Pietrasiewicz DBG (dev, "fail %s, state %d\n", __func__, state); 11208443f2d2SAndrzej Pietrasiewicz retval = -ESRCH; 11218443f2d2SAndrzej Pietrasiewicz break; 11228443f2d2SAndrzej Pietrasiewicz case STATE_DEV_UNCONNECTED: 11238443f2d2SAndrzej Pietrasiewicz case STATE_DEV_CONNECTED: 11248443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 11258443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s wait\n", __func__); 11268443f2d2SAndrzej Pietrasiewicz 11278443f2d2SAndrzej Pietrasiewicz /* wait for events */ 11288443f2d2SAndrzej Pietrasiewicz retval = wait_event_interruptible (dev->wait, 11298443f2d2SAndrzej Pietrasiewicz dev->ev_next != 0); 11308443f2d2SAndrzej Pietrasiewicz if (retval < 0) 11318443f2d2SAndrzej Pietrasiewicz return retval; 11328443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 11338443f2d2SAndrzej Pietrasiewicz goto scan; 11348443f2d2SAndrzej Pietrasiewicz } 11358443f2d2SAndrzej Pietrasiewicz 11368443f2d2SAndrzej Pietrasiewicz done: 11378443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 11388443f2d2SAndrzej Pietrasiewicz return retval; 11398443f2d2SAndrzej Pietrasiewicz } 11408443f2d2SAndrzej Pietrasiewicz 11418443f2d2SAndrzej Pietrasiewicz static struct usb_gadgetfs_event * 11428443f2d2SAndrzej Pietrasiewicz next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type) 11438443f2d2SAndrzej Pietrasiewicz { 11448443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event *event; 11458443f2d2SAndrzej Pietrasiewicz unsigned i; 11468443f2d2SAndrzej Pietrasiewicz 11478443f2d2SAndrzej Pietrasiewicz switch (type) { 11488443f2d2SAndrzej Pietrasiewicz /* these events purge the queue */ 11498443f2d2SAndrzej Pietrasiewicz case GADGETFS_DISCONNECT: 11508443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_SETUP) 11518443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 1; 11528443f2d2SAndrzej Pietrasiewicz // FALL THROUGH 11538443f2d2SAndrzej Pietrasiewicz case GADGETFS_CONNECT: 11548443f2d2SAndrzej Pietrasiewicz dev->ev_next = 0; 11558443f2d2SAndrzej Pietrasiewicz break; 11568443f2d2SAndrzej Pietrasiewicz case GADGETFS_SETUP: /* previous request timed out */ 11578443f2d2SAndrzej Pietrasiewicz case GADGETFS_SUSPEND: /* same effect */ 11588443f2d2SAndrzej Pietrasiewicz /* these events can't be repeated */ 11598443f2d2SAndrzej Pietrasiewicz for (i = 0; i != dev->ev_next; i++) { 11608443f2d2SAndrzej Pietrasiewicz if (dev->event [i].type != type) 11618443f2d2SAndrzej Pietrasiewicz continue; 11628443f2d2SAndrzej Pietrasiewicz DBG(dev, "discard old event[%d] %d\n", i, type); 11638443f2d2SAndrzej Pietrasiewicz dev->ev_next--; 11648443f2d2SAndrzej Pietrasiewicz if (i == dev->ev_next) 11658443f2d2SAndrzej Pietrasiewicz break; 11668443f2d2SAndrzej Pietrasiewicz /* indices start at zero, for simplicity */ 11678443f2d2SAndrzej Pietrasiewicz memmove (&dev->event [i], &dev->event [i + 1], 11688443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_gadgetfs_event) 11698443f2d2SAndrzej Pietrasiewicz * (dev->ev_next - i)); 11708443f2d2SAndrzej Pietrasiewicz } 11718443f2d2SAndrzej Pietrasiewicz break; 11728443f2d2SAndrzej Pietrasiewicz default: 11738443f2d2SAndrzej Pietrasiewicz BUG (); 11748443f2d2SAndrzej Pietrasiewicz } 11758443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "event[%d] = %d\n", dev->ev_next, type); 11768443f2d2SAndrzej Pietrasiewicz event = &dev->event [dev->ev_next++]; 11778443f2d2SAndrzej Pietrasiewicz BUG_ON (dev->ev_next > N_EVENT); 11788443f2d2SAndrzej Pietrasiewicz memset (event, 0, sizeof *event); 11798443f2d2SAndrzej Pietrasiewicz event->type = type; 11808443f2d2SAndrzej Pietrasiewicz return event; 11818443f2d2SAndrzej Pietrasiewicz } 11828443f2d2SAndrzej Pietrasiewicz 11838443f2d2SAndrzej Pietrasiewicz static ssize_t 11848443f2d2SAndrzej Pietrasiewicz ep0_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr) 11858443f2d2SAndrzej Pietrasiewicz { 11868443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 11878443f2d2SAndrzej Pietrasiewicz ssize_t retval = -ESRCH; 11888443f2d2SAndrzej Pietrasiewicz 11898443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 11908443f2d2SAndrzej Pietrasiewicz 11918443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */ 11928443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) { 11938443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0; 11948443f2d2SAndrzej Pietrasiewicz retval = -EIDRM; 11958443f2d2SAndrzej Pietrasiewicz 11968443f2d2SAndrzej Pietrasiewicz /* data and/or status stage for control request */ 11978443f2d2SAndrzej Pietrasiewicz } else if (dev->state == STATE_DEV_SETUP) { 11988443f2d2SAndrzej Pietrasiewicz 11998443f2d2SAndrzej Pietrasiewicz /* IN DATA+STATUS caller makes len <= wLength */ 12008443f2d2SAndrzej Pietrasiewicz if (dev->setup_in) { 12018443f2d2SAndrzej Pietrasiewicz retval = setup_req (dev->gadget->ep0, dev->req, len); 12028443f2d2SAndrzej Pietrasiewicz if (retval == 0) { 12038443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 12048443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 12058443f2d2SAndrzej Pietrasiewicz if (copy_from_user (dev->req->buf, buf, len)) 12068443f2d2SAndrzej Pietrasiewicz retval = -EFAULT; 12078443f2d2SAndrzej Pietrasiewicz else { 12088443f2d2SAndrzej Pietrasiewicz if (len < dev->setup_wLength) 12098443f2d2SAndrzej Pietrasiewicz dev->req->zero = 1; 12108443f2d2SAndrzej Pietrasiewicz retval = usb_ep_queue ( 12118443f2d2SAndrzej Pietrasiewicz dev->gadget->ep0, dev->req, 12128443f2d2SAndrzej Pietrasiewicz GFP_KERNEL); 12138443f2d2SAndrzej Pietrasiewicz } 12148443f2d2SAndrzej Pietrasiewicz if (retval < 0) { 12158443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 12168443f2d2SAndrzej Pietrasiewicz clean_req (dev->gadget->ep0, dev->req); 12178443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 12188443f2d2SAndrzej Pietrasiewicz } else 12198443f2d2SAndrzej Pietrasiewicz retval = len; 12208443f2d2SAndrzej Pietrasiewicz 12218443f2d2SAndrzej Pietrasiewicz return retval; 12228443f2d2SAndrzej Pietrasiewicz } 12238443f2d2SAndrzej Pietrasiewicz 12248443f2d2SAndrzej Pietrasiewicz /* can stall some OUT transfers */ 12258443f2d2SAndrzej Pietrasiewicz } else if (dev->setup_can_stall) { 12268443f2d2SAndrzej Pietrasiewicz VDEBUG(dev, "ep0out stall\n"); 12278443f2d2SAndrzej Pietrasiewicz (void) usb_ep_set_halt (dev->gadget->ep0); 12288443f2d2SAndrzej Pietrasiewicz retval = -EL2HLT; 12298443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 12308443f2d2SAndrzej Pietrasiewicz } else { 12318443f2d2SAndrzej Pietrasiewicz DBG(dev, "bogus ep0out stall!\n"); 12328443f2d2SAndrzej Pietrasiewicz } 12338443f2d2SAndrzej Pietrasiewicz } else 12348443f2d2SAndrzej Pietrasiewicz DBG (dev, "fail %s, state %d\n", __func__, dev->state); 12358443f2d2SAndrzej Pietrasiewicz 12368443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 12378443f2d2SAndrzej Pietrasiewicz return retval; 12388443f2d2SAndrzej Pietrasiewicz } 12398443f2d2SAndrzej Pietrasiewicz 12408443f2d2SAndrzej Pietrasiewicz static int 12418443f2d2SAndrzej Pietrasiewicz ep0_fasync (int f, struct file *fd, int on) 12428443f2d2SAndrzej Pietrasiewicz { 12438443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 12448443f2d2SAndrzej Pietrasiewicz // caller must F_SETOWN before signal delivery happens 12458443f2d2SAndrzej Pietrasiewicz VDEBUG (dev, "%s %s\n", __func__, on ? "on" : "off"); 12468443f2d2SAndrzej Pietrasiewicz return fasync_helper (f, fd, on, &dev->fasync); 12478443f2d2SAndrzej Pietrasiewicz } 12488443f2d2SAndrzej Pietrasiewicz 12498443f2d2SAndrzej Pietrasiewicz static struct usb_gadget_driver gadgetfs_driver; 12508443f2d2SAndrzej Pietrasiewicz 12518443f2d2SAndrzej Pietrasiewicz static int 12528443f2d2SAndrzej Pietrasiewicz dev_release (struct inode *inode, struct file *fd) 12538443f2d2SAndrzej Pietrasiewicz { 12548443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 12558443f2d2SAndrzej Pietrasiewicz 12568443f2d2SAndrzej Pietrasiewicz /* closing ep0 === shutdown all */ 12578443f2d2SAndrzej Pietrasiewicz 12588443f2d2SAndrzej Pietrasiewicz usb_gadget_unregister_driver (&gadgetfs_driver); 12598443f2d2SAndrzej Pietrasiewicz 12608443f2d2SAndrzej Pietrasiewicz /* at this point "good" hardware has disconnected the 12618443f2d2SAndrzej Pietrasiewicz * device from USB; the host won't see it any more. 12628443f2d2SAndrzej Pietrasiewicz * alternatively, all host requests will time out. 12638443f2d2SAndrzej Pietrasiewicz */ 12648443f2d2SAndrzej Pietrasiewicz 12658443f2d2SAndrzej Pietrasiewicz kfree (dev->buf); 12668443f2d2SAndrzej Pietrasiewicz dev->buf = NULL; 12678443f2d2SAndrzej Pietrasiewicz 126861fe2d75SGreg Kroah-Hartman /* other endpoints were all decoupled from this device */ 126961fe2d75SGreg Kroah-Hartman spin_lock_irq(&dev->lock); 127061fe2d75SGreg Kroah-Hartman dev->state = STATE_DEV_DISABLED; 127161fe2d75SGreg Kroah-Hartman spin_unlock_irq(&dev->lock); 127261fe2d75SGreg Kroah-Hartman 127361fe2d75SGreg Kroah-Hartman put_dev (dev); 12748443f2d2SAndrzej Pietrasiewicz return 0; 12758443f2d2SAndrzej Pietrasiewicz } 12768443f2d2SAndrzej Pietrasiewicz 12778443f2d2SAndrzej Pietrasiewicz static unsigned int 12788443f2d2SAndrzej Pietrasiewicz ep0_poll (struct file *fd, poll_table *wait) 12798443f2d2SAndrzej Pietrasiewicz { 12808443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 12818443f2d2SAndrzej Pietrasiewicz int mask = 0; 12828443f2d2SAndrzej Pietrasiewicz 12838443f2d2SAndrzej Pietrasiewicz poll_wait(fd, &dev->wait, wait); 12848443f2d2SAndrzej Pietrasiewicz 12858443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 12868443f2d2SAndrzej Pietrasiewicz 12878443f2d2SAndrzej Pietrasiewicz /* report fd mode change before acting on it */ 12888443f2d2SAndrzej Pietrasiewicz if (dev->setup_abort) { 12898443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0; 12908443f2d2SAndrzej Pietrasiewicz mask = POLLHUP; 12918443f2d2SAndrzej Pietrasiewicz goto out; 12928443f2d2SAndrzej Pietrasiewicz } 12938443f2d2SAndrzej Pietrasiewicz 12948443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_SETUP) { 12958443f2d2SAndrzej Pietrasiewicz if (dev->setup_in || dev->setup_can_stall) 12968443f2d2SAndrzej Pietrasiewicz mask = POLLOUT; 12978443f2d2SAndrzej Pietrasiewicz } else { 12988443f2d2SAndrzej Pietrasiewicz if (dev->ev_next != 0) 12998443f2d2SAndrzej Pietrasiewicz mask = POLLIN; 13008443f2d2SAndrzej Pietrasiewicz } 13018443f2d2SAndrzej Pietrasiewicz out: 13028443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock); 13038443f2d2SAndrzej Pietrasiewicz return mask; 13048443f2d2SAndrzej Pietrasiewicz } 13058443f2d2SAndrzej Pietrasiewicz 13068443f2d2SAndrzej Pietrasiewicz static long dev_ioctl (struct file *fd, unsigned code, unsigned long value) 13078443f2d2SAndrzej Pietrasiewicz { 13088443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 13098443f2d2SAndrzej Pietrasiewicz struct usb_gadget *gadget = dev->gadget; 13108443f2d2SAndrzej Pietrasiewicz long ret = -ENOTTY; 13118443f2d2SAndrzej Pietrasiewicz 13128443f2d2SAndrzej Pietrasiewicz if (gadget->ops->ioctl) 13138443f2d2SAndrzej Pietrasiewicz ret = gadget->ops->ioctl (gadget, code, value); 13148443f2d2SAndrzej Pietrasiewicz 13158443f2d2SAndrzej Pietrasiewicz return ret; 13168443f2d2SAndrzej Pietrasiewicz } 13178443f2d2SAndrzej Pietrasiewicz 13188443f2d2SAndrzej Pietrasiewicz /* used after device configuration */ 13198443f2d2SAndrzej Pietrasiewicz static const struct file_operations ep0_io_operations = { 13208443f2d2SAndrzej Pietrasiewicz .owner = THIS_MODULE, 13218443f2d2SAndrzej Pietrasiewicz .llseek = no_llseek, 13228443f2d2SAndrzej Pietrasiewicz 13238443f2d2SAndrzej Pietrasiewicz .read = ep0_read, 13248443f2d2SAndrzej Pietrasiewicz .write = ep0_write, 13258443f2d2SAndrzej Pietrasiewicz .fasync = ep0_fasync, 13268443f2d2SAndrzej Pietrasiewicz .poll = ep0_poll, 13278443f2d2SAndrzej Pietrasiewicz .unlocked_ioctl = dev_ioctl, 13288443f2d2SAndrzej Pietrasiewicz .release = dev_release, 13298443f2d2SAndrzej Pietrasiewicz }; 13308443f2d2SAndrzej Pietrasiewicz 13318443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 13328443f2d2SAndrzej Pietrasiewicz 13338443f2d2SAndrzej Pietrasiewicz /* The in-kernel gadget driver handles most ep0 issues, in particular 13348443f2d2SAndrzej Pietrasiewicz * enumerating the single configuration (as provided from user space). 13358443f2d2SAndrzej Pietrasiewicz * 13368443f2d2SAndrzej Pietrasiewicz * Unrecognized ep0 requests may be handled in user space. 13378443f2d2SAndrzej Pietrasiewicz */ 13388443f2d2SAndrzej Pietrasiewicz 13398443f2d2SAndrzej Pietrasiewicz static void make_qualifier (struct dev_data *dev) 13408443f2d2SAndrzej Pietrasiewicz { 13418443f2d2SAndrzej Pietrasiewicz struct usb_qualifier_descriptor qual; 13428443f2d2SAndrzej Pietrasiewicz struct usb_device_descriptor *desc; 13438443f2d2SAndrzej Pietrasiewicz 13448443f2d2SAndrzej Pietrasiewicz qual.bLength = sizeof qual; 13458443f2d2SAndrzej Pietrasiewicz qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER; 13468443f2d2SAndrzej Pietrasiewicz qual.bcdUSB = cpu_to_le16 (0x0200); 13478443f2d2SAndrzej Pietrasiewicz 13488443f2d2SAndrzej Pietrasiewicz desc = dev->dev; 13498443f2d2SAndrzej Pietrasiewicz qual.bDeviceClass = desc->bDeviceClass; 13508443f2d2SAndrzej Pietrasiewicz qual.bDeviceSubClass = desc->bDeviceSubClass; 13518443f2d2SAndrzej Pietrasiewicz qual.bDeviceProtocol = desc->bDeviceProtocol; 13528443f2d2SAndrzej Pietrasiewicz 13538443f2d2SAndrzej Pietrasiewicz /* assumes ep0 uses the same value for both speeds ... */ 13548443f2d2SAndrzej Pietrasiewicz qual.bMaxPacketSize0 = dev->gadget->ep0->maxpacket; 13558443f2d2SAndrzej Pietrasiewicz 13568443f2d2SAndrzej Pietrasiewicz qual.bNumConfigurations = 1; 13578443f2d2SAndrzej Pietrasiewicz qual.bRESERVED = 0; 13588443f2d2SAndrzej Pietrasiewicz 13598443f2d2SAndrzej Pietrasiewicz memcpy (dev->rbuf, &qual, sizeof qual); 13608443f2d2SAndrzej Pietrasiewicz } 13618443f2d2SAndrzej Pietrasiewicz 13628443f2d2SAndrzej Pietrasiewicz static int 13638443f2d2SAndrzej Pietrasiewicz config_buf (struct dev_data *dev, u8 type, unsigned index) 13648443f2d2SAndrzej Pietrasiewicz { 13658443f2d2SAndrzej Pietrasiewicz int len; 13668443f2d2SAndrzej Pietrasiewicz int hs = 0; 13678443f2d2SAndrzej Pietrasiewicz 13688443f2d2SAndrzej Pietrasiewicz /* only one configuration */ 13698443f2d2SAndrzej Pietrasiewicz if (index > 0) 13708443f2d2SAndrzej Pietrasiewicz return -EINVAL; 13718443f2d2SAndrzej Pietrasiewicz 13728443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(dev->gadget)) { 13738443f2d2SAndrzej Pietrasiewicz hs = (dev->gadget->speed == USB_SPEED_HIGH); 13748443f2d2SAndrzej Pietrasiewicz if (type == USB_DT_OTHER_SPEED_CONFIG) 13758443f2d2SAndrzej Pietrasiewicz hs = !hs; 13768443f2d2SAndrzej Pietrasiewicz } 13778443f2d2SAndrzej Pietrasiewicz if (hs) { 13788443f2d2SAndrzej Pietrasiewicz dev->req->buf = dev->hs_config; 13798443f2d2SAndrzej Pietrasiewicz len = le16_to_cpu(dev->hs_config->wTotalLength); 13808443f2d2SAndrzej Pietrasiewicz } else { 13818443f2d2SAndrzej Pietrasiewicz dev->req->buf = dev->config; 13828443f2d2SAndrzej Pietrasiewicz len = le16_to_cpu(dev->config->wTotalLength); 13838443f2d2SAndrzej Pietrasiewicz } 13848443f2d2SAndrzej Pietrasiewicz ((u8 *)dev->req->buf) [1] = type; 13858443f2d2SAndrzej Pietrasiewicz return len; 13868443f2d2SAndrzej Pietrasiewicz } 13878443f2d2SAndrzej Pietrasiewicz 13888443f2d2SAndrzej Pietrasiewicz static int 13898443f2d2SAndrzej Pietrasiewicz gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl) 13908443f2d2SAndrzej Pietrasiewicz { 13918443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget); 13928443f2d2SAndrzej Pietrasiewicz struct usb_request *req = dev->req; 13938443f2d2SAndrzej Pietrasiewicz int value = -EOPNOTSUPP; 13948443f2d2SAndrzej Pietrasiewicz struct usb_gadgetfs_event *event; 13958443f2d2SAndrzej Pietrasiewicz u16 w_value = le16_to_cpu(ctrl->wValue); 13968443f2d2SAndrzej Pietrasiewicz u16 w_length = le16_to_cpu(ctrl->wLength); 13978443f2d2SAndrzej Pietrasiewicz 13988443f2d2SAndrzej Pietrasiewicz spin_lock (&dev->lock); 13998443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 0; 14008443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_UNCONNECTED) { 14018443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(gadget) 14028443f2d2SAndrzej Pietrasiewicz && gadget->speed == USB_SPEED_HIGH 14038443f2d2SAndrzej Pietrasiewicz && dev->hs_config == NULL) { 14048443f2d2SAndrzej Pietrasiewicz spin_unlock(&dev->lock); 14058443f2d2SAndrzej Pietrasiewicz ERROR (dev, "no high speed config??\n"); 14068443f2d2SAndrzej Pietrasiewicz return -EINVAL; 14078443f2d2SAndrzej Pietrasiewicz } 14088443f2d2SAndrzej Pietrasiewicz 14098443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_CONNECTED; 14108443f2d2SAndrzej Pietrasiewicz 14118443f2d2SAndrzej Pietrasiewicz INFO (dev, "connected\n"); 14128443f2d2SAndrzej Pietrasiewicz event = next_event (dev, GADGETFS_CONNECT); 14138443f2d2SAndrzej Pietrasiewicz event->u.speed = gadget->speed; 14148443f2d2SAndrzej Pietrasiewicz ep0_readable (dev); 14158443f2d2SAndrzej Pietrasiewicz 14168443f2d2SAndrzej Pietrasiewicz /* host may have given up waiting for response. we can miss control 14178443f2d2SAndrzej Pietrasiewicz * requests handled lower down (device/endpoint status and features); 14188443f2d2SAndrzej Pietrasiewicz * then ep0_{read,write} will report the wrong status. controller 14198443f2d2SAndrzej Pietrasiewicz * driver will have aborted pending i/o. 14208443f2d2SAndrzej Pietrasiewicz */ 14218443f2d2SAndrzej Pietrasiewicz } else if (dev->state == STATE_DEV_SETUP) 14228443f2d2SAndrzej Pietrasiewicz dev->setup_abort = 1; 14238443f2d2SAndrzej Pietrasiewicz 14248443f2d2SAndrzej Pietrasiewicz req->buf = dev->rbuf; 14258443f2d2SAndrzej Pietrasiewicz req->context = NULL; 14268443f2d2SAndrzej Pietrasiewicz value = -EOPNOTSUPP; 14278443f2d2SAndrzej Pietrasiewicz switch (ctrl->bRequest) { 14288443f2d2SAndrzej Pietrasiewicz 14298443f2d2SAndrzej Pietrasiewicz case USB_REQ_GET_DESCRIPTOR: 14308443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != USB_DIR_IN) 14318443f2d2SAndrzej Pietrasiewicz goto unrecognized; 14328443f2d2SAndrzej Pietrasiewicz switch (w_value >> 8) { 14338443f2d2SAndrzej Pietrasiewicz 14348443f2d2SAndrzej Pietrasiewicz case USB_DT_DEVICE: 14358443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) sizeof *dev->dev); 14368443f2d2SAndrzej Pietrasiewicz dev->dev->bMaxPacketSize0 = dev->gadget->ep0->maxpacket; 14378443f2d2SAndrzej Pietrasiewicz req->buf = dev->dev; 14388443f2d2SAndrzej Pietrasiewicz break; 14398443f2d2SAndrzej Pietrasiewicz case USB_DT_DEVICE_QUALIFIER: 14408443f2d2SAndrzej Pietrasiewicz if (!dev->hs_config) 14418443f2d2SAndrzej Pietrasiewicz break; 14428443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) 14438443f2d2SAndrzej Pietrasiewicz sizeof (struct usb_qualifier_descriptor)); 14448443f2d2SAndrzej Pietrasiewicz make_qualifier (dev); 14458443f2d2SAndrzej Pietrasiewicz break; 14468443f2d2SAndrzej Pietrasiewicz case USB_DT_OTHER_SPEED_CONFIG: 14478443f2d2SAndrzej Pietrasiewicz // FALLTHROUGH 14488443f2d2SAndrzej Pietrasiewicz case USB_DT_CONFIG: 14498443f2d2SAndrzej Pietrasiewicz value = config_buf (dev, 14508443f2d2SAndrzej Pietrasiewicz w_value >> 8, 14518443f2d2SAndrzej Pietrasiewicz w_value & 0xff); 14528443f2d2SAndrzej Pietrasiewicz if (value >= 0) 14538443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) value); 14548443f2d2SAndrzej Pietrasiewicz break; 14558443f2d2SAndrzej Pietrasiewicz case USB_DT_STRING: 14568443f2d2SAndrzej Pietrasiewicz goto unrecognized; 14578443f2d2SAndrzej Pietrasiewicz 14588443f2d2SAndrzej Pietrasiewicz default: // all others are errors 14598443f2d2SAndrzej Pietrasiewicz break; 14608443f2d2SAndrzej Pietrasiewicz } 14618443f2d2SAndrzej Pietrasiewicz break; 14628443f2d2SAndrzej Pietrasiewicz 14638443f2d2SAndrzej Pietrasiewicz /* currently one config, two speeds */ 14648443f2d2SAndrzej Pietrasiewicz case USB_REQ_SET_CONFIGURATION: 14658443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != 0) 14668443f2d2SAndrzej Pietrasiewicz goto unrecognized; 14678443f2d2SAndrzej Pietrasiewicz if (0 == (u8) w_value) { 14688443f2d2SAndrzej Pietrasiewicz value = 0; 14698443f2d2SAndrzej Pietrasiewicz dev->current_config = 0; 14708443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(gadget, 8 /* mA */ ); 14718443f2d2SAndrzej Pietrasiewicz // user mode expected to disable endpoints 14728443f2d2SAndrzej Pietrasiewicz } else { 14738443f2d2SAndrzej Pietrasiewicz u8 config, power; 14748443f2d2SAndrzej Pietrasiewicz 14758443f2d2SAndrzej Pietrasiewicz if (gadget_is_dualspeed(gadget) 14768443f2d2SAndrzej Pietrasiewicz && gadget->speed == USB_SPEED_HIGH) { 14778443f2d2SAndrzej Pietrasiewicz config = dev->hs_config->bConfigurationValue; 14788443f2d2SAndrzej Pietrasiewicz power = dev->hs_config->bMaxPower; 14798443f2d2SAndrzej Pietrasiewicz } else { 14808443f2d2SAndrzej Pietrasiewicz config = dev->config->bConfigurationValue; 14818443f2d2SAndrzej Pietrasiewicz power = dev->config->bMaxPower; 14828443f2d2SAndrzej Pietrasiewicz } 14838443f2d2SAndrzej Pietrasiewicz 14848443f2d2SAndrzej Pietrasiewicz if (config == (u8) w_value) { 14858443f2d2SAndrzej Pietrasiewicz value = 0; 14868443f2d2SAndrzej Pietrasiewicz dev->current_config = config; 14878443f2d2SAndrzej Pietrasiewicz usb_gadget_vbus_draw(gadget, 2 * power); 14888443f2d2SAndrzej Pietrasiewicz } 14898443f2d2SAndrzej Pietrasiewicz } 14908443f2d2SAndrzej Pietrasiewicz 14918443f2d2SAndrzej Pietrasiewicz /* report SET_CONFIGURATION like any other control request, 14928443f2d2SAndrzej Pietrasiewicz * except that usermode may not stall this. the next 14938443f2d2SAndrzej Pietrasiewicz * request mustn't be allowed start until this finishes: 14948443f2d2SAndrzej Pietrasiewicz * endpoints and threads set up, etc. 14958443f2d2SAndrzej Pietrasiewicz * 14968443f2d2SAndrzej Pietrasiewicz * NOTE: older PXA hardware (before PXA 255: without UDCCFR) 14978443f2d2SAndrzej Pietrasiewicz * has bad/racey automagic that prevents synchronizing here. 14988443f2d2SAndrzej Pietrasiewicz * even kernel mode drivers often miss them. 14998443f2d2SAndrzej Pietrasiewicz */ 15008443f2d2SAndrzej Pietrasiewicz if (value == 0) { 15018443f2d2SAndrzej Pietrasiewicz INFO (dev, "configuration #%d\n", dev->current_config); 15028443f2d2SAndrzej Pietrasiewicz usb_gadget_set_state(gadget, USB_STATE_CONFIGURED); 15038443f2d2SAndrzej Pietrasiewicz if (dev->usermode_setup) { 15048443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 0; 15058443f2d2SAndrzej Pietrasiewicz goto delegate; 15068443f2d2SAndrzej Pietrasiewicz } 15078443f2d2SAndrzej Pietrasiewicz } 15088443f2d2SAndrzej Pietrasiewicz break; 15098443f2d2SAndrzej Pietrasiewicz 15108443f2d2SAndrzej Pietrasiewicz #ifndef CONFIG_USB_PXA25X 15118443f2d2SAndrzej Pietrasiewicz /* PXA automagically handles this request too */ 15128443f2d2SAndrzej Pietrasiewicz case USB_REQ_GET_CONFIGURATION: 15138443f2d2SAndrzej Pietrasiewicz if (ctrl->bRequestType != 0x80) 15148443f2d2SAndrzej Pietrasiewicz goto unrecognized; 15158443f2d2SAndrzej Pietrasiewicz *(u8 *)req->buf = dev->current_config; 15168443f2d2SAndrzej Pietrasiewicz value = min (w_length, (u16) 1); 15178443f2d2SAndrzej Pietrasiewicz break; 15188443f2d2SAndrzej Pietrasiewicz #endif 15198443f2d2SAndrzej Pietrasiewicz 15208443f2d2SAndrzej Pietrasiewicz default: 15218443f2d2SAndrzej Pietrasiewicz unrecognized: 15228443f2d2SAndrzej Pietrasiewicz VDEBUG (dev, "%s req%02x.%02x v%04x i%04x l%d\n", 15238443f2d2SAndrzej Pietrasiewicz dev->usermode_setup ? "delegate" : "fail", 15248443f2d2SAndrzej Pietrasiewicz ctrl->bRequestType, ctrl->bRequest, 15258443f2d2SAndrzej Pietrasiewicz w_value, le16_to_cpu(ctrl->wIndex), w_length); 15268443f2d2SAndrzej Pietrasiewicz 15278443f2d2SAndrzej Pietrasiewicz /* if there's an ep0 reader, don't stall */ 15288443f2d2SAndrzej Pietrasiewicz if (dev->usermode_setup) { 15298443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 1; 15308443f2d2SAndrzej Pietrasiewicz delegate: 15318443f2d2SAndrzej Pietrasiewicz dev->setup_in = (ctrl->bRequestType & USB_DIR_IN) 15328443f2d2SAndrzej Pietrasiewicz ? 1 : 0; 15338443f2d2SAndrzej Pietrasiewicz dev->setup_wLength = w_length; 15348443f2d2SAndrzej Pietrasiewicz dev->setup_out_ready = 0; 15358443f2d2SAndrzej Pietrasiewicz dev->setup_out_error = 0; 15368443f2d2SAndrzej Pietrasiewicz value = 0; 15378443f2d2SAndrzej Pietrasiewicz 15388443f2d2SAndrzej Pietrasiewicz /* read DATA stage for OUT right away */ 15398443f2d2SAndrzej Pietrasiewicz if (unlikely (!dev->setup_in && w_length)) { 15408443f2d2SAndrzej Pietrasiewicz value = setup_req (gadget->ep0, dev->req, 15418443f2d2SAndrzej Pietrasiewicz w_length); 15428443f2d2SAndrzej Pietrasiewicz if (value < 0) 15438443f2d2SAndrzej Pietrasiewicz break; 15448443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue (gadget->ep0, dev->req, 15458443f2d2SAndrzej Pietrasiewicz GFP_ATOMIC); 15468443f2d2SAndrzej Pietrasiewicz if (value < 0) { 15478443f2d2SAndrzej Pietrasiewicz clean_req (gadget->ep0, dev->req); 15488443f2d2SAndrzej Pietrasiewicz break; 15498443f2d2SAndrzej Pietrasiewicz } 15508443f2d2SAndrzej Pietrasiewicz 15518443f2d2SAndrzej Pietrasiewicz /* we can't currently stall these */ 15528443f2d2SAndrzej Pietrasiewicz dev->setup_can_stall = 0; 15538443f2d2SAndrzej Pietrasiewicz } 15548443f2d2SAndrzej Pietrasiewicz 15558443f2d2SAndrzej Pietrasiewicz /* state changes when reader collects event */ 15568443f2d2SAndrzej Pietrasiewicz event = next_event (dev, GADGETFS_SETUP); 15578443f2d2SAndrzej Pietrasiewicz event->u.setup = *ctrl; 15588443f2d2SAndrzej Pietrasiewicz ep0_readable (dev); 15598443f2d2SAndrzej Pietrasiewicz spin_unlock (&dev->lock); 15608443f2d2SAndrzej Pietrasiewicz return 0; 15618443f2d2SAndrzej Pietrasiewicz } 15628443f2d2SAndrzej Pietrasiewicz } 15638443f2d2SAndrzej Pietrasiewicz 15648443f2d2SAndrzej Pietrasiewicz /* proceed with data transfer and status phases? */ 15658443f2d2SAndrzej Pietrasiewicz if (value >= 0 && dev->state != STATE_DEV_SETUP) { 15668443f2d2SAndrzej Pietrasiewicz req->length = value; 15678443f2d2SAndrzej Pietrasiewicz req->zero = value < w_length; 15688443f2d2SAndrzej Pietrasiewicz value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC); 15698443f2d2SAndrzej Pietrasiewicz if (value < 0) { 15708443f2d2SAndrzej Pietrasiewicz DBG (dev, "ep_queue --> %d\n", value); 15718443f2d2SAndrzej Pietrasiewicz req->status = 0; 15728443f2d2SAndrzej Pietrasiewicz } 15738443f2d2SAndrzej Pietrasiewicz } 15748443f2d2SAndrzej Pietrasiewicz 15758443f2d2SAndrzej Pietrasiewicz /* device stalls when value < 0 */ 15768443f2d2SAndrzej Pietrasiewicz spin_unlock (&dev->lock); 15778443f2d2SAndrzej Pietrasiewicz return value; 15788443f2d2SAndrzej Pietrasiewicz } 15798443f2d2SAndrzej Pietrasiewicz 15808443f2d2SAndrzej Pietrasiewicz static void destroy_ep_files (struct dev_data *dev) 15818443f2d2SAndrzej Pietrasiewicz { 15828443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s %d\n", __func__, dev->state); 15838443f2d2SAndrzej Pietrasiewicz 15848443f2d2SAndrzej Pietrasiewicz /* dev->state must prevent interference */ 15858443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 15868443f2d2SAndrzej Pietrasiewicz while (!list_empty(&dev->epfiles)) { 15878443f2d2SAndrzej Pietrasiewicz struct ep_data *ep; 15888443f2d2SAndrzej Pietrasiewicz struct inode *parent; 15898443f2d2SAndrzej Pietrasiewicz struct dentry *dentry; 15908443f2d2SAndrzej Pietrasiewicz 15918443f2d2SAndrzej Pietrasiewicz /* break link to FS */ 15928443f2d2SAndrzej Pietrasiewicz ep = list_first_entry (&dev->epfiles, struct ep_data, epfiles); 15938443f2d2SAndrzej Pietrasiewicz list_del_init (&ep->epfiles); 15948443f2d2SAndrzej Pietrasiewicz dentry = ep->dentry; 15958443f2d2SAndrzej Pietrasiewicz ep->dentry = NULL; 15968443f2d2SAndrzej Pietrasiewicz parent = dentry->d_parent->d_inode; 15978443f2d2SAndrzej Pietrasiewicz 15988443f2d2SAndrzej Pietrasiewicz /* break link to controller */ 15998443f2d2SAndrzej Pietrasiewicz if (ep->state == STATE_EP_ENABLED) 16008443f2d2SAndrzej Pietrasiewicz (void) usb_ep_disable (ep->ep); 16018443f2d2SAndrzej Pietrasiewicz ep->state = STATE_EP_UNBOUND; 16028443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (ep->ep, ep->req); 16038443f2d2SAndrzej Pietrasiewicz ep->ep = NULL; 16048443f2d2SAndrzej Pietrasiewicz wake_up (&ep->wait); 16058443f2d2SAndrzej Pietrasiewicz put_ep (ep); 16068443f2d2SAndrzej Pietrasiewicz 16078443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 16088443f2d2SAndrzej Pietrasiewicz 16098443f2d2SAndrzej Pietrasiewicz /* break link to dcache */ 16108443f2d2SAndrzej Pietrasiewicz mutex_lock (&parent->i_mutex); 16118443f2d2SAndrzej Pietrasiewicz d_delete (dentry); 16128443f2d2SAndrzej Pietrasiewicz dput (dentry); 16138443f2d2SAndrzej Pietrasiewicz mutex_unlock (&parent->i_mutex); 16148443f2d2SAndrzej Pietrasiewicz 16158443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 16168443f2d2SAndrzej Pietrasiewicz } 16178443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 16188443f2d2SAndrzej Pietrasiewicz } 16198443f2d2SAndrzej Pietrasiewicz 16208443f2d2SAndrzej Pietrasiewicz 16218443f2d2SAndrzej Pietrasiewicz static struct inode * 16228443f2d2SAndrzej Pietrasiewicz gadgetfs_create_file (struct super_block *sb, char const *name, 16238443f2d2SAndrzej Pietrasiewicz void *data, const struct file_operations *fops, 16248443f2d2SAndrzej Pietrasiewicz struct dentry **dentry_p); 16258443f2d2SAndrzej Pietrasiewicz 16268443f2d2SAndrzej Pietrasiewicz static int activate_ep_files (struct dev_data *dev) 16278443f2d2SAndrzej Pietrasiewicz { 16288443f2d2SAndrzej Pietrasiewicz struct usb_ep *ep; 16298443f2d2SAndrzej Pietrasiewicz struct ep_data *data; 16308443f2d2SAndrzej Pietrasiewicz 16318443f2d2SAndrzej Pietrasiewicz gadget_for_each_ep (ep, dev->gadget) { 16328443f2d2SAndrzej Pietrasiewicz 16338443f2d2SAndrzej Pietrasiewicz data = kzalloc(sizeof(*data), GFP_KERNEL); 16348443f2d2SAndrzej Pietrasiewicz if (!data) 16358443f2d2SAndrzej Pietrasiewicz goto enomem0; 16368443f2d2SAndrzej Pietrasiewicz data->state = STATE_EP_DISABLED; 16378443f2d2SAndrzej Pietrasiewicz mutex_init(&data->lock); 16388443f2d2SAndrzej Pietrasiewicz init_waitqueue_head (&data->wait); 16398443f2d2SAndrzej Pietrasiewicz 16408443f2d2SAndrzej Pietrasiewicz strncpy (data->name, ep->name, sizeof (data->name) - 1); 16418443f2d2SAndrzej Pietrasiewicz atomic_set (&data->count, 1); 16428443f2d2SAndrzej Pietrasiewicz data->dev = dev; 16438443f2d2SAndrzej Pietrasiewicz get_dev (dev); 16448443f2d2SAndrzej Pietrasiewicz 16458443f2d2SAndrzej Pietrasiewicz data->ep = ep; 16468443f2d2SAndrzej Pietrasiewicz ep->driver_data = data; 16478443f2d2SAndrzej Pietrasiewicz 16488443f2d2SAndrzej Pietrasiewicz data->req = usb_ep_alloc_request (ep, GFP_KERNEL); 16498443f2d2SAndrzej Pietrasiewicz if (!data->req) 16508443f2d2SAndrzej Pietrasiewicz goto enomem1; 16518443f2d2SAndrzej Pietrasiewicz 16528443f2d2SAndrzej Pietrasiewicz data->inode = gadgetfs_create_file (dev->sb, data->name, 16538443f2d2SAndrzej Pietrasiewicz data, &ep_config_operations, 16548443f2d2SAndrzej Pietrasiewicz &data->dentry); 16558443f2d2SAndrzej Pietrasiewicz if (!data->inode) 16568443f2d2SAndrzej Pietrasiewicz goto enomem2; 16578443f2d2SAndrzej Pietrasiewicz list_add_tail (&data->epfiles, &dev->epfiles); 16588443f2d2SAndrzej Pietrasiewicz } 16598443f2d2SAndrzej Pietrasiewicz return 0; 16608443f2d2SAndrzej Pietrasiewicz 16618443f2d2SAndrzej Pietrasiewicz enomem2: 16628443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (ep, data->req); 16638443f2d2SAndrzej Pietrasiewicz enomem1: 16648443f2d2SAndrzej Pietrasiewicz put_dev (dev); 16658443f2d2SAndrzej Pietrasiewicz kfree (data); 16668443f2d2SAndrzej Pietrasiewicz enomem0: 16678443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s enomem\n", __func__); 16688443f2d2SAndrzej Pietrasiewicz destroy_ep_files (dev); 16698443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 16708443f2d2SAndrzej Pietrasiewicz } 16718443f2d2SAndrzej Pietrasiewicz 16728443f2d2SAndrzej Pietrasiewicz static void 16738443f2d2SAndrzej Pietrasiewicz gadgetfs_unbind (struct usb_gadget *gadget) 16748443f2d2SAndrzej Pietrasiewicz { 16758443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget); 16768443f2d2SAndrzej Pietrasiewicz 16778443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s\n", __func__); 16788443f2d2SAndrzej Pietrasiewicz 16798443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 16808443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNBOUND; 16818443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 16828443f2d2SAndrzej Pietrasiewicz 16838443f2d2SAndrzej Pietrasiewicz destroy_ep_files (dev); 16848443f2d2SAndrzej Pietrasiewicz gadget->ep0->driver_data = NULL; 16858443f2d2SAndrzej Pietrasiewicz set_gadget_data (gadget, NULL); 16868443f2d2SAndrzej Pietrasiewicz 16878443f2d2SAndrzej Pietrasiewicz /* we've already been disconnected ... no i/o is active */ 16888443f2d2SAndrzej Pietrasiewicz if (dev->req) 16898443f2d2SAndrzej Pietrasiewicz usb_ep_free_request (gadget->ep0, dev->req); 16908443f2d2SAndrzej Pietrasiewicz DBG (dev, "%s done\n", __func__); 16918443f2d2SAndrzej Pietrasiewicz put_dev (dev); 16928443f2d2SAndrzej Pietrasiewicz } 16938443f2d2SAndrzej Pietrasiewicz 16948443f2d2SAndrzej Pietrasiewicz static struct dev_data *the_device; 16958443f2d2SAndrzej Pietrasiewicz 16968443f2d2SAndrzej Pietrasiewicz static int gadgetfs_bind(struct usb_gadget *gadget, 16978443f2d2SAndrzej Pietrasiewicz struct usb_gadget_driver *driver) 16988443f2d2SAndrzej Pietrasiewicz { 16998443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = the_device; 17008443f2d2SAndrzej Pietrasiewicz 17018443f2d2SAndrzej Pietrasiewicz if (!dev) 17028443f2d2SAndrzej Pietrasiewicz return -ESRCH; 17038443f2d2SAndrzej Pietrasiewicz if (0 != strcmp (CHIP, gadget->name)) { 17048443f2d2SAndrzej Pietrasiewicz pr_err("%s expected %s controller not %s\n", 17058443f2d2SAndrzej Pietrasiewicz shortname, CHIP, gadget->name); 17068443f2d2SAndrzej Pietrasiewicz return -ENODEV; 17078443f2d2SAndrzej Pietrasiewicz } 17088443f2d2SAndrzej Pietrasiewicz 17098443f2d2SAndrzej Pietrasiewicz set_gadget_data (gadget, dev); 17108443f2d2SAndrzej Pietrasiewicz dev->gadget = gadget; 17118443f2d2SAndrzej Pietrasiewicz gadget->ep0->driver_data = dev; 17128443f2d2SAndrzej Pietrasiewicz 17138443f2d2SAndrzej Pietrasiewicz /* preallocate control response and buffer */ 17148443f2d2SAndrzej Pietrasiewicz dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL); 17158443f2d2SAndrzej Pietrasiewicz if (!dev->req) 17168443f2d2SAndrzej Pietrasiewicz goto enomem; 17178443f2d2SAndrzej Pietrasiewicz dev->req->context = NULL; 17188443f2d2SAndrzej Pietrasiewicz dev->req->complete = epio_complete; 17198443f2d2SAndrzej Pietrasiewicz 17208443f2d2SAndrzej Pietrasiewicz if (activate_ep_files (dev) < 0) 17218443f2d2SAndrzej Pietrasiewicz goto enomem; 17228443f2d2SAndrzej Pietrasiewicz 17238443f2d2SAndrzej Pietrasiewicz INFO (dev, "bound to %s driver\n", gadget->name); 17248443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock); 17258443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNCONNECTED; 17268443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock); 17278443f2d2SAndrzej Pietrasiewicz get_dev (dev); 17288443f2d2SAndrzej Pietrasiewicz return 0; 17298443f2d2SAndrzej Pietrasiewicz 17308443f2d2SAndrzej Pietrasiewicz enomem: 17318443f2d2SAndrzej Pietrasiewicz gadgetfs_unbind (gadget); 17328443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 17338443f2d2SAndrzej Pietrasiewicz } 17348443f2d2SAndrzej Pietrasiewicz 17358443f2d2SAndrzej Pietrasiewicz static void 17368443f2d2SAndrzej Pietrasiewicz gadgetfs_disconnect (struct usb_gadget *gadget) 17378443f2d2SAndrzej Pietrasiewicz { 17388443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget); 17398443f2d2SAndrzej Pietrasiewicz unsigned long flags; 17408443f2d2SAndrzej Pietrasiewicz 17418443f2d2SAndrzej Pietrasiewicz spin_lock_irqsave (&dev->lock, flags); 17428443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_UNCONNECTED) 17438443f2d2SAndrzej Pietrasiewicz goto exit; 17448443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_UNCONNECTED; 17458443f2d2SAndrzej Pietrasiewicz 17468443f2d2SAndrzej Pietrasiewicz INFO (dev, "disconnected\n"); 17478443f2d2SAndrzej Pietrasiewicz next_event (dev, GADGETFS_DISCONNECT); 17488443f2d2SAndrzej Pietrasiewicz ep0_readable (dev); 17498443f2d2SAndrzej Pietrasiewicz exit: 17508443f2d2SAndrzej Pietrasiewicz spin_unlock_irqrestore (&dev->lock, flags); 17518443f2d2SAndrzej Pietrasiewicz } 17528443f2d2SAndrzej Pietrasiewicz 17538443f2d2SAndrzej Pietrasiewicz static void 17548443f2d2SAndrzej Pietrasiewicz gadgetfs_suspend (struct usb_gadget *gadget) 17558443f2d2SAndrzej Pietrasiewicz { 17568443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = get_gadget_data (gadget); 17578443f2d2SAndrzej Pietrasiewicz 17588443f2d2SAndrzej Pietrasiewicz INFO (dev, "suspended from state %d\n", dev->state); 17598443f2d2SAndrzej Pietrasiewicz spin_lock (&dev->lock); 17608443f2d2SAndrzej Pietrasiewicz switch (dev->state) { 17618443f2d2SAndrzej Pietrasiewicz case STATE_DEV_SETUP: // VERY odd... host died?? 17628443f2d2SAndrzej Pietrasiewicz case STATE_DEV_CONNECTED: 17638443f2d2SAndrzej Pietrasiewicz case STATE_DEV_UNCONNECTED: 17648443f2d2SAndrzej Pietrasiewicz next_event (dev, GADGETFS_SUSPEND); 17658443f2d2SAndrzej Pietrasiewicz ep0_readable (dev); 17668443f2d2SAndrzej Pietrasiewicz /* FALLTHROUGH */ 17678443f2d2SAndrzej Pietrasiewicz default: 17688443f2d2SAndrzej Pietrasiewicz break; 17698443f2d2SAndrzej Pietrasiewicz } 17708443f2d2SAndrzej Pietrasiewicz spin_unlock (&dev->lock); 17718443f2d2SAndrzej Pietrasiewicz } 17728443f2d2SAndrzej Pietrasiewicz 17738443f2d2SAndrzej Pietrasiewicz static struct usb_gadget_driver gadgetfs_driver = { 17748443f2d2SAndrzej Pietrasiewicz .function = (char *) driver_desc, 17758443f2d2SAndrzej Pietrasiewicz .bind = gadgetfs_bind, 17768443f2d2SAndrzej Pietrasiewicz .unbind = gadgetfs_unbind, 17778443f2d2SAndrzej Pietrasiewicz .setup = gadgetfs_setup, 17780eba4550SPeter Chen .reset = gadgetfs_disconnect, 17798443f2d2SAndrzej Pietrasiewicz .disconnect = gadgetfs_disconnect, 17808443f2d2SAndrzej Pietrasiewicz .suspend = gadgetfs_suspend, 17818443f2d2SAndrzej Pietrasiewicz 17828443f2d2SAndrzej Pietrasiewicz .driver = { 17838443f2d2SAndrzej Pietrasiewicz .name = (char *) shortname, 17848443f2d2SAndrzej Pietrasiewicz }, 17858443f2d2SAndrzej Pietrasiewicz }; 17868443f2d2SAndrzej Pietrasiewicz 17878443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 17888443f2d2SAndrzej Pietrasiewicz 17898443f2d2SAndrzej Pietrasiewicz static void gadgetfs_nop(struct usb_gadget *arg) { } 17908443f2d2SAndrzej Pietrasiewicz 17918443f2d2SAndrzej Pietrasiewicz static int gadgetfs_probe(struct usb_gadget *gadget, 17928443f2d2SAndrzej Pietrasiewicz struct usb_gadget_driver *driver) 17938443f2d2SAndrzej Pietrasiewicz { 17948443f2d2SAndrzej Pietrasiewicz CHIP = gadget->name; 17958443f2d2SAndrzej Pietrasiewicz return -EISNAM; 17968443f2d2SAndrzej Pietrasiewicz } 17978443f2d2SAndrzej Pietrasiewicz 17988443f2d2SAndrzej Pietrasiewicz static struct usb_gadget_driver probe_driver = { 17998443f2d2SAndrzej Pietrasiewicz .max_speed = USB_SPEED_HIGH, 18008443f2d2SAndrzej Pietrasiewicz .bind = gadgetfs_probe, 18018443f2d2SAndrzej Pietrasiewicz .unbind = gadgetfs_nop, 18028443f2d2SAndrzej Pietrasiewicz .setup = (void *)gadgetfs_nop, 18038443f2d2SAndrzej Pietrasiewicz .disconnect = gadgetfs_nop, 18048443f2d2SAndrzej Pietrasiewicz .driver = { 18058443f2d2SAndrzej Pietrasiewicz .name = "nop", 18068443f2d2SAndrzej Pietrasiewicz }, 18078443f2d2SAndrzej Pietrasiewicz }; 18088443f2d2SAndrzej Pietrasiewicz 18098443f2d2SAndrzej Pietrasiewicz 18108443f2d2SAndrzej Pietrasiewicz /* DEVICE INITIALIZATION 18118443f2d2SAndrzej Pietrasiewicz * 18128443f2d2SAndrzej Pietrasiewicz * fd = open ("/dev/gadget/$CHIP", O_RDWR) 18138443f2d2SAndrzej Pietrasiewicz * status = write (fd, descriptors, sizeof descriptors) 18148443f2d2SAndrzej Pietrasiewicz * 18158443f2d2SAndrzej Pietrasiewicz * That write establishes the device configuration, so the kernel can 18168443f2d2SAndrzej Pietrasiewicz * bind to the controller ... guaranteeing it can handle enumeration 18178443f2d2SAndrzej Pietrasiewicz * at all necessary speeds. Descriptor order is: 18188443f2d2SAndrzej Pietrasiewicz * 18198443f2d2SAndrzej Pietrasiewicz * . message tag (u32, host order) ... for now, must be zero; it 18208443f2d2SAndrzej Pietrasiewicz * would change to support features like multi-config devices 18218443f2d2SAndrzej Pietrasiewicz * . full/low speed config ... all wTotalLength bytes (with interface, 18228443f2d2SAndrzej Pietrasiewicz * class, altsetting, endpoint, and other descriptors) 18238443f2d2SAndrzej Pietrasiewicz * . high speed config ... all descriptors, for high speed operation; 18248443f2d2SAndrzej Pietrasiewicz * this one's optional except for high-speed hardware 18258443f2d2SAndrzej Pietrasiewicz * . device descriptor 18268443f2d2SAndrzej Pietrasiewicz * 18278443f2d2SAndrzej Pietrasiewicz * Endpoints are not yet enabled. Drivers must wait until device 18288443f2d2SAndrzej Pietrasiewicz * configuration and interface altsetting changes create 18298443f2d2SAndrzej Pietrasiewicz * the need to configure (or unconfigure) them. 18308443f2d2SAndrzej Pietrasiewicz * 18318443f2d2SAndrzej Pietrasiewicz * After initialization, the device stays active for as long as that 18328443f2d2SAndrzej Pietrasiewicz * $CHIP file is open. Events must then be read from that descriptor, 18338443f2d2SAndrzej Pietrasiewicz * such as configuration notifications. 18348443f2d2SAndrzej Pietrasiewicz */ 18358443f2d2SAndrzej Pietrasiewicz 18368443f2d2SAndrzej Pietrasiewicz static int is_valid_config (struct usb_config_descriptor *config) 18378443f2d2SAndrzej Pietrasiewicz { 18388443f2d2SAndrzej Pietrasiewicz return config->bDescriptorType == USB_DT_CONFIG 18398443f2d2SAndrzej Pietrasiewicz && config->bLength == USB_DT_CONFIG_SIZE 18408443f2d2SAndrzej Pietrasiewicz && config->bConfigurationValue != 0 18418443f2d2SAndrzej Pietrasiewicz && (config->bmAttributes & USB_CONFIG_ATT_ONE) != 0 18428443f2d2SAndrzej Pietrasiewicz && (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0; 18438443f2d2SAndrzej Pietrasiewicz /* FIXME if gadget->is_otg, _must_ include an otg descriptor */ 18448443f2d2SAndrzej Pietrasiewicz /* FIXME check lengths: walk to end */ 18458443f2d2SAndrzej Pietrasiewicz } 18468443f2d2SAndrzej Pietrasiewicz 18478443f2d2SAndrzej Pietrasiewicz static ssize_t 18488443f2d2SAndrzej Pietrasiewicz dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr) 18498443f2d2SAndrzej Pietrasiewicz { 18508443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = fd->private_data; 18518443f2d2SAndrzej Pietrasiewicz ssize_t value = len, length = len; 18528443f2d2SAndrzej Pietrasiewicz unsigned total; 18538443f2d2SAndrzej Pietrasiewicz u32 tag; 18548443f2d2SAndrzej Pietrasiewicz char *kbuf; 18558443f2d2SAndrzej Pietrasiewicz 18568443f2d2SAndrzej Pietrasiewicz if (len < (USB_DT_CONFIG_SIZE + USB_DT_DEVICE_SIZE + 4)) 18578443f2d2SAndrzej Pietrasiewicz return -EINVAL; 18588443f2d2SAndrzej Pietrasiewicz 18598443f2d2SAndrzej Pietrasiewicz /* we might need to change message format someday */ 18608443f2d2SAndrzej Pietrasiewicz if (copy_from_user (&tag, buf, 4)) 18618443f2d2SAndrzej Pietrasiewicz return -EFAULT; 18628443f2d2SAndrzej Pietrasiewicz if (tag != 0) 18638443f2d2SAndrzej Pietrasiewicz return -EINVAL; 18648443f2d2SAndrzej Pietrasiewicz buf += 4; 18658443f2d2SAndrzej Pietrasiewicz length -= 4; 18668443f2d2SAndrzej Pietrasiewicz 18678443f2d2SAndrzej Pietrasiewicz kbuf = memdup_user(buf, length); 18688443f2d2SAndrzej Pietrasiewicz if (IS_ERR(kbuf)) 18698443f2d2SAndrzej Pietrasiewicz return PTR_ERR(kbuf); 18708443f2d2SAndrzej Pietrasiewicz 18718443f2d2SAndrzej Pietrasiewicz spin_lock_irq (&dev->lock); 18728443f2d2SAndrzej Pietrasiewicz value = -EINVAL; 18738443f2d2SAndrzej Pietrasiewicz if (dev->buf) 18748443f2d2SAndrzej Pietrasiewicz goto fail; 18758443f2d2SAndrzej Pietrasiewicz dev->buf = kbuf; 18768443f2d2SAndrzej Pietrasiewicz 18778443f2d2SAndrzej Pietrasiewicz /* full or low speed config */ 18788443f2d2SAndrzej Pietrasiewicz dev->config = (void *) kbuf; 18798443f2d2SAndrzej Pietrasiewicz total = le16_to_cpu(dev->config->wTotalLength); 18808443f2d2SAndrzej Pietrasiewicz if (!is_valid_config (dev->config) || total >= length) 18818443f2d2SAndrzej Pietrasiewicz goto fail; 18828443f2d2SAndrzej Pietrasiewicz kbuf += total; 18838443f2d2SAndrzej Pietrasiewicz length -= total; 18848443f2d2SAndrzej Pietrasiewicz 18858443f2d2SAndrzej Pietrasiewicz /* optional high speed config */ 18868443f2d2SAndrzej Pietrasiewicz if (kbuf [1] == USB_DT_CONFIG) { 18878443f2d2SAndrzej Pietrasiewicz dev->hs_config = (void *) kbuf; 18888443f2d2SAndrzej Pietrasiewicz total = le16_to_cpu(dev->hs_config->wTotalLength); 18898443f2d2SAndrzej Pietrasiewicz if (!is_valid_config (dev->hs_config) || total >= length) 18908443f2d2SAndrzej Pietrasiewicz goto fail; 18918443f2d2SAndrzej Pietrasiewicz kbuf += total; 18928443f2d2SAndrzej Pietrasiewicz length -= total; 18938443f2d2SAndrzej Pietrasiewicz } 18948443f2d2SAndrzej Pietrasiewicz 18958443f2d2SAndrzej Pietrasiewicz /* could support multiple configs, using another encoding! */ 18968443f2d2SAndrzej Pietrasiewicz 18978443f2d2SAndrzej Pietrasiewicz /* device descriptor (tweaked for paranoia) */ 18988443f2d2SAndrzej Pietrasiewicz if (length != USB_DT_DEVICE_SIZE) 18998443f2d2SAndrzej Pietrasiewicz goto fail; 19008443f2d2SAndrzej Pietrasiewicz dev->dev = (void *)kbuf; 19018443f2d2SAndrzej Pietrasiewicz if (dev->dev->bLength != USB_DT_DEVICE_SIZE 19028443f2d2SAndrzej Pietrasiewicz || dev->dev->bDescriptorType != USB_DT_DEVICE 19038443f2d2SAndrzej Pietrasiewicz || dev->dev->bNumConfigurations != 1) 19048443f2d2SAndrzej Pietrasiewicz goto fail; 19058443f2d2SAndrzej Pietrasiewicz dev->dev->bNumConfigurations = 1; 19068443f2d2SAndrzej Pietrasiewicz dev->dev->bcdUSB = cpu_to_le16 (0x0200); 19078443f2d2SAndrzej Pietrasiewicz 19088443f2d2SAndrzej Pietrasiewicz /* triggers gadgetfs_bind(); then we can enumerate. */ 19098443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 19108443f2d2SAndrzej Pietrasiewicz if (dev->hs_config) 19118443f2d2SAndrzej Pietrasiewicz gadgetfs_driver.max_speed = USB_SPEED_HIGH; 19128443f2d2SAndrzej Pietrasiewicz else 19138443f2d2SAndrzej Pietrasiewicz gadgetfs_driver.max_speed = USB_SPEED_FULL; 19148443f2d2SAndrzej Pietrasiewicz 19158443f2d2SAndrzej Pietrasiewicz value = usb_gadget_probe_driver(&gadgetfs_driver); 19168443f2d2SAndrzej Pietrasiewicz if (value != 0) { 19178443f2d2SAndrzej Pietrasiewicz kfree (dev->buf); 19188443f2d2SAndrzej Pietrasiewicz dev->buf = NULL; 19198443f2d2SAndrzej Pietrasiewicz } else { 19208443f2d2SAndrzej Pietrasiewicz /* at this point "good" hardware has for the first time 19218443f2d2SAndrzej Pietrasiewicz * let the USB the host see us. alternatively, if users 19228443f2d2SAndrzej Pietrasiewicz * unplug/replug that will clear all the error state. 19238443f2d2SAndrzej Pietrasiewicz * 19248443f2d2SAndrzej Pietrasiewicz * note: everything running before here was guaranteed 19258443f2d2SAndrzej Pietrasiewicz * to choke driver model style diagnostics. from here 19268443f2d2SAndrzej Pietrasiewicz * on, they can work ... except in cleanup paths that 19278443f2d2SAndrzej Pietrasiewicz * kick in after the ep0 descriptor is closed. 19288443f2d2SAndrzej Pietrasiewicz */ 19298443f2d2SAndrzej Pietrasiewicz fd->f_op = &ep0_io_operations; 19308443f2d2SAndrzej Pietrasiewicz value = len; 19318443f2d2SAndrzej Pietrasiewicz } 19328443f2d2SAndrzej Pietrasiewicz return value; 19338443f2d2SAndrzej Pietrasiewicz 19348443f2d2SAndrzej Pietrasiewicz fail: 19358443f2d2SAndrzej Pietrasiewicz spin_unlock_irq (&dev->lock); 19368443f2d2SAndrzej Pietrasiewicz pr_debug ("%s: %s fail %Zd, %p\n", shortname, __func__, value, dev); 19378443f2d2SAndrzej Pietrasiewicz kfree (dev->buf); 19388443f2d2SAndrzej Pietrasiewicz dev->buf = NULL; 19398443f2d2SAndrzej Pietrasiewicz return value; 19408443f2d2SAndrzej Pietrasiewicz } 19418443f2d2SAndrzej Pietrasiewicz 19428443f2d2SAndrzej Pietrasiewicz static int 19438443f2d2SAndrzej Pietrasiewicz dev_open (struct inode *inode, struct file *fd) 19448443f2d2SAndrzej Pietrasiewicz { 19458443f2d2SAndrzej Pietrasiewicz struct dev_data *dev = inode->i_private; 19468443f2d2SAndrzej Pietrasiewicz int value = -EBUSY; 19478443f2d2SAndrzej Pietrasiewicz 19488443f2d2SAndrzej Pietrasiewicz spin_lock_irq(&dev->lock); 19498443f2d2SAndrzej Pietrasiewicz if (dev->state == STATE_DEV_DISABLED) { 19508443f2d2SAndrzej Pietrasiewicz dev->ev_next = 0; 19518443f2d2SAndrzej Pietrasiewicz dev->state = STATE_DEV_OPENED; 19528443f2d2SAndrzej Pietrasiewicz fd->private_data = dev; 19538443f2d2SAndrzej Pietrasiewicz get_dev (dev); 19548443f2d2SAndrzej Pietrasiewicz value = 0; 19558443f2d2SAndrzej Pietrasiewicz } 19568443f2d2SAndrzej Pietrasiewicz spin_unlock_irq(&dev->lock); 19578443f2d2SAndrzej Pietrasiewicz return value; 19588443f2d2SAndrzej Pietrasiewicz } 19598443f2d2SAndrzej Pietrasiewicz 19608443f2d2SAndrzej Pietrasiewicz static const struct file_operations dev_init_operations = { 19618443f2d2SAndrzej Pietrasiewicz .llseek = no_llseek, 19628443f2d2SAndrzej Pietrasiewicz 19638443f2d2SAndrzej Pietrasiewicz .open = dev_open, 19648443f2d2SAndrzej Pietrasiewicz .write = dev_config, 19658443f2d2SAndrzej Pietrasiewicz .fasync = ep0_fasync, 19668443f2d2SAndrzej Pietrasiewicz .unlocked_ioctl = dev_ioctl, 19678443f2d2SAndrzej Pietrasiewicz .release = dev_release, 19688443f2d2SAndrzej Pietrasiewicz }; 19698443f2d2SAndrzej Pietrasiewicz 19708443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 19718443f2d2SAndrzej Pietrasiewicz 19728443f2d2SAndrzej Pietrasiewicz /* FILESYSTEM AND SUPERBLOCK OPERATIONS 19738443f2d2SAndrzej Pietrasiewicz * 19748443f2d2SAndrzej Pietrasiewicz * Mounting the filesystem creates a controller file, used first for 19758443f2d2SAndrzej Pietrasiewicz * device configuration then later for event monitoring. 19768443f2d2SAndrzej Pietrasiewicz */ 19778443f2d2SAndrzej Pietrasiewicz 19788443f2d2SAndrzej Pietrasiewicz 19798443f2d2SAndrzej Pietrasiewicz /* FIXME PAM etc could set this security policy without mount options 19808443f2d2SAndrzej Pietrasiewicz * if epfiles inherited ownership and permissons from ep0 ... 19818443f2d2SAndrzej Pietrasiewicz */ 19828443f2d2SAndrzej Pietrasiewicz 19838443f2d2SAndrzej Pietrasiewicz static unsigned default_uid; 19848443f2d2SAndrzej Pietrasiewicz static unsigned default_gid; 19858443f2d2SAndrzej Pietrasiewicz static unsigned default_perm = S_IRUSR | S_IWUSR; 19868443f2d2SAndrzej Pietrasiewicz 19878443f2d2SAndrzej Pietrasiewicz module_param (default_uid, uint, 0644); 19888443f2d2SAndrzej Pietrasiewicz module_param (default_gid, uint, 0644); 19898443f2d2SAndrzej Pietrasiewicz module_param (default_perm, uint, 0644); 19908443f2d2SAndrzej Pietrasiewicz 19918443f2d2SAndrzej Pietrasiewicz 19928443f2d2SAndrzej Pietrasiewicz static struct inode * 19938443f2d2SAndrzej Pietrasiewicz gadgetfs_make_inode (struct super_block *sb, 19948443f2d2SAndrzej Pietrasiewicz void *data, const struct file_operations *fops, 19958443f2d2SAndrzej Pietrasiewicz int mode) 19968443f2d2SAndrzej Pietrasiewicz { 19978443f2d2SAndrzej Pietrasiewicz struct inode *inode = new_inode (sb); 19988443f2d2SAndrzej Pietrasiewicz 19998443f2d2SAndrzej Pietrasiewicz if (inode) { 20008443f2d2SAndrzej Pietrasiewicz inode->i_ino = get_next_ino(); 20018443f2d2SAndrzej Pietrasiewicz inode->i_mode = mode; 20028443f2d2SAndrzej Pietrasiewicz inode->i_uid = make_kuid(&init_user_ns, default_uid); 20038443f2d2SAndrzej Pietrasiewicz inode->i_gid = make_kgid(&init_user_ns, default_gid); 20048443f2d2SAndrzej Pietrasiewicz inode->i_atime = inode->i_mtime = inode->i_ctime 20058443f2d2SAndrzej Pietrasiewicz = CURRENT_TIME; 20068443f2d2SAndrzej Pietrasiewicz inode->i_private = data; 20078443f2d2SAndrzej Pietrasiewicz inode->i_fop = fops; 20088443f2d2SAndrzej Pietrasiewicz } 20098443f2d2SAndrzej Pietrasiewicz return inode; 20108443f2d2SAndrzej Pietrasiewicz } 20118443f2d2SAndrzej Pietrasiewicz 20128443f2d2SAndrzej Pietrasiewicz /* creates in fs root directory, so non-renamable and non-linkable. 20138443f2d2SAndrzej Pietrasiewicz * so inode and dentry are paired, until device reconfig. 20148443f2d2SAndrzej Pietrasiewicz */ 20158443f2d2SAndrzej Pietrasiewicz static struct inode * 20168443f2d2SAndrzej Pietrasiewicz gadgetfs_create_file (struct super_block *sb, char const *name, 20178443f2d2SAndrzej Pietrasiewicz void *data, const struct file_operations *fops, 20188443f2d2SAndrzej Pietrasiewicz struct dentry **dentry_p) 20198443f2d2SAndrzej Pietrasiewicz { 20208443f2d2SAndrzej Pietrasiewicz struct dentry *dentry; 20218443f2d2SAndrzej Pietrasiewicz struct inode *inode; 20228443f2d2SAndrzej Pietrasiewicz 20238443f2d2SAndrzej Pietrasiewicz dentry = d_alloc_name(sb->s_root, name); 20248443f2d2SAndrzej Pietrasiewicz if (!dentry) 20258443f2d2SAndrzej Pietrasiewicz return NULL; 20268443f2d2SAndrzej Pietrasiewicz 20278443f2d2SAndrzej Pietrasiewicz inode = gadgetfs_make_inode (sb, data, fops, 20288443f2d2SAndrzej Pietrasiewicz S_IFREG | (default_perm & S_IRWXUGO)); 20298443f2d2SAndrzej Pietrasiewicz if (!inode) { 20308443f2d2SAndrzej Pietrasiewicz dput(dentry); 20318443f2d2SAndrzej Pietrasiewicz return NULL; 20328443f2d2SAndrzej Pietrasiewicz } 20338443f2d2SAndrzej Pietrasiewicz d_add (dentry, inode); 20348443f2d2SAndrzej Pietrasiewicz *dentry_p = dentry; 20358443f2d2SAndrzej Pietrasiewicz return inode; 20368443f2d2SAndrzej Pietrasiewicz } 20378443f2d2SAndrzej Pietrasiewicz 20388443f2d2SAndrzej Pietrasiewicz static const struct super_operations gadget_fs_operations = { 20398443f2d2SAndrzej Pietrasiewicz .statfs = simple_statfs, 20408443f2d2SAndrzej Pietrasiewicz .drop_inode = generic_delete_inode, 20418443f2d2SAndrzej Pietrasiewicz }; 20428443f2d2SAndrzej Pietrasiewicz 20438443f2d2SAndrzej Pietrasiewicz static int 20448443f2d2SAndrzej Pietrasiewicz gadgetfs_fill_super (struct super_block *sb, void *opts, int silent) 20458443f2d2SAndrzej Pietrasiewicz { 20468443f2d2SAndrzej Pietrasiewicz struct inode *inode; 20478443f2d2SAndrzej Pietrasiewicz struct dev_data *dev; 20488443f2d2SAndrzej Pietrasiewicz 20498443f2d2SAndrzej Pietrasiewicz if (the_device) 20508443f2d2SAndrzej Pietrasiewicz return -ESRCH; 20518443f2d2SAndrzej Pietrasiewicz 20528443f2d2SAndrzej Pietrasiewicz /* fake probe to determine $CHIP */ 20538443f2d2SAndrzej Pietrasiewicz CHIP = NULL; 20548443f2d2SAndrzej Pietrasiewicz usb_gadget_probe_driver(&probe_driver); 20558443f2d2SAndrzej Pietrasiewicz if (!CHIP) 20568443f2d2SAndrzej Pietrasiewicz return -ENODEV; 20578443f2d2SAndrzej Pietrasiewicz 20588443f2d2SAndrzej Pietrasiewicz /* superblock */ 20598443f2d2SAndrzej Pietrasiewicz sb->s_blocksize = PAGE_CACHE_SIZE; 20608443f2d2SAndrzej Pietrasiewicz sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 20618443f2d2SAndrzej Pietrasiewicz sb->s_magic = GADGETFS_MAGIC; 20628443f2d2SAndrzej Pietrasiewicz sb->s_op = &gadget_fs_operations; 20638443f2d2SAndrzej Pietrasiewicz sb->s_time_gran = 1; 20648443f2d2SAndrzej Pietrasiewicz 20658443f2d2SAndrzej Pietrasiewicz /* root inode */ 20668443f2d2SAndrzej Pietrasiewicz inode = gadgetfs_make_inode (sb, 20678443f2d2SAndrzej Pietrasiewicz NULL, &simple_dir_operations, 20688443f2d2SAndrzej Pietrasiewicz S_IFDIR | S_IRUGO | S_IXUGO); 20698443f2d2SAndrzej Pietrasiewicz if (!inode) 20708443f2d2SAndrzej Pietrasiewicz goto Enomem; 20718443f2d2SAndrzej Pietrasiewicz inode->i_op = &simple_dir_inode_operations; 20728443f2d2SAndrzej Pietrasiewicz if (!(sb->s_root = d_make_root (inode))) 20738443f2d2SAndrzej Pietrasiewicz goto Enomem; 20748443f2d2SAndrzej Pietrasiewicz 20758443f2d2SAndrzej Pietrasiewicz /* the ep0 file is named after the controller we expect; 20768443f2d2SAndrzej Pietrasiewicz * user mode code can use it for sanity checks, like we do. 20778443f2d2SAndrzej Pietrasiewicz */ 20788443f2d2SAndrzej Pietrasiewicz dev = dev_new (); 20798443f2d2SAndrzej Pietrasiewicz if (!dev) 20808443f2d2SAndrzej Pietrasiewicz goto Enomem; 20818443f2d2SAndrzej Pietrasiewicz 20828443f2d2SAndrzej Pietrasiewicz dev->sb = sb; 20838443f2d2SAndrzej Pietrasiewicz if (!gadgetfs_create_file (sb, CHIP, 20848443f2d2SAndrzej Pietrasiewicz dev, &dev_init_operations, 20858443f2d2SAndrzej Pietrasiewicz &dev->dentry)) { 20868443f2d2SAndrzej Pietrasiewicz put_dev(dev); 20878443f2d2SAndrzej Pietrasiewicz goto Enomem; 20888443f2d2SAndrzej Pietrasiewicz } 20898443f2d2SAndrzej Pietrasiewicz 20908443f2d2SAndrzej Pietrasiewicz /* other endpoint files are available after hardware setup, 20918443f2d2SAndrzej Pietrasiewicz * from binding to a controller. 20928443f2d2SAndrzej Pietrasiewicz */ 20938443f2d2SAndrzej Pietrasiewicz the_device = dev; 20948443f2d2SAndrzej Pietrasiewicz return 0; 20958443f2d2SAndrzej Pietrasiewicz 20968443f2d2SAndrzej Pietrasiewicz Enomem: 20978443f2d2SAndrzej Pietrasiewicz return -ENOMEM; 20988443f2d2SAndrzej Pietrasiewicz } 20998443f2d2SAndrzej Pietrasiewicz 21008443f2d2SAndrzej Pietrasiewicz /* "mount -t gadgetfs path /dev/gadget" ends up here */ 21018443f2d2SAndrzej Pietrasiewicz static struct dentry * 21028443f2d2SAndrzej Pietrasiewicz gadgetfs_mount (struct file_system_type *t, int flags, 21038443f2d2SAndrzej Pietrasiewicz const char *path, void *opts) 21048443f2d2SAndrzej Pietrasiewicz { 21058443f2d2SAndrzej Pietrasiewicz return mount_single (t, flags, opts, gadgetfs_fill_super); 21068443f2d2SAndrzej Pietrasiewicz } 21078443f2d2SAndrzej Pietrasiewicz 21088443f2d2SAndrzej Pietrasiewicz static void 21098443f2d2SAndrzej Pietrasiewicz gadgetfs_kill_sb (struct super_block *sb) 21108443f2d2SAndrzej Pietrasiewicz { 21118443f2d2SAndrzej Pietrasiewicz kill_litter_super (sb); 21128443f2d2SAndrzej Pietrasiewicz if (the_device) { 21138443f2d2SAndrzej Pietrasiewicz put_dev (the_device); 21148443f2d2SAndrzej Pietrasiewicz the_device = NULL; 21158443f2d2SAndrzej Pietrasiewicz } 21168443f2d2SAndrzej Pietrasiewicz } 21178443f2d2SAndrzej Pietrasiewicz 21188443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 21198443f2d2SAndrzej Pietrasiewicz 21208443f2d2SAndrzej Pietrasiewicz static struct file_system_type gadgetfs_type = { 21218443f2d2SAndrzej Pietrasiewicz .owner = THIS_MODULE, 21228443f2d2SAndrzej Pietrasiewicz .name = shortname, 21238443f2d2SAndrzej Pietrasiewicz .mount = gadgetfs_mount, 21248443f2d2SAndrzej Pietrasiewicz .kill_sb = gadgetfs_kill_sb, 21258443f2d2SAndrzej Pietrasiewicz }; 21268443f2d2SAndrzej Pietrasiewicz MODULE_ALIAS_FS("gadgetfs"); 21278443f2d2SAndrzej Pietrasiewicz 21288443f2d2SAndrzej Pietrasiewicz /*----------------------------------------------------------------------*/ 21298443f2d2SAndrzej Pietrasiewicz 21308443f2d2SAndrzej Pietrasiewicz static int __init init (void) 21318443f2d2SAndrzej Pietrasiewicz { 21328443f2d2SAndrzej Pietrasiewicz int status; 21338443f2d2SAndrzej Pietrasiewicz 21348443f2d2SAndrzej Pietrasiewicz status = register_filesystem (&gadgetfs_type); 21358443f2d2SAndrzej Pietrasiewicz if (status == 0) 21368443f2d2SAndrzej Pietrasiewicz pr_info ("%s: %s, version " DRIVER_VERSION "\n", 21378443f2d2SAndrzej Pietrasiewicz shortname, driver_desc); 21388443f2d2SAndrzej Pietrasiewicz return status; 21398443f2d2SAndrzej Pietrasiewicz } 21408443f2d2SAndrzej Pietrasiewicz module_init (init); 21418443f2d2SAndrzej Pietrasiewicz 21428443f2d2SAndrzej Pietrasiewicz static void __exit cleanup (void) 21438443f2d2SAndrzej Pietrasiewicz { 21448443f2d2SAndrzej Pietrasiewicz pr_debug ("unregister %s\n", shortname); 21458443f2d2SAndrzej Pietrasiewicz unregister_filesystem (&gadgetfs_type); 21468443f2d2SAndrzej Pietrasiewicz } 21478443f2d2SAndrzej Pietrasiewicz module_exit (cleanup); 21488443f2d2SAndrzej Pietrasiewicz 2149