2 * USB Skeleton driver - 2.0
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 easy to read and use, as no locks are now
16 #include <linux/config.h>
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/module.h>
22 #include <linux/kref.h>
23 #include <asm/uaccess.h>
24 #include <linux/usb.h>
27 /* Define these values to match your devices */
28 #define USB_SKEL_VENDOR_ID 0xfff0
29 #define USB_SKEL_PRODUCT_ID 0xfff0
31 /* table of devices that work with this driver */
32 static struct usb_device_id skel_table
[] = {
33 { USB_DEVICE(USB_SKEL_VENDOR_ID
, USB_SKEL_PRODUCT_ID
) },
34 { } /* Terminating entry */
36 MODULE_DEVICE_TABLE (usb
, skel_table
);
39 /* Get a minor range for your devices from the usb maintainer */
40 #define USB_SKEL_MINOR_BASE 192
42 /* Structure to hold all of our device specific stuff */
44 struct usb_device
* udev
; /* the usb device for this device */
45 struct usb_interface
* interface
; /* the interface for this device */
46 unsigned char * bulk_in_buffer
; /* the buffer to receive data */
47 size_t bulk_in_size
; /* the size of the receive buffer */
48 __u8 bulk_in_endpointAddr
; /* the address of the bulk in endpoint */
49 __u8 bulk_out_endpointAddr
; /* the address of the bulk out endpoint */
52 #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
54 static struct usb_driver skel_driver
;
56 static void skel_delete(struct kref
*kref
)
58 struct usb_skel
*dev
= to_skel_dev(kref
);
60 usb_put_dev(dev
->udev
);
61 kfree (dev
->bulk_in_buffer
);
65 static int skel_open(struct inode
*inode
, struct file
*file
)
68 struct usb_interface
*interface
;
72 subminor
= iminor(inode
);
74 interface
= usb_find_interface(&skel_driver
, subminor
);
76 err ("%s - error, can't find device for minor %d",
77 __FUNCTION__
, subminor
);
82 dev
= usb_get_intfdata(interface
);
88 /* increment our usage count for the device */
91 /* save our object in the file's private structure */
92 file
->private_data
= dev
;
98 static int skel_release(struct inode
*inode
, struct file
*file
)
100 struct usb_skel
*dev
;
102 dev
= (struct usb_skel
*)file
->private_data
;
106 /* decrement the count on our device */
107 kref_put(&dev
->kref
, skel_delete
);
111 static ssize_t
skel_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
113 struct usb_skel
*dev
;
116 dev
= (struct usb_skel
*)file
->private_data
;
118 /* do a blocking bulk read to get data from the device */
119 retval
= usb_bulk_msg(dev
->udev
,
120 usb_rcvbulkpipe(dev
->udev
, dev
->bulk_in_endpointAddr
),
122 min(dev
->bulk_in_size
, count
),
125 /* if the read was successful, copy the data to userspace */
127 if (copy_to_user(buffer
, dev
->bulk_in_buffer
, count
))
136 static void skel_write_bulk_callback(struct urb
*urb
, struct pt_regs
*regs
)
138 struct usb_skel
*dev
;
140 dev
= (struct usb_skel
*)urb
->context
;
142 /* sync/async unlink faults aren't errors */
144 !(urb
->status
== -ENOENT
||
145 urb
->status
== -ECONNRESET
||
146 urb
->status
== -ESHUTDOWN
)) {
147 dbg("%s - nonzero write bulk status received: %d",
148 __FUNCTION__
, urb
->status
);
151 /* free up our allocated buffer */
152 usb_buffer_free(urb
->dev
, urb
->transfer_buffer_length
,
153 urb
->transfer_buffer
, urb
->transfer_dma
);
156 static ssize_t
skel_write(struct file
*file
, const char *user_buffer
, size_t count
, loff_t
*ppos
)
158 struct usb_skel
*dev
;
160 struct urb
*urb
= NULL
;
163 dev
= (struct usb_skel
*)file
->private_data
;
165 /* verify that we actually have some data to write */
169 /* create a urb, and a buffer for it, and copy the data to the urb */
170 urb
= usb_alloc_urb(0, GFP_KERNEL
);
176 buf
= usb_buffer_alloc(dev
->udev
, count
, GFP_KERNEL
, &urb
->transfer_dma
);
182 if (copy_from_user(buf
, user_buffer
, count
)) {
187 /* initialize the urb properly */
188 usb_fill_bulk_urb(urb
, dev
->udev
,
189 usb_sndbulkpipe(dev
->udev
, dev
->bulk_out_endpointAddr
),
190 buf
, count
, skel_write_bulk_callback
, dev
);
191 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
193 /* send the data out the bulk port */
194 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
196 err("%s - failed submitting write urb, error %d", __FUNCTION__
, retval
);
200 /* release our reference to this urb, the USB core will eventually free it entirely */
207 usb_buffer_free(dev
->udev
, count
, buf
, urb
->transfer_dma
);
212 static struct file_operations skel_fops
= {
213 .owner
= THIS_MODULE
,
217 .release
= skel_release
,
221 * usb class driver info in order to get a minor number from the usb core,
222 * and to have the device registered with devfs and the driver core
224 static struct usb_class_driver skel_class
= {
225 .name
= "usb/skel%d",
227 .mode
= S_IFCHR
| S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
,
228 .minor_base
= USB_SKEL_MINOR_BASE
,
231 static int skel_probe(struct usb_interface
*interface
, const struct usb_device_id
*id
)
233 struct usb_skel
*dev
= NULL
;
234 struct usb_host_interface
*iface_desc
;
235 struct usb_endpoint_descriptor
*endpoint
;
238 int retval
= -ENOMEM
;
240 /* allocate memory for our device state and initialize it */
241 dev
= kmalloc(sizeof(*dev
), GFP_KERNEL
);
243 err("Out of memory");
246 memset(dev
, 0x00, sizeof(*dev
));
247 kref_init(&dev
->kref
);
249 dev
->udev
= usb_get_dev(interface_to_usbdev(interface
));
250 dev
->interface
= interface
;
252 /* set up the endpoint information */
253 /* use only the first bulk-in and bulk-out endpoints */
254 iface_desc
= interface
->cur_altsetting
;
255 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
256 endpoint
= &iface_desc
->endpoint
[i
].desc
;
258 if (!dev
->bulk_in_endpointAddr
&&
259 (endpoint
->bEndpointAddress
& USB_DIR_IN
) &&
260 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
261 == USB_ENDPOINT_XFER_BULK
)) {
262 /* we found a bulk in endpoint */
263 buffer_size
= endpoint
->wMaxPacketSize
;
264 dev
->bulk_in_size
= buffer_size
;
265 dev
->bulk_in_endpointAddr
= endpoint
->bEndpointAddress
;
266 dev
->bulk_in_buffer
= kmalloc(buffer_size
, GFP_KERNEL
);
267 if (!dev
->bulk_in_buffer
) {
268 err("Could not allocate bulk_in_buffer");
273 if (!dev
->bulk_out_endpointAddr
&&
274 !(endpoint
->bEndpointAddress
& USB_DIR_IN
) &&
275 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
276 == USB_ENDPOINT_XFER_BULK
)) {
277 /* we found a bulk out endpoint */
278 dev
->bulk_out_endpointAddr
= endpoint
->bEndpointAddress
;
281 if (!(dev
->bulk_in_endpointAddr
&& dev
->bulk_out_endpointAddr
)) {
282 err("Could not find both bulk-in and bulk-out endpoints");
286 /* save our data pointer in this interface device */
287 usb_set_intfdata(interface
, dev
);
289 /* we can register the device now, as it is ready */
290 retval
= usb_register_dev(interface
, &skel_class
);
292 /* something prevented us from registering this driver */
293 err("Not able to get a minor for this device.");
294 usb_set_intfdata(interface
, NULL
);
298 /* let the user know what node this device is now attached to */
299 info("USB Skeleton device now attached to USBSkel-%d", interface
->minor
);
304 kref_put(&dev
->kref
, skel_delete
);
308 static void skel_disconnect(struct usb_interface
*interface
)
310 struct usb_skel
*dev
;
311 int minor
= interface
->minor
;
313 /* prevent skel_open() from racing skel_disconnect() */
316 dev
= usb_get_intfdata(interface
);
317 usb_set_intfdata(interface
, NULL
);
319 /* give back our minor */
320 usb_deregister_dev(interface
, &skel_class
);
324 /* decrement our usage count */
325 kref_put(&dev
->kref
, skel_delete
);
327 info("USB Skeleton #%d now disconnected", minor
);
330 static struct usb_driver skel_driver
= {
331 .owner
= THIS_MODULE
,
334 .disconnect
= skel_disconnect
,
335 .id_table
= skel_table
,
338 static int __init
usb_skel_init(void)
342 /* register this driver with the USB subsystem */
343 result
= usb_register(&skel_driver
);
345 err("usb_register failed. Error number %d", result
);
350 static void __exit
usb_skel_exit(void)
352 /* deregister this driver with the USB subsystem */
353 usb_deregister(&skel_driver
);
356 module_init (usb_skel_init
);
357 module_exit (usb_skel_exit
);
359 MODULE_LICENSE("GPL");