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