15fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
3c0704541SLuiz Fernando N. Capitulino * USB Skeleton driver - 2.2
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
8121e287cSAlan Stern * but has been rewritten to be easier to read and use.
91da177e4SLinus Torvalds */
101da177e4SLinus Torvalds
111da177e4SLinus Torvalds #include <linux/kernel.h>
121da177e4SLinus Torvalds #include <linux/errno.h>
131da177e4SLinus Torvalds #include <linux/slab.h>
141da177e4SLinus Torvalds #include <linux/module.h>
151da177e4SLinus Torvalds #include <linux/kref.h>
163ae9da1cSGreg Kroah-Hartman #include <linux/uaccess.h>
171da177e4SLinus Torvalds #include <linux/usb.h>
18121e287cSAlan Stern #include <linux/mutex.h>
191da177e4SLinus Torvalds
201da177e4SLinus Torvalds
211da177e4SLinus Torvalds /* Define these values to match your devices */
221da177e4SLinus Torvalds #define USB_SKEL_VENDOR_ID 0xfff0
231da177e4SLinus Torvalds #define USB_SKEL_PRODUCT_ID 0xfff0
241da177e4SLinus Torvalds
251da177e4SLinus Torvalds /* table of devices that work with this driver */
261bd4f29dSNémeth Márton static const struct usb_device_id skel_table[] = {
271da177e4SLinus Torvalds { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
281da177e4SLinus Torvalds { } /* Terminating entry */
291da177e4SLinus Torvalds };
301da177e4SLinus Torvalds MODULE_DEVICE_TABLE(usb, skel_table);
311da177e4SLinus Torvalds
321da177e4SLinus Torvalds
331da177e4SLinus Torvalds /* Get a minor range for your devices from the usb maintainer */
341da177e4SLinus Torvalds #define USB_SKEL_MINOR_BASE 192
351da177e4SLinus Torvalds
36ff906518SOliver Neukum /* our private defines. if this grows any larger, use your own .h file */
37ff906518SOliver Neukum #define MAX_TRANSFER (PAGE_SIZE - 512)
38a599e486SJacob Huisman /*
39a599e486SJacob Huisman * MAX_TRANSFER is chosen so that the VM is not stressed by
40a599e486SJacob Huisman * allocations > PAGE_SIZE and the number of packets in a page
41a599e486SJacob Huisman * is an integer 512 is the largest possible packet on EHCI
42a599e486SJacob Huisman */
43ff906518SOliver Neukum #define WRITES_IN_FLIGHT 8
44ba35e02bSOliver Neukum /* arbitrarily chosen */
45ff906518SOliver Neukum
461da177e4SLinus Torvalds /* Structure to hold all of our device specific stuff */
471da177e4SLinus Torvalds struct usb_skel {
48ba35e02bSOliver Neukum struct usb_device *udev; /* the usb device for this device */
491da177e4SLinus Torvalds struct usb_interface *interface; /* the interface for this device */
50ff906518SOliver Neukum struct semaphore limit_sem; /* limiting the number of writes in progress */
51403dfb58SOliver Neukum struct usb_anchor submitted; /* in case we need to retract our submissions */
52e7389cc9SOliver Neukum struct urb *bulk_in_urb; /* the urb to read data with */
531da177e4SLinus Torvalds unsigned char *bulk_in_buffer; /* the buffer to receive data */
541da177e4SLinus Torvalds size_t bulk_in_size; /* the size of the receive buffer */
55e7389cc9SOliver Neukum size_t bulk_in_filled; /* number of bytes in the buffer */
56e7389cc9SOliver Neukum size_t bulk_in_copied; /* already copied to user space */
571da177e4SLinus Torvalds __u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
581da177e4SLinus Torvalds __u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */
59403dfb58SOliver Neukum int errors; /* the last request tanked */
60e7389cc9SOliver Neukum bool ongoing_read; /* a read is going on */
61403dfb58SOliver Neukum spinlock_t err_lock; /* lock for errors */
621da177e4SLinus Torvalds struct kref kref;
63121e287cSAlan Stern struct mutex io_mutex; /* synchronize I/O with disconnect */
64bed5ef23SJohan Hovold unsigned long disconnected:1;
65c79041a4SDu Xing wait_queue_head_t bulk_in_wait; /* to wait for an ongoing read */
661da177e4SLinus Torvalds };
671da177e4SLinus Torvalds #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
681da177e4SLinus Torvalds
691da177e4SLinus Torvalds static struct usb_driver skel_driver;
70403dfb58SOliver Neukum static void skel_draw_down(struct usb_skel *dev);
711da177e4SLinus Torvalds
skel_delete(struct kref * kref)721da177e4SLinus Torvalds static void skel_delete(struct kref *kref)
731da177e4SLinus Torvalds {
741da177e4SLinus Torvalds struct usb_skel *dev = to_skel_dev(kref);
751da177e4SLinus Torvalds
76e7389cc9SOliver Neukum usb_free_urb(dev->bulk_in_urb);
775c290a5eSJohan Hovold usb_put_intf(dev->interface);
781da177e4SLinus Torvalds usb_put_dev(dev->udev);
791da177e4SLinus Torvalds kfree(dev->bulk_in_buffer);
801da177e4SLinus Torvalds kfree(dev);
811da177e4SLinus Torvalds }
821da177e4SLinus Torvalds
skel_open(struct inode * inode,struct file * file)831da177e4SLinus Torvalds static int skel_open(struct inode *inode, struct file *file)
841da177e4SLinus Torvalds {
851da177e4SLinus Torvalds struct usb_skel *dev;
861da177e4SLinus Torvalds struct usb_interface *interface;
871da177e4SLinus Torvalds int subminor;
881da177e4SLinus Torvalds int retval = 0;
891da177e4SLinus Torvalds
901da177e4SLinus Torvalds subminor = iminor(inode);
911da177e4SLinus Torvalds
921da177e4SLinus Torvalds interface = usb_find_interface(&skel_driver, subminor);
931da177e4SLinus Torvalds if (!interface) {
944212cd74SGreg Kroah-Hartman pr_err("%s - error, can't find device for minor %d\n",
95441b62c1SHarvey Harrison __func__, subminor);
961da177e4SLinus Torvalds retval = -ENODEV;
971da177e4SLinus Torvalds goto exit;
981da177e4SLinus Torvalds }
991da177e4SLinus Torvalds
1001da177e4SLinus Torvalds dev = usb_get_intfdata(interface);
1011da177e4SLinus Torvalds if (!dev) {
1021da177e4SLinus Torvalds retval = -ENODEV;
1031da177e4SLinus Torvalds goto exit;
1041da177e4SLinus Torvalds }
1051da177e4SLinus Torvalds
106e8cebb9cSConstantine Shulyupin retval = usb_autopm_get_interface(interface);
107e8cebb9cSConstantine Shulyupin if (retval)
108e8cebb9cSConstantine Shulyupin goto exit;
109e8cebb9cSConstantine Shulyupin
1101da177e4SLinus Torvalds /* increment our usage count for the device */
1111da177e4SLinus Torvalds kref_get(&dev->kref);
1121da177e4SLinus Torvalds
1131da177e4SLinus Torvalds /* save our object in the file's private structure */
1141da177e4SLinus Torvalds file->private_data = dev;
1151da177e4SLinus Torvalds
1161da177e4SLinus Torvalds exit:
1171da177e4SLinus Torvalds return retval;
1181da177e4SLinus Torvalds }
1191da177e4SLinus Torvalds
skel_release(struct inode * inode,struct file * file)1201da177e4SLinus Torvalds static int skel_release(struct inode *inode, struct file *file)
1211da177e4SLinus Torvalds {
1221da177e4SLinus Torvalds struct usb_skel *dev;
1231da177e4SLinus Torvalds
124e53e841dSJoe Perches dev = file->private_data;
1251da177e4SLinus Torvalds if (dev == NULL)
1261da177e4SLinus Torvalds return -ENODEV;
1271da177e4SLinus Torvalds
12801d883d4SAlan Stern /* allow the device to be autosuspended */
12901d883d4SAlan Stern usb_autopm_put_interface(dev->interface);
13001d883d4SAlan Stern
1311da177e4SLinus Torvalds /* decrement the count on our device */
1321da177e4SLinus Torvalds kref_put(&dev->kref, skel_delete);
1331da177e4SLinus Torvalds return 0;
1341da177e4SLinus Torvalds }
1351da177e4SLinus Torvalds
skel_flush(struct file * file,fl_owner_t id)136403dfb58SOliver Neukum static int skel_flush(struct file *file, fl_owner_t id)
137403dfb58SOliver Neukum {
138403dfb58SOliver Neukum struct usb_skel *dev;
139403dfb58SOliver Neukum int res;
140403dfb58SOliver Neukum
141e53e841dSJoe Perches dev = file->private_data;
142403dfb58SOliver Neukum if (dev == NULL)
143403dfb58SOliver Neukum return -ENODEV;
144403dfb58SOliver Neukum
145403dfb58SOliver Neukum /* wait for io to stop */
146403dfb58SOliver Neukum mutex_lock(&dev->io_mutex);
147403dfb58SOliver Neukum skel_draw_down(dev);
148403dfb58SOliver Neukum
149403dfb58SOliver Neukum /* read out errors, leave subsequent opens a clean slate */
150403dfb58SOliver Neukum spin_lock_irq(&dev->err_lock);
151403dfb58SOliver Neukum res = dev->errors ? (dev->errors == -EPIPE ? -EPIPE : -EIO) : 0;
152403dfb58SOliver Neukum dev->errors = 0;
153403dfb58SOliver Neukum spin_unlock_irq(&dev->err_lock);
154403dfb58SOliver Neukum
155403dfb58SOliver Neukum mutex_unlock(&dev->io_mutex);
156403dfb58SOliver Neukum
157403dfb58SOliver Neukum return res;
158403dfb58SOliver Neukum }
159403dfb58SOliver Neukum
skel_read_bulk_callback(struct urb * urb)160e7389cc9SOliver Neukum static void skel_read_bulk_callback(struct urb *urb)
161e7389cc9SOliver Neukum {
162e7389cc9SOliver Neukum struct usb_skel *dev;
1638982c844SJohn Ogness unsigned long flags;
164e7389cc9SOliver Neukum
165e7389cc9SOliver Neukum dev = urb->context;
166e7389cc9SOliver Neukum
1678982c844SJohn Ogness spin_lock_irqsave(&dev->err_lock, flags);
168e7389cc9SOliver Neukum /* sync/async unlink faults aren't errors */
169e7389cc9SOliver Neukum if (urb->status) {
170e7389cc9SOliver Neukum if (!(urb->status == -ENOENT ||
171e7389cc9SOliver Neukum urb->status == -ECONNRESET ||
172e7389cc9SOliver Neukum urb->status == -ESHUTDOWN))
1734212cd74SGreg Kroah-Hartman dev_err(&dev->interface->dev,
1744212cd74SGreg Kroah-Hartman "%s - nonzero write bulk status received: %d\n",
175e7389cc9SOliver Neukum __func__, urb->status);
176e7389cc9SOliver Neukum
177e7389cc9SOliver Neukum dev->errors = urb->status;
178e7389cc9SOliver Neukum } else {
179e7389cc9SOliver Neukum dev->bulk_in_filled = urb->actual_length;
180e7389cc9SOliver Neukum }
181e7389cc9SOliver Neukum dev->ongoing_read = 0;
1828982c844SJohn Ogness spin_unlock_irqrestore(&dev->err_lock, flags);
183e7389cc9SOliver Neukum
184c79041a4SDu Xing wake_up_interruptible(&dev->bulk_in_wait);
185e7389cc9SOliver Neukum }
186e7389cc9SOliver Neukum
skel_do_read_io(struct usb_skel * dev,size_t count)187e7389cc9SOliver Neukum static int skel_do_read_io(struct usb_skel *dev, size_t count)
188e7389cc9SOliver Neukum {
189e7389cc9SOliver Neukum int rv;
190e7389cc9SOliver Neukum
191e7389cc9SOliver Neukum /* prepare a read */
192e7389cc9SOliver Neukum usb_fill_bulk_urb(dev->bulk_in_urb,
193e7389cc9SOliver Neukum dev->udev,
194e7389cc9SOliver Neukum usb_rcvbulkpipe(dev->udev,
195e7389cc9SOliver Neukum dev->bulk_in_endpointAddr),
196e7389cc9SOliver Neukum dev->bulk_in_buffer,
197e7389cc9SOliver Neukum min(dev->bulk_in_size, count),
198e7389cc9SOliver Neukum skel_read_bulk_callback,
199e7389cc9SOliver Neukum dev);
200e7389cc9SOliver Neukum /* tell everybody to leave the URB alone */
201e7389cc9SOliver Neukum spin_lock_irq(&dev->err_lock);
202e7389cc9SOliver Neukum dev->ongoing_read = 1;
203e7389cc9SOliver Neukum spin_unlock_irq(&dev->err_lock);
204e7389cc9SOliver Neukum
205c79041a4SDu Xing /* submit bulk in urb, which means no data to deliver */
206c79041a4SDu Xing dev->bulk_in_filled = 0;
207c79041a4SDu Xing dev->bulk_in_copied = 0;
208c79041a4SDu Xing
209e7389cc9SOliver Neukum /* do it */
210e7389cc9SOliver Neukum rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
211e7389cc9SOliver Neukum if (rv < 0) {
2124212cd74SGreg Kroah-Hartman dev_err(&dev->interface->dev,
2134212cd74SGreg Kroah-Hartman "%s - failed submitting read urb, error %d\n",
214e7389cc9SOliver Neukum __func__, rv);
215e7389cc9SOliver Neukum rv = (rv == -ENOMEM) ? rv : -EIO;
216e7389cc9SOliver Neukum spin_lock_irq(&dev->err_lock);
217e7389cc9SOliver Neukum dev->ongoing_read = 0;
218e7389cc9SOliver Neukum spin_unlock_irq(&dev->err_lock);
219e7389cc9SOliver Neukum }
220e7389cc9SOliver Neukum
221e7389cc9SOliver Neukum return rv;
222e7389cc9SOliver Neukum }
223e7389cc9SOliver Neukum
skel_read(struct file * file,char * buffer,size_t count,loff_t * ppos)2243ae9da1cSGreg Kroah-Hartman static ssize_t skel_read(struct file *file, char *buffer, size_t count,
2253ae9da1cSGreg Kroah-Hartman loff_t *ppos)
2261da177e4SLinus Torvalds {
2271da177e4SLinus Torvalds struct usb_skel *dev;
228e7389cc9SOliver Neukum int rv;
229e7389cc9SOliver Neukum bool ongoing_io;
2301da177e4SLinus Torvalds
231e53e841dSJoe Perches dev = file->private_data;
2321da177e4SLinus Torvalds
233369dca42SJohan Hovold if (!count)
234e7389cc9SOliver Neukum return 0;
235e7389cc9SOliver Neukum
236e7389cc9SOliver Neukum /* no concurrent readers */
237e7389cc9SOliver Neukum rv = mutex_lock_interruptible(&dev->io_mutex);
238e7389cc9SOliver Neukum if (rv < 0)
239e7389cc9SOliver Neukum return rv;
240e7389cc9SOliver Neukum
241bed5ef23SJohan Hovold if (dev->disconnected) { /* disconnect() was called */
242e7389cc9SOliver Neukum rv = -ENODEV;
243121e287cSAlan Stern goto exit;
244121e287cSAlan Stern }
245121e287cSAlan Stern
246e7389cc9SOliver Neukum /* if IO is under way, we must not touch things */
247e7389cc9SOliver Neukum retry:
248e7389cc9SOliver Neukum spin_lock_irq(&dev->err_lock);
249e7389cc9SOliver Neukum ongoing_io = dev->ongoing_read;
250e7389cc9SOliver Neukum spin_unlock_irq(&dev->err_lock);
2511da177e4SLinus Torvalds
252e7389cc9SOliver Neukum if (ongoing_io) {
2538cd01664SOliver Neukum /* nonblocking IO shall not wait */
2548cd01664SOliver Neukum if (file->f_flags & O_NONBLOCK) {
2558cd01664SOliver Neukum rv = -EAGAIN;
2568cd01664SOliver Neukum goto exit;
2578cd01664SOliver Neukum }
258e7389cc9SOliver Neukum /*
259e7389cc9SOliver Neukum * IO may take forever
260e7389cc9SOliver Neukum * hence wait in an interruptible state
261e7389cc9SOliver Neukum */
262c79041a4SDu Xing rv = wait_event_interruptible(dev->bulk_in_wait, (!dev->ongoing_read));
263e7389cc9SOliver Neukum if (rv < 0)
264e7389cc9SOliver Neukum goto exit;
265e7389cc9SOliver Neukum }
266e7389cc9SOliver Neukum
267e7389cc9SOliver Neukum /* errors must be reported */
2683ae9da1cSGreg Kroah-Hartman rv = dev->errors;
2693ae9da1cSGreg Kroah-Hartman if (rv < 0) {
270e7389cc9SOliver Neukum /* any error is reported once */
271e7389cc9SOliver Neukum dev->errors = 0;
272e7389cc9SOliver Neukum /* to preserve notifications about reset */
273e7389cc9SOliver Neukum rv = (rv == -EPIPE) ? rv : -EIO;
274e7389cc9SOliver Neukum /* report it */
275e7389cc9SOliver Neukum goto exit;
276e7389cc9SOliver Neukum }
277e7389cc9SOliver Neukum
278e7389cc9SOliver Neukum /*
279e7389cc9SOliver Neukum * if the buffer is filled we may satisfy the read
280e7389cc9SOliver Neukum * else we need to start IO
281e7389cc9SOliver Neukum */
282e7389cc9SOliver Neukum
283e7389cc9SOliver Neukum if (dev->bulk_in_filled) {
284e7389cc9SOliver Neukum /* we had read data */
285e7389cc9SOliver Neukum size_t available = dev->bulk_in_filled - dev->bulk_in_copied;
286e7389cc9SOliver Neukum size_t chunk = min(available, count);
287e7389cc9SOliver Neukum
288e7389cc9SOliver Neukum if (!available) {
289e7389cc9SOliver Neukum /*
290e7389cc9SOliver Neukum * all data has been used
291e7389cc9SOliver Neukum * actual IO needs to be done
292e7389cc9SOliver Neukum */
293e7389cc9SOliver Neukum rv = skel_do_read_io(dev, count);
294e7389cc9SOliver Neukum if (rv < 0)
295e7389cc9SOliver Neukum goto exit;
296e7389cc9SOliver Neukum else
297e7389cc9SOliver Neukum goto retry;
298e7389cc9SOliver Neukum }
299e7389cc9SOliver Neukum /*
300e7389cc9SOliver Neukum * data is available
301e7389cc9SOliver Neukum * chunk tells us how much shall be copied
302e7389cc9SOliver Neukum */
303e7389cc9SOliver Neukum
304e7389cc9SOliver Neukum if (copy_to_user(buffer,
305e7389cc9SOliver Neukum dev->bulk_in_buffer + dev->bulk_in_copied,
306e7389cc9SOliver Neukum chunk))
307e7389cc9SOliver Neukum rv = -EFAULT;
308e7389cc9SOliver Neukum else
309e7389cc9SOliver Neukum rv = chunk;
310e7389cc9SOliver Neukum
311e7389cc9SOliver Neukum dev->bulk_in_copied += chunk;
312e7389cc9SOliver Neukum
313e7389cc9SOliver Neukum /*
314e7389cc9SOliver Neukum * if we are asked for more than we have,
315e7389cc9SOliver Neukum * we start IO but don't wait
316e7389cc9SOliver Neukum */
317e7389cc9SOliver Neukum if (available < count)
318e7389cc9SOliver Neukum skel_do_read_io(dev, count - chunk);
319e7389cc9SOliver Neukum } else {
320e7389cc9SOliver Neukum /* no data in the buffer */
321e7389cc9SOliver Neukum rv = skel_do_read_io(dev, count);
322e7389cc9SOliver Neukum if (rv < 0)
323e7389cc9SOliver Neukum goto exit;
324140983c2SChen Wang else
325e7389cc9SOliver Neukum goto retry;
326e7389cc9SOliver Neukum }
327121e287cSAlan Stern exit:
328121e287cSAlan Stern mutex_unlock(&dev->io_mutex);
329e7389cc9SOliver Neukum return rv;
3301da177e4SLinus Torvalds }
3311da177e4SLinus Torvalds
skel_write_bulk_callback(struct urb * urb)3327d12e780SDavid Howells static void skel_write_bulk_callback(struct urb *urb)
3331da177e4SLinus Torvalds {
3341da177e4SLinus Torvalds struct usb_skel *dev;
3358982c844SJohn Ogness unsigned long flags;
3361da177e4SLinus Torvalds
337cdc97792SMing Lei dev = urb->context;
3381da177e4SLinus Torvalds
3391da177e4SLinus Torvalds /* sync/async unlink faults aren't errors */
340403dfb58SOliver Neukum if (urb->status) {
341403dfb58SOliver Neukum if (!(urb->status == -ENOENT ||
3421da177e4SLinus Torvalds urb->status == -ECONNRESET ||
343403dfb58SOliver Neukum urb->status == -ESHUTDOWN))
3444212cd74SGreg Kroah-Hartman dev_err(&dev->interface->dev,
3454212cd74SGreg Kroah-Hartman "%s - nonzero write bulk status received: %d\n",
346441b62c1SHarvey Harrison __func__, urb->status);
347403dfb58SOliver Neukum
3488982c844SJohn Ogness spin_lock_irqsave(&dev->err_lock, flags);
349403dfb58SOliver Neukum dev->errors = urb->status;
3508982c844SJohn Ogness spin_unlock_irqrestore(&dev->err_lock, flags);
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds
3531da177e4SLinus Torvalds /* free up our allocated buffer */
354997ea58eSDaniel Mack usb_free_coherent(urb->dev, urb->transfer_buffer_length,
3551da177e4SLinus Torvalds urb->transfer_buffer, urb->transfer_dma);
356ff906518SOliver Neukum up(&dev->limit_sem);
3571da177e4SLinus Torvalds }
3581da177e4SLinus Torvalds
skel_write(struct file * file,const char * user_buffer,size_t count,loff_t * ppos)3593ae9da1cSGreg Kroah-Hartman static ssize_t skel_write(struct file *file, const char *user_buffer,
3603ae9da1cSGreg Kroah-Hartman size_t count, loff_t *ppos)
3611da177e4SLinus Torvalds {
3621da177e4SLinus Torvalds struct usb_skel *dev;
3631da177e4SLinus Torvalds int retval = 0;
3641da177e4SLinus Torvalds struct urb *urb = NULL;
3651da177e4SLinus Torvalds char *buf = NULL;
366*8c9e880bSPhilipp Hortmann size_t writesize = min_t(size_t, count, MAX_TRANSFER);
3671da177e4SLinus Torvalds
368e53e841dSJoe Perches dev = file->private_data;
3691da177e4SLinus Torvalds
3701da177e4SLinus Torvalds /* verify that we actually have some data to write */
3711da177e4SLinus Torvalds if (count == 0)
3721da177e4SLinus Torvalds goto exit;
3731da177e4SLinus Torvalds
3743ae9da1cSGreg Kroah-Hartman /*
3753ae9da1cSGreg Kroah-Hartman * limit the number of URBs in flight to stop a user from using up all
3763ae9da1cSGreg Kroah-Hartman * RAM
3773ae9da1cSGreg Kroah-Hartman */
3784de84057SJulia Lawall if (!(file->f_flags & O_NONBLOCK)) {
379c8dd7709SSam Bishop if (down_interruptible(&dev->limit_sem)) {
380c8dd7709SSam Bishop retval = -ERESTARTSYS;
381c8dd7709SSam Bishop goto exit;
382c8dd7709SSam Bishop }
38379819986SOliver Neukum } else {
38479819986SOliver Neukum if (down_trylock(&dev->limit_sem)) {
38579819986SOliver Neukum retval = -EAGAIN;
38679819986SOliver Neukum goto exit;
38779819986SOliver Neukum }
38879819986SOliver Neukum }
389ff906518SOliver Neukum
390403dfb58SOliver Neukum spin_lock_irq(&dev->err_lock);
3913ae9da1cSGreg Kroah-Hartman retval = dev->errors;
3923ae9da1cSGreg Kroah-Hartman if (retval < 0) {
393403dfb58SOliver Neukum /* any error is reported once */
394403dfb58SOliver Neukum dev->errors = 0;
395403dfb58SOliver Neukum /* to preserve notifications about reset */
396403dfb58SOliver Neukum retval = (retval == -EPIPE) ? retval : -EIO;
397403dfb58SOliver Neukum }
398403dfb58SOliver Neukum spin_unlock_irq(&dev->err_lock);
399403dfb58SOliver Neukum if (retval < 0)
400403dfb58SOliver Neukum goto error;
401403dfb58SOliver Neukum
4021da177e4SLinus Torvalds /* create a urb, and a buffer for it, and copy the data to the urb */
4031da177e4SLinus Torvalds urb = usb_alloc_urb(0, GFP_KERNEL);
4041da177e4SLinus Torvalds if (!urb) {
4051da177e4SLinus Torvalds retval = -ENOMEM;
4061da177e4SLinus Torvalds goto error;
4071da177e4SLinus Torvalds }
4081da177e4SLinus Torvalds
409997ea58eSDaniel Mack buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,
4103ae9da1cSGreg Kroah-Hartman &urb->transfer_dma);
4111da177e4SLinus Torvalds if (!buf) {
4121da177e4SLinus Torvalds retval = -ENOMEM;
4131da177e4SLinus Torvalds goto error;
4141da177e4SLinus Torvalds }
4151da177e4SLinus Torvalds
416ff906518SOliver Neukum if (copy_from_user(buf, user_buffer, writesize)) {
4171da177e4SLinus Torvalds retval = -EFAULT;
4181da177e4SLinus Torvalds goto error;
4191da177e4SLinus Torvalds }
4201da177e4SLinus Torvalds
421ba35e02bSOliver Neukum /* this lock makes sure we don't submit URBs to gone devices */
422ba35e02bSOliver Neukum mutex_lock(&dev->io_mutex);
423bed5ef23SJohan Hovold if (dev->disconnected) { /* disconnect() was called */
424ba35e02bSOliver Neukum mutex_unlock(&dev->io_mutex);
425ba35e02bSOliver Neukum retval = -ENODEV;
426ba35e02bSOliver Neukum goto error;
427ba35e02bSOliver Neukum }
428ba35e02bSOliver Neukum
4291da177e4SLinus Torvalds /* initialize the urb properly */
4301da177e4SLinus Torvalds usb_fill_bulk_urb(urb, dev->udev,
4311da177e4SLinus Torvalds usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
432ff906518SOliver Neukum buf, writesize, skel_write_bulk_callback, dev);
4331da177e4SLinus Torvalds urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
434403dfb58SOliver Neukum usb_anchor_urb(urb, &dev->submitted);
4351da177e4SLinus Torvalds
4361da177e4SLinus Torvalds /* send the data out the bulk port */
4371da177e4SLinus Torvalds retval = usb_submit_urb(urb, GFP_KERNEL);
438ba35e02bSOliver Neukum mutex_unlock(&dev->io_mutex);
4391da177e4SLinus Torvalds if (retval) {
4404212cd74SGreg Kroah-Hartman dev_err(&dev->interface->dev,
4414212cd74SGreg Kroah-Hartman "%s - failed submitting write urb, error %d\n",
4424212cd74SGreg Kroah-Hartman __func__, retval);
443403dfb58SOliver Neukum goto error_unanchor;
4441da177e4SLinus Torvalds }
4451da177e4SLinus Torvalds
4463ae9da1cSGreg Kroah-Hartman /*
4473ae9da1cSGreg Kroah-Hartman * release our reference to this urb, the USB core will eventually free
4483ae9da1cSGreg Kroah-Hartman * it entirely
4493ae9da1cSGreg Kroah-Hartman */
4501da177e4SLinus Torvalds usb_free_urb(urb);
4511da177e4SLinus Torvalds
452ba35e02bSOliver Neukum
453ff906518SOliver Neukum return writesize;
4541da177e4SLinus Torvalds
455403dfb58SOliver Neukum error_unanchor:
456403dfb58SOliver Neukum usb_unanchor_urb(urb);
4571da177e4SLinus Torvalds error:
458121e287cSAlan Stern if (urb) {
459997ea58eSDaniel Mack usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);
4601da177e4SLinus Torvalds usb_free_urb(urb);
461121e287cSAlan Stern }
462ff906518SOliver Neukum up(&dev->limit_sem);
463121e287cSAlan Stern
464121e287cSAlan Stern exit:
4651da177e4SLinus Torvalds return retval;
4661da177e4SLinus Torvalds }
4671da177e4SLinus Torvalds
468066202ddSLuiz Fernando N. Capitulino static const struct file_operations skel_fops = {
4691da177e4SLinus Torvalds .owner = THIS_MODULE,
4701da177e4SLinus Torvalds .read = skel_read,
4711da177e4SLinus Torvalds .write = skel_write,
4721da177e4SLinus Torvalds .open = skel_open,
4731da177e4SLinus Torvalds .release = skel_release,
474403dfb58SOliver Neukum .flush = skel_flush,
4756038f373SArnd Bergmann .llseek = noop_llseek,
4761da177e4SLinus Torvalds };
4771da177e4SLinus Torvalds
4781da177e4SLinus Torvalds /*
4791da177e4SLinus Torvalds * usb class driver info in order to get a minor number from the usb core,
480595b14cbSGreg Kroah-Hartman * and to have the device registered with the driver core
4811da177e4SLinus Torvalds */
4821da177e4SLinus Torvalds static struct usb_class_driver skel_class = {
483d6e5bcf4SGreg Kroah-Hartman .name = "skel%d",
4841da177e4SLinus Torvalds .fops = &skel_fops,
4851da177e4SLinus Torvalds .minor_base = USB_SKEL_MINOR_BASE,
4861da177e4SLinus Torvalds };
4871da177e4SLinus Torvalds
skel_probe(struct usb_interface * interface,const struct usb_device_id * id)4883ae9da1cSGreg Kroah-Hartman static int skel_probe(struct usb_interface *interface,
4893ae9da1cSGreg Kroah-Hartman const struct usb_device_id *id)
4901da177e4SLinus Torvalds {
491c0704541SLuiz Fernando N. Capitulino struct usb_skel *dev;
492af59f895SJohan Hovold struct usb_endpoint_descriptor *bulk_in, *bulk_out;
493af59f895SJohan Hovold int retval;
4941da177e4SLinus Torvalds
4951da177e4SLinus Torvalds /* allocate memory for our device state and initialize it */
496ff906518SOliver Neukum dev = kzalloc(sizeof(*dev), GFP_KERNEL);
497dc0c32c9SWolfram Sang if (!dev)
498af59f895SJohan Hovold return -ENOMEM;
499af59f895SJohan Hovold
5001da177e4SLinus Torvalds kref_init(&dev->kref);
501ff906518SOliver Neukum sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
502121e287cSAlan Stern mutex_init(&dev->io_mutex);
503403dfb58SOliver Neukum spin_lock_init(&dev->err_lock);
504403dfb58SOliver Neukum init_usb_anchor(&dev->submitted);
505c79041a4SDu Xing init_waitqueue_head(&dev->bulk_in_wait);
5061da177e4SLinus Torvalds
5071da177e4SLinus Torvalds dev->udev = usb_get_dev(interface_to_usbdev(interface));
5085c290a5eSJohan Hovold dev->interface = usb_get_intf(interface);
5091da177e4SLinus Torvalds
5101da177e4SLinus Torvalds /* set up the endpoint information */
5111da177e4SLinus Torvalds /* use only the first bulk-in and bulk-out endpoints */
512af59f895SJohan Hovold retval = usb_find_common_endpoints(interface->cur_altsetting,
513af59f895SJohan Hovold &bulk_in, &bulk_out, NULL, NULL);
514af59f895SJohan Hovold if (retval) {
5154212cd74SGreg Kroah-Hartman dev_err(&interface->dev,
5164212cd74SGreg Kroah-Hartman "Could not find both bulk-in and bulk-out endpoints\n");
5171da177e4SLinus Torvalds goto error;
5181da177e4SLinus Torvalds }
5191da177e4SLinus Torvalds
520af59f895SJohan Hovold dev->bulk_in_size = usb_endpoint_maxp(bulk_in);
521af59f895SJohan Hovold dev->bulk_in_endpointAddr = bulk_in->bEndpointAddress;
522af59f895SJohan Hovold dev->bulk_in_buffer = kmalloc(dev->bulk_in_size, GFP_KERNEL);
523af59f895SJohan Hovold if (!dev->bulk_in_buffer) {
524af59f895SJohan Hovold retval = -ENOMEM;
525af59f895SJohan Hovold goto error;
526af59f895SJohan Hovold }
527af59f895SJohan Hovold dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
528af59f895SJohan Hovold if (!dev->bulk_in_urb) {
529af59f895SJohan Hovold retval = -ENOMEM;
530af59f895SJohan Hovold goto error;
531af59f895SJohan Hovold }
532af59f895SJohan Hovold
533af59f895SJohan Hovold dev->bulk_out_endpointAddr = bulk_out->bEndpointAddress;
534af59f895SJohan Hovold
5351da177e4SLinus Torvalds /* save our data pointer in this interface device */
5361da177e4SLinus Torvalds usb_set_intfdata(interface, dev);
5371da177e4SLinus Torvalds
5381da177e4SLinus Torvalds /* we can register the device now, as it is ready */
5391da177e4SLinus Torvalds retval = usb_register_dev(interface, &skel_class);
5401da177e4SLinus Torvalds if (retval) {
5411da177e4SLinus Torvalds /* something prevented us from registering this driver */
5424212cd74SGreg Kroah-Hartman dev_err(&interface->dev,
5434212cd74SGreg Kroah-Hartman "Not able to get a minor for this device.\n");
5441da177e4SLinus Torvalds usb_set_intfdata(interface, NULL);
5451da177e4SLinus Torvalds goto error;
5461da177e4SLinus Torvalds }
5471da177e4SLinus Torvalds
5481da177e4SLinus Torvalds /* let the user know what node this device is now attached to */
549a5f5ea23SMatt Kraai dev_info(&interface->dev,
550a5f5ea23SMatt Kraai "USB Skeleton device now attached to USBSkel-%d",
551a5f5ea23SMatt Kraai interface->minor);
5521da177e4SLinus Torvalds return 0;
5531da177e4SLinus Torvalds
5541da177e4SLinus Torvalds error:
555ba35e02bSOliver Neukum /* this frees allocated memory */
5561da177e4SLinus Torvalds kref_put(&dev->kref, skel_delete);
557af59f895SJohan Hovold
5581da177e4SLinus Torvalds return retval;
5591da177e4SLinus Torvalds }
5601da177e4SLinus Torvalds
skel_disconnect(struct usb_interface * interface)5611da177e4SLinus Torvalds static void skel_disconnect(struct usb_interface *interface)
5621da177e4SLinus Torvalds {
5631da177e4SLinus Torvalds struct usb_skel *dev;
5641da177e4SLinus Torvalds int minor = interface->minor;
5651da177e4SLinus Torvalds
5661da177e4SLinus Torvalds dev = usb_get_intfdata(interface);
5671da177e4SLinus Torvalds
5681da177e4SLinus Torvalds /* give back our minor */
5691da177e4SLinus Torvalds usb_deregister_dev(interface, &skel_class);
5701da177e4SLinus Torvalds
571121e287cSAlan Stern /* prevent more I/O from starting */
572121e287cSAlan Stern mutex_lock(&dev->io_mutex);
573bed5ef23SJohan Hovold dev->disconnected = 1;
574121e287cSAlan Stern mutex_unlock(&dev->io_mutex);
575121e287cSAlan Stern
57663530018SJohan Hovold usb_kill_urb(dev->bulk_in_urb);
577e73c7247SOliver Neukum usb_kill_anchored_urbs(&dev->submitted);
578e73c7247SOliver Neukum
5791da177e4SLinus Torvalds /* decrement our usage count */
5801da177e4SLinus Torvalds kref_put(&dev->kref, skel_delete);
5811da177e4SLinus Torvalds
582a5f5ea23SMatt Kraai dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor);
5831da177e4SLinus Torvalds }
5841da177e4SLinus Torvalds
skel_draw_down(struct usb_skel * dev)585403dfb58SOliver Neukum static void skel_draw_down(struct usb_skel *dev)
586403dfb58SOliver Neukum {
587403dfb58SOliver Neukum int time;
588403dfb58SOliver Neukum
589403dfb58SOliver Neukum time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
590403dfb58SOliver Neukum if (!time)
591403dfb58SOliver Neukum usb_kill_anchored_urbs(&dev->submitted);
592e7389cc9SOliver Neukum usb_kill_urb(dev->bulk_in_urb);
593403dfb58SOliver Neukum }
594403dfb58SOliver Neukum
skel_suspend(struct usb_interface * intf,pm_message_t message)595758f7e16SOliver Neukum static int skel_suspend(struct usb_interface *intf, pm_message_t message)
596758f7e16SOliver Neukum {
597758f7e16SOliver Neukum struct usb_skel *dev = usb_get_intfdata(intf);
598758f7e16SOliver Neukum
599758f7e16SOliver Neukum if (!dev)
600758f7e16SOliver Neukum return 0;
601758f7e16SOliver Neukum skel_draw_down(dev);
602758f7e16SOliver Neukum return 0;
603758f7e16SOliver Neukum }
604758f7e16SOliver Neukum
skel_resume(struct usb_interface * intf)605758f7e16SOliver Neukum static int skel_resume(struct usb_interface *intf)
606758f7e16SOliver Neukum {
607758f7e16SOliver Neukum return 0;
608758f7e16SOliver Neukum }
609758f7e16SOliver Neukum
skel_pre_reset(struct usb_interface * intf)61087d093e2SOliver Neukum static int skel_pre_reset(struct usb_interface *intf)
61187d093e2SOliver Neukum {
61287d093e2SOliver Neukum struct usb_skel *dev = usb_get_intfdata(intf);
61387d093e2SOliver Neukum
61487d093e2SOliver Neukum mutex_lock(&dev->io_mutex);
61587d093e2SOliver Neukum skel_draw_down(dev);
61687d093e2SOliver Neukum
61787d093e2SOliver Neukum return 0;
61887d093e2SOliver Neukum }
61987d093e2SOliver Neukum
skel_post_reset(struct usb_interface * intf)62087d093e2SOliver Neukum static int skel_post_reset(struct usb_interface *intf)
62187d093e2SOliver Neukum {
62287d093e2SOliver Neukum struct usb_skel *dev = usb_get_intfdata(intf);
62387d093e2SOliver Neukum
62487d093e2SOliver Neukum /* we are sure no URBs are active - no locking needed */
62587d093e2SOliver Neukum dev->errors = -EPIPE;
62687d093e2SOliver Neukum mutex_unlock(&dev->io_mutex);
62787d093e2SOliver Neukum
62887d093e2SOliver Neukum return 0;
62987d093e2SOliver Neukum }
63087d093e2SOliver Neukum
6311da177e4SLinus Torvalds static struct usb_driver skel_driver = {
6321da177e4SLinus Torvalds .name = "skeleton",
6331da177e4SLinus Torvalds .probe = skel_probe,
6341da177e4SLinus Torvalds .disconnect = skel_disconnect,
635758f7e16SOliver Neukum .suspend = skel_suspend,
636758f7e16SOliver Neukum .resume = skel_resume,
63787d093e2SOliver Neukum .pre_reset = skel_pre_reset,
63887d093e2SOliver Neukum .post_reset = skel_post_reset,
6391da177e4SLinus Torvalds .id_table = skel_table,
640ba35e02bSOliver Neukum .supports_autosuspend = 1,
6411da177e4SLinus Torvalds };
6421da177e4SLinus Torvalds
64365db4305SGreg Kroah-Hartman module_usb_driver(skel_driver);
6441da177e4SLinus Torvalds
645e4c48351SMarcus Folkesson MODULE_LICENSE("GPL v2");
646