drivers/usb/misc/legousbtower.c

   1 /*
   2  * LEGO USB Tower driver
   3  *
   4  * Copyright (C) 2003 David Glance <davidgsf@sourceforge.net>
   5  *               2001 Juergen Stuber <stuber@loria.fr>
   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 timeout (from a patch by Chris Riesen and
  37  *     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  */
  45
  46 #include <linux/config.h>
  47 #include <linux/kernel.h>
  48 #include <linux/errno.h>
  49 #include <linux/init.h>
  50 #include <linux/slab.h>
  51 #include <linux/module.h>
  52 #include <linux/smp_lock.h>
  53 #include <linux/completion.h>
  54 #include <asm/uaccess.h>
  55 #include <linux/usb.h>
  56
  57
  58 #ifdef CONFIG_USB_DEBUG
  59         static int debug = 4;
  60 #else
  61         static int debug = 1;
  62 #endif
  63
  64 /* Use our own dbg macro */
  65 #undef dbg
  66 #define dbg(lvl, format, arg...) do { if (debug >= lvl) printk(KERN_DEBUG  __FILE__ " : " format " \n", ## arg); } while (0)
  67
  68
  69 /* Version Information */
  70 #define DRIVER_VERSION "v0.56"
  71 #define DRIVER_AUTHOR "David Glance, davidgsf@sourceforge.net"
  72 #define DRIVER_DESC "LEGO USB Tower Driver"
  73
  74 /* Module paramaters */
  75 MODULE_PARM(debug, "i");
  76 MODULE_PARM_DESC(debug, "Debug enabled or not");
  77
  78
  79 /* Define these values to match your device */
  80 #define LEGO_USB_TOWER_VENDOR_ID        0x0694
  81 #define LEGO_USB_TOWER_PRODUCT_ID       0x0001
  82
  83 /* table of devices that work with this driver */
  84 static struct usb_device_id tower_table [] = {
  85         { USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
  86         { }                                     /* Terminating entry */
  87 };
  88
  89 MODULE_DEVICE_TABLE (usb, tower_table);
  90
  91 #define LEGO_USB_TOWER_MINOR_BASE       160
  92
  93 /* we can have up to this number of device plugged in at once */
  94 #define MAX_DEVICES             16
  95
  96 #define COMMAND_TIMEOUT         (2*HZ)  /* 2 second timeout for a command */
  97
  98 /* Structure to hold all of our device specific stuff */
  99 struct lego_usb_tower {
 100         struct semaphore        sem;            /* locks this structure */
 101         struct usb_device*      udev;           /* save off the usb device pointer */
 102         struct usb_interface*   interface;
 103         unsigned char           minor;          /* the starting minor number for this device */
 104
 105         int                     open_count;     /* number of times this port has been opened */
 106
 107         char*                   read_buffer;
 108         int                     read_buffer_length;
 109
 110         wait_queue_head_t       read_wait;
 111         wait_queue_head_t       write_wait;
 112
 113         char*                   interrupt_in_buffer;
 114         struct usb_endpoint_descriptor* interrupt_in_endpoint;
 115         struct urb*             interrupt_in_urb;
 116
 117         char*                   interrupt_out_buffer;
 118         struct usb_endpoint_descriptor* interrupt_out_endpoint;
 119         struct urb*             interrupt_out_urb;
 120
 121 };
 122
 123 /* Note that no locking is needed:
 124  * read_buffer is arbitrated by read_buffer_length == 0
 125  * interrupt_out_buffer is arbitrated by interrupt_out_urb->status == -EINPROGRESS
 126  * interrupt_in_buffer belongs to urb alone and is overwritten on overflow
 127  */
 128
 129 /* local function prototypes */
 130 static ssize_t tower_read       (struct file *file, char *buffer, size_t count, loff_t *ppos);
 131 static ssize_t tower_write      (struct file *file, const char *buffer, size_t count, loff_t *ppos);
 132 static inline void tower_delete (struct lego_usb_tower *dev);
 133 static int tower_open           (struct inode *inode, struct file *file);
 134 static int tower_release        (struct inode *inode, struct file *file);
 135 static int tower_release_internal (struct lego_usb_tower *dev);
 136 static void tower_abort_transfers (struct lego_usb_tower *dev);
 137 static void tower_interrupt_in_callback (struct urb *urb, struct pt_regs *regs);
 138 static void tower_interrupt_out_callback (struct urb *urb, struct pt_regs *regs);
 139
 140 static int  tower_probe (struct usb_interface *interface, const struct usb_device_id *id);
 141 static void tower_disconnect    (struct usb_interface *interface);
 142
 143
 144 /* prevent races between open() and disconnect */
 145 static DECLARE_MUTEX (disconnect_sem);
 146
 147 /* file operations needed when we register this driver */
 148 static struct file_operations tower_fops = {
 149         .owner =        THIS_MODULE,
 150         .read  =        tower_read,
 151         .write =        tower_write,
 152         .open =         tower_open,
 153         .release =      tower_release,
 154 };
 155
 156 /*
 157  * usb class driver info in order to get a minor number from the usb core,
 158  * and to have the device registered with devfs and the driver core
 159  */
 160 static struct usb_class_driver tower_class = {
 161         .name =         "usb/legousbtower%d",
 162         .fops =         &tower_fops,
 163         .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
 164         .minor_base =   LEGO_USB_TOWER_MINOR_BASE,
 165 };
 166
 167
 168 /* usb specific object needed to register this driver with the usb subsystem */
 169 static struct usb_driver tower_driver = {
 170         .owner =        THIS_MODULE,
 171         .name =         "legousbtower",
 172         .probe =        tower_probe,
 173         .disconnect =   tower_disconnect,
 174         .id_table =     tower_table,
 175 };
 176
 177
 178 /**
 179  *      lego_usb_tower_debug_data
 180  */
 181 static inline void lego_usb_tower_debug_data (int level, const char *function, int size, const unsigned char *data)
 182 {
 183         int i;
 184
 185         if (debug < level)
 186                 return;
 187
 188         printk (KERN_DEBUG __FILE__": %s - length = %d, data = ", function, size);
 189         for (i = 0; i < size; ++i) {
 190                 printk ("%.2x ", data[i]);
 191         }
 192         printk ("\n");
 193 }
 194
 195
 196 /**
 197  *      tower_delete
 198  */
 199 static inline void tower_delete (struct lego_usb_tower *dev)
 200 {
 201         dbg(2, "%s enter", __func__);
 202
 203         tower_abort_transfers (dev);
 204
 205         /* free data structures */
 206         if (dev->interrupt_in_urb != NULL) {
 207                 usb_free_urb (dev->interrupt_in_urb);
 208         }
 209         if (dev->interrupt_out_urb != NULL) {
 210                 usb_free_urb (dev->interrupt_out_urb);
 211         }
 212         kfree (dev->read_buffer);
 213         kfree (dev->interrupt_in_buffer);
 214         kfree (dev->interrupt_out_buffer);
 215         kfree (dev);
 216
 217         dbg(2, "%s : leave", __func__);
 218 }
 219
 220
 221 /**
 222  *      tower_open
 223  */
 224 static int tower_open (struct inode *inode, struct file *file)
 225 {
 226         struct lego_usb_tower *dev = NULL;
 227         int subminor;
 228         int retval = 0;
 229         struct usb_interface *interface;
 230
 231         dbg(2,"%s : enter", __func__);
 232
 233         subminor = iminor(inode);
 234
 235         down (&disconnect_sem);
 236
 237         interface = usb_find_interface (&tower_driver, subminor);
 238
 239         if (!interface) {
 240                 err ("%s - error, can't find device for minor %d",
 241                      __FUNCTION__, subminor);
 242                 retval = -ENODEV;
 243                 goto exit_no_device;
 244         }
 245
 246         dev = usb_get_intfdata(interface);
 247
 248         if (!dev) {
 249                 retval = -ENODEV;
 250                 goto exit_no_device;
 251         }
 252
 253         /* lock this device */
 254         down (&dev->sem);
 255
 256
 257         /* increment our usage count for the device */
 258         ++dev->open_count;
 259
 260         /* save device in the file's private structure */
 261         file->private_data = dev;
 262
 263
 264         /* initialize in direction */
 265         dev->read_buffer_length = 0;
 266
 267         up (&dev->sem);
 268
 269 exit_no_device:
 270
 271         up (&disconnect_sem);
 272
 273         dbg(2,"%s : leave, return value %d ", __func__, retval);
 274
 275         return retval;
 276 }
 277
 278 /**
 279  *      tower_release
 280  */
 281 static int tower_release (struct inode *inode, struct file *file)
 282 {
 283         struct lego_usb_tower *dev;
 284         int retval = 0;
 285
 286         dbg(2," %s : enter", __func__);
 287
 288         dev = (struct lego_usb_tower *)file->private_data;
 289
 290         if (dev == NULL) {
 291                 dbg(1," %s : object is NULL", __func__);
 292                 retval = -ENODEV;
 293                 goto exit;
 294         }
 295
 296
 297         /* lock our device */
 298         down (&dev->sem);
 299
 300         if (dev->open_count <= 0) {
 301                 dbg(1," %s : device not opened", __func__);
 302                 retval = -ENODEV;
 303                 goto exit;
 304         }
 305
 306         /* do the work */
 307         retval = tower_release_internal (dev);
 308
 309 exit:
 310         up (&dev->sem);
 311         dbg(2," %s : leave, return value %d", __func__, retval);
 312         return retval;
 313 }
 314
 315
 316 /**
 317  *      tower_release_internal
 318  */
 319 static int tower_release_internal (struct lego_usb_tower *dev)
 320 {
 321         int retval = 0;
 322
 323         dbg(2," %s : enter", __func__);
 324
 325         if (dev->udev == NULL) {
 326                 /* the device was unplugged before the file was released */
 327                 tower_delete (dev);
 328                 goto exit;
 329         }
 330
 331         /* decrement our usage count for the device */
 332         --dev->open_count;
 333         if (dev->open_count <= 0) {
 334                 tower_abort_transfers (dev);
 335                 dev->open_count = 0;
 336         }
 337
 338 exit:
 339         dbg(2," %s : leave", __func__);
 340         return retval;
 341 }
 342
 343
 344 /**
 345  *      tower_abort_transfers
 346  *      aborts transfers and frees associated data structures
 347  */
 348 static void tower_abort_transfers (struct lego_usb_tower *dev)
 349 {
 350         dbg(2," %s : enter", __func__);
 351
 352         if (dev == NULL) {
 353                 dbg(1," %s : dev is null", __func__);
 354                 goto exit;
 355         }
 356
 357         /* shutdown transfer */
 358         if (dev->interrupt_in_urb != NULL) {
 359                 usb_unlink_urb (dev->interrupt_in_urb);
 360         }
 361         if (dev->interrupt_out_urb != NULL) {
 362                 usb_unlink_urb (dev->interrupt_out_urb);
 363         }
 364
 365 exit:
 366         dbg(2," %s : leave", __func__);
 367 }
 368
 369
 370 /**
 371  *      tower_read
 372  */
 373 static ssize_t tower_read (struct file *file, char *buffer, size_t count, loff_t *ppos)
 374 {
 375         struct lego_usb_tower *dev;
 376         size_t bytes_read = 0;
 377         size_t bytes_to_read;
 378         int i;
 379         int retval = 0;
 380         int timeout = 0;
 381
 382         dbg(2," %s : enter, count = %Zd", __func__, count);
 383
 384         dev = (struct lego_usb_tower *)file->private_data;
 385
 386         /* lock this object */
 387         down (&dev->sem);
 388
 389         /* verify that the device wasn't unplugged */
 390         if (dev->udev == NULL) {
 391                 retval = -ENODEV;
 392                 err("No device or device unplugged %d", retval);
 393                 goto exit;
 394         }
 395
 396         /* verify that we actually have some data to read */
 397         if (count == 0) {
 398                 dbg(1," %s : read request of 0 bytes", __func__);
 399                 goto exit;
 400         }
 401
 402
 403         timeout = COMMAND_TIMEOUT;
 404
 405         while (1) {
 406                 if (dev->read_buffer_length == 0) {
 407
 408                         /* start reading */
 409                         usb_fill_int_urb (dev->interrupt_in_urb,dev->udev,
 410                                           usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
 411                                           dev->interrupt_in_buffer,
 412                                           dev->interrupt_in_endpoint->wMaxPacketSize,
 413                                           tower_interrupt_in_callback,
 414                                           dev,
 415                                           dev->interrupt_in_endpoint->bInterval);
 416
 417                         retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);
 418
 419                         if (retval < 0) {
 420                                 err("Couldn't submit interrupt_in_urb");
 421                                 goto exit;
 422                         }
 423
 424                         if (timeout <= 0) {
 425                                 retval = -ETIMEDOUT;
 426                                 goto exit;
 427                         }
 428
 429                         if (signal_pending(current)) {
 430                                 retval = -EINTR;
 431                                 goto exit;
 432                         }
 433
 434                         up (&dev->sem);
 435                         timeout = interruptible_sleep_on_timeout (&dev->read_wait, timeout);
 436                         down (&dev->sem);
 437
 438                 } else {
 439                         /* copy the data from read_buffer into userspace */
 440                         bytes_to_read = count > dev->read_buffer_length ? dev->read_buffer_length : count;
 441                         if (copy_to_user (buffer, dev->read_buffer, bytes_to_read) != 0) {
 442                                 retval = -EFAULT;
 443                                 goto exit;
 444                         }
 445                         dev->read_buffer_length -= bytes_to_read;
 446                         for (i=0; i<dev->read_buffer_length; i++) {
 447                                 dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
 448                         }
 449
 450                         buffer += bytes_to_read;
 451                         count -= bytes_to_read;
 452                         bytes_read += bytes_to_read;
 453                         if (count == 0) {
 454                                 break;
 455                         }
 456                 }
 457         }
 458
 459         retval = bytes_read;
 460
 461 exit:
 462         /* unlock the device */
 463         up (&dev->sem);
 464
 465         dbg(2," %s : leave, return value %d", __func__, retval);
 466         return retval;
 467 }
 468
 469
 470 /**
 471  *      tower_write
 472  */
 473 static ssize_t tower_write (struct file *file, const char *buffer, size_t count, loff_t *ppos)
 474 {
 475         struct lego_usb_tower *dev;
 476         size_t bytes_written = 0;
 477         size_t bytes_to_write;
 478         size_t buffer_size;
 479         int retval = 0;
 480         int timeout = 0;
 481
 482         dbg(2," %s : enter, count = %Zd", __func__, count);
 483
 484         dev = (struct lego_usb_tower *)file->private_data;
 485
 486         /* lock this object */
 487         down (&dev->sem);
 488
 489         /* verify that the device wasn't unplugged */
 490         if (dev->udev == NULL) {
 491                 retval = -ENODEV;
 492                 err("No device or device unplugged %d", retval);
 493                 goto exit;
 494         }
 495
 496         /* verify that we actually have some data to write */
 497         if (count == 0) {
 498                 dbg(1," %s : write request of 0 bytes", __func__);
 499                 goto exit;
 500         }
 501
 502
 503         while (count > 0) {
 504                 if (dev->interrupt_out_urb->status == -EINPROGRESS) {
 505                         timeout = COMMAND_TIMEOUT;
 506
 507                         while (timeout > 0) {
 508                                 if (signal_pending(current)) {
 509                                         dbg(1," %s : interrupted", __func__);
 510                                         retval = -EINTR;
 511                                         goto exit;
 512                                 }
 513                                 up (&dev->sem);
 514                                 timeout = interruptible_sleep_on_timeout (&dev->write_wait, timeout);
 515                                 down (&dev->sem);
 516                                 if (timeout > 0) {
 517                                         break;
 518                                 }
 519                                 dbg(1," %s : interrupted timeout: %d", __func__, timeout);
 520                         }
 521
 522
 523                         dbg(1," %s : final timeout: %d", __func__, timeout);
 524
 525                         if (timeout == 0) {
 526                                 dbg(1, "%s - command timed out.", __func__);
 527                                 retval = -ETIMEDOUT;
 528                                 goto exit;
 529                         }
 530
 531                         dbg(4," %s : in progress, count = %Zd", __func__, count);
 532                 } else {
 533                         dbg(4," %s : sending, count = %Zd", __func__, count);
 534
 535                         /* write the data into interrupt_out_buffer from userspace */
 536                         buffer_size = dev->interrupt_out_endpoint->wMaxPacketSize;
 537                         bytes_to_write = count > buffer_size ? buffer_size : count;
 538                         dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd", __func__, buffer_size, count, bytes_to_write);
 539
 540                         if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
 541                                 retval = -EFAULT;
 542                                 goto exit;
 543                         }
 544
 545                         /* send off the urb */
 546                         usb_fill_int_urb(dev->interrupt_out_urb,
 547                                         dev->udev,
 548                                         usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
 549                                         dev->interrupt_out_buffer,
 550                                         bytes_to_write,
 551                                         tower_interrupt_out_callback,
 552                                         dev,
 553                                         dev->interrupt_in_endpoint->bInterval);
 554
 555                         dev->interrupt_out_urb->actual_length = bytes_to_write;
 556                         retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
 557
 558                         if (retval < 0) {
 559                                 err("Couldn't submit interrupt_out_urb %d", retval);
 560                                 goto exit;
 561                         }
 562
 563                         buffer += bytes_to_write;
 564                         count -= bytes_to_write;
 565
 566                         bytes_written += bytes_to_write;
 567                 }
 568         }
 569
 570         retval = bytes_written;
 571
 572 exit:
 573         /* unlock the device */
 574         up (&dev->sem);
 575
 576         dbg(2," %s : leave, return value %d", __func__, retval);
 577
 578         return retval;
 579 }
 580
 581
 582 /**
 583  *      tower_interrupt_in_callback
 584  */
 585 static void tower_interrupt_in_callback (struct urb *urb, struct pt_regs *regs)
 586 {
 587         struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context;
 588
 589         dbg(4," %s : enter, status %d", __func__, urb->status);
 590
 591         lego_usb_tower_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
 592
 593         if (urb->status != 0) {
 594                 if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)) {
 595                         dbg(1," %s : nonzero status received: %d", __func__, urb->status);
 596                 }
 597                 goto exit;
 598         }
 599
 600         down (&dev->sem);
 601
 602         if (urb->actual_length > 0) {
 603                 if (dev->read_buffer_length < (4 * dev->interrupt_in_endpoint->wMaxPacketSize) - (urb->actual_length)) {
 604
 605                         memcpy (dev->read_buffer+dev->read_buffer_length, dev->interrupt_in_buffer, urb->actual_length);
 606
 607                         dev->read_buffer_length += urb->actual_length;
 608                         dbg(1," %s reading  %d ", __func__, urb->actual_length);
 609                         wake_up_interruptible (&dev->read_wait);
 610
 611                 } else {
 612                         dbg(1," %s : read_buffer overflow", __func__);
 613                 }
 614         }
 615
 616         up (&dev->sem);
 617
 618 exit:
 619         lego_usb_tower_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
 620         dbg(4," %s : leave, status %d", __func__, urb->status);
 621 }
 622
 623
 624 /**
 625  *      tower_interrupt_out_callback
 626  */
 627 static void tower_interrupt_out_callback (struct urb *urb, struct pt_regs *regs)
 628 {
 629         struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context;
 630
 631         dbg(4," %s : enter, status %d", __func__, urb->status);
 632         lego_usb_tower_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
 633
 634         if (urb->status != 0) {
 635                 if ((urb->status != -ENOENT) &&
 636                     (urb->status != -ECONNRESET)) {
 637                         dbg(1, " %s :nonzero status received: %d", __func__, urb->status);
 638                 }
 639                 goto exit;
 640         }
 641
 642         wake_up_interruptible(&dev->write_wait);
 643 exit:
 644
 645         lego_usb_tower_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
 646         dbg(4," %s : leave, status %d", __func__, urb->status);
 647 }
 648
 649
 650 /**
 651  *      tower_probe
 652  *
 653  *      Called by the usb core when a new device is connected that it thinks
 654  *      this driver might be interested in.
 655  */
 656 static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id)
 657 {
 658         struct usb_device *udev = interface_to_usbdev(interface);
 659         struct lego_usb_tower *dev = NULL;
 660         struct usb_host_interface *iface_desc;
 661         struct usb_endpoint_descriptor* endpoint;
 662         int i;
 663         int retval = -ENOMEM;
 664
 665         dbg(2," %s : enter", __func__);
 666
 667         if (udev == NULL) {
 668                 info ("udev is NULL.");
 669         }
 670
 671         /* See if the device offered us matches what we can accept */
 672         if ((udev->descriptor.idVendor != LEGO_USB_TOWER_VENDOR_ID) ||
 673             (udev->descriptor.idProduct != LEGO_USB_TOWER_PRODUCT_ID)) {
 674                 return -ENODEV;
 675         }
 676
 677
 678         /* allocate memory for our device state and intialize it */
 679
 680         dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
 681
 682         if (dev == NULL) {
 683                 err ("Out of memory");
 684                 goto exit;
 685         }
 686
 687         init_MUTEX (&dev->sem);
 688
 689         dev->udev = udev;
 690         dev->open_count = 0;
 691
 692         dev->read_buffer = NULL;
 693         dev->read_buffer_length = 0;
 694
 695         init_waitqueue_head (&dev->read_wait);
 696         init_waitqueue_head (&dev->write_wait);
 697
 698         dev->interrupt_in_buffer = NULL;
 699         dev->interrupt_in_endpoint = NULL;
 700         dev->interrupt_in_urb = NULL;
 701
 702         dev->interrupt_out_buffer = NULL;
 703         dev->interrupt_out_endpoint = NULL;
 704         dev->interrupt_out_urb = NULL;
 705
 706
 707         iface_desc = &interface->altsetting[0];
 708
 709         /* set up the endpoint information */
 710         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 711                 endpoint = &iface_desc->endpoint[i].desc;
 712
 713                 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&
 714                     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
 715                         dev->interrupt_in_endpoint = endpoint;
 716                 }
 717
 718                 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) &&
 719                     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
 720                         dev->interrupt_out_endpoint = endpoint;
 721                 }
 722         }
 723         if(dev->interrupt_in_endpoint == NULL) {
 724                 err("interrupt in endpoint not found");
 725                 goto error;
 726         }
 727         if (dev->interrupt_out_endpoint == NULL) {
 728                 err("interrupt out endpoint not found");
 729                 goto error;
 730         }
 731
 732         dev->read_buffer = kmalloc ((4*dev->interrupt_in_endpoint->wMaxPacketSize), GFP_KERNEL);
 733         if (!dev->read_buffer) {
 734                 err("Couldn't allocate read_buffer");
 735                 goto error;
 736         }
 737         dev->interrupt_in_buffer = kmalloc (dev->interrupt_in_endpoint->wMaxPacketSize, GFP_KERNEL);
 738         if (!dev->interrupt_in_buffer) {
 739                 err("Couldn't allocate interrupt_in_buffer");
 740                 goto error;
 741         }
 742         dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 743         if (!dev->interrupt_in_urb) {
 744                 err("Couldn't allocate interrupt_in_urb");
 745                 goto error;
 746         }
 747         dev->interrupt_out_buffer = kmalloc (dev->interrupt_out_endpoint->wMaxPacketSize, GFP_KERNEL);
 748         if (!dev->interrupt_out_buffer) {
 749                 err("Couldn't allocate interrupt_out_buffer");
 750                 goto error;
 751         }
 752         dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 753         if (!dev->interrupt_out_urb) {
 754                 err("Couldn't allocate interrupt_out_urb");
 755                 goto error;
 756         }
 757
 758         /* we can register the device now, as it is ready */
 759         usb_set_intfdata (interface, dev);
 760
 761         retval = usb_register_dev (interface, &tower_class);
 762
 763         if (retval) {
 764                 /* something prevented us from registering this driver */
 765                 err ("Not able to get a minor for this device.");
 766                 usb_set_intfdata (interface, NULL);
 767                 goto error;
 768         }
 769
 770         dev->minor = interface->minor;
 771
 772         /* let the user know what node this device is now attached to */
 773         info ("LEGO USB Tower device now attached to /dev/usb/lego%d", (dev->minor - LEGO_USB_TOWER_MINOR_BASE));
 774
 775
 776
 777 exit:
 778         dbg(2," %s : leave, return value 0x%.8lx (dev)", __func__, (long) dev);
 779
 780         return retval;
 781
 782 error:
 783         tower_delete(dev);
 784         return retval;
 785 }
 786
 787
 788 /**
 789  *      tower_disconnect
 790  *
 791  *      Called by the usb core when the device is removed from the system.
 792  */
 793 static void tower_disconnect (struct usb_interface *interface)
 794 {
 795         struct lego_usb_tower *dev;
 796         int minor;
 797
 798         dbg(2," %s : enter", __func__);
 799
 800         down (&disconnect_sem);
 801
 802         dev = usb_get_intfdata (interface);
 803         usb_set_intfdata (interface, NULL);
 804
 805
 806         down (&dev->sem);
 807
 808         minor = dev->minor;
 809
 810         /* give back our minor */
 811         usb_deregister_dev (interface, &tower_class);
 812
 813         /* if the device is not opened, then we clean up right now */
 814         if (!dev->open_count) {
 815                 up (&dev->sem);
 816                 tower_delete (dev);
 817         } else {
 818                 dev->udev = NULL;
 819                 up (&dev->sem);
 820         }
 821
 822         up (&disconnect_sem);
 823
 824         info("LEGO USB Tower #%d now disconnected", (minor - LEGO_USB_TOWER_MINOR_BASE));
 825
 826         dbg(2," %s : leave", __func__);
 827 }
 828
 829
 830
 831 /**
 832  *      lego_usb_tower_init
 833  */
 834 static int __init lego_usb_tower_init(void)
 835 {
 836         int result;
 837         int retval = 0;
 838
 839         dbg(2," %s : enter", __func__);
 840
 841         /* register this driver with the USB subsystem */
 842         result = usb_register(&tower_driver);
 843         if (result < 0) {
 844                 err("usb_register failed for the "__FILE__" driver. Error number %d", result);
 845                 retval = -1;
 846                 goto exit;
 847         }
 848
 849         info(DRIVER_DESC " " DRIVER_VERSION);
 850
 851 exit:
 852         dbg(2," %s : leave, return value %d", __func__, retval);
 853
 854         return retval;
 855 }
 856
 857
 858 /**
 859  *      lego_usb_tower_exit
 860  */
 861 static void __exit lego_usb_tower_exit(void)
 862 {
 863         dbg(2," %s : enter", __func__);
 864
 865         /* deregister this driver with the USB subsystem */
 866         usb_deregister (&tower_driver);
 867
 868         dbg(2," %s : leave", __func__);
 869 }
 870
 871 module_init (lego_usb_tower_init);
 872 module_exit (lego_usb_tower_exit);
 873
 874 MODULE_AUTHOR(DRIVER_AUTHOR);
 875 MODULE_DESCRIPTION(DRIVER_DESC);
 876 #ifdef MODULE_LICENSE
 877 MODULE_LICENSE("GPL");
 878 #endif