Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/usb/misc/usblcd.c

  1 /*****************************************************************************
  2  *                          USBLCD Kernel Driver                             *
  3  *                            Version 1.05                                   *
  4  *             (C) 2005 Georges Toth <g.toth@e-biz.lu>                       *
  5  *                                                                           *
  6  *     This file is licensed under the GPL. See COPYING in the package.      *
  7  * Based on usb-skeleton.c 2.0 by Greg Kroah-Hartman (greg@kroah.com)        *
  8  *                                                                           *
  9  *                                                                           *
 10  * 28.02.05 Complete rewrite of the original usblcd.c driver,                *
 11  *          based on usb_skeleton.c.                                         *
 12  *          This new driver allows more than one USB-LCD to be connected     *
 13  *          and controlled, at once                                          *
 14  *****************************************************************************/
 15 #include <linux/module.h>
 16 #include <linux/kernel.h>
 17 #include <linux/slab.h>
 18 #include <linux/errno.h>
 19 #include <linux/mutex.h>
 20 #include <linux/uaccess.h>
 21 #include <linux/usb.h>
 22 
 23 #define DRIVER_VERSION "USBLCD Driver Version 1.05"
 24 
 25 #define USBLCD_MINOR            144
 26 
 27 #define IOCTL_GET_HARD_VERSION  1
 28 #define IOCTL_GET_DRV_VERSION   2
 29 
 30 
 31 static DEFINE_MUTEX(lcd_mutex);
 32 static const struct usb_device_id id_table[] = {
 33         { .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },
 34         { },
 35 };
 36 MODULE_DEVICE_TABLE(usb, id_table);
 37 
 38 static DEFINE_MUTEX(open_disc_mutex);
 39 
 40 
 41 struct usb_lcd {
 42         struct usb_device       *udev;                  /* init: probe_lcd */
 43         struct usb_interface    *interface;             /* the interface for
 44                                                            this device */
 45         unsigned char           *bulk_in_buffer;        /* the buffer to receive
 46                                                            data */
 47         size_t                  bulk_in_size;           /* the size of the
 48                                                            receive buffer */
 49         __u8                    bulk_in_endpointAddr;   /* the address of the
 50                                                            bulk in endpoint */
 51         __u8                    bulk_out_endpointAddr;  /* the address of the
 52                                                            bulk out endpoint */
 53         struct kref             kref;
 54         struct semaphore        limit_sem;              /* to stop writes at
 55                                                            full throttle from
 56                                                            using up all RAM */
 57         struct usb_anchor       submitted;              /* URBs to wait for
 58                                                            before suspend */
 59 };
 60 #define to_lcd_dev(d) container_of(d, struct usb_lcd, kref)
 61 
 62 #define USB_LCD_CONCURRENT_WRITES       5
 63 
 64 static struct usb_driver lcd_driver;
 65 
 66 
 67 static void lcd_delete(struct kref *kref)
 68 {
 69         struct usb_lcd *dev = to_lcd_dev(kref);
 70 
 71         usb_put_dev(dev->udev);
 72         kfree(dev->bulk_in_buffer);
 73         kfree(dev);
 74 }
 75 
 76 
 77 static int lcd_open(struct inode *inode, struct file *file)
 78 {
 79         struct usb_lcd *dev;
 80         struct usb_interface *interface;
 81         int subminor, r;
 82 
 83         mutex_lock(&lcd_mutex);
 84         subminor = iminor(inode);
 85 
 86         interface = usb_find_interface(&lcd_driver, subminor);
 87         if (!interface) {
 88                 mutex_unlock(&lcd_mutex);
 89                 printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d\n",
 90                        __func__, subminor);
 91                 return -ENODEV;
 92         }
 93 
 94         mutex_lock(&open_disc_mutex);
 95         dev = usb_get_intfdata(interface);
 96         if (!dev) {
 97                 mutex_unlock(&open_disc_mutex);
 98                 mutex_unlock(&lcd_mutex);
 99                 return -ENODEV;
100         }
101 
102         /* increment our usage count for the device */
103         kref_get(&dev->kref);
104         mutex_unlock(&open_disc_mutex);
105 
106         /* grab a power reference */
107         r = usb_autopm_get_interface(interface);
108         if (r < 0) {
109                 kref_put(&dev->kref, lcd_delete);
110                 mutex_unlock(&lcd_mutex);
111                 return r;
112         }
113 
114         /* save our object in the file's private structure */
115         file->private_data = dev;
116         mutex_unlock(&lcd_mutex);
117 
118         return 0;
119 }
120 
121 static int lcd_release(struct inode *inode, struct file *file)
122 {
123         struct usb_lcd *dev;
124 
125         dev = file->private_data;
126         if (dev == NULL)
127                 return -ENODEV;
128 
129         /* decrement the count on our device */
130         usb_autopm_put_interface(dev->interface);
131         kref_put(&dev->kref, lcd_delete);
132         return 0;
133 }
134 
135 static ssize_t lcd_read(struct file *file, char __user * buffer,
136                         size_t count, loff_t *ppos)
137 {
138         struct usb_lcd *dev;
139         int retval = 0;
140         int bytes_read;
141 
142         dev = file->private_data;
143 
144         /* do a blocking bulk read to get data from the device */
145         retval = usb_bulk_msg(dev->udev,
146                               usb_rcvbulkpipe(dev->udev,
147                                               dev->bulk_in_endpointAddr),
148                               dev->bulk_in_buffer,
149                               min(dev->bulk_in_size, count),
150                               &bytes_read, 10000);
151 
152         /* if the read was successful, copy the data to userspace */
153         if (!retval) {
154                 if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read))
155                         retval = -EFAULT;
156                 else
157                         retval = bytes_read;
158         }
159 
160         return retval;
161 }
162 
163 static long lcd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
164 {
165         struct usb_lcd *dev;
166         u16 bcdDevice;
167         char buf[30];
168 
169         dev = file->private_data;
170         if (dev == NULL)
171                 return -ENODEV;
172 
173         switch (cmd) {
174         case IOCTL_GET_HARD_VERSION:
175                 mutex_lock(&lcd_mutex);
176                 bcdDevice = le16_to_cpu((dev->udev)->descriptor.bcdDevice);
177                 sprintf(buf, "%1d%1d.%1d%1d",
178                         (bcdDevice & 0xF000)>>12,
179                         (bcdDevice & 0xF00)>>8,
180                         (bcdDevice & 0xF0)>>4,
181                         (bcdDevice & 0xF));
182                 mutex_unlock(&lcd_mutex);
183                 if (copy_to_user((void __user *)arg, buf, strlen(buf)) != 0)
184                         return -EFAULT;
185                 break;
186         case IOCTL_GET_DRV_VERSION:
187                 sprintf(buf, DRIVER_VERSION);
188                 if (copy_to_user((void __user *)arg, buf, strlen(buf)) != 0)
189                         return -EFAULT;
190                 break;
191         default:
192                 return -ENOTTY;
193                 break;
194         }
195 
196         return 0;
197 }
198 
199 static void lcd_write_bulk_callback(struct urb *urb)
200 {
201         struct usb_lcd *dev;
202         int status = urb->status;
203 
204         dev = urb->context;
205 
206         /* sync/async unlink faults aren't errors */
207         if (status &&
208             !(status == -ENOENT ||
209               status == -ECONNRESET ||
210               status == -ESHUTDOWN)) {
211                 dev_dbg(&dev->interface->dev,
212                         "nonzero write bulk status received: %d\n", status);
213         }
214 
215         /* free up our allocated buffer */
216         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
217                           urb->transfer_buffer, urb->transfer_dma);
218         up(&dev->limit_sem);
219 }
220 
221 static ssize_t lcd_write(struct file *file, const char __user * user_buffer,
222                          size_t count, loff_t *ppos)
223 {
224         struct usb_lcd *dev;
225         int retval = 0, r;
226         struct urb *urb = NULL;
227         char *buf = NULL;
228 
229         dev = file->private_data;
230 
231         /* verify that we actually have some data to write */
232         if (count == 0)
233                 goto exit;
234 
235         r = down_interruptible(&dev->limit_sem);
236         if (r < 0)
237                 return -EINTR;
238 
239         /* create a urb, and a buffer for it, and copy the data to the urb */
240         urb = usb_alloc_urb(0, GFP_KERNEL);
241         if (!urb) {
242                 retval = -ENOMEM;
243                 goto err_no_buf;
244         }
245 
246         buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL,
247                                  &urb->transfer_dma);
248         if (!buf) {
249                 retval = -ENOMEM;
250                 goto error;
251         }
252 
253         if (copy_from_user(buf, user_buffer, count)) {
254                 retval = -EFAULT;
255                 goto error;
256         }
257 
258         /* initialize the urb properly */
259         usb_fill_bulk_urb(urb, dev->udev,
260                           usb_sndbulkpipe(dev->udev,
261                           dev->bulk_out_endpointAddr),
262                           buf, count, lcd_write_bulk_callback, dev);
263         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
264 
265         usb_anchor_urb(urb, &dev->submitted);
266 
267         /* send the data out the bulk port */
268         retval = usb_submit_urb(urb, GFP_KERNEL);
269         if (retval) {
270                 dev_err(&dev->udev->dev,
271                         "%s - failed submitting write urb, error %d\n",
272                         __func__, retval);
273                 goto error_unanchor;
274         }
275 
276         /* release our reference to this urb,
277            the USB core will eventually free it entirely */
278         usb_free_urb(urb);
279 
280 exit:
281         return count;
282 error_unanchor:
283         usb_unanchor_urb(urb);
284 error:
285         usb_free_coherent(dev->udev, count, buf, urb->transfer_dma);
286         usb_free_urb(urb);
287 err_no_buf:
288         up(&dev->limit_sem);
289         return retval;
290 }
291 
292 static const struct file_operations lcd_fops = {
293         .owner =        THIS_MODULE,
294         .read =         lcd_read,
295         .write =        lcd_write,
296         .open =         lcd_open,
297         .unlocked_ioctl = lcd_ioctl,
298         .release =      lcd_release,
299         .llseek =        noop_llseek,
300 };
301 
302 /*
303  * usb class driver info in order to get a minor number from the usb core,
304  * and to have the device registered with the driver core
305  */
306 static struct usb_class_driver lcd_class = {
307         .name =         "lcd%d",
308         .fops =         &lcd_fops,
309         .minor_base =   USBLCD_MINOR,
310 };
311 
312 static int lcd_probe(struct usb_interface *interface,
313                      const struct usb_device_id *id)
314 {
315         struct usb_lcd *dev = NULL;
316         struct usb_host_interface *iface_desc;
317         struct usb_endpoint_descriptor *endpoint;
318         size_t buffer_size;
319         int i;
320         int retval = -ENOMEM;
321 
322         /* allocate memory for our device state and initialize it */
323         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
324         if (dev == NULL) {
325                 dev_err(&interface->dev, "Out of memory\n");
326                 goto error;
327         }
328         kref_init(&dev->kref);
329         sema_init(&dev->limit_sem, USB_LCD_CONCURRENT_WRITES);
330         init_usb_anchor(&dev->submitted);
331 
332         dev->udev = usb_get_dev(interface_to_usbdev(interface));
333         dev->interface = interface;
334 
335         if (le16_to_cpu(dev->udev->descriptor.idProduct) != 0x0001) {
336                 dev_warn(&interface->dev, "USBLCD model not supported.\n");
337                 retval = -ENODEV;
338                 goto error;
339         }
340 
341         /* set up the endpoint information */
342         /* use only the first bulk-in and bulk-out endpoints */
343         iface_desc = interface->cur_altsetting;
344         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
345                 endpoint = &iface_desc->endpoint[i].desc;
346 
347                 if (!dev->bulk_in_endpointAddr &&
348                     usb_endpoint_is_bulk_in(endpoint)) {
349                         /* we found a bulk in endpoint */
350                         buffer_size = usb_endpoint_maxp(endpoint);
351                         dev->bulk_in_size = buffer_size;
352                         dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
353                         dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
354                         if (!dev->bulk_in_buffer) {
355                                 dev_err(&interface->dev,
356                                         "Could not allocate bulk_in_buffer\n");
357                                 goto error;
358                         }
359                 }
360 
361                 if (!dev->bulk_out_endpointAddr &&
362                     usb_endpoint_is_bulk_out(endpoint)) {
363                         /* we found a bulk out endpoint */
364                         dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
365                 }
366         }
367         if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
368                 dev_err(&interface->dev,
369                         "Could not find both bulk-in and bulk-out endpoints\n");
370                 goto error;
371         }
372 
373         /* save our data pointer in this interface device */
374         usb_set_intfdata(interface, dev);
375 
376         /* we can register the device now, as it is ready */
377         retval = usb_register_dev(interface, &lcd_class);
378         if (retval) {
379                 /* something prevented us from registering this driver */
380                 dev_err(&interface->dev,
381                         "Not able to get a minor for this device.\n");
382                 usb_set_intfdata(interface, NULL);
383                 goto error;
384         }
385 
386         i = le16_to_cpu(dev->udev->descriptor.bcdDevice);
387 
388         dev_info(&interface->dev, "USBLCD Version %1d%1d.%1d%1d found "
389                  "at address %d\n", (i & 0xF000)>>12, (i & 0xF00)>>8,
390                  (i & 0xF0)>>4, (i & 0xF), dev->udev->devnum);
391 
392         /* let the user know what node this device is now attached to */
393         dev_info(&interface->dev, "USB LCD device now attached to USBLCD-%d\n",
394                  interface->minor);
395         return 0;
396 
397 error:
398         if (dev)
399                 kref_put(&dev->kref, lcd_delete);
400         return retval;
401 }
402 
403 static void lcd_draw_down(struct usb_lcd *dev)
404 {
405         int time;
406 
407         time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
408         if (!time)
409                 usb_kill_anchored_urbs(&dev->submitted);
410 }
411 
412 static int lcd_suspend(struct usb_interface *intf, pm_message_t message)
413 {
414         struct usb_lcd *dev = usb_get_intfdata(intf);
415 
416         if (!dev)
417                 return 0;
418         lcd_draw_down(dev);
419         return 0;
420 }
421 
422 static int lcd_resume(struct usb_interface *intf)
423 {
424         return 0;
425 }
426 
427 static void lcd_disconnect(struct usb_interface *interface)
428 {
429         struct usb_lcd *dev;
430         int minor = interface->minor;
431 
432         mutex_lock(&open_disc_mutex);
433         dev = usb_get_intfdata(interface);
434         usb_set_intfdata(interface, NULL);
435         mutex_unlock(&open_disc_mutex);
436 
437         /* give back our minor */
438         usb_deregister_dev(interface, &lcd_class);
439 
440         /* decrement our usage count */
441         kref_put(&dev->kref, lcd_delete);
442 
443         dev_info(&interface->dev, "USB LCD #%d now disconnected\n", minor);
444 }
445 
446 static struct usb_driver lcd_driver = {
447         .name =         "usblcd",
448         .probe =        lcd_probe,
449         .disconnect =   lcd_disconnect,
450         .suspend =      lcd_suspend,
451         .resume =       lcd_resume,
452         .id_table =     id_table,
453         .supports_autosuspend = 1,
454 };
455 
456 module_usb_driver(lcd_driver);
457 
458 MODULE_AUTHOR("Georges Toth <g.toth@e-biz.lu>");
459 MODULE_DESCRIPTION(DRIVER_VERSION);
460 MODULE_LICENSE("GPL");
461 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us