drivers/usb/misc/legousbtower.c

   1 /*
   2  * LEGO USB Tower driver
   3  *
   4  * Copyright (C) 2003 David Glance <davidgsf@sourceforge.net>
   5  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License as
   9  *      published by the Free Software Foundation; either version 2 of
  10  *      the License, or (at your option) any later version.
  11  *
  12  * derived from USB Skeleton driver - 0.5
  13  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
  14  *
  15  * History:
  16  *
  17  * 2001-10-13 - 0.1 js
  18  *   - first version
  19  * 2001-11-03 - 0.2 js
  20  *   - simplified buffering, one-shot URBs for writing
  21  * 2001-11-10 - 0.3 js
  22  *   - removed IOCTL (setting power/mode is more complicated, postponed)
  23  * 2001-11-28 - 0.4 js
  24  *   - added vendor commands for mode of operation and power level in open
  25  * 2001-12-04 - 0.5 js
  26  *   - set IR mode by default (by oversight 0.4 set VLL mode)
  27  * 2002-01-11 - 0.5? pcchan
  28  *   - make read buffer reusable and work around bytes_to_write issue between
  29  *     uhci and legusbtower
  30  * 2002-09-23 - 0.52 david (david@csse.uwa.edu.au)
  31  *   - imported into lejos project
  32  *   - changed wake_up to wake_up_interruptible
  33  *   - changed to use lego0 rather than tower0
  34  *   - changed dbg() to use __func__ rather than deprecated __func__
  35  * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
  36  *   - changed read and write to write everything or
  37  *     timeout (from a patch by Chris Riesen and Brett Thaeler driver)
  38  *   - added ioctl functionality to set timeouts
  39  * 2003-07-18 - 0.54 davidgsf (david@csse.uwa.edu.au)
  40  *   - initial import into LegoUSB project
  41  *   - merge of existing LegoUSB.c driver
  42  * 2003-07-18 - 0.56 davidgsf (david@csse.uwa.edu.au)
  43  *   - port to 2.6 style driver
  44  * 2004-02-29 - 0.6 Juergen Stuber <starblue@users.sourceforge.net>
  45  *   - fix locking
  46  *   - unlink read URBs which are no longer needed
  47  *   - allow increased buffer size, eliminates need for timeout on write
  48  *   - have read URB running continuously
  49  *   - added poll
  50  *   - forbid seeking
  51  *   - added nonblocking I/O
  52  *   - changed back __func__ to __func__
  53  *   - read and log tower firmware version
  54  *   - reset tower on probe, avoids failure of first write
  55  * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
  56  *   - timeout read now only after inactivity, shorten default accordingly
  57  * 2004-03-11 - 0.8 Juergen Stuber <starblue@users.sourceforge.net>
  58  *   - log major, minor instead of possibly confusing device filename
  59  *   - whitespace cleanup
  60  * 2004-03-12 - 0.9 Juergen Stuber <starblue@users.sourceforge.net>
  61  *   - normalize whitespace in debug messages
  62  *   - take care about endianness in control message responses
  63  * 2004-03-13 - 0.91 Juergen Stuber <starblue@users.sourceforge.net>
  64  *   - make default intervals longer to accommodate current EHCI driver
  65  * 2004-03-19 - 0.92 Juergen Stuber <starblue@users.sourceforge.net>
  66  *   - replaced atomic_t by memory barriers
  67  * 2004-04-21 - 0.93 Juergen Stuber <starblue@users.sourceforge.net>
  68  *   - wait for completion of write urb in release (needed for remotecontrol)
  69  *   - corrected poll for write direction (missing negation)
  70  * 2004-04-22 - 0.94 Juergen Stuber <starblue@users.sourceforge.net>
  71  *   - make device locking interruptible
  72  * 2004-04-30 - 0.95 Juergen Stuber <starblue@users.sourceforge.net>
  73  *   - check for valid udev on resubmitting and unlinking urbs
  74  * 2004-08-03 - 0.96 Juergen Stuber <starblue@users.sourceforge.net>
  75  *   - move reset into open to clean out spurious data
  76  */
  77
  78 #include <linux/kernel.h>
  79 #include <linux/errno.h>
  80 #include <linux/init.h>
  81 #include <linux/slab.h>
  82 #include <linux/module.h>
  83 #include <linux/completion.h>
  84 #include <linux/mutex.h>
  85 #include <asm/uaccess.h>
  86 #include <linux/usb.h>
  87 #include <linux/poll.h>
  88
  89
  90 #ifdef CONFIG_USB_DEBUG
  91         static int debug = 4;
  92 #else
  93         static int debug = 0;
  94 #endif
  95
  96 /* Use our own dbg macro */
  97 #undef dbg
  98 #define dbg(lvl, format, arg...)                                        \
  99 do {                                                                    \
 100         if (debug >= lvl)                                               \
 101                 printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
 102 } while (0)
 103
 104 /* Version Information */
 105 #define DRIVER_VERSION "v0.96"
 106 #define DRIVER_AUTHOR "Juergen Stuber <starblue@sourceforge.net>"
 107 #define DRIVER_DESC "LEGO USB Tower Driver"
 108
 109 /* Module parameters */
 110 module_param(debug, int, S_IRUGO | S_IWUSR);
 111 MODULE_PARM_DESC(debug, "Debug enabled or not");
 112
 113 /* The defaults are chosen to work with the latest versions of leJOS and NQC.
 114  */
 115
 116 /* Some legacy software likes to receive packets in one piece.
 117  * In this case read_buffer_size should exceed the maximal packet length
 118  * (417 for datalog uploads), and packet_timeout should be set.
 119  */
 120 static int read_buffer_size = 480;
 121 module_param(read_buffer_size, int, 0);
 122 MODULE_PARM_DESC(read_buffer_size, "Read buffer size");
 123
 124 /* Some legacy software likes to send packets in one piece.
 125  * In this case write_buffer_size should exceed the maximal packet length
 126  * (417 for firmware and program downloads).
 127  * A problem with long writes is that the following read may time out
 128  * if the software is not prepared to wait long enough.
 129  */
 130 static int write_buffer_size = 480;
 131 module_param(write_buffer_size, int, 0);
 132 MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
 133
 134 /* Some legacy software expects reads to contain whole LASM packets.
 135  * To achieve this, characters which arrive before a packet timeout
 136  * occurs will be returned in a single read operation.
 137  * A problem with long reads is that the software may time out
 138  * if it is not prepared to wait long enough.
 139  * The packet timeout should be greater than the time between the
 140  * reception of subsequent characters, which should arrive about
 141  * every 5ms for the standard 2400 baud.
 142  * Set it to 0 to disable.
 143  */
 144 static int packet_timeout = 50;
 145 module_param(packet_timeout, int, 0);
 146 MODULE_PARM_DESC(packet_timeout, "Packet timeout in ms");
 147
 148 /* Some legacy software expects blocking reads to time out.
 149  * Timeout occurs after the specified time of read and write inactivity.
 150  * Set it to 0 to disable.
 151  */
 152 static int read_timeout = 200;
 153 module_param(read_timeout, int, 0);
 154 MODULE_PARM_DESC(read_timeout, "Read timeout in ms");
 155
 156 /* As of kernel version 2.6.4 ehci-hcd uses an
 157  * "only one interrupt transfer per frame" shortcut
 158  * to simplify the scheduling of periodic transfers.
 159  * This conflicts with our standard 1ms intervals for in and out URBs.
 160  * We use default intervals of 2ms for in and 8ms for out transfers,
 161  * which is fast enough for 2400 baud and allows a small additional load.
 162  * Increase the interval to allow more devices that do interrupt transfers,
 163  * or set to 0 to use the standard interval from the endpoint descriptors.
 164  */
 165 static int interrupt_in_interval = 2;
 166 module_param(interrupt_in_interval, int, 0);
 167 MODULE_PARM_DESC(interrupt_in_interval, "Interrupt in interval in ms");
 168
 169 static int interrupt_out_interval = 8;
 170 module_param(interrupt_out_interval, int, 0);
 171 MODULE_PARM_DESC(interrupt_out_interval, "Interrupt out interval in ms");
 172
 173 /* Define these values to match your device */
 174 #define LEGO_USB_TOWER_VENDOR_ID        0x0694
 175 #define LEGO_USB_TOWER_PRODUCT_ID       0x0001
 176
 177 /* Vendor requests */
 178 #define LEGO_USB_TOWER_REQUEST_RESET            0x04
 179 #define LEGO_USB_TOWER_REQUEST_GET_VERSION      0xFD
 180
 181 struct tower_reset_reply {
 182         __le16 size;            /* little-endian */
 183         __u8 err_code;
 184         __u8 spare;
 185 } __attribute__ ((packed));
 186
 187 struct tower_get_version_reply {
 188         __le16 size;            /* little-endian */
 189         __u8 err_code;
 190         __u8 spare;
 191         __u8 major;
 192         __u8 minor;
 193         __le16 build_no;                /* little-endian */
 194 } __attribute__ ((packed));
 195
 196
 197 /* table of devices that work with this driver */
 198 static const struct usb_device_id tower_table[] = {
 199         { USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
 200         { }                                     /* Terminating entry */
 201 };
 202
 203 MODULE_DEVICE_TABLE (usb, tower_table);
 204 static DEFINE_MUTEX(open_disc_mutex);
 205
 206 #define LEGO_USB_TOWER_MINOR_BASE       160
 207
 208
 209 /* Structure to hold all of our device specific stuff */
 210 struct lego_usb_tower {
 211         struct mutex            lock;           /* locks this structure */
 212         struct usb_device*      udev;           /* save off the usb device pointer */
 213         unsigned char           minor;          /* the starting minor number for this device */
 214
 215         int                     open_count;     /* number of times this port has been opened */
 216
 217         char*                   read_buffer;
 218         size_t                  read_buffer_length; /* this much came in */
 219         size_t                  read_packet_length; /* this much will be returned on read */
 220         spinlock_t              read_buffer_lock;
 221         int                     packet_timeout_jiffies;
 222         unsigned long           read_last_arrival;
 223
 224         wait_queue_head_t       read_wait;
 225         wait_queue_head_t       write_wait;
 226
 227         char*                   interrupt_in_buffer;
 228         struct usb_endpoint_descriptor* interrupt_in_endpoint;
 229         struct urb*             interrupt_in_urb;
 230         int                     interrupt_in_interval;
 231         int                     interrupt_in_running;
 232         int                     interrupt_in_done;
 233
 234         char*                   interrupt_out_buffer;
 235         struct usb_endpoint_descriptor* interrupt_out_endpoint;
 236         struct urb*             interrupt_out_urb;
 237         int                     interrupt_out_interval;
 238         int                     interrupt_out_busy;
 239
 240 };
 241
 242
 243 /* local function prototypes */
 244 static ssize_t tower_read       (struct file *file, char __user *buffer, size_t count, loff_t *ppos);
 245 static ssize_t tower_write      (struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
 246 static inline void tower_delete (struct lego_usb_tower *dev);
 247 static int tower_open           (struct inode *inode, struct file *file);
 248 static int tower_release        (struct inode *inode, struct file *file);
 249 static unsigned int tower_poll  (struct file *file, poll_table *wait);
 250 static loff_t tower_llseek      (struct file *file, loff_t off, int whence);
 251
 252 static void tower_abort_transfers (struct lego_usb_tower *dev);
 253 static void tower_check_for_read_packet (struct lego_usb_tower *dev);
 254 static void tower_interrupt_in_callback (struct urb *urb);
 255 static void tower_interrupt_out_callback (struct urb *urb);
 256
 257 static int  tower_probe (struct usb_interface *interface, const struct usb_device_id *id);
 258 static void tower_disconnect    (struct usb_interface *interface);
 259
 260
 261 /* file operations needed when we register this driver */
 262 static const struct file_operations tower_fops = {
 263         .owner =        THIS_MODULE,
 264         .read  =        tower_read,
 265         .write =        tower_write,
 266         .open =         tower_open,
 267         .release =      tower_release,
 268         .poll =         tower_poll,
 269         .llseek =       tower_llseek,
 270 };
 271
 272 static char *legousbtower_devnode(struct device *dev, umode_t *mode)
 273 {
 274         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 275 }
 276
 277 /*
 278  * usb class driver info in order to get a minor number from the usb core,
 279  * and to have the device registered with the driver core
 280  */
 281 static struct usb_class_driver tower_class = {
 282         .name =         "legousbtower%d",
 283         .devnode =      legousbtower_devnode,
 284         .fops =         &tower_fops,
 285         .minor_base =   LEGO_USB_TOWER_MINOR_BASE,
 286 };
 287
 288
 289 /* usb specific object needed to register this driver with the usb subsystem */
 290 static struct usb_driver tower_driver = {
 291         .name =         "legousbtower",
 292         .probe =        tower_probe,
 293         .disconnect =   tower_disconnect,
 294         .id_table =     tower_table,
 295 };
 296
 297
 298 /**
 299  *      lego_usb_tower_debug_data
 300  */
 301 static inline void lego_usb_tower_debug_data (int level, const char *function, int size, const unsigned char *data)
 302 {
 303         int i;
 304
 305         if (debug < level)
 306                 return;
 307
 308         printk (KERN_DEBUG "%s: %s - length = %d, data = ", __FILE__, function, size);
 309         for (i = 0; i < size; ++i) {
 310                 printk ("%.2x ", data[i]);
 311         }
 312         printk ("\n");
 313 }
 314
 315
 316 /**
 317  *      tower_delete
 318  */
 319 static inline void tower_delete (struct lego_usb_tower *dev)
 320 {
 321         dbg(2, "%s: enter", __func__);
 322
 323         tower_abort_transfers (dev);
 324
 325         /* free data structures */
 326         usb_free_urb(dev->interrupt_in_urb);
 327         usb_free_urb(dev->interrupt_out_urb);
 328         kfree (dev->read_buffer);
 329         kfree (dev->interrupt_in_buffer);
 330         kfree (dev->interrupt_out_buffer);
 331         kfree (dev);
 332
 333         dbg(2, "%s: leave", __func__);
 334 }
 335
 336
 337 /**
 338  *      tower_open
 339  */
 340 static int tower_open (struct inode *inode, struct file *file)
 341 {
 342         struct lego_usb_tower *dev = NULL;
 343         int subminor;
 344         int retval = 0;
 345         struct usb_interface *interface;
 346         struct tower_reset_reply reset_reply;
 347         int result;
 348
 349         dbg(2, "%s: enter", __func__);
 350
 351         nonseekable_open(inode, file);
 352         subminor = iminor(inode);
 353
 354         interface = usb_find_interface (&tower_driver, subminor);
 355
 356         if (!interface) {
 357                 printk(KERN_ERR "%s - error, can't find device for minor %d\n",
 358                        __func__, subminor);
 359                 retval = -ENODEV;
 360                 goto exit;
 361         }
 362
 363         mutex_lock(&open_disc_mutex);
 364         dev = usb_get_intfdata(interface);
 365
 366         if (!dev) {
 367                 mutex_unlock(&open_disc_mutex);
 368                 retval = -ENODEV;
 369                 goto exit;
 370         }
 371
 372         /* lock this device */
 373         if (mutex_lock_interruptible(&dev->lock)) {
 374                 mutex_unlock(&open_disc_mutex);
 375                 retval = -ERESTARTSYS;
 376                 goto exit;
 377         }
 378
 379
 380         /* allow opening only once */
 381         if (dev->open_count) {
 382                 mutex_unlock(&open_disc_mutex);
 383                 retval = -EBUSY;
 384                 goto unlock_exit;
 385         }
 386         dev->open_count = 1;
 387         mutex_unlock(&open_disc_mutex);
 388
 389         /* reset the tower */
 390         result = usb_control_msg (dev->udev,
 391                                   usb_rcvctrlpipe(dev->udev, 0),
 392                                   LEGO_USB_TOWER_REQUEST_RESET,
 393                                   USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
 394                                   0,
 395                                   0,
 396                                   &reset_reply,
 397                                   sizeof(reset_reply),
 398                                   1000);
 399         if (result < 0) {
 400                 dev_err(&dev->udev->dev,
 401                         "LEGO USB Tower reset control request failed\n");
 402                 retval = result;
 403                 goto unlock_exit;
 404         }
 405
 406         /* initialize in direction */
 407         dev->read_buffer_length = 0;
 408         dev->read_packet_length = 0;
 409         usb_fill_int_urb (dev->interrupt_in_urb,
 410                           dev->udev,
 411                           usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
 412                           dev->interrupt_in_buffer,
 413                           usb_endpoint_maxp(dev->interrupt_in_endpoint),
 414                           tower_interrupt_in_callback,
 415                           dev,
 416                           dev->interrupt_in_interval);
 417
 418         dev->interrupt_in_running = 1;
 419         dev->interrupt_in_done = 0;
 420         mb();
 421
 422         retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);
 423         if (retval) {
 424                 dev_err(&dev->udev->dev,
 425                         "Couldn't submit interrupt_in_urb %d\n", retval);
 426                 dev->interrupt_in_running = 0;
 427                 dev->open_count = 0;
 428                 goto unlock_exit;
 429         }
 430
 431         /* save device in the file's private structure */
 432         file->private_data = dev;
 433
 434 unlock_exit:
 435         mutex_unlock(&dev->lock);
 436
 437 exit:
 438         dbg(2, "%s: leave, return value %d ", __func__, retval);
 439
 440         return retval;
 441 }
 442
 443 /**
 444  *      tower_release
 445  */
 446 static int tower_release (struct inode *inode, struct file *file)
 447 {
 448         struct lego_usb_tower *dev;
 449         int retval = 0;
 450
 451         dbg(2, "%s: enter", __func__);
 452
 453         dev = file->private_data;
 454
 455         if (dev == NULL) {
 456                 dbg(1, "%s: object is NULL", __func__);
 457                 retval = -ENODEV;
 458                 goto exit_nolock;
 459         }
 460
 461         mutex_lock(&open_disc_mutex);
 462         if (mutex_lock_interruptible(&dev->lock)) {
 463                 retval = -ERESTARTSYS;
 464                 goto exit;
 465         }
 466
 467         if (dev->open_count != 1) {
 468                 dbg(1, "%s: device not opened exactly once", __func__);
 469                 retval = -ENODEV;
 470                 goto unlock_exit;
 471         }
 472         if (dev->udev == NULL) {
 473                 /* the device was unplugged before the file was released */
 474
 475                 /* unlock here as tower_delete frees dev */
 476                 mutex_unlock(&dev->lock);
 477                 tower_delete (dev);
 478                 goto exit;
 479         }
 480
 481         /* wait until write transfer is finished */
 482         if (dev->interrupt_out_busy) {
 483                 wait_event_interruptible_timeout (dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);
 484         }
 485         tower_abort_transfers (dev);
 486         dev->open_count = 0;
 487
 488 unlock_exit:
 489         mutex_unlock(&dev->lock);
 490
 491 exit:
 492         mutex_unlock(&open_disc_mutex);
 493 exit_nolock:
 494         dbg(2, "%s: leave, return value %d", __func__, retval);
 495         return retval;
 496 }
 497
 498
 499 /**
 500  *      tower_abort_transfers
 501  *      aborts transfers and frees associated data structures
 502  */
 503 static void tower_abort_transfers (struct lego_usb_tower *dev)
 504 {
 505         dbg(2, "%s: enter", __func__);
 506
 507         if (dev == NULL) {
 508                 dbg(1, "%s: dev is null", __func__);
 509                 goto exit;
 510         }
 511
 512         /* shutdown transfer */
 513         if (dev->interrupt_in_running) {
 514                 dev->interrupt_in_running = 0;
 515                 mb();
 516                 if (dev->udev)
 517                         usb_kill_urb (dev->interrupt_in_urb);
 518         }
 519         if (dev->interrupt_out_busy && dev->udev)
 520                 usb_kill_urb(dev->interrupt_out_urb);
 521
 522 exit:
 523         dbg(2, "%s: leave", __func__);
 524 }
 525
 526
 527 /**
 528  *      tower_check_for_read_packet
 529  *
 530  *      To get correct semantics for signals and non-blocking I/O
 531  *      with packetizing we pretend not to see any data in the read buffer
 532  *      until it has been there unchanged for at least
 533  *      dev->packet_timeout_jiffies, or until the buffer is full.
 534  */
 535 static void tower_check_for_read_packet (struct lego_usb_tower *dev)
 536 {
 537         spin_lock_irq (&dev->read_buffer_lock);
 538         if (!packet_timeout
 539             || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)
 540             || dev->read_buffer_length == read_buffer_size) {
 541                 dev->read_packet_length = dev->read_buffer_length;
 542         }
 543         dev->interrupt_in_done = 0;
 544         spin_unlock_irq (&dev->read_buffer_lock);
 545 }
 546
 547
 548 /**
 549  *      tower_poll
 550  */
 551 static unsigned int tower_poll (struct file *file, poll_table *wait)
 552 {
 553         struct lego_usb_tower *dev;
 554         unsigned int mask = 0;
 555
 556         dbg(2, "%s: enter", __func__);
 557
 558         dev = file->private_data;
 559
 560         if (!dev->udev)
 561                 return POLLERR | POLLHUP;
 562
 563         poll_wait(file, &dev->read_wait, wait);
 564         poll_wait(file, &dev->write_wait, wait);
 565
 566         tower_check_for_read_packet(dev);
 567         if (dev->read_packet_length > 0) {
 568                 mask |= POLLIN | POLLRDNORM;
 569         }
 570         if (!dev->interrupt_out_busy) {
 571                 mask |= POLLOUT | POLLWRNORM;
 572         }
 573
 574         dbg(2, "%s: leave, mask = %d", __func__, mask);
 575
 576         return mask;
 577 }
 578
 579
 580 /**
 581  *      tower_llseek
 582  */
 583 static loff_t tower_llseek (struct file *file, loff_t off, int whence)
 584 {
 585         return -ESPIPE;         /* unseekable */
 586 }
 587
 588
 589 /**
 590  *      tower_read
 591  */
 592 static ssize_t tower_read (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 593 {
 594         struct lego_usb_tower *dev;
 595         size_t bytes_to_read;
 596         int i;
 597         int retval = 0;
 598         unsigned long timeout = 0;
 599
 600         dbg(2, "%s: enter, count = %Zd", __func__, count);
 601
 602         dev = file->private_data;
 603
 604         /* lock this object */
 605         if (mutex_lock_interruptible(&dev->lock)) {
 606                 retval = -ERESTARTSYS;
 607                 goto exit;
 608         }
 609
 610         /* verify that the device wasn't unplugged */
 611         if (dev->udev == NULL) {
 612                 retval = -ENODEV;
 613                 printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval);
 614                 goto unlock_exit;
 615         }
 616
 617         /* verify that we actually have some data to read */
 618         if (count == 0) {
 619                 dbg(1, "%s: read request of 0 bytes", __func__);
 620                 goto unlock_exit;
 621         }
 622
 623         if (read_timeout) {
 624                 timeout = jiffies + read_timeout * HZ / 1000;
 625         }
 626
 627         /* wait for data */
 628         tower_check_for_read_packet (dev);
 629         while (dev->read_packet_length == 0) {
 630                 if (file->f_flags & O_NONBLOCK) {
 631                         retval = -EAGAIN;
 632                         goto unlock_exit;
 633                 }
 634                 retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
 635                 if (retval < 0) {
 636                         goto unlock_exit;
 637                 }
 638
 639                 /* reset read timeout during read or write activity */
 640                 if (read_timeout
 641                     && (dev->read_buffer_length || dev->interrupt_out_busy)) {
 642                         timeout = jiffies + read_timeout * HZ / 1000;
 643                 }
 644                 /* check for read timeout */
 645                 if (read_timeout && time_after (jiffies, timeout)) {
 646                         retval = -ETIMEDOUT;
 647                         goto unlock_exit;
 648                 }
 649                 tower_check_for_read_packet (dev);
 650         }
 651
 652         /* copy the data from read_buffer into userspace */
 653         bytes_to_read = min(count, dev->read_packet_length);
 654
 655         if (copy_to_user (buffer, dev->read_buffer, bytes_to_read)) {
 656                 retval = -EFAULT;
 657                 goto unlock_exit;
 658         }
 659
 660         spin_lock_irq (&dev->read_buffer_lock);
 661         dev->read_buffer_length -= bytes_to_read;
 662         dev->read_packet_length -= bytes_to_read;
 663         for (i=0; i<dev->read_buffer_length; i++) {
 664                 dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
 665         }
 666         spin_unlock_irq (&dev->read_buffer_lock);
 667
 668         retval = bytes_to_read;
 669
 670 unlock_exit:
 671         /* unlock the device */
 672         mutex_unlock(&dev->lock);
 673
 674 exit:
 675         dbg(2, "%s: leave, return value %d", __func__, retval);
 676         return retval;
 677 }
 678
 679
 680 /**
 681  *      tower_write
 682  */
 683 static ssize_t tower_write (struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 684 {
 685         struct lego_usb_tower *dev;
 686         size_t bytes_to_write;
 687         int retval = 0;
 688
 689         dbg(2, "%s: enter, count = %Zd", __func__, count);
 690
 691         dev = file->private_data;
 692
 693         /* lock this object */
 694         if (mutex_lock_interruptible(&dev->lock)) {
 695                 retval = -ERESTARTSYS;
 696                 goto exit;
 697         }
 698
 699         /* verify that the device wasn't unplugged */
 700         if (dev->udev == NULL) {
 701                 retval = -ENODEV;
 702                 printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval);
 703                 goto unlock_exit;
 704         }
 705
 706         /* verify that we actually have some data to write */
 707         if (count == 0) {
 708                 dbg(1, "%s: write request of 0 bytes", __func__);
 709                 goto unlock_exit;
 710         }
 711
 712         /* wait until previous transfer is finished */
 713         while (dev->interrupt_out_busy) {
 714                 if (file->f_flags & O_NONBLOCK) {
 715                         retval = -EAGAIN;
 716                         goto unlock_exit;
 717                 }
 718                 retval = wait_event_interruptible (dev->write_wait, !dev->interrupt_out_busy);
 719                 if (retval) {
 720                         goto unlock_exit;
 721                 }
 722         }
 723
 724         /* write the data into interrupt_out_buffer from userspace */
 725         bytes_to_write = min_t(int, count, write_buffer_size);
 726         dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __func__, count, bytes_to_write);
 727
 728         if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
 729                 retval = -EFAULT;
 730                 goto unlock_exit;
 731         }
 732
 733         /* send off the urb */
 734         usb_fill_int_urb(dev->interrupt_out_urb,
 735                          dev->udev,
 736                          usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
 737                          dev->interrupt_out_buffer,
 738                          bytes_to_write,
 739                          tower_interrupt_out_callback,
 740                          dev,
 741                          dev->interrupt_out_interval);
 742
 743         dev->interrupt_out_busy = 1;
 744         wmb();
 745
 746         retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
 747         if (retval) {
 748                 dev->interrupt_out_busy = 0;
 749                 dev_err(&dev->udev->dev,
 750                         "Couldn't submit interrupt_out_urb %d\n", retval);
 751                 goto unlock_exit;
 752         }
 753         retval = bytes_to_write;
 754
 755 unlock_exit:
 756         /* unlock the device */
 757         mutex_unlock(&dev->lock);
 758
 759 exit:
 760         dbg(2, "%s: leave, return value %d", __func__, retval);
 761
 762         return retval;
 763 }
 764
 765
 766 /**
 767  *      tower_interrupt_in_callback
 768  */
 769 static void tower_interrupt_in_callback (struct urb *urb)
 770 {
 771         struct lego_usb_tower *dev = urb->context;
 772         int status = urb->status;
 773         int retval;
 774
 775         dbg(4, "%s: enter, status %d", __func__, status);
 776
 777         lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 778
 779         if (status) {
 780                 if (status == -ENOENT ||
 781                     status == -ECONNRESET ||
 782                     status == -ESHUTDOWN) {
 783                         goto exit;
 784                 } else {
 785                         dbg(1, "%s: nonzero status received: %d", __func__, status);
 786                         goto resubmit; /* maybe we can recover */
 787                 }
 788         }
 789
 790         if (urb->actual_length > 0) {
 791                 spin_lock (&dev->read_buffer_lock);
 792                 if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {
 793                         memcpy (dev->read_buffer + dev->read_buffer_length,
 794                                 dev->interrupt_in_buffer,
 795                                 urb->actual_length);
 796                         dev->read_buffer_length += urb->actual_length;
 797                         dev->read_last_arrival = jiffies;
 798                         dbg(3, "%s: received %d bytes", __func__, urb->actual_length);
 799                 } else {
 800                         printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __func__, urb->actual_length);
 801                 }
 802                 spin_unlock (&dev->read_buffer_lock);
 803         }
 804
 805 resubmit:
 806         /* resubmit if we're still running */
 807         if (dev->interrupt_in_running && dev->udev) {
 808                 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
 809                 if (retval)
 810                         dev_err(&dev->udev->dev,
 811                                 "%s: usb_submit_urb failed (%d)\n",
 812                                 __func__, retval);
 813         }
 814
 815 exit:
 816         dev->interrupt_in_done = 1;
 817         wake_up_interruptible (&dev->read_wait);
 818
 819         lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 820         dbg(4, "%s: leave, status %d", __func__, status);
 821 }
 822
 823
 824 /**
 825  *      tower_interrupt_out_callback
 826  */
 827 static void tower_interrupt_out_callback (struct urb *urb)
 828 {
 829         struct lego_usb_tower *dev = urb->context;
 830         int status = urb->status;
 831
 832         dbg(4, "%s: enter, status %d", __func__, status);
 833         lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 834
 835         /* sync/async unlink faults aren't errors */
 836         if (status && !(status == -ENOENT ||
 837                         status == -ECONNRESET ||
 838                         status == -ESHUTDOWN)) {
 839                 dbg(1, "%s - nonzero write bulk status received: %d",
 840                     __func__, status);
 841         }
 842
 843         dev->interrupt_out_busy = 0;
 844         wake_up_interruptible(&dev->write_wait);
 845
 846         lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 847         dbg(4, "%s: leave, status %d", __func__, status);
 848 }
 849
 850
 851 /**
 852  *      tower_probe
 853  *
 854  *      Called by the usb core when a new device is connected that it thinks
 855  *      this driver might be interested in.
 856  */
 857 static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id)
 858 {
 859         struct device *idev = &interface->dev;
 860         struct usb_device *udev = interface_to_usbdev(interface);
 861         struct lego_usb_tower *dev = NULL;
 862         struct usb_host_interface *iface_desc;
 863         struct usb_endpoint_descriptor* endpoint;
 864         struct tower_get_version_reply get_version_reply;
 865         int i;
 866         int retval = -ENOMEM;
 867         int result;
 868
 869         dbg(2, "%s: enter", __func__);
 870
 871         /* allocate memory for our device state and initialize it */
 872
 873         dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
 874
 875         if (dev == NULL) {
 876                 dev_err(idev, "Out of memory\n");
 877                 goto exit;
 878         }
 879
 880         mutex_init(&dev->lock);
 881
 882         dev->udev = udev;
 883         dev->open_count = 0;
 884
 885         dev->read_buffer = NULL;
 886         dev->read_buffer_length = 0;
 887         dev->read_packet_length = 0;
 888         spin_lock_init (&dev->read_buffer_lock);
 889         dev->packet_timeout_jiffies = packet_timeout * HZ / 1000;
 890         dev->read_last_arrival = jiffies;
 891
 892         init_waitqueue_head (&dev->read_wait);
 893         init_waitqueue_head (&dev->write_wait);
 894
 895         dev->interrupt_in_buffer = NULL;
 896         dev->interrupt_in_endpoint = NULL;
 897         dev->interrupt_in_urb = NULL;
 898         dev->interrupt_in_running = 0;
 899         dev->interrupt_in_done = 0;
 900
 901         dev->interrupt_out_buffer = NULL;
 902         dev->interrupt_out_endpoint = NULL;
 903         dev->interrupt_out_urb = NULL;
 904         dev->interrupt_out_busy = 0;
 905
 906         iface_desc = interface->cur_altsetting;
 907
 908         /* set up the endpoint information */
 909         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 910                 endpoint = &iface_desc->endpoint[i].desc;
 911
 912                 if (usb_endpoint_xfer_int(endpoint)) {
 913                         if (usb_endpoint_dir_in(endpoint))
 914                                 dev->interrupt_in_endpoint = endpoint;
 915                         else
 916                                 dev->interrupt_out_endpoint = endpoint;
 917                 }
 918         }
 919         if(dev->interrupt_in_endpoint == NULL) {
 920                 dev_err(idev, "interrupt in endpoint not found\n");
 921                 goto error;
 922         }
 923         if (dev->interrupt_out_endpoint == NULL) {
 924                 dev_err(idev, "interrupt out endpoint not found\n");
 925                 goto error;
 926         }
 927
 928         dev->read_buffer = kmalloc (read_buffer_size, GFP_KERNEL);
 929         if (!dev->read_buffer) {
 930                 dev_err(idev, "Couldn't allocate read_buffer\n");
 931                 goto error;
 932         }
 933         dev->interrupt_in_buffer = kmalloc (usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
 934         if (!dev->interrupt_in_buffer) {
 935                 dev_err(idev, "Couldn't allocate interrupt_in_buffer\n");
 936                 goto error;
 937         }
 938         dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 939         if (!dev->interrupt_in_urb) {
 940                 dev_err(idev, "Couldn't allocate interrupt_in_urb\n");
 941                 goto error;
 942         }
 943         dev->interrupt_out_buffer = kmalloc (write_buffer_size, GFP_KERNEL);
 944         if (!dev->interrupt_out_buffer) {
 945                 dev_err(idev, "Couldn't allocate interrupt_out_buffer\n");
 946                 goto error;
 947         }
 948         dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 949         if (!dev->interrupt_out_urb) {
 950                 dev_err(idev, "Couldn't allocate interrupt_out_urb\n");
 951                 goto error;
 952         }
 953         dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
 954         dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
 955
 956         /* we can register the device now, as it is ready */
 957         usb_set_intfdata (interface, dev);
 958
 959         retval = usb_register_dev (interface, &tower_class);
 960
 961         if (retval) {
 962                 /* something prevented us from registering this driver */
 963                 dev_err(idev, "Not able to get a minor for this device.\n");
 964                 usb_set_intfdata (interface, NULL);
 965                 goto error;
 966         }
 967         dev->minor = interface->minor;
 968
 969         /* let the user know what node this device is now attached to */
 970         dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "
 971                  "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),
 972                  USB_MAJOR, dev->minor);
 973
 974         /* get the firmware version and log it */
 975         result = usb_control_msg (udev,
 976                                   usb_rcvctrlpipe(udev, 0),
 977                                   LEGO_USB_TOWER_REQUEST_GET_VERSION,
 978                                   USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
 979                                   0,
 980                                   0,
 981                                   &get_version_reply,
 982                                   sizeof(get_version_reply),
 983                                   1000);
 984         if (result < 0) {
 985                 dev_err(idev, "LEGO USB Tower get version control request failed\n");
 986                 retval = result;
 987                 goto error;
 988         }
 989         dev_info(&interface->dev, "LEGO USB Tower firmware version is %d.%d "
 990                  "build %d\n", get_version_reply.major,
 991                  get_version_reply.minor,
 992                  le16_to_cpu(get_version_reply.build_no));
 993
 994
 995 exit:
 996         dbg(2, "%s: leave, return value 0x%.8lx (dev)", __func__, (long) dev);
 997
 998         return retval;
 999
