Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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)
325                 goto error;
326         kref_init(&dev->kref);
327         sema_init(&dev->limit_sem, USB_LCD_CONCURRENT_WRITES);
328         init_usb_anchor(&dev->submitted);
329 
330         dev->udev = usb_get_dev(interface_to_usbdev(interface));
331         dev->interface = interface;
332 
333         if (le16_to_cpu(dev->udev->descriptor.idProduct) != 0x0001) {
334                 dev_warn(&interface->dev, "USBLCD model not supported.\n");
335                 retval = -ENODEV;
336                 goto error;
337         }
338 
339         /* set up the endpoint information */
340         /* use only the first bulk-in and bulk-out endpoints */
341         iface_desc = interface->cur_altsetting;
342         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
343                 endpoint = &iface_desc->endpoint[i].desc;
344 
345                 if (!dev->bulk_in_endpointAddr &&
346                     usb_endpoint_is_bulk_in(endpoint)) {
347                         /* we found a bulk in endpoint */
348                         buffer_size = usb_endpoint_maxp(endpoint);
349                         dev->bulk_in_size = buffer_size;
350                         dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
351                         dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
352                         if (!dev->bulk_in_buffer)
353                                 goto error;
354                 }
355 
356                 if (!dev->bulk_out_endpointAddr &&
357                     usb_endpoint_is_bulk_out(endpoint)) {
358                         /* we found a bulk out endpoint */
359                         dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
360                 }
361         }
362         if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
363                 dev_err(&interface->dev,
364                         "Could not find both bulk-in and bulk-out endpoints\n");
365                 goto error;
366         }
367 
368         /* save our data pointer in this interface device */
369         usb_set_intfdata(interface, dev);
370 
371         /* we can register the device now, as it is ready */
372         retval = usb_register_dev(interface, &lcd_class);
373         if (retval) {
374                 /* something prevented us from registering this driver */
375                 dev_err(&interface->dev,
376                         "Not able to get a minor for this device.\n");
377                 usb_set_intfdata(interface, NULL);
378                 goto error;
379         }
380 
381         i = le16_to_cpu(dev->udev->descriptor.bcdDevice);
382 
383         dev_info(&interface->dev, "USBLCD Version %1d%1d.%1d%1d found "
384                  "at address %d\n", (i & 0xF000)>>12, (i & 0xF00)>>8,
385                  (i & 0xF0)>>4, (i & 0xF), dev->udev->devnum);
386 
387         /* let the user know what node this device is now attached to */
388         dev_info(&interface->dev, "USB LCD device now attached to USBLCD-%d\n",
389                  interface->minor);
390         return 0;
391 
392 error:
393         if (dev)
394                 kref_put(&dev->kref, lcd_delete);
395         return retval;
396 }
397 
398 static void lcd_draw_down(struct usb_lcd *dev)
399 {
400         int time;
401 
402         time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
403         if (!time)
404                 usb_kill_anchored_urbs(&dev->submitted);
405 }
406 
407 static int lcd_suspend(struct usb_interface *intf, pm_message_t message)
408 {
409         struct usb_lcd *dev = usb_get_intfdata(intf);
410 
411         if (!dev)
412                 return 0;
413         lcd_draw_down(dev);
414         return 0;
415 }
416 
417 static int lcd_resume(struct usb_interface *intf)
418 {
419         return 0;
420 }
421 
422 static void lcd_disconnect(struct usb_interface *interface)
423 {
424         struct usb_lcd *dev;
425         int minor = interface->minor;
426 
427         mutex_lock(&open_disc_mutex);
428         dev = usb_get_intfdata(interface);
429         usb_set_intfdata(interface, NULL);
430         mutex_unlock(&open_disc_mutex);
431 
432         /* give back our minor */
433         usb_deregister_dev(interface, &lcd_class);
434 
435         /* decrement our usage count */
436         kref_put(&dev->kref, lcd_delete);
437 
438         dev_info(&interface->dev, "USB LCD #%d now disconnected\n", minor);
439 }
440 
441 static struct usb_driver lcd_driver = {
442         .name =         "usblcd",
443         .probe =        lcd_probe,
444         .disconnect =   lcd_disconnect,
445         .suspend =      lcd_suspend,
446         .resume =       lcd_resume,
447         .id_table =     id_table,
448         .supports_autosuspend = 1,
449 };
450 
451 module_usb_driver(lcd_driver);
452 
453 MODULE_AUTHOR("Georges Toth <g.toth@e-biz.lu>");
454 MODULE_DESCRIPTION(DRIVER_VERSION);
455 MODULE_LICENSE("GPL");
456 

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