drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2003 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   6  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License version
  10  *      2 as published by the Free Software Foundation.
  11  *
  12  * This driver was originally based on the ACM driver by Armin Fuerst (which was
  13  * based on a driver by Brad Keryan)
  14  *
  15  * See Documentation/usb/usb-serial.txt for more information on using this driver
  16  *
  17  * (12/10/2002) gkh
  18  *      Split the ports off into their own struct device, and added a
  19  *      usb-serial bus driver.
  20  *
  21  * (11/19/2002) gkh
  22  *      removed a few #ifdefs for the generic code and cleaned up the failure
  23  *      logic in initialization.
  24  *
  25  * (10/02/2002) gkh
  26  *      moved the console code to console.c and out of this file.
  27  *
  28  * (06/05/2002) gkh
  29  *      moved location of startup() call in serial_probe() until after all
  30  *      of the port information and endpoints are initialized.  This makes
  31  *      things easier for some drivers.
  32  *
  33  * (04/10/2002) gkh
  34  *      added serial_read_proc function which creates a
  35  *      /proc/tty/driver/usb-serial file.
  36  *
  37  * (03/27/2002) gkh
  38  *      Got USB serial console code working properly and merged into the main
  39  *      version of the tree.  Thanks to Randy Dunlap for the initial version
  40  *      of this code, and for pushing me to finish it up.
  41  *      The USB serial console works with any usb serial driver device.
  42  *
  43  * (03/21/2002) gkh
  44  *      Moved all manipulation of port->open_count into the core.  Now the
  45  *      individual driver's open and close functions are called only when the
  46  *      first open() and last close() is called.  Making the drivers a bit
  47  *      smaller and simpler.
  48  *      Fixed a bug if a driver didn't have the owner field set.
  49  *
  50  * (02/26/2002) gkh
  51  *      Moved all locking into the main serial_* functions, instead of having
  52  *      the individual drivers have to grab the port semaphore.  This should
  53  *      reduce races.
  54  *      Reworked the MOD_INC logic a bit to always increment and decrement, even
  55  *      if the generic driver is being used.
  56  *
  57  * (10/10/2001) gkh
  58  *      usb_serial_disconnect() now sets the serial->dev pointer is to NULL to
  59  *      help prevent child drivers from accessing the device since it is now
  60  *      gone.
  61  *
  62  * (09/13/2001) gkh
  63  *      Moved generic driver initialize after we have registered with the USB
  64  *      core.  Thanks to Randy Dunlap for pointing this problem out.
  65  *
  66  * (07/03/2001) gkh
  67  *      Fixed module paramater size.  Thanks to John Brockmeyer for the pointer.
  68  *      Fixed vendor and product getting defined through the MODULE_PARM macro
  69  *      if the Generic driver wasn't compiled in.
  70  *      Fixed problem with generic_shutdown() not being called for drivers that
  71  *      don't have a shutdown() function.
  72  *
  73  * (06/06/2001) gkh
  74  *      added evil hack that is needed for the prolific pl2303 device due to the
  75  *      crazy way its endpoints are set up.
  76  *
  77  * (05/30/2001) gkh
  78  *      switched from using spinlock to a semaphore, which fixes lots of problems.
  79  *
  80  * (04/08/2001) gb
  81  *      Identify version on module load.
  82  *
  83  * 2001_02_05 gkh
  84  *      Fixed buffer overflows bug with the generic serial driver.  Thanks to
  85  *      Todd Squires <squirest@ct0.com> for fixing this.
  86  *
  87  * (01/10/2001) gkh
  88  *      Fixed bug where the generic serial adaptor grabbed _any_ device that was
  89  *      offered to it.
  90  *
  91  * (12/12/2000) gkh
  92  *      Removed MOD_INC and MOD_DEC from poll and disconnect functions, and
  93  *      moved them to the serial_open and serial_close functions.
  94  *      Also fixed bug with there not being a MOD_DEC for the generic driver
  95  *      (thanks to Gary Brubaker for finding this.)
  96  *
  97  * (11/29/2000) gkh
  98  *      Small NULL pointer initialization cleanup which saves a bit of disk image
  99  *
 100  * (11/01/2000) Adam J. Richter
 101  *      instead of using idVendor/idProduct pairs, usb serial drivers
 102  *      now identify their hardware interest with usb_device_id tables,
 103  *      which they usually have anyhow for use with MODULE_DEVICE_TABLE.
 104  *
 105  * (10/05/2000) gkh
 106  *      Fixed bug with urb->dev not being set properly, now that the usb
 107  *      core needs it.
 108  *
 109  * (09/11/2000) gkh
 110  *      Removed DEBUG #ifdefs with call to usb_serial_debug_data
 111  *
 112  * (08/28/2000) gkh
 113  *      Added port_lock to port structure.
 114  *      Added locks for SMP safeness to generic driver
 115  *      Fixed the ability to open a generic device's port more than once.
 116  *
 117  * (07/23/2000) gkh
 118  *      Added bulk_out_endpointAddress to port structure.
 119  *
 120  * (07/19/2000) gkh, pberger, and borchers
 121  *      Modifications to allow usb-serial drivers to be modules.
 122  *
 123  * (07/03/2000) gkh
 124  *      Added more debugging to serial_ioctl call
 125  *
 126  * (06/25/2000) gkh
 127  *      Changed generic_write_bulk_callback to not call wake_up_interruptible
 128  *      directly, but to have port_softint do it at a safer time.
 129  *
 130  * (06/23/2000) gkh
 131  *      Cleaned up debugging statements in a quest to find UHCI timeout bug.
 132  *
 133  * (05/22/2000) gkh
 134  *      Changed the makefile, enabling the big CONFIG_USB_SERIAL_SOMTHING to be
 135  *      removed from the individual device source files.
 136  *
 137  * (05/03/2000) gkh
 138  *      Added the Digi Acceleport driver from Al Borchers and Peter Berger.
 139  *
 140  * (05/02/2000) gkh
 141  *      Changed devfs and tty register code to work properly now. This was based on
 142  *      the ACM driver changes by Vojtech Pavlik.
 143  *
 144  * (04/27/2000) Ryan VanderBijl
 145  *      Put calls to *_paranoia_checks into one function.
 146  *
 147  * (04/23/2000) gkh
 148  *      Fixed bug that Randy Dunlap found for Generic devices with no bulk out ports.
 149  *      Moved when the startup code printed out the devices that are supported.
 150  *
 151  * (04/19/2000) gkh
 152  *      Added driver for ZyXEL omni.net lcd plus ISDN TA
 153  *      Made startup info message specify which drivers were compiled in.
 154  *
 155  * (04/03/2000) gkh
 156  *      Changed the probe process to remove the module unload races.
 157  *      Changed where the tty layer gets initialized to have devfs work nicer.
 158  *      Added initial devfs support.
 159  *
 160  * (03/26/2000) gkh
 161  *      Split driver up into device specific pieces.
 162  *
 163  * (03/19/2000) gkh
 164  *      Fixed oops that could happen when device was removed while a program
 165  *      was talking to the device.
 166  *      Removed the static urbs and now all urbs are created and destroyed
 167  *      dynamically.
 168  *      Reworked the internal interface. Now everything is based on the
 169  *      usb_serial_port structure instead of the larger usb_serial structure.
 170  *      This fixes the bug that a multiport device could not have more than
 171  *      one port open at one time.
 172  *
 173  * (03/17/2000) gkh
 174  *      Added config option for debugging messages.
 175  *      Added patch for keyspan pda from Brian Warner.
 176  *
 177  * (03/06/2000) gkh
 178  *      Added the keyspan pda code from Brian Warner <warner@lothar.com>
 179  *      Moved a bunch of the port specific stuff into its own structure. This
 180  *      is in anticipation of the true multiport devices (there's a bug if you
 181  *      try to access more than one port of any multiport device right now)
 182  *
 183  * (02/21/2000) gkh
 184  *      Made it so that any serial devices only have to specify which functions
 185  *      they want to overload from the generic function calls (great,
 186  *      inheritance in C, in a driver, just what I wanted...)
 187  *      Added support for set_termios and ioctl function calls. No drivers take
 188  *      advantage of this yet.
 189  *      Removed the #ifdef MODULE, now there is no module specific code.
 190  *      Cleaned up a few comments in usb-serial.h that were wrong (thanks again
 191  *      to Miles Lott).
 192  *      Small fix to get_free_serial.
 193  *
 194  * (02/14/2000) gkh
 195  *      Removed the Belkin and Peracom functionality from the driver due to
 196  *      the lack of support from the vendor, and me not wanting people to
 197  *      accidenatly buy the device, expecting it to work with Linux.
 198  *      Added read_bulk_callback and write_bulk_callback to the type structure
 199  *      for the needs of the FTDI and WhiteHEAT driver.
 200  *      Changed all reverences to FTDI to FTDI_SIO at the request of Bill
 201  *      Ryder.
 202  *      Changed the output urb size back to the max endpoint size to make
 203  *      the ftdi_sio driver have it easier, and due to the fact that it didn't
 204  *      really increase the speed any.
 205  *
 206  * (02/11/2000) gkh
 207  *      Added VISOR_FUNCTION_CONSOLE to the visor startup function. This was a
 208  *      patch from Miles Lott (milos@insync.net).
 209  *      Fixed bug with not restoring the minor range that a device grabs, if
 210  *      the startup function fails (thanks Miles for finding this).
 211  *
 212  * (02/05/2000) gkh
 213  *      Added initial framework for the Keyspan PDA serial converter so that
 214  *      Brian Warner has a place to put his code.
 215  *      Made the ezusb specific functions generic enough that different
 216  *      devices can use them (whiteheat and keyspan_pda both need them).
 217  *      Split out a whole bunch of structure and other stuff to a separate
 218  *      usb-serial.h file.
 219  *      Made the Visor connection messages a little more understandable, now
 220  *      that Miles Lott (milos@insync.net) has gotten the Generic channel to
 221  *      work. Also made them always show up in the log file.
 222  *
 223  * (01/25/2000) gkh
 224  *      Added initial framework for FTDI serial converter so that Bill Ryder
 225  *      has a place to put his code.
 226  *      Added the vendor specific info from Handspring. Now we can print out
 227  *      informational debug messages as well as understand what is happening.
 228  *
 229  * (01/23/2000) gkh
 230  *      Fixed problem of crash when trying to open a port that didn't have a
 231  *      device assigned to it. Made the minor node finding a little smarter,
 232  *      now it looks to find a continuous space for the new device.
 233  *
 234  * (01/21/2000) gkh
 235  *      Fixed bug in visor_startup with patch from Miles Lott (milos@insync.net)
 236  *      Fixed get_serial_by_minor which was all messed up for multi port
 237  *      devices. Fixed multi port problem for generic devices. Now the number
 238  *      of ports is determined by the number of bulk out endpoints for the
 239  *      generic device.
 240  *
 241  * (01/19/2000) gkh
 242  *      Removed lots of cruft that was around from the old (pre urb) driver
 243  *      interface.
 244  *      Made the serial_table dynamic. This should save lots of memory when
 245  *      the number of minor nodes goes up to 256.
 246  *      Added initial support for devices that have more than one port.
 247  *      Added more debugging comments for the Visor, and added a needed
 248  *      set_configuration call.
 249  *
 250  * (01/17/2000) gkh
 251  *      Fixed the WhiteHEAT firmware (my processing tool had a bug)
 252  *      and added new debug loader firmware for it.
 253  *      Removed the put_char function as it isn't really needed.
 254  *      Added visor startup commands as found by the Win98 dump.
 255  *
 256  * (01/13/2000) gkh
 257  *      Fixed the vendor id for the generic driver to the one I meant it to be.
 258  *
 259  * (01/12/2000) gkh
 260  *      Forget the version numbering...that's pretty useless...
 261  *      Made the driver able to be compiled so that the user can select which
 262  *      converter they want to use. This allows people who only want the Visor
 263  *      support to not pay the memory size price of the WhiteHEAT.
 264  *      Fixed bug where the generic driver (idVendor=0000 and idProduct=0000)
 265  *      grabbed the root hub. Not good.
 266  *
 267  * version 0.4.0 (01/10/2000) gkh
 268  *      Added whiteheat.h containing the firmware for the ConnectTech WhiteHEAT
 269  *      device. Added startup function to allow firmware to be downloaded to
 270  *      a device if it needs to be.
 271  *      Added firmware download logic to the WhiteHEAT device.
 272  *      Started to add #defines to split up the different drivers for potential
 273  *      configuration option.
 274  *
 275  * version 0.3.1 (12/30/99) gkh
 276  *      Fixed problems with urb for bulk out.
 277  *      Added initial support for multiple sets of endpoints. This enables
 278  *      the Handspring Visor to be attached successfully. Only the first
 279  *      bulk in / bulk out endpoint pair is being used right now.
 280  *
 281  * version 0.3.0 (12/27/99) gkh
 282  *      Added initial support for the Handspring Visor based on a patch from
 283  *      Miles Lott (milos@sneety.insync.net)
 284  *      Cleaned up the code a bunch and converted over to using urbs only.
 285  *
 286  * version 0.2.3 (12/21/99) gkh
 287  *      Added initial support for the Connect Tech WhiteHEAT converter.
 288  *      Incremented the number of ports in expectation of getting the
 289  *      WhiteHEAT to work properly (4 ports per connection).
 290  *      Added notification on insertion and removal of what port the
 291  *      device is/was connected to (and what kind of device it was).
 292  *
 293  * version 0.2.2 (12/16/99) gkh
 294  *      Changed major number to the new allocated number. We're legal now!
 295  *
 296  * version 0.2.1 (12/14/99) gkh
 297  *      Fixed bug that happens when device node is opened when there isn't a
 298  *      device attached to it. Thanks to marek@webdesign.no for noticing this.
 299  *
 300  * version 0.2.0 (11/10/99) gkh
 301  *      Split up internals to make it easier to add different types of serial
 302  *      converters to the code.
 303  *      Added a "generic" driver that gets it's vendor and product id
 304  *      from when the module is loaded. Thanks to David E. Nelson (dnelson@jump.net)
 305  *      for the idea and sample code (from the usb scanner driver.)
 306  *      Cleared up any licensing questions by releasing it under the GNU GPL.
 307  *
 308  * version 0.1.2 (10/25/99) gkh
 309  *      Fixed bug in detecting device.
 310  *
 311  * version 0.1.1 (10/05/99) gkh
 312  *      Changed the major number to not conflict with anything else.
 313  *
 314  * version 0.1 (09/28/99) gkh
 315  *      Can recognize the two different devices and start up a read from
 316  *      device when asked to. Writes also work. No control signals yet, this
 317  *      all is vendor specific data (i.e. no spec), also no control for
 318  *      different baud rates or other bit settings.
 319  *      Currently we are using the same devid as the acm driver. This needs
 320  *      to change.
 321  *
 322  */
 323
 324 #include <linux/config.h>
 325 #include <linux/kernel.h>
 326 #include <linux/errno.h>
 327 #include <linux/init.h>
 328 #include <linux/slab.h>
 329 #include <linux/tty.h>
 330 #include <linux/tty_driver.h>
 331 #include <linux/tty_flip.h>
 332 #include <linux/module.h>
 333 #include <linux/spinlock.h>
 334 #include <linux/list.h>
 335 #include <linux/smp_lock.h>
 336 #include <asm/uaccess.h>
 337 #include <linux/usb.h>
 338
 339
 340 #ifdef CONFIG_USB_SERIAL_DEBUG
 341         static int debug = 1;
 342 #else
 343         static int debug;
 344 #endif
 345
 346 #include "usb-serial.h"
 347 #include "pl2303.h"
 348
 349 /*
 350  * Version Information
 351  */
 352 #define DRIVER_VERSION "v2.0"
 353 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
 354 #define DRIVER_DESC "USB Serial Driver core"
 355
 356
 357 #ifdef CONFIG_USB_SERIAL_GENERIC
 358 /* we want to look at all devices, as the vendor/product id can change
 359  * depending on the command line argument */
 360 static struct usb_device_id generic_serial_ids[] = {
 361         {.driver_info = 42},
 362         {}
 363 };
 364
 365 #endif /* CONFIG_USB_SERIAL_GENERIC */
 366
 367 /* Driver structure we register with the USB core */
 368 static struct usb_driver usb_serial_driver = {
 369         .owner =        THIS_MODULE,
 370         .name =         "usbserial",
 371         .probe =        usb_serial_probe,
 372         .disconnect =   usb_serial_disconnect,
 373 #ifdef CONFIG_USB_SERIAL_GENERIC
 374         .id_table =     generic_serial_ids,
 375 #endif
 376 };
 377
 378 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
 379    the MODULE_DEVICE_TABLE declarations in each serial driver
 380    cause the "hotplug" program to pull in whatever module is necessary
 381    via modprobe, and modprobe will load usbserial because the serial
 382    drivers depend on it.
 383 */
 384
 385 static struct usb_serial        *serial_table[SERIAL_TTY_MINORS];       /* initially all NULL */
 386 static LIST_HEAD(usb_serial_driver_list);
 387
 388
 389 struct usb_serial *usb_serial_get_by_index(unsigned index)
 390 {
 391         struct usb_serial *serial = serial_table[index];
 392
 393         if (serial)
 394                 kref_get(&serial->kref);
 395         return serial;
 396 }
 397
 398 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
 399 {
 400         unsigned int i, j;
 401         int good_spot;
 402
 403         dbg("%s %d", __FUNCTION__, num_ports);
 404
 405         *minor = 0;
 406         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 407                 if (serial_table[i])
 408                         continue;
 409
 410                 good_spot = 1;
 411                 for (j = 1; j <= num_ports-1; ++j)
 412                         if ((serial_table[i+j]) || (i+j >= SERIAL_TTY_MINORS)) {
 413                                 good_spot = 0;
 414                                 i += j;
 415                                 break;
 416                         }
 417                 if (good_spot == 0)
 418                         continue;
 419
 420                 serial->magic = USB_SERIAL_MAGIC;
 421                 *minor = i;
 422                 dbg("%s - minor base = %d", __FUNCTION__, *minor);
 423                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
 424                         serial_table[i] = serial;
 425                 return serial;
 426         }
 427         return NULL;
 428 }
 429
 430 static void return_serial (struct usb_serial *serial)
 431 {
 432         int i;
 433
 434         dbg("%s", __FUNCTION__);
 435
 436         if (serial == NULL)
 437                 return;
 438
 439         for (i = 0; i < serial->num_ports; ++i) {
 440                 serial_table[serial->minor + i] = NULL;
 441         }
 442
 443         return;
 444 }
 445
 446 /*****************************************************************************
 447  * Driver tty interface functions
 448  *****************************************************************************/
 449 static int serial_open (struct tty_struct *tty, struct file * filp)
 450 {
 451         struct usb_serial *serial;
 452         struct usb_serial_port *port;
 453         unsigned int portNumber;
 454         int retval = 0;
 455
 456         dbg("%s", __FUNCTION__);
 457
 458         /* initialize the pointer incase something fails */
 459         tty->driver_data = NULL;
 460
 461         /* get the serial object associated with this tty pointer */
 462         serial = usb_serial_get_by_index(tty->index);
 463
 464         if (serial_paranoia_check (serial, __FUNCTION__))
 465                 return -ENODEV;
 466
 467         /* set up our port structure making the tty driver remember our port object, and us it */
 468         portNumber = tty->index - serial->minor;
 469         port = serial->port[portNumber];
 470         tty->driver_data = port;
 471
 472         port->tty = tty;
 473
 474         /* lock this module before we call it,
 475            this may, which means we must bail out, safe because we are called with BKL held */
 476         if (!try_module_get(serial->type->owner)) {
 477                 retval = -ENODEV;
 478                 goto bailout;
 479         }
 480
 481         ++port->open_count;
 482         if (port->open_count == 1) {
 483                 /* only call the device specific open if this
 484                  * is the first time the port is opened */
 485                 retval = serial->type->open(port, filp);
 486                 if (retval) {
 487                         port->open_count = 0;
 488                         module_put(serial->type->owner);
 489                         kref_put(&serial->kref);
 490                 }
 491         }
 492 bailout:
 493         return retval;
 494 }
 495
 496 static void serial_close(struct tty_struct *tty, struct file * filp)
 497 {
 498         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 499         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 500
 501         if (!serial)
 502                 return;
 503
 504         dbg("%s - port %d", __FUNCTION__, port->number);
 505
 506         --port->open_count;
 507         if (port->open_count <= 0) {
 508                 /* only call the device specific close if this
 509                  * port is being closed by the last owner */
 510                 port->serial->type->close(port, filp);
 511                 port->open_count = 0;
 512
 513                 if (port->tty) {
 514                         if (port->tty->driver_data)
 515                                 port->tty->driver_data = NULL;
 516                         port->tty = NULL;
 517                 }
 518         }
 519
 520         module_put(port->serial->type->owner);
 521         kref_put(&port->serial->kref);
 522 }
 523
 524 static int serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count)
 525 {
 526         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 527         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 528         int retval = -EINVAL;
 529
 530         if (!serial)
 531                 return -ENODEV;
 532
 533         dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
 534
 535         if (!port->open_count) {
 536                 dbg("%s - port not opened", __FUNCTION__);
 537                 goto exit;
 538         }
 539
 540         /* pass on to the driver specific version of this function */
 541         retval = serial->type->write(port, from_user, buf, count);
 542
 543 exit:
 544         return retval;
 545 }
 546
 547 static int serial_write_room (struct tty_struct *tty)
 548 {
 549         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 550         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 551         int retval = -EINVAL;
 552
 553         if (!serial)
 554                 return -ENODEV;
 555
 556         dbg("%s - port %d", __FUNCTION__, port->number);
 557
 558         if (!port->open_count) {
 559                 dbg("%s - port not open", __FUNCTION__);
 560                 goto exit;
 561         }
 562
 563         /* pass on to the driver specific version of this function */
 564         retval = serial->type->write_room(port);
 565
 566 exit:
 567         return retval;
 568 }
 569
 570 static int serial_chars_in_buffer (struct tty_struct *tty)
 571 {
 572         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 573         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 574         int retval = -EINVAL;
 575
 576         if (!serial)
 577                 return -ENODEV;
 578
 579         dbg("%s = port %d", __FUNCTION__, port->number);
 580
 581         if (!port->open_count) {
 582                 dbg("%s - port not open", __FUNCTION__);
 583                 goto exit;
 584         }
 585
 586         /* pass on to the driver specific version of this function */
 587         retval = serial->type->chars_in_buffer(port);
 588
 589 exit:
 590         return retval;
 591 }
 592
 593 static void serial_throttle (struct tty_struct * tty)
 594 {
 595         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 596         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 597
 598         if (!serial)
 599                 return;
 600
 601         dbg("%s - port %d", __FUNCTION__, port->number);
 602
 603         if (!port->open_count) {
 604                 dbg ("%s - port not open", __FUNCTION__);
 605                 goto exit;
 606         }
 607
 608         /* pass on to the driver specific version of this function */
 609         if (serial->type->throttle)
 610                 serial->type->throttle(port);
 611
 612 exit:
 613         ;
 614 }
 615
 616 static void serial_unthrottle (struct tty_struct * tty)
 617 {
 618         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 619         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 620
 621         if (!serial)
 622                 return;
 623
 624         dbg("%s - port %d", __FUNCTION__, port->number);
 625
 626         if (!port->open_count) {
 627                 dbg("%s - port not open", __FUNCTION__);
 628                 goto exit;
 629         }
 630
 631         /* pass on to the driver specific version of this function */
 632         if (serial->type->unthrottle)
 633                 serial->type->unthrottle(port);
 634
 635 exit:
 636         ;
 637 }
 638
 639 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 640 {
 641         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 642         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 643         int retval = -ENODEV;
 644
 645         if (!serial)
 646                 return -ENODEV;
 647
 648         dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
 649
 650         if (!port->open_count) {
 651                 dbg ("%s - port not open", __FUNCTION__);
 652                 goto exit;
 653         }
 654
 655         /* pass on to the driver specific version of this function if it is available */
 656         if (serial->type->ioctl)
 657                 retval = serial->type->ioctl(port, file, cmd, arg);
 658         else
 659                 retval = -ENOIOCTLCMD;
 660
 661 exit:
 662         return retval;
 663 }
 664
 665 static void serial_set_termios (struct tty_struct *tty, struct termios * old)
 666 {
 667         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 668         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 669
 670         if (!serial)
 671                 return;
 672
 673         dbg("%s - port %d", __FUNCTION__, port->number);
 674
 675         if (!port->open_count) {
 676                 dbg("%s - port not open", __FUNCTION__);
 677                 goto exit;
 678         }
 679
 680         /* pass on to the driver specific version of this function if it is available */
 681         if (serial->type->set_termios)
 682                 serial->type->set_termios(port, old);
 683
 684 exit:
 685         ;
 686 }
 687
 688 static void serial_break (struct tty_struct *tty, int break_state)
 689 {
 690         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 691         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 692
 693         if (!serial)
 694                 return;
 695
 696         dbg("%s - port %d", __FUNCTION__, port->number);
 697
 698         if (!port->open_count) {
 699                 dbg("%s - port not open", __FUNCTION__);
 700                 goto exit;
 701         }
 702
 703         /* pass on to the driver specific version of this function if it is available */
 704         if (serial->type->break_ctl)
 705                 serial->type->break_ctl(port, break_state);
 706
 707 exit:
 708         ;
 709 }
 710
 711 static void serial_shutdown (struct usb_serial *serial)
 712 {
 713         dbg ("%s", __FUNCTION__);
 714
 715         serial->type->shutdown(serial);
 716 }
 717
 718 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
 719 {
 720         struct usb_serial *serial;
 721         int length = 0;
 722         int i;
 723         off_t begin = 0;
 724         char tmp[40];
 725
 726         dbg("%s", __FUNCTION__);
 727         length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
 728         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
 729                 serial = usb_serial_get_by_index(i);
 730                 if (serial == NULL)
 731                         continue;
 732
 733                 length += sprintf (page+length, "%d:", i);
 734                 if (serial->type->owner)
 735                         length += sprintf (page+length, " module:%s", module_name(serial->type->owner));
 736                 length += sprintf (page+length, " name:\"%s\"", serial->type->name);
 737                 length += sprintf (page+length, " vendor:%04x product:%04x", serial->vendor, serial->product);
 738                 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
 739                 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
 740
 741                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 742                 length += sprintf (page+length, " path:%s", tmp);
 743
 744                 length += sprintf (page+length, "\n");
 745                 if ((length + begin) > (off + count))
 746                         goto done;
 747                 if ((length + begin) < off) {
 748                         begin += length;
 749                         length = 0;
 750                 }
 751                 kref_put(&serial->kref);
 752         }
 753         *eof = 1;
 754 done:
 755         if (off >= (length + begin))
 756                 return 0;
 757         *start = page + (off-begin);
 758         return ((count < begin+length-off) ? count : begin+length-off);
 759 }
 760
 761 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
 762 {
 763         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 764         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 765
 766         if (!serial)
 767                 goto exit;
 768
 769         dbg("%s - port %d", __FUNCTION__, port->number);
 770
 771         if (!port->open_count) {
 772                 dbg("%s - port not open", __FUNCTION__);
 773                 goto exit;
 774         }
 775
 776         if (serial->type->tiocmget)
 777                 return serial->type->tiocmget(port, file);
 778
 779 exit:
 780         return -EINVAL;
 781 }
 782
 783 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
 784                             unsigned int set, unsigned int clear)
 785 {
 786         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 787         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
 788
 789         if (!serial)
 790                 goto exit;
 791
 792         dbg("%s - port %d", __FUNCTION__, port->number);
 793
 794         if (!port->open_count) {
 795                 dbg("%s - port not open", __FUNCTION__);
 796                 goto exit;
 797         }
 798
 799         if (serial->type->tiocmset)
 800                 return serial->type->tiocmset(port, file, set, clear);
 801
 802 exit:
 803         return -EINVAL;
 804 }
 805
 806 void usb_serial_port_softint(void *private)
 807 {
 808         struct usb_serial_port *port = (struct usb_serial_port *)private;
 809         struct usb_serial *serial;
 810         struct tty_struct *tty;
 811
 812         dbg("%s - port %d", __FUNCTION__, port->number);
 813
 814         if (!port)
 815                 return;
 816
 817         serial = get_usb_serial (port, __FUNCTION__);
 818         if (!serial)
 819                 return;
 820
 821         tty = port->tty;
 822         if (!tty)
 823                 return;
 824
 825         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
 826                 dbg("%s - write wakeup call.", __FUNCTION__);
 827                 (tty->ldisc.write_wakeup)(tty);
 828         }
 829
 830         wake_up_interruptible(&tty->write_wait);
 831 }
 832
 833 static void destroy_serial(struct kref *kref)
 834 {
 835         struct usb_serial *serial;
 836         struct usb_serial_port *port;
 837         int i;
 838
 839         serial = to_usb_serial(kref);
 840
 841         dbg ("%s - %s", __FUNCTION__, serial->type->name);
 842         serial_shutdown (serial);
 843
 844         /* return the minor range that this device had */
 845         return_serial(serial);
 846
 847         for (i = 0; i < serial->num_ports; ++i)
 848                 serial->port[i]->open_count = 0;
 849
 850         /* the ports are cleaned up and released in port_release() */
 851         for (i = 0; i < serial->num_ports; ++i)
 852                 if (serial->port[i]->dev.parent != NULL) {
 853                         device_unregister(&serial->port[i]->dev);
 854                         serial->port[i] = NULL;
 855                 }
 856
 857         /* If this is a "fake" port, we have to clean it up here, as it will
 858          * not get cleaned up in port_release() as it was never registered with
 859          * the driver core */
 860         if (serial->num_ports < serial->num_port_pointers) {
 861                 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
 862                         port = serial->port[i];
 863                         if (!port)
 864                                 continue;
 865                         if (port->read_urb) {
 866                                 usb_unlink_urb(port->read_urb);
 867                                 usb_free_urb(port->read_urb);
 868                         }
 869                         if (port->write_urb) {
 870                                 usb_unlink_urb(port->write_urb);
 871                                 usb_free_urb(port->write_urb);
 872                         }
 873                         if (port->interrupt_in_urb) {
 874                                 usb_unlink_urb(port->interrupt_in_urb);
 875                                 usb_free_urb(port->interrupt_in_urb);
 876                         }
 877                         kfree(port->bulk_in_buffer);
 878                         kfree(port->bulk_out_buffer);
 879                         kfree(port->interrupt_in_buffer);
 880                 }
 881         }
 882
 883         usb_put_dev(serial->dev);
 884
 885         /* free up any memory that we allocated */
 886         kfree (serial);
 887 }
 888
 889 static void port_release(struct device *dev)
 890 {
 891         struct usb_serial_port *port = to_usb_serial_port(dev);
 892
 893         dbg ("%s - %s", __FUNCTION__, dev->bus_id);
 894         if (port->read_urb) {
 895                 usb_unlink_urb(port->read_urb);
 896                 usb_free_urb(port->read_urb);
 897         }
 898         if (port->write_urb) {
 899                 usb_unlink_urb(port->write_urb);
 900                 usb_free_urb(port->write_urb);
 901         }
 902         if (port->interrupt_in_urb) {
 903                 usb_unlink_urb(port->interrupt_in_urb);
 904                 usb_free_urb(port->interrupt_in_urb);
 905         }
 906         kfree(port->bulk_in_buffer);
 907         kfree(port->bulk_out_buffer);
 908         kfree(port->interrupt_in_buffer);
 909         kfree(port);
 910 }
 911
 912 static struct usb_serial * create_serial (struct usb_device *dev,
 913                                           struct usb_interface *interface,
 914                                           struct usb_serial_device_type *type)
 915 {
 916         struct usb_serial *serial;
 917
 918         serial = kmalloc (sizeof (*serial), GFP_KERNEL);
 919         if (!serial) {
 920                 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
 921                 return NULL;
 922         }
 923         memset (serial, 0, sizeof(*serial));
 924         serial->dev = usb_get_dev(dev);
 925         serial->type = type;
 926         serial->interface = interface;
 927         serial->vendor = dev->descriptor.idVendor;
 928         serial->product = dev->descriptor.idProduct;
 929         kref_init(&serial->kref, destroy_serial);
 930
 931         return serial;
 932 }
 933
 934 int usb_serial_probe(struct usb_interface *interface,
 935                                const struct usb_device_id *id)
 936 {
 937         struct usb_device *dev = interface_to_usbdev (interface);
 938         struct usb_serial *serial = NULL;
 939         struct usb_serial_port *port;
 940         struct usb_host_interface *iface_desc;
 941         struct usb_endpoint_descriptor *endpoint;
 942         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 943         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 944         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 945         struct usb_serial_device_type *type = NULL;
 946         struct list_head *tmp;
 947         int retval;
 948         int found;
 949         int minor;
 950         int buffer_size;
 951         int i;
 952         int num_interrupt_in = 0;
 953         int num_bulk_in = 0;
 954         int num_bulk_out = 0;
 955         int num_ports = 0;
 956         int max_endpoints;
 957         const struct usb_device_id *id_pattern = NULL;
 958
 959         /* loop through our list of known serial converters, and see if this
 960            device matches. */
 961         found = 0;
 962         list_for_each (tmp, &usb_serial_driver_list) {
 963                 type = list_entry(tmp, struct usb_serial_device_type, driver_list);
 964                 id_pattern = usb_match_id(interface, type->id_table);
 965                 if (id_pattern != NULL) {
 966                         dbg("descriptor matches");
 967                         found = 1;
 968                         break;
 969                 }
 970         }
 971         if (!found) {
 972                 /* no match */
 973                 dbg("none matched");
 974                 return -ENODEV;
 975         }
 976
 977         serial = create_serial (dev, interface, type);
 978         if (!serial) {
 979                 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
 980                 return -ENODEV;
 981         }
 982
 983         /* if this device type has a probe function, call it */
 984         if (type->probe) {
 985                 if (!try_module_get(type->owner)) {
 986                         dev_err(&interface->dev, "module get failed, exiting\n");
 987                         kfree (serial);
 988                         return -EIO;
 989                 }
 990                 retval = type->probe (serial, id_pattern);
 991                 module_put(type->owner);
 992
 993                 if (retval) {
 994                         dbg ("sub driver rejected device");
 995                         kfree (serial);
 996                         return retval;
 997                 }
 998         }
 999
1000         /* descriptor matches, let's find the endpoints needed */
1001         /* check out the endpoints */
1002         iface_desc = interface->cur_altsetting;
1003         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1004                 endpoint = &iface_desc->endpoint[i].desc;
1005
1006                 if ((endpoint->bEndpointAddress & 0x80) &&
1007                     ((endpoint->bmAttributes & 3) == 0x02)) {
1008                         /* we found a bulk in endpoint */
1009                         dbg("found bulk in");
1010                         bulk_in_endpoint[num_bulk_in] = endpoint;
1011                         ++num_bulk_in;
1012                 }
1013
1014                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
1015                     ((endpoint->bmAttributes & 3) == 0x02)) {
1016                         /* we found a bulk out endpoint */
1017                         dbg("found bulk out");
1018                         bulk_out_endpoint[num_bulk_out] = endpoint;
1019                         ++num_bulk_out;
1020                 }
1021
1022                 if ((endpoint->bEndpointAddress & 0x80) &&
1023                     ((endpoint->bmAttributes & 3) == 0x03)) {
1024                         /* we found a interrupt in endpoint */
1025                         dbg("found interrupt in");
1026                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
1027                         ++num_interrupt_in;
1028                 }
1029         }
1030
1031 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
1032         /* BEGIN HORRIBLE HACK FOR PL2303 */
1033         /* this is needed due to the looney way its endpoints are set up */
1034         if (((dev->descriptor.idVendor == PL2303_VENDOR_ID) &&
1035              (dev->descriptor.idProduct == PL2303_PRODUCT_ID)) ||
1036             ((dev->descriptor.idVendor == ATEN_VENDOR_ID) &&
1037              (dev->descriptor.idProduct == ATEN_PRODUCT_ID))) {
1038                 if (interface != dev->actconfig->interface[0]) {
1039                         /* check out the endpoints of the other interface*/
1040                         iface_desc = &dev->actconfig->interface[0]->altsetting[0];
1041                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1042                                 endpoint = &iface_desc->endpoint[i].desc;
1043                                 if ((endpoint->bEndpointAddress & 0x80) &&
1044                                     ((endpoint->bmAttributes & 3) == 0x03)) {
1045                                         /* we found a interrupt in endpoint */
1046                                         dbg("found interrupt in for Prolific device on separate interface");
1047                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
1048                                         ++num_interrupt_in;
1049                                 }
1050                         }
1051                 }
1052
1053                 /* Now make sure the PL-2303 is configured correctly.
1054                  * If not, give up now and hope this hack will work
1055                  * properly during a later invocation of usb_serial_probe
1056                  */
1057                 if (num_bulk_in == 0 || num_bulk_out == 0) {
1058                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
1059                         kfree (serial);
1060                         return -ENODEV;
1061                 }
1062         }
1063         /* END HORRIBLE HACK FOR PL2303 */
1064 #endif
1065
1066         /* found all that we need */
1067         dev_info(&interface->dev, "%s converter detected\n", type->name);
1068
1069 #ifdef CONFIG_USB_SERIAL_GENERIC
1070         if (type == &usb_serial_generic_device) {
1071                 num_ports = num_bulk_out;
1072                 if (num_ports == 0) {
1073                         dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
1074                         kfree (serial);
1075                         return -EIO;
1076                 }
1077         }
1078 #endif
1079         if (!num_ports) {
1080                 /* if this device type has a calc_num_ports function, call it */
1081                 if (type->calc_num_ports) {
1082                         if (!try_module_get(type->owner)) {
1083                                 dev_err(&interface->dev, "module get failed, exiting\n");
1084                                 kfree (serial);
1085                                 return -EIO;
1086                         }
1087                         num_ports = type->calc_num_ports (serial);
1088                         module_put(type->owner);
1089                 }
1090                 if (!num_ports)
1091                         num_ports = type->num_ports;
1092         }
1093
1094         if (get_free_serial (serial, num_ports, &minor) == NULL) {
1095                 dev_err(&interface->dev, "No more free serial devices\n");
1096                 kfree (serial);
1097                 return -ENOMEM;
1098         }
1099
1100         serial->minor = minor;
1101         serial->num_ports = num_ports;
1102         serial->num_bulk_in = num_bulk_in;
1103         serial->num_bulk_out = num_bulk_out;
1104         serial->num_interrupt_in = num_interrupt_in;
1105
1106         /* create our ports, we need as many as the max endpoints */
1107         /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
1108         max_endpoints = max(num_bulk_in, num_bulk_out);
1109         max_endpoints = max(max_endpoints, num_interrupt_in);
1110         max_endpoints = max(max_endpoints, (int)serial->num_ports);
1111         serial->num_port_pointers = max_endpoints;
1112         dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
1113         for (i = 0; i < max_endpoints; ++i) {
1114                 port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
1115                 if (!port)
1116                         goto probe_error;
1117                 memset(port, 0x00, sizeof(struct usb_serial_port));
1118                 port->number = i + serial->minor;
1119                 port->serial = serial;
1120                 port->magic = USB_SERIAL_PORT_MAGIC;
1121                 INIT_WORK(&port->work, usb_serial_port_softint, port);
1122                 serial->port[i] = port;
1123         }
1124
1125         /* set up the endpoint information */
1126         for (i = 0; i < num_bulk_in; ++i) {
1127                 endpoint = bulk_in_endpoint[i];
1128                 port = serial->port[i];
1129                 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
1130                 if (!port->read_urb) {
1131                         dev_err(&interface->dev, "No free urbs available\n");
1132                         goto probe_error;
1133                 }
1134                 buffer_size = endpoint->wMaxPacketSize;
1135                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
1136                 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1137                 if (!port->bulk_in_buffer) {
1138                         dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
1139                         goto probe_error;
1140                 }
1141                 usb_fill_bulk_urb (port->read_urb, dev,
1142                                    usb_rcvbulkpipe (dev,
1143                                                     endpoint->bEndpointAddress),
1144                                    port->bulk_in_buffer, buffer_size,
1145                                    serial->type->read_bulk_callback,
1146                                    port);
1147         }
1148
1149         for (i = 0; i < num_bulk_out; ++i) {
1150                 endpoint = bulk_out_endpoint[i];
1151                 port = serial->port[i];
1152                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
1153                 if (!port->write_urb) {
1154                         dev_err(&interface->dev, "No free urbs available\n");
1155                         goto probe_error;
1156                 }
1157                 buffer_size = endpoint->wMaxPacketSize;
1158                 port->bulk_out_size = buffer_size;
1159                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
1160                 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
1161                 if (!port->bulk_out_buffer) {
1162                         dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
1163                         goto probe_error;
1164                 }
1165                 usb_fill_bulk_urb (port->write_urb, dev,
1166                                    usb_sndbulkpipe (dev,
1167                                                     endpoint->bEndpointAddress),
1168                                    port->bulk_out_buffer, buffer_size,
1169                                    serial->type->write_bulk_callback,
1170                                    port);
1171         }
1172
1173         for (i = 0; i < num_interrupt_in; ++i) {
1174                 endpoint = interrupt_in_endpoint[i];
1175                 port = serial->port[i];
1176                 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1177                 if (!port->interrupt_in_urb) {
1178                         dev_err(&interface->dev, "No free urbs available\n");
1179                         goto probe_error;
1180                 }
1181                 buffer_size = endpoint->wMaxPacketSize;
1182                 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
1183                 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1184                 if (!port->interrupt_in_buffer) {
1185                         dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
1186                         goto probe_error;
1187                 }
1188                 usb_fill_int_urb (port->interrupt_in_urb, dev,
1189                                   usb_rcvintpipe (dev,
1190                                                   endpoint->bEndpointAddress),
1191                                   port->interrupt_in_buffer, buffer_size,
1192                                   serial->type->read_int_callback, port,
1193                                   endpoint->bInterval);
1194         }
1195
1196         /* if this device type has an attach function, call it */
1197         if (type->attach) {
1198                 if (!try_module_get(type->owner)) {
1199                         dev_err(&interface->dev, "module get failed, exiting\n");
1200                         goto probe_error;
1201                 }
1202                 retval = type->attach (serial);
1203                 module_put(type->owner);
1204                 if (retval < 0)
1205                         goto probe_error;
1206                 if (retval > 0) {
1207                         /* quietly accept this device, but don't bind to a serial port
1208                          * as it's about to disappear */
1209                         goto exit;
1210                 }
1211         }
1212
1213         /* register all of the individual ports with the driver core */
1214         for (i = 0; i < num_ports; ++i) {
1215                 port = serial->port[i];
1216                 port->dev.parent = &interface->dev;
1217                 port->dev.driver = NULL;
1218                 port->dev.bus = &usb_serial_bus_type;
1219                 port->dev.release = &port_release;
1220
1221                 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1222                 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1223                 device_register (&port->dev);
1224         }
1225
1226         usb_serial_console_init (debug, minor);
1227
1228 exit:
1229         /* success */
1230         usb_set_intfdata (interface, serial);
1231         return 0;
1232
1233 probe_error:
1234         for (i = 0; i < num_bulk_in; ++i) {
1235                 port = serial->port[i];
1236                 if (!port)
1237                         continue;
1238                 if (port->read_urb)
1239                         usb_free_urb (port->read_urb);
1240                 kfree(port->bulk_in_buffer);
1241         }
1242         for (i = 0; i < num_bulk_out; ++i) {
1243                 port = serial->port[i];
1244                 if (!port)
1245                         continue;
1246                 if (port->write_urb)
1247                         usb_free_urb (port->write_urb);
1248                 kfree(port->bulk_out_buffer);
1249         }
1250         for (i = 0; i < num_interrupt_in; ++i) {
1251                 port = serial->port[i];
1252                 if (!port)
1253                         continue;
1254                 if (port->interrupt_in_urb)
1255                         usb_free_urb (port->interrupt_in_urb);
1256                 kfree(port->interrupt_in_buffer);
1257         }
1258
1259         /* return the minor range that this device had */
1260         return_serial (serial);
1261
1262         /* free up any memory that we allocated */
1263         for (i = 0; i < serial->num_port_pointers; ++i)
1264                 kfree(serial->port[i]);
1265         kfree (serial);
1266         return -EIO;
1267 }
1268
1269 void usb_serial_disconnect(struct usb_interface *interface)
1270 {
1271         struct usb_serial *serial = usb_get_intfdata (interface);
1272         struct device *dev = &interface->dev;
1273
1274         dbg ("%s", __FUNCTION__);
1275
1276         usb_set_intfdata (interface, NULL);
1277         if (serial) {
1278                 /* let the last holder of this object
1279                  * cause it to be cleaned up */
1280                 kref_put(&serial->kref);
1281         }
1282         dev_info(dev, "device disconnected\n");
1283 }
1284
1285 static struct tty_operations serial_ops = {
1286         .open =                 serial_open,
1287         .close =                serial_close,
1288         .write =                serial_write,
1289         .write_room =           serial_write_room,
1290         .ioctl =                serial_ioctl,
1291         .set_termios =          serial_set_termios,
1292         .throttle =             serial_throttle,
1293         .unthrottle =           serial_unthrottle,
1294         .break_ctl =            serial_break,
1295         .chars_in_buffer =      serial_chars_in_buffer,
1296         .read_proc =            serial_read_proc,
1297         .tiocmget =             serial_tiocmget,
1298         .tiocmset =             serial_tiocmset,
1299 };
1300
1301 struct tty_driver *usb_serial_tty_driver;
1302
1303 static int __init usb_serial_init(void)
1304 {
1305         int i;
1306         int result = 0;
1307
1308         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1309         if (!usb_serial_tty_driver)
1310                 return -ENOMEM;
1311
1312         /* Initialize our global data */
1313         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1314                 serial_table[i] = NULL;
1315         }
1316
1317         bus_register(&usb_serial_bus_type);
1318
1319         /* register the generic driver, if we should */
1320         result = usb_serial_generic_register(debug);
1321         if (result < 0) {
1322                 err("%s - registering generic driver failed", __FUNCTION__);
1323                 goto exit;
1324         }
1325
1326         usb_serial_tty_driver->owner = THIS_MODULE;
1327         usb_serial_tty_driver->driver_name = "usbserial";
1328         usb_serial_tty_driver->devfs_name = "usb/tts/";
1329         usb_serial_tty_driver->name =   "ttyUSB";
1330         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1331         usb_serial_tty_driver->minor_start = 0;
1332         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1333         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1334         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
1335         usb_serial_tty_driver->init_termios = tty_std_termios;
1336         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1337         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1338         result = tty_register_driver(usb_serial_tty_driver);
1339         if (result) {
1340                 err("%s - tty_register_driver failed", __FUNCTION__);
1341                 goto exit_generic;
1342         }
1343
1344         /* register the USB driver */
1345         result = usb_register(&usb_serial_driver);
1346         if (result < 0) {
1347                 err("%s - usb_register failed", __FUNCTION__);
1348                 goto exit_tty;
1349         }
1350
1351         info(DRIVER_DESC " " DRIVER_VERSION);
1352
1353         return result;
1354
1355 exit_tty:
1356         tty_unregister_driver(usb_serial_tty_driver);
1357
1358 exit_generic:
1359         usb_serial_generic_deregister();
1360
1361 exit:
1362         err ("%s - returning with error %d", __FUNCTION__, result);
1363         put_tty_driver(usb_serial_tty_driver);
1364         return result;
1365 }
1366
1367
1368 static void __exit usb_serial_exit(void)
1369 {
1370         usb_serial_console_exit();
1371
1372         usb_serial_generic_deregister();
1373
1374         usb_deregister(&usb_serial_driver);
1375         tty_unregister_driver(usb_serial_tty_driver);
1376         put_tty_driver(usb_serial_tty_driver);
1377         bus_unregister(&usb_serial_bus_type);
1378 }
1379
1380
1381 module_init(usb_serial_init);
1382 module_exit(usb_serial_exit);
1383
1384 #define set_to_generic_if_null(type, function)                          \
1385         do {                                                            \
1386                 if (!type->function) {                                  \
1387                         type->function = usb_serial_generic_##function; \
1388                         dbg("Had to override the " #function            \
1389                                  " usb serial operation with the generic one.");\
1390                         }                                               \
1391         } while (0)
1392
1393 static void fixup_generic(struct usb_serial_device_type *device)
1394 {
1395         set_to_generic_if_null(device, open);
1396         set_to_generic_if_null(device, write);
1397         set_to_generic_if_null(device, close);
1398         set_to_generic_if_null(device, write_room);
1399         set_to_generic_if_null(device, chars_in_buffer);
1400         set_to_generic_if_null(device, read_bulk_callback);
1401         set_to_generic_if_null(device, write_bulk_callback);
1402         set_to_generic_if_null(device, shutdown);
1403 }
1404
1405 int usb_serial_register(struct usb_serial_device_type *new_device)
1406 {
1407         int retval;
1408
1409         fixup_generic(new_device);
1410
1411         /* Add this device to our list of devices */
1412         list_add(&new_device->driver_list, &usb_serial_driver_list);
1413
1414         retval =  usb_serial_bus_register (new_device);
1415
1416         if (retval)
1417                 goto error;
1418
1419         info("USB Serial support registered for %s", new_device->name);
1420
1421         return retval;
1422 error:
1423         err("problem %d when registering driver %s", retval, new_device->name);
1424         list_del(&new_device->driver_list);
1425
1426         return retval;
1427 }
1428
1429
1430 void usb_serial_deregister(struct usb_serial_device_type *device)
1431 {
1432         struct usb_serial *serial;
1433         int i;
1434
1435         info("USB Serial deregistering driver %s", device->name);
1436
1437         /* clear out the serial_table if the device is attached to a port */
1438         for(i = 0; i < SERIAL_TTY_MINORS; ++i) {
1439                 serial = serial_table[i];
1440                 if ((serial != NULL) && (serial->type == device)) {
1441                         usb_driver_release_interface (&usb_serial_driver, serial->interface);
1442                         usb_serial_disconnect (serial->interface);
1443                 }
1444         }
1445
1446         list_del(&device->driver_list);
1447         usb_serial_bus_deregister (device);
1448 }
1449
1450
1451
1452 /* If the usb-serial core is built into the core, the usb-serial drivers
1453    need these symbols to load properly as modules. */
1454 EXPORT_SYMBOL(usb_serial_register);
1455 EXPORT_SYMBOL(usb_serial_deregister);
1456 EXPORT_SYMBOL(usb_serial_probe);
1457 EXPORT_SYMBOL(usb_serial_disconnect);
1458 EXPORT_SYMBOL(usb_serial_port_softint);
1459
1460
1461 /* Module information */
1462 MODULE_AUTHOR( DRIVER_AUTHOR );
1463 MODULE_DESCRIPTION( DRIVER_DESC );
1464 MODULE_LICENSE("GPL");
1465
1466 MODULE_PARM(debug, "i");
1467 MODULE_PARM_DESC(debug, "Debug enabled or not");