LXR linux/drivers/usb/misc/usblcd.c

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