2 * USB Skeleton driver - 2.1
4 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, version 2.
10 * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
11 * but has been rewritten to be easier to read and use.
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/module.h>
20 #include <linux/kref.h>
21 #include <asm/uaccess.h>
22 #include <linux/usb.h>
23 #include <linux/mutex.h>
26 /* Define these values to match your devices */
27 #define USB_SKEL_VENDOR_ID 0xfff0
28 #define USB_SKEL_PRODUCT_ID 0xfff0
30 /* table of devices that work with this driver */
31 static struct usb_device_id skel_table
[] = {
32 { USB_DEVICE(USB_SKEL_VENDOR_ID
, USB_SKEL_PRODUCT_ID
) },
33 { } /* Terminating entry */
35 MODULE_DEVICE_TABLE (usb
, skel_table
);
38 /* Get a minor range for your devices from the usb maintainer */
39 #define USB_SKEL_MINOR_BASE 192
41 /* our private defines. if this grows any larger, use your own .h file */
42 #define MAX_TRANSFER ( PAGE_SIZE - 512 )
43 #define WRITES_IN_FLIGHT 8
45 /* Structure to hold all of our device specific stuff */
47 struct usb_device
* udev
; /* the usb device for this device */
48 struct usb_interface
* interface
; /* the interface for this device */
49 struct semaphore limit_sem
; /* limiting the number of writes in progress */
50 unsigned char * bulk_in_buffer
; /* the buffer to receive data */
51 size_t bulk_in_size
; /* the size of the receive buffer */
52 __u8 bulk_in_endpointAddr
; /* the address of the bulk in endpoint */
53 __u8 bulk_out_endpointAddr
; /* the address of the bulk out endpoint */
55 struct mutex io_mutex
; /* synchronize I/O with disconnect */
57 #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
59 static struct usb_driver skel_driver
;
61 static void skel_delete(struct kref
*kref
)
63 struct usb_skel
*dev
= to_skel_dev(kref
);
65 usb_put_dev(dev
->udev
);
66 kfree (dev
->bulk_in_buffer
);
70 static int skel_open(struct inode
*inode
, struct file
*file
)
73 struct usb_interface
*interface
;
77 subminor
= iminor(inode
);
79 interface
= usb_find_interface(&skel_driver
, subminor
);
81 err ("%s - error, can't find device for minor %d",
82 __FUNCTION__
, subminor
);
87 dev
= usb_get_intfdata(interface
);
93 /* increment our usage count for the device */
96 /* save our object in the file's private structure */
97 file
->private_data
= dev
;
103 static int skel_release(struct inode
*inode
, struct file
*file
)
105 struct usb_skel
*dev
;
107 dev
= (struct usb_skel
*)file
->private_data
;
111 /* decrement the count on our device */
112 kref_put(&dev
->kref
, skel_delete
);
116 static ssize_t
skel_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
118 struct usb_skel
*dev
;
122 dev
= (struct usb_skel
*)file
->private_data
;
124 mutex_lock(&dev
->io_mutex
);
125 if (!dev
->interface
) { /* disconnect() was called */
130 /* do a blocking bulk read to get data from the device */
131 retval
= usb_bulk_msg(dev
->udev
,
132 usb_rcvbulkpipe(dev
->udev
, dev
->bulk_in_endpointAddr
),
134 min(dev
->bulk_in_size
, count
),
137 /* if the read was successful, copy the data to userspace */
139 if (copy_to_user(buffer
, dev
->bulk_in_buffer
, bytes_read
))
146 mutex_unlock(&dev
->io_mutex
);
150 static void skel_write_bulk_callback(struct urb
*urb
, struct pt_regs
*regs
)
152 struct usb_skel
*dev
;
154 dev
= (struct usb_skel
*)urb
->context
;
156 /* sync/async unlink faults aren't errors */
158 !(urb
->status
== -ENOENT
||
159 urb
->status
== -ECONNRESET
||
160 urb
->status
== -ESHUTDOWN
)) {
161 dbg("%s - nonzero write bulk status received: %d",
162 __FUNCTION__
, urb
->status
);
165 /* free up our allocated buffer */
166 usb_buffer_free(urb
->dev
, urb
->transfer_buffer_length
,
167 urb
->transfer_buffer
, urb
->transfer_dma
);
171 static ssize_t
skel_write(struct file
*file
, const char *user_buffer
, size_t count
, loff_t
*ppos
)
173 struct usb_skel
*dev
;
175 struct urb
*urb
= NULL
;
177 size_t writesize
= min(count
, (size_t)MAX_TRANSFER
);
179 dev
= (struct usb_skel
*)file
->private_data
;
181 /* verify that we actually have some data to write */
185 /* limit the number of URBs in flight to stop a user from using up all RAM */
186 if (down_interruptible(&dev
->limit_sem
)) {
187 retval
= -ERESTARTSYS
;
191 mutex_lock(&dev
->io_mutex
);
192 if (!dev
->interface
) { /* disconnect() was called */
197 /* create a urb, and a buffer for it, and copy the data to the urb */
198 urb
= usb_alloc_urb(0, GFP_KERNEL
);
204 buf
= usb_buffer_alloc(dev
->udev
, writesize
, GFP_KERNEL
, &urb
->transfer_dma
);
210 if (copy_from_user(buf
, user_buffer
, writesize
)) {
215 /* initialize the urb properly */
216 usb_fill_bulk_urb(urb
, dev
->udev
,
217 usb_sndbulkpipe(dev
->udev
, dev
->bulk_out_endpointAddr
),
218 buf
, writesize
, skel_write_bulk_callback
, dev
);
219 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
221 /* send the data out the bulk port */
222 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
224 err("%s - failed submitting write urb, error %d", __FUNCTION__
, retval
);
228 /* release our reference to this urb, the USB core will eventually free it entirely */
231 mutex_unlock(&dev
->io_mutex
);
236 usb_buffer_free(dev
->udev
, writesize
, buf
, urb
->transfer_dma
);
239 mutex_unlock(&dev
->io_mutex
);
246 static struct file_operations skel_fops
= {
247 .owner
= THIS_MODULE
,
251 .release
= skel_release
,
255 * usb class driver info in order to get a minor number from the usb core,
256 * and to have the device registered with the driver core
258 static struct usb_class_driver skel_class
= {
261 .minor_base
= USB_SKEL_MINOR_BASE
,
264 static int skel_probe(struct usb_interface
*interface
, const struct usb_device_id
*id
)
266 struct usb_skel
*dev
= NULL
;
267 struct usb_host_interface
*iface_desc
;
268 struct usb_endpoint_descriptor
*endpoint
;
271 int retval
= -ENOMEM
;
273 /* allocate memory for our device state and initialize it */
274 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
276 err("Out of memory");
279 kref_init(&dev
->kref
);
280 sema_init(&dev
->limit_sem
, WRITES_IN_FLIGHT
);
281 mutex_init(&dev
->io_mutex
);
283 dev
->udev
= usb_get_dev(interface_to_usbdev(interface
));
284 dev
->interface
= interface
;
286 /* set up the endpoint information */
287 /* use only the first bulk-in and bulk-out endpoints */
288 iface_desc
= interface
->cur_altsetting
;
289 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
290 endpoint
= &iface_desc
->endpoint
[i
].desc
;
292 if (!dev
->bulk_in_endpointAddr
&&
293 ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
295 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
296 == USB_ENDPOINT_XFER_BULK
)) {
297 /* we found a bulk in endpoint */
298 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
299 dev
->bulk_in_size
= buffer_size
;
300 dev
->bulk_in_endpointAddr
= endpoint
->bEndpointAddress
;
301 dev
->bulk_in_buffer
= kmalloc(buffer_size
, GFP_KERNEL
);
302 if (!dev
->bulk_in_buffer
) {
303 err("Could not allocate bulk_in_buffer");
308 if (!dev
->bulk_out_endpointAddr
&&
309 ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
311 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
312 == USB_ENDPOINT_XFER_BULK
)) {
313 /* we found a bulk out endpoint */
314 dev
->bulk_out_endpointAddr
= endpoint
->bEndpointAddress
;
317 if (!(dev
->bulk_in_endpointAddr
&& dev
->bulk_out_endpointAddr
)) {
318 err("Could not find both bulk-in and bulk-out endpoints");
322 /* save our data pointer in this interface device */
323 usb_set_intfdata(interface
, dev
);
325 /* we can register the device now, as it is ready */
326 retval
= usb_register_dev(interface
, &skel_class
);
328 /* something prevented us from registering this driver */
329 err("Not able to get a minor for this device.");
330 usb_set_intfdata(interface
, NULL
);
334 /* let the user know what node this device is now attached to */
335 info("USB Skeleton device now attached to USBSkel-%d", interface
->minor
);
340 kref_put(&dev
->kref
, skel_delete
);
344 static void skel_disconnect(struct usb_interface
*interface
)
346 struct usb_skel
*dev
;
347 int minor
= interface
->minor
;
349 /* prevent skel_open() from racing skel_disconnect() */
352 dev
= usb_get_intfdata(interface
);
353 usb_set_intfdata(interface
, NULL
);
355 /* give back our minor */
356 usb_deregister_dev(interface
, &skel_class
);
358 /* prevent more I/O from starting */
359 mutex_lock(&dev
->io_mutex
);
360 dev
->interface
= NULL
;
361 mutex_unlock(&dev
->io_mutex
);
365 /* decrement our usage count */
366 kref_put(&dev
->kref
, skel_delete
);
368 info("USB Skeleton #%d now disconnected", minor
);
371 static struct usb_driver skel_driver
= {
374 .disconnect
= skel_disconnect
,
375 .id_table
= skel_table
,
378 static int __init
usb_skel_init(void)
382 /* register this driver with the USB subsystem */
383 result
= usb_register(&skel_driver
);
385 err("usb_register failed. Error number %d", result
);
390 static void __exit
usb_skel_exit(void)
392 /* deregister this driver with the USB subsystem */
393 usb_deregister(&skel_driver
);
396 module_init (usb_skel_init
);
397 module_exit (usb_skel_exit
);
399 MODULE_LICENSE("GPL");