SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/frontier/alphatrack.c

   1 /*
   2  * Frontier Designs Alphatrack driver
   3  *
   4  * Copyright (C) 2007 Michael Taht (m@taht.net)
   5  *
   6  * Based on the usbled driver and ldusb drivers by
   7  *
   8  * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com)
   9  * Copyright (C) 2005 Michael Hund <mhund@ld-didactic.de>
  10  *
  11  * The ldusb driver was, in turn, derived from Lego USB Tower driver
  12  * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net>
  13  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
  14  *
  15  *      This program is free software; you can redistribute it and/or
  16  *      modify it under the terms of the GNU General Public License as
  17  *      published by the Free Software Foundation, version 2.
  18  *
  19  */
  20
  21 /**
  22  * This driver uses a ring buffer for time critical reading of
  23  * interrupt in reports and provides read and write methods for
  24  * raw interrupt reports.
  25  */
  26
  27 /* Note: this currently uses a dumb ringbuffer for reads and writes.
  28  * A more optimal driver would cache and kill off outstanding urbs that are
  29  * now invalid, and ignore ones that already were in the queue but valid
  30  * as we only have 30 commands for the alphatrack. In particular this is
  31  * key for getting lights to flash in time as otherwise many commands
  32  * can be buffered up before the light change makes it to the interface.
  33 */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/errno.h>
  37 #include <linux/init.h>
  38 #include <linux/slab.h>
  39 #include <linux/module.h>
  40 #include <linux/kobject.h>
  41 #include <linux/mutex.h>
  42 #include <linux/version.h>
  43
  44 #include <linux/uaccess.h>
  45 #include <linux/input.h>
  46 #include <linux/usb.h>
  47 #include <linux/poll.h>
  48
  49 #include "surface_sysfs.h"
  50
  51 #include "alphatrack.h"
  52
  53 #define VENDOR_ID       0x165b
  54 #define PRODUCT_ID      0xfad1
  55
  56 #ifdef CONFIG_USB_DYNAMIC_MINORS
  57 #define USB_ALPHATRACK_MINOR_BASE       0
  58 #else
  59 /* FIXME 176 - is another driver's minor - apply for that */
  60 #define USB_ALPHATRACK_MINOR_BASE       176
  61 #endif
  62
  63 /* table of devices that work with this driver */
  64 static struct usb_device_id usb_alphatrack_table[] = {
  65         {USB_DEVICE(VENDOR_ID, PRODUCT_ID)},
  66         {}                      /* Terminating entry */
  67 };
  68
  69 MODULE_DEVICE_TABLE(usb, usb_alphatrack_table);
  70 MODULE_VERSION("0.41");
  71 MODULE_AUTHOR("Mike Taht <m@taht.net>");
  72 MODULE_DESCRIPTION("Alphatrack USB Driver");
  73 MODULE_LICENSE("GPL");
  74 MODULE_SUPPORTED_DEVICE("Frontier Designs Alphatrack Control Surface");
  75
  76 /* These aren't done yet */
  77
  78 #define SUPPRESS_EXTRA_ONLINE_EVENTS 0
  79 #define BUFFERED_WRITES 0
  80 #define SUPPRESS_EXTRA_OFFLINE_EVENTS 0
  81 #define COMPRESS_FADER_EVENTS 0
  82
  83 #define BUFFERED_READS 1
  84 #define RING_BUFFER_SIZE 512
  85 #define WRITE_BUFFER_SIZE 34
  86 #define ALPHATRACK_USB_TIMEOUT 10
  87 #define OUTPUT_CMD_SIZE 8
  88 #define INPUT_CMD_SIZE 12
  89 #define ALPHATRACK_DEBUG 0
  90
  91 static int debug = ALPHATRACK_DEBUG;
  92
  93 /* Use our own dbg macro */
  94 #define dbg_info(dev, format, arg...) do \
  95     { if (debug) dev_info(dev , format , ## arg); } while (0)
  96
  97 #define alphatrack_ocmd_info(dev, cmd, format, arg...)
  98
  99 #define alphatrack_icmd_info(dev, cmd, format, arg...)
 100
 101 /* Module parameters */
 102
 103 module_param(debug, int, S_IRUGO | S_IWUSR);
 104 MODULE_PARM_DESC(debug, "Debug enabled or not");
 105
 106 /* All interrupt in transfers are collected in a ring buffer to
 107  * avoid racing conditions and get better performance of the driver.
 108  */
 109
 110 static int ring_buffer_size = RING_BUFFER_SIZE;
 111
 112 module_param(ring_buffer_size, int, S_IRUGO);
 113 MODULE_PARM_DESC(ring_buffer_size, "Read ring buffer size");
 114
 115 /* The write_buffer can one day contain more than one interrupt out transfer.
 116  */
 117
 118 static int write_buffer_size = WRITE_BUFFER_SIZE;
 119 module_param(write_buffer_size, int, S_IRUGO);
 120 MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
 121
 122 /*
 123  * Increase the interval for debugging purposes.
 124  * or set to 1 to use the standard interval from the endpoint descriptors.
 125  */
 126
 127 static int min_interrupt_in_interval = ALPHATRACK_USB_TIMEOUT;
 128 module_param(min_interrupt_in_interval, int, 0);
 129 MODULE_PARM_DESC(min_interrupt_in_interval,
 130                  "Minimum interrupt in interval in ms");
 131
 132 static int min_interrupt_out_interval = ALPHATRACK_USB_TIMEOUT;
 133 module_param(min_interrupt_out_interval, int, 0);
 134 MODULE_PARM_DESC(min_interrupt_out_interval,
 135                  "Minimum interrupt out interval in ms");
 136
 137 /* Structure to hold all of our device specific stuff */
 138
 139 struct usb_alphatrack {
 140         struct semaphore sem;   /* locks this structure */
 141         struct usb_interface *intf;     /* save off the usb interface pointer */
 142         int open_count;         /* number of times this port has been opened */
 143
 144         /* make gcc happy */
 145         struct alphatrack_icmd (*ring_buffer)[RING_BUFFER_SIZE];
 146         struct alphatrack_ocmd (*write_buffer)[WRITE_BUFFER_SIZE];
 147         unsigned int ring_head;
 148         unsigned int ring_tail;
 149
 150         wait_queue_head_t read_wait;
 151         wait_queue_head_t write_wait;
 152
 153         unsigned char *interrupt_in_buffer;
 154         unsigned char *oldi_buffer;
 155         struct usb_endpoint_descriptor *interrupt_in_endpoint;
 156         struct urb *interrupt_in_urb;
 157         int interrupt_in_interval;
 158         size_t interrupt_in_endpoint_size;
 159         int interrupt_in_running;
 160         int interrupt_in_done;
 161
 162         char *interrupt_out_buffer;
 163         struct usb_endpoint_descriptor *interrupt_out_endpoint;
 164         struct urb *interrupt_out_urb;
 165         int interrupt_out_interval;
 166         size_t interrupt_out_endpoint_size;
 167         int interrupt_out_busy;
 168
 169         atomic_t writes_pending;
 170         int event;              /* alternate interface to events */
 171         int fader;              /* 10 bits */
 172         int lights;             /* 23 bits */
 173         unsigned char dump_state;       /* 0 if disabled 1 if enabled */
 174         unsigned char enable;   /* 0 if disabled 1 if enabled */
 175         unsigned char offline;  /* if the device is out of range or asleep */
 176         unsigned char verbose;  /* be verbose in error reporting */
 177         unsigned char last_cmd[OUTPUT_CMD_SIZE];
 178         unsigned char screen[32];
 179 };
 180
 181 /* prevent races between open() and disconnect() */
 182 static DEFINE_MUTEX(disconnect_mutex);
 183
 184 /* forward declaration */
 185
 186 static struct usb_driver usb_alphatrack_driver;
 187
 188 /**
 189  *      usb_alphatrack_abort_transfers
 190  *      aborts transfers and frees associated data structures
 191  */
 192 static void usb_alphatrack_abort_transfers(struct usb_alphatrack *dev)
 193 {
 194         /* shutdown transfer */
 195         if (dev->interrupt_in_running) {
 196                 dev->interrupt_in_running = 0;
 197                 if (dev->intf)
 198                         usb_kill_urb(dev->interrupt_in_urb);
 199         }
 200         if (dev->interrupt_out_busy)
 201                 if (dev->intf)
 202                         usb_kill_urb(dev->interrupt_out_urb);
 203 }
 204
 205 /**
 206  *      usb_alphatrack_delete
 207  */
 208 static void usb_alphatrack_delete(struct usb_alphatrack *dev)
 209 {
 210         usb_alphatrack_abort_transfers(dev);
 211         usb_free_urb(dev->interrupt_in_urb);
 212         usb_free_urb(dev->interrupt_out_urb);
 213         kfree(dev->ring_buffer);
 214         kfree(dev->interrupt_in_buffer);
 215         kfree(dev->interrupt_out_buffer);
 216         kfree(dev);             /* fixme oldi_buffer */
 217 }
 218
 219 /**
 220  *      usb_alphatrack_interrupt_in_callback
 221  */
 222
 223 static void usb_alphatrack_interrupt_in_callback(struct urb *urb)
 224 {
 225         struct usb_alphatrack *dev = urb->context;
 226         unsigned int next_ring_head;
 227         int retval = -1;
 228
 229         if (urb->status) {
 230                 if (urb->status == -ENOENT ||
 231                     urb->status == -ECONNRESET || urb->status == -ESHUTDOWN) {
 232                         goto exit;
 233                 } else {
 234                         dbg_info(&dev->intf->dev,
 235                                  "%s: nonzero status received: %d\n", __func__,
 236                                  urb->status);
 237                         goto resubmit;  /* maybe we can recover */
 238                 }
 239         }
 240
 241         if (urb->actual_length != INPUT_CMD_SIZE) {
 242                 dev_warn(&dev->intf->dev,
 243                          "Urb length was %d bytes!!"
 244                          "Do something intelligent \n", urb->actual_length);
 245         } else {
 246                 alphatrack_ocmd_info(&dev->intf->dev,
 247                                      &(*dev->ring_buffer)[dev->ring_tail].cmd,
 248                                      "%s", "bla");
 249                 if (memcmp
 250                     (dev->interrupt_in_buffer, dev->oldi_buffer,
 251                      INPUT_CMD_SIZE) == 0) {
 252                         goto resubmit;
 253                 }
 254                 memcpy(dev->oldi_buffer, dev->interrupt_in_buffer,
 255                        INPUT_CMD_SIZE);
 256
 257 #if SUPPRESS_EXTRA_OFFLINE_EVENTS
 258                 if (dev->offline == 2 && dev->interrupt_in_buffer[1] == 0xff)
 259                         goto resubmit;
 260                 if (dev->offline == 1 && dev->interrupt_in_buffer[1] == 0xff) {
 261                         dev->offline = 2;
 262                         goto resubmit;
 263                 }
 264 /* Always pass one offline event up the stack */
 265                 if (dev->offline > 0 && dev->interrupt_in_buffer[1] != 0xff)
 266                         dev->offline = 0;
 267                 if (dev->offline == 0 && dev->interrupt_in_buffer[1] == 0xff)
 268                         dev->offline = 1;
 269 #endif
 270                 dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n",
 271                          __func__, dev->ring_head, dev->ring_tail);
 272                 next_ring_head = (dev->ring_head + 1) % ring_buffer_size;
 273
 274                 if (next_ring_head != dev->ring_tail) {
 275                         memcpy(&((*dev->ring_buffer)[dev->ring_head]),
 276                                dev->interrupt_in_buffer, urb->actual_length);
 277                         dev->ring_head = next_ring_head;
 278                         retval = 0;
 279                         memset(dev->interrupt_in_buffer, 0, urb->actual_length);
 280                 } else {
 281                         dev_warn(&dev->intf->dev,
 282                                  "Ring buffer overflow, %d bytes dropped\n",
 283                                  urb->actual_length);
 284                         memset(dev->interrupt_in_buffer, 0, urb->actual_length);
 285                 }
 286         }
 287
 288 resubmit:
 289         /* resubmit if we're still running */
 290         if (dev->interrupt_in_running && dev->intf) {
 291                 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
 292                 if (retval)
 293                         dev_err(&dev->intf->dev,
 294                                 "usb_submit_urb failed (%d)\n", retval);
 295         }
 296
 297 exit:
 298         dev->interrupt_in_done = 1;
 299         wake_up_interruptible(&dev->read_wait);
 300 }
 301
 302 /**
 303  *      usb_alphatrack_interrupt_out_callback
 304  */
 305 static void usb_alphatrack_interrupt_out_callback(struct urb *urb)
 306 {
 307         struct usb_alphatrack *dev = urb->context;
 308
 309         /* sync/async unlink faults aren't errors */
 310         if (urb->status && !(urb->status == -ENOENT ||
 311                              urb->status == -ECONNRESET ||
 312                              urb->status == -ESHUTDOWN))
 313                 dbg_info(&dev->intf->dev,
 314                          "%s - nonzero write interrupt status received: %d\n",
 315                          __func__, urb->status);
 316         atomic_dec(&dev->writes_pending);
 317         dev->interrupt_out_busy = 0;
 318         wake_up_interruptible(&dev->write_wait);
 319 }
 320
 321 /**
 322  *      usb_alphatrack_open
 323  */
 324 static int usb_alphatrack_open(struct inode *inode, struct file *file)
 325 {
 326         struct usb_alphatrack *dev;
 327         int subminor;
 328         int retval = 0;
 329         struct usb_interface *interface;
 330
 331         nonseekable_open(inode, file);
 332         subminor = iminor(inode);
 333
 334         mutex_lock(&disconnect_mutex);
 335
 336         interface = usb_find_interface(&usb_alphatrack_driver, subminor);
 337
 338         if (!interface) {
 339                 err("%s - error, can't find device for minor %d\n",
 340                     __func__, subminor);
 341                 retval = -ENODEV;
 342                 goto unlock_disconnect_exit;
 343         }
 344
 345         dev = usb_get_intfdata(interface);
 346
 347         if (!dev) {
 348                 retval = -ENODEV;
 349                 goto unlock_disconnect_exit;
 350         }
 351
 352         /* lock this device */
 353         if (down_interruptible(&dev->sem)) {
 354                 retval = -ERESTARTSYS;
 355                 goto unlock_disconnect_exit;
 356         }
 357
 358         /* allow opening only once */
 359         if (dev->open_count) {
 360                 retval = -EBUSY;
 361                 goto unlock_exit;
 362         }
 363         dev->open_count = 1;
 364
 365         /* initialize in direction */
 366         dev->ring_head = 0;
 367         dev->ring_tail = 0;
 368         usb_fill_int_urb(dev->interrupt_in_urb,
 369                          interface_to_usbdev(interface),
 370                          usb_rcvintpipe(interface_to_usbdev(interface),
 371                                         dev->interrupt_in_endpoint->
 372                                         bEndpointAddress),
 373                          dev->interrupt_in_buffer,
 374                          dev->interrupt_in_endpoint_size,
 375                          usb_alphatrack_interrupt_in_callback, dev,
 376                          dev->interrupt_in_interval);
 377
 378         dev->interrupt_in_running = 1;
 379         dev->interrupt_in_done = 0;
 380         dev->enable = 1;
 381         dev->offline = 0;
 382
 383         retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
 384         if (retval) {
 385                 dev_err(&interface->dev,
 386                         "Couldn't submit interrupt_in_urb %d\n", retval);
 387                 dev->interrupt_in_running = 0;
 388                 dev->open_count = 0;
 389                 goto unlock_exit;
 390         }
 391
 392         /* save device in the file's private structure */
 393         file->private_data = dev;
 394
 395 unlock_exit:
 396         up(&dev->sem);
 397
 398 unlock_disconnect_exit:
 399         mutex_unlock(&disconnect_mutex);
 400
 401         return retval;
 402 }
 403
 404 /**
 405  *      usb_alphatrack_release
 406  */
 407 static int usb_alphatrack_release(struct inode *inode, struct file *file)
 408 {
 409         struct usb_alphatrack *dev;
 410         int retval = 0;
 411
 412         dev = file->private_data;
 413
 414         if (dev == NULL) {
 415                 retval = -ENODEV;
 416                 goto exit;
 417         }
 418
 419         if (down_interruptible(&dev->sem)) {
 420                 retval = -ERESTARTSYS;
 421                 goto exit;
 422         }
 423
 424         if (dev->open_count != 1) {
 425                 retval = -ENODEV;
 426                 goto unlock_exit;
 427         }
 428
 429         if (dev->intf == NULL) {
 430                 /* the device was unplugged before the file was released */
 431                 up(&dev->sem);
 432                 /* unlock here as usb_alphatrack_delete frees dev */
 433                 usb_alphatrack_delete(dev);
 434                 retval = -ENODEV;
 435                 goto exit;
 436         }
 437
 438         /* wait until write transfer is finished */
 439         if (dev->interrupt_out_busy)
 440                 wait_event_interruptible_timeout(dev->write_wait,
 441                                                  !dev->interrupt_out_busy,
 442                                                  2 * HZ);
 443         usb_alphatrack_abort_transfers(dev);
 444         dev->open_count = 0;
 445
 446 unlock_exit:
 447         up(&dev->sem);
 448
 449 exit:
 450         return retval;
 451 }
 452
 453 /**
 454  *      usb_alphatrack_poll
 455  */
 456 static unsigned int usb_alphatrack_poll(struct file *file, poll_table * wait)
 457 {
 458         struct usb_alphatrack *dev;
 459         unsigned int mask = 0;
 460
 461         dev = file->private_data;
 462
 463         poll_wait(file, &dev->read_wait, wait);
 464         poll_wait(file, &dev->write_wait, wait);
 465
 466         if (dev->ring_head != dev->ring_tail)
 467                 mask |= POLLIN | POLLRDNORM;
 468         if (!dev->interrupt_out_busy)
 469                 mask |= POLLOUT | POLLWRNORM;
 470
 471         return mask;
 472 }
 473
 474 /**
 475  *      usb_alphatrack_read
 476  */
 477 static ssize_t usb_alphatrack_read(struct file *file, char __user *buffer,
 478                                    size_t count, loff_t *ppos)
 479 {
 480         struct usb_alphatrack *dev;
 481         int retval = 0;
 482
 483         int c = 0;
 484
 485         dev = file->private_data;
 486
 487         /* verify that we actually have some data to read */
 488         if (count == 0)
 489                 goto exit;
 490
 491         /* lock this object */
 492         if (down_interruptible(&dev->sem)) {
 493                 retval = -ERESTARTSYS;
 494                 goto exit;
 495         }
 496
 497         /* verify that the device wasn't unplugged */
 498         if (dev->intf == NULL) {
 499                 retval = -ENODEV;
 500                 err("No device or device unplugged %d\n", retval);
 501                 goto unlock_exit;
 502         }
 503
 504         while (dev->ring_head == dev->ring_tail) {
 505                 if (file->f_flags & O_NONBLOCK) {
 506                         retval = -EAGAIN;
 507                         goto unlock_exit;
 508                 }
 509                 dev->interrupt_in_done = 0;
 510                 retval =
 511                     wait_event_interruptible(dev->read_wait,
 512                                              dev->interrupt_in_done);
 513                 if (retval < 0)
 514                         goto unlock_exit;
 515         }
 516
 517         alphatrack_ocmd_info(&dev->intf->dev,
 518                              &(*dev->ring_buffer)[dev->ring_tail].cmd, "%s",
 519                              ": copying to userspace");
 520
 521         c = 0;
 522         while ((c < count) && (dev->ring_tail != dev->ring_head)) {
 523                 if (copy_to_user
 524                     (&buffer[c], &(*dev->ring_buffer)[dev->ring_tail],
 525                      INPUT_CMD_SIZE)) {
 526                         retval = -EFAULT;
 527                         goto unlock_exit;
 528                 }
 529                 dev->ring_tail = (dev->ring_tail + 1) % ring_buffer_size;
 530                 c += INPUT_CMD_SIZE;
 531                 dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n",
 532                          __func__, dev->ring_head, dev->ring_tail);
 533         }
 534         retval = c;
 535
 536 unlock_exit:
 537         /* unlock the device */
 538         up(&dev->sem);
 539
 540 exit:
 541         return retval;
 542 }
 543
 544 /**
 545  *      usb_alphatrack_write
 546  */
 547 static ssize_t usb_alphatrack_write(struct file *file,
 548                                     const char __user *buffer, size_t count,
 549                                     loff_t *ppos)
 550 {
 551         struct usb_alphatrack *dev;
 552         size_t bytes_to_write;
 553         int retval = 0;
 554
 555         dev = file->private_data;
 556
 557         /* verify that we actually have some data to write */
 558         if (count == 0)
 559                 goto exit;
 560
 561         /* lock this object */
 562         if (down_interruptible(&dev->sem)) {
 563                 retval = -ERESTARTSYS;
 564                 goto exit;
 565         }
 566
 567         /* verify that the device wasn't unplugged */
 568         if (dev->intf == NULL) {
 569                 retval = -ENODEV;
 570                 err("No device or device unplugged %d\n", retval);
 571                 goto unlock_exit;
 572         }
 573
 574         /* wait until previous transfer is finished */
 575         if (dev->interrupt_out_busy) {
 576                 if (file->f_flags & O_NONBLOCK) {
 577                         retval = -EAGAIN;
 578                         goto unlock_exit;
 579                 }
 580                 retval =
 581                     wait_event_interruptible(dev->write_wait,
 582                                              !dev->interrupt_out_busy);
 583                 if (retval < 0)
 584                         goto unlock_exit;
 585         }
 586
 587         /* write the data into interrupt_out_buffer from userspace */
 588         /* FIXME - if you write more than 12 bytes this breaks */
 589         bytes_to_write =
 590             min(count, write_buffer_size * dev->interrupt_out_endpoint_size);
 591         if (bytes_to_write < count)
 592                 dev_warn(&dev->intf->dev,
 593                          "Write buffer overflow, %zd bytes dropped\n",
 594                          count - bytes_to_write);
 595
 596         dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n",
 597                  __func__, count, bytes_to_write);
 598
 599         if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
 600                 retval = -EFAULT;
 601                 goto unlock_exit;
 602         }
 603
 604         if (dev->interrupt_out_endpoint == NULL) {
 605                 err("Endpoint should not be be null! \n");
 606                 goto unlock_exit;
 607         }
 608
 609         /* send off the urb */
 610         usb_fill_int_urb(dev->interrupt_out_urb,
 611                          interface_to_usbdev(dev->intf),
 612                          usb_sndintpipe(interface_to_usbdev(dev->intf),
 613                                         dev->interrupt_out_endpoint->
 614                                         bEndpointAddress),
 615                          dev->interrupt_out_buffer, bytes_to_write,
 616                          usb_alphatrack_interrupt_out_callback, dev,
 617                          dev->interrupt_out_interval);
 618         dev->interrupt_out_busy = 1;
 619         atomic_inc(&dev->writes_pending);
 620         wmb();
 621
 622         retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
 623         if (retval) {
 624                 dev->interrupt_out_busy = 0;
 625                 err("Couldn't submit interrupt_out_urb %d\n", retval);
 626                 atomic_dec(&dev->writes_pending);
 627                 goto unlock_exit;
 628         }
 629         retval = bytes_to_write;
 630
 631 unlock_exit:
 632         /* unlock the device */
 633         up(&dev->sem);
 634
 635 exit:
 636         return retval;
 637 }
 638
 639 /* file operations needed when we register this driver */
 640 static const struct file_operations usb_alphatrack_fops = {
 641         .owner = THIS_MODULE,
 642         .read = usb_alphatrack_read,
 643         .write = usb_alphatrack_write,
 644         .open = usb_alphatrack_open,
 645         .release = usb_alphatrack_release,
 646         .poll = usb_alphatrack_poll,
 647 };
 648
 649 /*
 650  * usb class driver info in order to get a minor number from the usb core,
 651  * and to have the device registered with the driver core
 652  */
 653
 654 static struct usb_class_driver usb_alphatrack_class = {
 655         .name = "alphatrack%d",
 656         .fops = &usb_alphatrack_fops,
 657         .minor_base = USB_ALPHATRACK_MINOR_BASE,
 658 };
 659
 660 /**
 661  *      usb_alphatrack_probe
 662  *
 663  *      Called by the usb core when a new device is connected that it thinks
 664  *      this driver might be interested in.
 665  */
 666 static int usb_alphatrack_probe(struct usb_interface *intf,
 667                                 const struct usb_device_id *id)
 668 {
 669         struct usb_device *udev = interface_to_usbdev(intf);
 670         struct usb_alphatrack *dev = NULL;
 671         struct usb_host_interface *iface_desc;
 672         struct usb_endpoint_descriptor *endpoint;
 673         int i;
 674         int true_size;
 675         int retval = -ENOMEM;
 676
 677         /* allocate memory for our device state and intialize it */
 678
 679         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 680         if (dev == NULL) {
 681                 dev_err(&intf->dev, "Out of memory\n");
 682                 goto exit;
 683         }
 684         init_MUTEX(&dev->sem);
 685         dev->intf = intf;
 686         init_waitqueue_head(&dev->read_wait);
 687         init_waitqueue_head(&dev->write_wait);
 688
 689         iface_desc = intf->cur_altsetting;
 690
 691         /* set up the endpoint information */
 692         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 693                 endpoint = &iface_desc->endpoint[i].desc;
 694
 695                 if (usb_endpoint_is_int_in(endpoint))
 696                         dev->interrupt_in_endpoint = endpoint;
 697
 698                 if (usb_endpoint_is_int_out(endpoint))
 699                         dev->interrupt_out_endpoint = endpoint;
 700         }
 701         if (dev->interrupt_in_endpoint == NULL) {
 702                 dev_err(&intf->dev, "Interrupt in endpoint not found\n");
 703                 goto error;
 704         }
 705         if (dev->interrupt_out_endpoint == NULL)
 706                 dev_warn(&intf->dev,
 707                          "Interrupt out endpoint not found"
 708                          "(using control endpoint instead)\n");
 709
 710         dev->interrupt_in_endpoint_size =
 711             le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize);
 712
 713         if (dev->interrupt_in_endpoint_size != 64)
 714                 dev_warn(&intf->dev, "Interrupt in endpoint size is not 64!\n");
 715
 716         if (ring_buffer_size == 0)
 717                 ring_buffer_size = RING_BUFFER_SIZE;
 718
 719         true_size = min(ring_buffer_size, RING_BUFFER_SIZE);
 720
 721         /* FIXME - there are more usb_alloc routines for dma correctness.
 722            Needed? */
 723         dev->ring_buffer =
 724             kmalloc((true_size * sizeof(struct alphatrack_icmd)), GFP_KERNEL);
 725
 726         if (!dev->ring_buffer) {
 727                 dev_err(&intf->dev,
 728                         "Couldn't allocate input ring_buffer of size %d\n",
 729                         true_size);
 730                 goto error;
 731         }
 732
 733         dev->interrupt_in_buffer =
 734             kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
 735
 736         if (!dev->interrupt_in_buffer) {
 737                 dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n");
 738                 goto error;
 739         }
 740         dev->oldi_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
 741         if (!dev->oldi_buffer) {
 742                 dev_err(&intf->dev, "Couldn't allocate old buffer\n");
 743                 goto error;
 744         }
 745         dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 746         if (!dev->interrupt_in_urb) {
 747                 dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n");
 748                 goto error;
 749         }
 750
 751         dev->interrupt_out_endpoint_size =
 752             dev->interrupt_out_endpoint ? le16_to_cpu(dev->
 753                                                       interrupt_out_endpoint->
 754                                                       wMaxPacketSize) : udev->
 755             descriptor.bMaxPacketSize0;
 756
 757         if (dev->interrupt_out_endpoint_size != 64)
 758                 dev_warn(&intf->dev,
 759                          "Interrupt out endpoint size is not 64!)\n");
 760
 761         if (write_buffer_size == 0)
 762                 write_buffer_size = WRITE_BUFFER_SIZE;
 763         true_size = min(write_buffer_size, WRITE_BUFFER_SIZE);
 764
 765         dev->interrupt_out_buffer =
 766             kmalloc(true_size * dev->interrupt_out_endpoint_size, GFP_KERNEL);
 767
 768         if (!dev->interrupt_out_buffer) {
 769                 dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n");
 770                 goto error;
 771         }
 772
 773         dev->write_buffer =
 774             kmalloc(sizeof(struct alphatrack_ocmd) * true_size, GFP_KERNEL);
 775
 776         if (!dev->write_buffer) {
 777                 dev_err(&intf->dev, "Couldn't allocate write_buffer \n");
 778                 goto error;
 779         }
 780
 781         dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 782         if (!dev->interrupt_out_urb) {
 783                 dev_err(&intf->dev, "Couldn't allocate interrupt_out_urb\n");
 784                 goto error;
 785         }
 786         dev->interrupt_in_interval =
 787             min_interrupt_in_interval >
 788             dev->interrupt_in_endpoint->
 789             bInterval ? min_interrupt_in_interval : dev->interrupt_in_endpoint->
 790             bInterval;
 791         if (dev->interrupt_out_endpoint)
 792                 dev->interrupt_out_interval =
 793                     min_interrupt_out_interval >
 794                     dev->interrupt_out_endpoint->
 795                     bInterval ? min_interrupt_out_interval : dev->
 796                     interrupt_out_endpoint->bInterval;
 797
 798         /* we can register the device now, as it is ready */
 799         usb_set_intfdata(intf, dev);
 800
 801         atomic_set(&dev->writes_pending, 0);
 802         retval = usb_register_dev(intf, &usb_alphatrack_class);
 803         if (retval) {
 804                 /* something prevented us from registering this driver */
 805                 dev_err(&intf->dev,
 806                         "Not able to get a minor for this device.\n");
 807                 usb_set_intfdata(intf, NULL);
 808                 goto error;
 809         }
 810
 811         /* let the user know what node this device is now attached to */
 812         dev_info(&intf->dev,
 813                  "Alphatrack Device #%d now attached to major %d minor %d\n",
 814                  (intf->minor - USB_ALPHATRACK_MINOR_BASE), USB_MAJOR,
 815                  intf->minor);
 816
 817 exit:
 818         return retval;
 819
 820 error:
 821         usb_alphatrack_delete(dev);
 822
 823         return retval;
 824 }
 825
 826 /**
 827  *      usb_alphatrack_disconnect
 828  *
 829  *      Called by the usb core when the device is removed from the system.
 830  */
 831 static void usb_alphatrack_disconnect(struct usb_interface *intf)
 832 {
 833         struct usb_alphatrack *dev;
 834         int minor;
 835
 836         mutex_lock(&disconnect_mutex);
 837
 838         dev = usb_get_intfdata(intf);
 839         usb_set_intfdata(intf, NULL);
 840
 841         down(&dev->sem);
 842
 843         minor = intf->minor;
 844
 845         /* give back our minor */
 846         usb_deregister_dev(intf, &usb_alphatrack_class);
 847
 848         /* if the device is not opened, then we clean up right now */
 849         if (!dev->open_count) {
 850                 up(&dev->sem);
 851                 usb_alphatrack_delete(dev);
 852         } else {
 853                 dev->intf = NULL;
 854                 up(&dev->sem);
 855         }
 856
 857         atomic_set(&dev->writes_pending, 0);
 858         mutex_unlock(&disconnect_mutex);
 859
 860         dev_info(&intf->dev, "Alphatrack Surface #%d now disconnected\n",
 861                  (minor - USB_ALPHATRACK_MINOR_BASE));
 862 }
 863
 864 /* usb specific object needed to register this driver with the usb subsystem */
 865 static struct usb_driver usb_alphatrack_driver = {
 866         .name = "alphatrack",
 867         .probe = usb_alphatrack_probe,
 868         .disconnect = usb_alphatrack_disconnect,
 869         .id_table = usb_alphatrack_table,
 870 };
 871
 872 /**
 873  *      usb_alphatrack_init
 874  */
 875 static int __init usb_alphatrack_init(void)
 876 {
 877         int retval;
 878
 879         /* register this driver with the USB subsystem */
 880         retval = usb_register(&usb_alphatrack_driver);
 881         if (retval)
 882                 err("usb_register failed for the " __FILE__
 883                     " driver. Error number %d\n", retval);
 884
 885         return retval;
 886 }
 887
 888 /**
 889  *      usb_alphatrack_exit
 890  */
 891 static void __exit usb_alphatrack_exit(void)
 892 {
 893         /* deregister this driver with the USB subsystem */
 894         usb_deregister(&usb_alphatrack_driver);
 895 }
 896
 897 module_init(usb_alphatrack_init);
 898 module_exit(usb_alphatrack_exit);