git.oblomov.eu Git - linux-2.6/blob - drivers/usb/misc/vstusb.c

   1 /*****************************************************************************
   2  *  File: drivers/usb/misc/vstusb.c
   3  *
   4  *  Purpose: Support for the bulk USB Vernier Spectrophotometers
   5  *
   6  *  Author:     Johnnie Peters
   7  *              Axian Consulting
   8  *              Beaverton, OR, USA 97005
   9  *
  10  *  Modified by:     EQware Engineering, Inc.
  11  *                   Oregon City, OR, USA 97045
  12  *
  13  *  Copyright:  2007, 2008
  14  *              Vernier Software & Technology
  15  *              Beaverton, OR, USA 97005
  16  *
  17  *  Web:        www.vernier.com
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License version 2 as
  21  *  published by the Free Software Foundation.
  22  *
  23  *****************************************************************************/
  24 #include <linux/kernel.h>
  25 #include <linux/errno.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/module.h>
  29 #include <linux/mutex.h>
  30 #include <linux/uaccess.h>
  31 #include <linux/usb.h>
  32
  33 #include <linux/usb/vstusb.h>
  34
  35 #define DRIVER_VERSION "VST USB Driver Version 1.5"
  36 #define DRIVER_DESC "Vernier Software Technology Bulk USB Driver"
  37
  38 #ifdef CONFIG_USB_DYNAMIC_MINORS
  39         #define VSTUSB_MINOR_BASE       0
  40 #else
  41         #define VSTUSB_MINOR_BASE       199
  42 #endif
  43
  44 #define USB_VENDOR_OCEANOPTICS  0x2457
  45 #define USB_VENDOR_VERNIER      0x08F7  /* Vernier Software & Technology */
  46
  47 #define USB_PRODUCT_USB2000     0x1002
  48 #define USB_PRODUCT_ADC1000_FW  0x1003  /* firmware download (renumerates) */
  49 #define USB_PRODUCT_ADC1000     0x1004
  50 #define USB_PRODUCT_HR2000_FW   0x1009  /* firmware download (renumerates) */
  51 #define USB_PRODUCT_HR2000      0x100A
  52 #define USB_PRODUCT_HR4000_FW   0x1011  /* firmware download (renumerates) */
  53 #define USB_PRODUCT_HR4000      0x1012
  54 #define USB_PRODUCT_USB650      0x1014  /* "Red Tide" */
  55 #define USB_PRODUCT_QE65000     0x1018
  56 #define USB_PRODUCT_USB4000     0x1022
  57 #define USB_PRODUCT_USB325      0x1024  /* "Vernier Spectrometer" */
  58
  59 #define USB_PRODUCT_LABPRO      0x0001
  60 #define USB_PRODUCT_LABQUEST    0x0005
  61
  62 #define VST_MAXBUFFER           (64*1024)
  63
  64 static struct usb_device_id id_table[] = {
  65         { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB2000)},
  66         { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_HR4000)},
  67         { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB650)},
  68         { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB4000)},
  69         { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB325)},
  70         { USB_DEVICE(USB_VENDOR_VERNIER, USB_PRODUCT_LABQUEST)},
  71         { USB_DEVICE(USB_VENDOR_VERNIER, USB_PRODUCT_LABPRO)},
  72         {},
  73 };
  74
  75 MODULE_DEVICE_TABLE(usb, id_table);
  76
  77 struct vstusb_device {
  78         struct kref                             kref;
  79         struct mutex            lock;
  80         struct usb_device       *usb_dev;
  81         char                    present;
  82         char                    isopen;
  83         struct usb_anchor       submitted;
  84         int                     rd_pipe;
  85         int                     rd_timeout_ms;
  86         int                     wr_pipe;
  87         int                     wr_timeout_ms;
  88 };
  89 #define to_vst_dev(d) container_of(d, struct vstusb_device, kref)
  90
  91 static struct usb_driver vstusb_driver;
  92
  93 static void vstusb_delete(struct kref *kref)
  94 {
  95         struct vstusb_device *vstdev = to_vst_dev(kref);
  96
  97         usb_put_dev(vstdev->usb_dev);
  98         kfree(vstdev);
  99 }
 100
 101 static int vstusb_open(struct inode *inode, struct file *file)
 102 {
 103         struct vstusb_device *vstdev;
 104         struct usb_interface *interface;
 105
 106         interface = usb_find_interface(&vstusb_driver, iminor(inode));
 107
 108         if (!interface) {
 109                 printk(KERN_ERR KBUILD_MODNAME
 110                        ": %s - error, can't find device for minor %d\n",
 111                        __func__, iminor(inode));
 112                 return -ENODEV;
 113         }
 114
 115         vstdev = usb_get_intfdata(interface);
 116
 117         if (!vstdev)
 118                 return -ENODEV;
 119
 120         /* lock this device */
 121         mutex_lock(&vstdev->lock);
 122
 123         /* can only open one time */
 124         if ((!vstdev->present) || (vstdev->isopen)) {
 125                 mutex_unlock(&vstdev->lock);
 126                 return -EBUSY;
 127         }
 128
 129         /* increment our usage count */
 130         kref_get(&vstdev->kref);
 131
 132         vstdev->isopen = 1;
 133
 134         /* save device in the file's private structure */
 135         file->private_data = vstdev;
 136
 137         dev_dbg(&vstdev->usb_dev->dev, "%s: opened\n", __func__);
 138
 139         mutex_unlock(&vstdev->lock);
 140
 141         return 0;
 142 }
 143
 144 static int vstusb_release(struct inode *inode, struct file *file)
 145 {
 146         struct vstusb_device *vstdev;
 147
 148         vstdev = file->private_data;
 149
 150         if (vstdev == NULL)
 151                 return -ENODEV;
 152
 153         mutex_lock(&vstdev->lock);
 154
 155         vstdev->isopen = 0;
 156
 157         dev_dbg(&vstdev->usb_dev->dev, "%s: released\n", __func__);
 158
 159         mutex_unlock(&vstdev->lock);
 160
 161         kref_put(&vstdev->kref, vstusb_delete);
 162
 163         return 0;
 164 }
 165
 166 static void usb_api_blocking_completion(struct urb *urb)
 167 {
 168         struct completion *completeit = urb->context;
 169
 170         complete(completeit);
 171 }
 172
 173 static int vstusb_fill_and_send_urb(struct urb *urb,
 174                                     struct usb_device *usb_dev,
 175                                     unsigned int pipe, void *data,
 176                                     unsigned int len, struct completion *done)
 177 {
 178         struct usb_host_endpoint *ep;
 179         struct usb_host_endpoint **hostep;
 180         unsigned int pipend;
 181
 182         int status;
 183
 184         hostep = usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out;
 185         pipend = usb_pipeendpoint(pipe);
 186         ep = hostep[pipend];
 187
 188         if (!ep || (len == 0))
 189                 return -EINVAL;
 190
 191         if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 192             == USB_ENDPOINT_XFER_INT) {
 193                 pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
 194                 usb_fill_int_urb(urb, usb_dev, pipe, data, len,
 195                                  (usb_complete_t)usb_api_blocking_completion,
 196                                  NULL, ep->desc.bInterval);
 197         } else
 198                 usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
 199                                   (usb_complete_t)usb_api_blocking_completion,
 200                                   NULL);
 201
 202         init_completion(done);
 203         urb->context = done;
 204         urb->actual_length = 0;
 205         status = usb_submit_urb(urb, GFP_KERNEL);
 206
 207         return status;
 208 }
 209
 210 static int vstusb_complete_urb(struct urb *urb, struct completion *done,
 211                                int timeout, int *actual_length)
 212 {
 213         unsigned long expire;
 214         int status;
 215
 216         expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
 217         if (!wait_for_completion_interruptible_timeout(done, expire)) {
 218                 usb_kill_urb(urb);
 219                 status = urb->status == -ENOENT ? -ETIMEDOUT : urb->status;
 220
 221                 dev_dbg(&urb->dev->dev,
 222                         "%s timed out on ep%d%s len=%d/%d, urb status = %d\n",
 223                         current->comm,
 224                         usb_pipeendpoint(urb->pipe),
 225                         usb_pipein(urb->pipe) ? "in" : "out",
 226                         urb->actual_length,
 227                         urb->transfer_buffer_length,
 228                         urb->status);
 229
 230         } else {
 231                 if (signal_pending(current)) {
 232                         /* if really an error */
 233                         if (urb->status && !((urb->status == -ENOENT)     ||
 234                                              (urb->status == -ECONNRESET) ||
 235                                              (urb->status == -ESHUTDOWN))) {
 236                                 status = -EINTR;
 237                                 usb_kill_urb(urb);
 238                         } else {
 239                                 status = 0;
 240                         }
 241
 242                         dev_dbg(&urb->dev->dev,
 243                                 "%s: signal pending on ep%d%s len=%d/%d,"
 244                                 "urb status = %d\n",
 245                                 current->comm,
 246                                 usb_pipeendpoint(urb->pipe),
 247                                 usb_pipein(urb->pipe) ? "in" : "out",
 248                                 urb->actual_length,
 249                                 urb->transfer_buffer_length,
 250                                 urb->status);
 251
 252                 } else {
 253                         status = urb->status;
 254                 }
 255         }
 256
 257         if (actual_length)
 258                 *actual_length = urb->actual_length;
 259
 260         return status;
 261 }
 262
 263 static ssize_t vstusb_read(struct file *file, char __user *buffer,
 264                            size_t count, loff_t *ppos)
 265 {
 266         struct vstusb_device *vstdev;
 267         int cnt = -1;
 268         void *buf;
 269         int retval = 0;
 270
 271         struct urb              *urb;
 272         struct usb_device       *dev;
 273         unsigned int            pipe;
 274         int                     timeout;
 275
 276         DECLARE_COMPLETION_ONSTACK(done);
 277
 278         vstdev = file->private_data;
 279
 280         if (vstdev == NULL)
 281                 return -ENODEV;
 282
 283         /* verify that we actually want to read some data */
 284         if ((count == 0) || (count > VST_MAXBUFFER))
 285                 return -EINVAL;
 286
 287         /* lock this object */
 288         if (mutex_lock_interruptible(&vstdev->lock))
 289                 return -ERESTARTSYS;
 290
 291         /* anyone home */
 292         if (!vstdev->present) {
 293                 mutex_unlock(&vstdev->lock);
 294                 printk(KERN_ERR KBUILD_MODNAME
 295                        ": %s: device not present\n", __func__);
 296                 return -ENODEV;
 297         }
 298
 299         /* pull out the necessary data */
 300         dev =     vstdev->usb_dev;
 301         pipe =    usb_rcvbulkpipe(dev, vstdev->rd_pipe);
 302         timeout = vstdev->rd_timeout_ms;
 303
 304         buf = kmalloc(count, GFP_KERNEL);
 305         if (buf == NULL) {
 306                 mutex_unlock(&vstdev->lock);
 307                 return -ENOMEM;
 308         }
 309
 310         urb = usb_alloc_urb(0, GFP_KERNEL);
 311         if (!urb) {
 312                 kfree(buf);
 313                 mutex_unlock(&vstdev->lock);
 314                 return -ENOMEM;
 315         }
 316
 317         usb_anchor_urb(urb, &vstdev->submitted);
 318         retval = vstusb_fill_and_send_urb(urb, dev, pipe, buf, count, &done);
 319         mutex_unlock(&vstdev->lock);
 320         if (retval) {
 321                 usb_unanchor_urb(urb);
 322                 dev_err(&dev->dev, "%s: error %d filling and sending urb %d\n",
 323                         __func__, retval, pipe);
 324                 goto exit;
 325         }
 326
 327         retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
 328         if (retval) {
 329                 dev_err(&dev->dev, "%s: error %d completing urb %d\n",
 330                         __func__, retval, pipe);
 331                 goto exit;
 332         }
 333
 334         if (copy_to_user(buffer, buf, cnt)) {
 335                 dev_err(&dev->dev, "%s: can't copy_to_user\n", __func__);
 336                 retval = -EFAULT;
 337         } else {
 338                 retval = cnt;
 339                 dev_dbg(&dev->dev, "%s: read %d bytes from pipe %d\n",
 340                         __func__, cnt, pipe);
 341         }
 342
 343 exit:
 344         usb_free_urb(urb);
 345         kfree(buf);
 346         return retval;
 347 }
 348
 349 static ssize_t vstusb_write(struct file *file, const char __user *buffer,
 350                             size_t count, loff_t *ppos)
 351 {
 352         struct vstusb_device *vstdev;
 353         int cnt = -1;
 354         void *buf;
 355         int retval = 0;
 356
 357         struct urb              *urb;
 358         struct usb_device       *dev;
 359         unsigned int            pipe;
 360         int                     timeout;
 361
 362         DECLARE_COMPLETION_ONSTACK(done);
 363
 364         vstdev = file->private_data;
 365
 366         if (vstdev == NULL)
 367                 return -ENODEV;
 368
 369         /* verify that we actually have some data to write */
 370         if ((count == 0) || (count > VST_MAXBUFFER))
 371                 return retval;
 372
 373         /* lock this object */
 374         if (mutex_lock_interruptible(&vstdev->lock))
 375                 return -ERESTARTSYS;
 376
 377         /* anyone home */
 378         if (!vstdev->present) {
 379                 mutex_unlock(&vstdev->lock);
 380                 printk(KERN_ERR KBUILD_MODNAME
 381                        ": %s: device not present\n", __func__);
 382                 return -ENODEV;
 383         }
 384
 385         /* pull out the necessary data */
 386         dev =     vstdev->usb_dev;
 387         pipe =    usb_sndbulkpipe(dev, vstdev->wr_pipe);
 388         timeout = vstdev->wr_timeout_ms;
 389
 390         buf = kmalloc(count, GFP_KERNEL);
 391         if (buf == NULL) {
 392                 mutex_unlock(&vstdev->lock);
 393                 return -ENOMEM;
 394         }
 395
 396         urb = usb_alloc_urb(0, GFP_KERNEL);
 397         if (!urb) {
 398                 kfree(buf);
 399                 mutex_unlock(&vstdev->lock);
 400                 return -ENOMEM;
 401         }
 402
 403         if (copy_from_user(buf, buffer, count)) {
 404                 mutex_unlock(&vstdev->lock);
 405                 dev_err(&dev->dev, "%s: can't copy_from_user\n", __func__);
 406                 retval = -EFAULT;
 407                 goto exit;
 408         }
 409
 410         usb_anchor_urb(urb, &vstdev->submitted);
 411         retval = vstusb_fill_and_send_urb(urb, dev, pipe, buf, count, &done);
 412         mutex_unlock(&vstdev->lock);
 413         if (retval) {
 414                 usb_unanchor_urb(urb);
 415                 dev_err(&dev->dev, "%s: error %d filling and sending urb %d\n",
 416                         __func__, retval, pipe);
 417                 goto exit;
 418         }
 419
 420         retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
 421         if (retval) {
 422                 dev_err(&dev->dev, "%s: error %d completing urb %d\n",
 423                         __func__, retval, pipe);
 424                 goto exit;
 425         } else {
 426                 retval = cnt;
 427                 dev_dbg(&dev->dev, "%s: sent %d bytes to pipe %d\n",
 428                         __func__, cnt, pipe);
 429         }
 430
 431 exit:
 432         usb_free_urb(urb);
 433         kfree(buf);
 434         return retval;
 435 }
 436
 437 static long vstusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 438 {
 439         int retval = 0;
 440         int cnt = -1;
 441         void __user *data = (void __user *)arg;
 442         struct vstusb_args usb_data;
 443
 444         struct vstusb_device *vstdev;
 445         void *buffer = NULL; /* must be initialized. buffer is
 446                               * referenced on exit but not all
 447                               * ioctls allocate it */
 448
 449         struct urb              *urb = NULL; /* must be initialized. urb is
 450                                               * referenced on exit but not all
 451                                               * ioctls allocate it */
 452         struct usb_device       *dev;
 453         unsigned int            pipe;
 454         int                     timeout;
 455
 456         DECLARE_COMPLETION_ONSTACK(done);
 457
 458         vstdev = file->private_data;
 459
 460         if (_IOC_TYPE(cmd) != VST_IOC_MAGIC) {
 461                 dev_warn(&vstdev->usb_dev->dev,
 462                          "%s: ioctl command %x, bad ioctl magic %x, "
 463                          "expected %x\n", __func__, cmd,
 464                          _IOC_TYPE(cmd), VST_IOC_MAGIC);
 465                 return -EINVAL;
 466         }
 467
 468         if (vstdev == NULL)
 469                 return -ENODEV;
 470
 471         if (copy_from_user(&usb_data, data, sizeof(struct vstusb_args))) {
 472                 dev_err(&vstdev->usb_dev->dev, "%s: can't copy_from_user\n",
 473                         __func__);
 474                 return -EFAULT;
 475         }
 476
 477         /* lock this object */
 478         if (mutex_lock_interruptible(&vstdev->lock)) {
 479                 retval = -ERESTARTSYS;
 480                 goto exit;
 481         }
 482
 483         /* anyone home */
 484         if (!vstdev->present) {
 485                 mutex_unlock(&vstdev->lock);
 486                 dev_err(&vstdev->usb_dev->dev, "%s: device not present\n",
 487                         __func__);
 488                 retval = -ENODEV;
 489                 goto exit;
 490         }
 491
 492         /* pull out the necessary data */
 493         dev = vstdev->usb_dev;
 494
 495         switch (cmd) {
 496
 497         case IOCTL_VSTUSB_CONFIG_RW:
 498
 499                 vstdev->rd_pipe = usb_data.rd_pipe;
 500                 vstdev->rd_timeout_ms = usb_data.rd_timeout_ms;
 501                 vstdev->wr_pipe = usb_data.wr_pipe;
 502                 vstdev->wr_timeout_ms = usb_data.wr_timeout_ms;
 503
 504                 mutex_unlock(&vstdev->lock);
 505
 506                 dev_dbg(&dev->dev, "%s: setting pipes/timeouts, "
 507                         "rdpipe = %d, rdtimeout = %d, "
 508                         "wrpipe = %d, wrtimeout = %d\n", __func__,
 509                         vstdev->rd_pipe, vstdev->rd_timeout_ms,
 510                         vstdev->wr_pipe, vstdev->wr_timeout_ms);
 511                 break;
 512
 513         case IOCTL_VSTUSB_SEND_PIPE:
 514
 515                 if ((usb_data.count == 0) || (usb_data.count > VST_MAXBUFFER)) {
 516                         mutex_unlock(&vstdev->lock);
 517                         retval = -EINVAL;
 518                         goto exit;
 519                 }
 520
 521                 buffer = kmalloc(usb_data.count, GFP_KERNEL);
 522                 if (buffer == NULL) {
 523                         mutex_unlock(&vstdev->lock);
 524                         retval = -ENOMEM;
 525                         goto exit;
 526                 }
 527
 528                 urb = usb_alloc_urb(0, GFP_KERNEL);
 529                 if (!urb) {
 530                         mutex_unlock(&vstdev->lock);
 531                         retval = -ENOMEM;
 532                         goto exit;
 533                 }
 534
 535                 timeout = usb_data.timeout_ms;
 536
 537                 pipe = usb_sndbulkpipe(dev, usb_data.pipe);
 538
 539                 if (copy_from_user(buffer, usb_data.buffer, usb_data.count)) {
 540                         dev_err(&dev->dev, "%s: can't copy_from_user\n",
 541                                 __func__);
 542                         mutex_unlock(&vstdev->lock);
 543                         retval = -EFAULT;
 544                         goto exit;
 545                 }
 546
 547                 usb_anchor_urb(urb, &vstdev->submitted);
 548                 retval = vstusb_fill_and_send_urb(urb, dev, pipe, buffer,
 549                                                   usb_data.count, &done);
 550                 mutex_unlock(&vstdev->lock);
 551                 if (retval) {
 552                         usb_unanchor_urb(urb);
 553                         dev_err(&dev->dev,
 554                                 "%s: error %d filling and sending urb %d\n",
 555                                 __func__, retval, pipe);
 556                         goto exit;
 557                 }
 558
 559                 retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
 560                 if (retval) {
 561                         dev_err(&dev->dev, "%s: error %d completing urb %d\n",
 562                                 __func__, retval, pipe);
 563                 }
 564
 565                 break;
 566         case IOCTL_VSTUSB_RECV_PIPE:
 567
 568                 if ((usb_data.count == 0) || (usb_data.count > VST_MAXBUFFER)) {
 569                         mutex_unlock(&vstdev->lock);
 570                         retval = -EINVAL;
 571                         goto exit;
 572                 }
 573
 574                 buffer = kmalloc(usb_data.count, GFP_KERNEL);
 575                 if (buffer == NULL) {
 576                         mutex_unlock(&vstdev->lock);
 577                         retval = -ENOMEM;
 578                         goto exit;
 579                 }
 580
 581                 urb = usb_alloc_urb(0, GFP_KERNEL);
 582                 if (!urb) {
 583                         mutex_unlock(&vstdev->lock);
 584                         retval = -ENOMEM;
 585                         goto exit;
 586                 }
 587
 588                 timeout = usb_data.timeout_ms;
 589
 590                 pipe = usb_rcvbulkpipe(dev, usb_data.pipe);
 591
 592                 usb_anchor_urb(urb, &vstdev->submitted);
 593                 retval = vstusb_fill_and_send_urb(urb, dev, pipe, buffer,
 594                                                   usb_data.count, &done);
 595                 mutex_unlock(&vstdev->lock);
 596                 if (retval) {
 597                         usb_unanchor_urb(urb);
 598                         dev_err(&dev->dev,
 599                                 "%s: error %d filling and sending urb %d\n",
 600                                 __func__, retval, pipe);
 601                         goto exit;
 602                 }
 603
 604                 retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
 605                 if (retval) {
 606                         dev_err(&dev->dev, "%s: error %d completing urb %d\n",
 607                                 __func__, retval, pipe);
 608                         goto exit;
 609                 }
 610
 611                 if (copy_to_user(usb_data.buffer, buffer, cnt)) {
 612                         dev_err(&dev->dev, "%s: can't copy_to_user\n",
 613                                 __func__);
 614                         retval = -EFAULT;
 615                         goto exit;
 616                 }
 617
 618                 usb_data.count = cnt;
 619                 if (copy_to_user(data, &usb_data, sizeof(struct vstusb_args))) {
 620                         dev_err(&dev->dev, "%s: can't copy_to_user\n",
 621                                 __func__);
 622                         retval = -EFAULT;
 623                 } else {
 624                         dev_dbg(&dev->dev, "%s: recv %zd bytes from pipe %d\n",
 625                                 __func__, usb_data.count, usb_data.pipe);
 626                 }
 627
 628                 break;
 629
 630         default:
 631                 mutex_unlock(&vstdev->lock);
 632                 dev_warn(&dev->dev, "ioctl_vstusb: invalid ioctl cmd %x\n",
 633                          cmd);
 634                 return -EINVAL;
 635                 break;
 636         }
 637 exit:
 638         usb_free_urb(urb);
 639         kfree(buffer);
 640         return retval;
 641 }
 642
 643 static const struct file_operations vstusb_fops = {
 644         .owner =                THIS_MODULE,
 645         .read =                 vstusb_read,
 646         .write =                vstusb_write,
 647         .unlocked_ioctl =       vstusb_ioctl,
 648         .compat_ioctl =         vstusb_ioctl,
 649         .open =                 vstusb_open,
 650         .release =              vstusb_release,
 651 };
 652
 653 static struct usb_class_driver usb_vstusb_class = {
 654         .name =         "usb/vstusb%d",
 655         .fops =         &vstusb_fops,
 656         .minor_base =   VSTUSB_MINOR_BASE,
 657 };
 658
 659 static int vstusb_probe(struct usb_interface *intf,
 660                         const struct usb_device_id *id)
 661 {
 662         struct usb_device *dev = interface_to_usbdev(intf);
 663         struct vstusb_device *vstdev;
 664         int i;
 665         int retval = 0;
 666
 667         /* allocate memory for our device state and intialize it */
 668
 669         vstdev = kzalloc(sizeof(*vstdev), GFP_KERNEL);
 670         if (vstdev == NULL)
 671                 return -ENOMEM;
 672
 673         /* must do usb_get_dev() prior to kref_init() since the kref_put()
 674          * release function will do a usb_put_dev() */
 675         usb_get_dev(dev);
 676         kref_init(&vstdev->kref);
 677         mutex_init(&vstdev->lock);
 678
 679         i = dev->descriptor.bcdDevice;
 680
 681         dev_dbg(&intf->dev, "Version %1d%1d.%1d%1d found at address %d\n",
 682                 (i & 0xF000) >> 12, (i & 0xF00) >> 8,
 683                 (i & 0xF0) >> 4, (i & 0xF), dev->devnum);
 684
 685         vstdev->present = 1;
 686         vstdev->isopen = 0;
 687         vstdev->usb_dev = dev;
 688         init_usb_anchor(&vstdev->submitted);
 689
 690         usb_set_intfdata(intf, vstdev);
 691         retval = usb_register_dev(intf, &usb_vstusb_class);
 692         if (retval) {
 693                 dev_err(&intf->dev,
 694                         "%s: Not able to get a minor for this device.\n",
 695                         __func__);
 696                 usb_set_intfdata(intf, NULL);
 697                 kref_put(&vstdev->kref, vstusb_delete);
 698                 return retval;
 699         }
 700
 701         /* let the user know what node this device is now attached to */
 702         dev_info(&intf->dev,
 703                  "VST USB Device #%d now attached to major %d minor %d\n",
 704                  (intf->minor - VSTUSB_MINOR_BASE), USB_MAJOR, intf->minor);
 705
 706         dev_info(&intf->dev, "%s, %s\n", DRIVER_DESC, DRIVER_VERSION);
 707
 708         return retval;
 709 }
 710
 711 static void vstusb_disconnect(struct usb_interface *intf)
 712 {
 713         struct vstusb_device *vstdev = usb_get_intfdata(intf);
 714
 715         usb_deregister_dev(intf, &usb_vstusb_class);
 716         usb_set_intfdata(intf, NULL);
 717
 718         if (vstdev) {
 719
 720                 mutex_lock(&vstdev->lock);
 721                 vstdev->present = 0;
 722
 723                 usb_kill_anchored_urbs(&vstdev->submitted);
 724
 725                 mutex_unlock(&vstdev->lock);
 726
 727                 kref_put(&vstdev->kref, vstusb_delete);
 728         }
 729
 730 }
 731
 732 static int vstusb_suspend(struct usb_interface *intf, pm_message_t message)
 733 {
 734         struct vstusb_device *vstdev = usb_get_intfdata(intf);
 735         int time;
 736         if (!vstdev)
 737                 return 0;
 738
 739         mutex_lock(&vstdev->lock);
 740         time = usb_wait_anchor_empty_timeout(&vstdev->submitted, 1000);
 741         if (!time)
 742                 usb_kill_anchored_urbs(&vstdev->submitted);
 743         mutex_unlock(&vstdev->lock);
 744
 745         return 0;
 746 }
 747
 748 static int vstusb_resume(struct usb_interface *intf)
 749 {
 750         return 0;
 751 }
 752
 753 static struct usb_driver vstusb_driver = {
 754         .name =         "vstusb",
 755         .probe =        vstusb_probe,
 756         .disconnect =   vstusb_disconnect,
 757         .suspend =      vstusb_suspend,
 758         .resume =       vstusb_resume,
 759         .id_table = id_table,
 760 };
 761
 762 static int __init vstusb_init(void)
 763 {
 764         int rc;
 765
 766         rc = usb_register(&vstusb_driver);
 767         if (rc)
 768                 printk(KERN_ERR "%s: failed to register (%d)", __func__, rc);
 769
 770         return rc;
 771 }
 772
 773 static void __exit vstusb_exit(void)
 774 {
 775         usb_deregister(&vstusb_driver);
 776 }
 777
 778 module_init(vstusb_init);
 779 module_exit(vstusb_exit);
 780
 781 MODULE_AUTHOR("Dennis O'Brien/Stephen Ware");
 782 MODULE_DESCRIPTION(DRIVER_VERSION);
 783 MODULE_LICENSE("GPL");