1000 error:
1001         tower_delete(dev);
1002         return retval;
1003 }
1004
1005
1006 /**
1007  *      tower_disconnect
1008  *
1009  *      Called by the usb core when the device is removed from the system.
1010  */
1011 static void tower_disconnect (struct usb_interface *interface)
1012 {
1013         struct lego_usb_tower *dev;
1014         int minor;
1015
1016         dbg(2, "%s: enter", __func__);
1017
1018         dev = usb_get_intfdata (interface);
1019         mutex_lock(&open_disc_mutex);
1020         usb_set_intfdata (interface, NULL);
1021
1022         minor = dev->minor;
1023
1024         /* give back our minor */
1025         usb_deregister_dev (interface, &tower_class);
1026
1027         mutex_lock(&dev->lock);
1028         mutex_unlock(&open_disc_mutex);
1029
1030         /* if the device is not opened, then we clean up right now */
1031         if (!dev->open_count) {
1032                 mutex_unlock(&dev->lock);
1033                 tower_delete (dev);
1034         } else {
1035                 dev->udev = NULL;
1036                 /* wake up pollers */
1037                 wake_up_interruptible_all(&dev->read_wait);
1038                 wake_up_interruptible_all(&dev->write_wait);
1039                 mutex_unlock(&dev->lock);
1040         }
1041
1042         dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",
1043                  (minor - LEGO_USB_TOWER_MINOR_BASE));
1044
1045         dbg(2, "%s: leave", __func__);
1046 }
1047
1048 module_usb_driver(tower_driver);
1049
1050 MODULE_AUTHOR(DRIVER_AUTHOR);
1051 MODULE_DESCRIPTION(DRIVER_DESC);
1052 #ifdef MODULE_LICENSE
1053 MODULE_LICENSE("GPL");
1054 #endif