drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2004 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/moduleparam.h>
 334 #include <linux/spinlock.h>
 335 #include <linux/list.h>
 336 #include <linux/smp_lock.h>
 337 #include <asm/uaccess.h>
 338 #include <linux/usb.h>
 339 #include "usb-serial.h"
 340 #include "pl2303.h"
 341
 342 /*
 343  * Version Information
 344  */
 345 #define DRIVER_VERSION "v2.0"
 346 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
 347 #define DRIVER_DESC "USB Serial Driver core"
 348
 349 /* Driver structure we register with the USB core */
 350 static struct usb_driver usb_serial_driver = {
 351         .owner =        THIS_MODULE,
 352         .name =         "usbserial",
 353         .probe =        usb_serial_probe,
 354         .disconnect =   usb_serial_disconnect,
 355 };
 356
 357 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
 358    the MODULE_DEVICE_TABLE declarations in each serial driver
 359    cause the "hotplug" program to pull in whatever module is necessary
 360    via modprobe, and modprobe will load usbserial because the serial
 361    drivers depend on it.
 362 */
 363
 364 static int debug;
 365 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];      /* initially all NULL */
 366 static LIST_HEAD(usb_serial_driver_list);
 367
 368 struct usb_serial *usb_serial_get_by_index(unsigned index)
 369 {
 370         struct usb_serial *serial = serial_table[index];
 371
 372         if (serial)
 373                 kref_get(&serial->kref);
 374         return serial;
 375 }
 376
 377 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
 378 {
 379         unsigned int i, j;
 380         int good_spot;
 381
 382         dbg("%s %d", __FUNCTION__, num_ports);
 383
 384         *minor = 0;
 385         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 386                 if (serial_table[i])
 387                         continue;
 388
 389                 good_spot = 1;
 390                 for (j = 1; j <= num_ports-1; ++j)
 391                         if ((serial_table[i+j]) || (i+j >= SERIAL_TTY_MINORS)) {
 392                                 good_spot = 0;
 393                                 i += j;
 394                                 break;
 395                         }
 396                 if (good_spot == 0)
 397                         continue;
 398
 399                 *minor = i;
 400                 dbg("%s - minor base = %d", __FUNCTION__, *minor);
 401                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
 402                         serial_table[i] = serial;
 403                 return serial;
 404         }
 405         return NULL;
 406 }
 407
 408 static void return_serial (struct usb_serial *serial)
 409 {
 410         int i;
 411
 412         dbg("%s", __FUNCTION__);
 413
 414         if (serial == NULL)
 415                 return;
 416
 417         for (i = 0; i < serial->num_ports; ++i) {
 418                 serial_table[serial->minor + i] = NULL;
 419         }
 420
 421         return;
 422 }
 423
 424 static void destroy_serial(struct kref *kref)
 425 {
 426         struct usb_serial *serial;
 427         struct usb_serial_port *port;
 428         int i;
 429
 430         serial = to_usb_serial(kref);
 431
 432         dbg ("%s - %s", __FUNCTION__, serial->type->name);
 433
 434         serial->type->shutdown(serial);
 435
 436         /* return the minor range that this device had */
 437         return_serial(serial);
 438
 439         for (i = 0; i < serial->num_ports; ++i)
 440                 serial->port[i]->open_count = 0;
 441
 442         /* the ports are cleaned up and released in port_release() */
 443         for (i = 0; i < serial->num_ports; ++i)
 444                 if (serial->port[i]->dev.parent != NULL) {
 445                         device_unregister(&serial->port[i]->dev);
 446                         serial->port[i] = NULL;
 447                 }
 448
 449         /* If this is a "fake" port, we have to clean it up here, as it will
 450          * not get cleaned up in port_release() as it was never registered with
 451          * the driver core */
 452         if (serial->num_ports < serial->num_port_pointers) {
 453                 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
 454                         port = serial->port[i];
 455                         if (!port)
 456                                 continue;
 457                         if (port->read_urb) {
 458                                 usb_unlink_urb(port->read_urb);
 459                                 usb_free_urb(port->read_urb);
 460                         }
 461                         if (port->write_urb) {
 462                                 usb_unlink_urb(port->write_urb);
 463                                 usb_free_urb(port->write_urb);
 464                         }
 465                         if (port->interrupt_in_urb) {
 466                                 usb_unlink_urb(port->interrupt_in_urb);
 467                                 usb_free_urb(port->interrupt_in_urb);
 468                         }
 469                         kfree(port->bulk_in_buffer);
 470                         kfree(port->bulk_out_buffer);
 471                         kfree(port->interrupt_in_buffer);
 472                 }
 473         }
 474
 475         usb_put_dev(serial->dev);
 476
 477         /* free up any memory that we allocated */
 478         kfree (serial);
 479 }
 480
 481 /*****************************************************************************
 482  * Driver tty interface functions
 483  *****************************************************************************/
 484 static int serial_open (struct tty_struct *tty, struct file * filp)
 485 {
 486         struct usb_serial *serial;
 487         struct usb_serial_port *port;
 488         unsigned int portNumber;
 489         int retval = 0;
 490
 491         dbg("%s", __FUNCTION__);
 492
 493         /* initialize the pointer incase something fails */
 494         tty->driver_data = NULL;
 495
 496         /* get the serial object associated with this tty pointer */
 497         serial = usb_serial_get_by_index(tty->index);
 498         if (!serial) {
 499                 retval = -ENODEV;
 500                 goto bailout;
 501         }
 502
 503         /* set up our port structure making the tty driver remember our port object, and us it */
 504         portNumber = tty->index - serial->minor;
 505         port = serial->port[portNumber];
 506         tty->driver_data = port;
 507
 508         port->tty = tty;
 509
 510         /* lock this module before we call it,
 511            this may, which means we must bail out, safe because we are called with BKL held */
 512         if (!try_module_get(serial->type->owner)) {
 513                 retval = -ENODEV;
 514                 goto bailout;
 515         }
 516
 517         ++port->open_count;
 518         if (port->open_count == 1) {
 519                 /* only call the device specific open if this
 520                  * is the first time the port is opened */
 521                 retval = serial->type->open(port, filp);
 522                 if (retval) {
 523                         port->open_count = 0;
 524                         module_put(serial->type->owner);
 525                         kref_put(&serial->kref, destroy_serial);
 526                 }
 527         }
 528 bailout:
 529         return retval;
 530 }
 531
 532 static void serial_close(struct tty_struct *tty, struct file * filp)
 533 {
 534         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 535
 536         if (!port)
 537                 return;
 538
 539         dbg("%s - port %d", __FUNCTION__, port->number);
 540
 541         --port->open_count;
 542         if (port->open_count <= 0) {
 543                 /* only call the device specific close if this
 544                  * port is being closed by the last owner */
 545                 port->serial->type->close(port, filp);
 546                 port->open_count = 0;
 547
 548                 if (port->tty) {
 549                         if (port->tty->driver_data)
 550                                 port->tty->driver_data = NULL;
 551                         port->tty = NULL;
 552                 }
 553         }
 554
 555         module_put(port->serial->type->owner);
 556         kref_put(&port->serial->kref, destroy_serial);
 557 }
 558
 559 static int serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count)
 560 {
 561         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 562         int retval = -EINVAL;
 563
 564         dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
 565
 566         if (!port->open_count) {
 567                 dbg("%s - port not opened", __FUNCTION__);
 568                 goto exit;
 569         }
 570
 571         /* pass on to the driver specific version of this function */
 572         retval = port->serial->type->write(port, from_user, buf, count);
 573
 574 exit:
 575         return retval;
 576 }
 577
 578 static int serial_write_room (struct tty_struct *tty)
 579 {
 580         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 581         int retval = -EINVAL;
 582
 583         dbg("%s - port %d", __FUNCTION__, port->number);
 584
 585         if (!port->open_count) {
 586                 dbg("%s - port not open", __FUNCTION__);
 587                 goto exit;
 588         }
 589
 590         /* pass on to the driver specific version of this function */
 591         retval = port->serial->type->write_room(port);
 592
 593 exit:
 594         return retval;
 595 }
 596
 597 static int serial_chars_in_buffer (struct tty_struct *tty)
 598 {
 599         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 600         int retval = -EINVAL;
 601
 602         dbg("%s = port %d", __FUNCTION__, port->number);
 603
 604         if (!port->open_count) {
 605                 dbg("%s - port not open", __FUNCTION__);
 606                 goto exit;
 607         }
 608
 609         /* pass on to the driver specific version of this function */
 610         retval = port->serial->type->chars_in_buffer(port);
 611
 612 exit:
 613         return retval;
 614 }
 615
 616 static void serial_throttle (struct tty_struct * tty)
 617 {
 618         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 619
 620         dbg("%s - port %d", __FUNCTION__, port->number);
 621
 622         if (!port->open_count) {
 623                 dbg ("%s - port not open", __FUNCTION__);
 624                 goto exit;
 625         }
 626
 627         /* pass on to the driver specific version of this function */
 628         if (port->serial->type->throttle)
 629                 port->serial->type->throttle(port);
 630
 631 exit:
 632         ;
 633 }
 634
 635 static void serial_unthrottle (struct tty_struct * tty)
 636 {
 637         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 638
 639         dbg("%s - port %d", __FUNCTION__, port->number);
 640
 641         if (!port->open_count) {
 642                 dbg("%s - port not open", __FUNCTION__);
 643                 goto exit;
 644         }
 645
 646         /* pass on to the driver specific version of this function */
 647         if (port->serial->type->unthrottle)
 648                 port->serial->type->unthrottle(port);
 649
 650 exit:
 651         ;
 652 }
 653
 654 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 655 {
 656         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 657         int retval = -ENODEV;
 658
 659         dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
 660
 661         if (!port->open_count) {
 662                 dbg ("%s - port not open", __FUNCTION__);
 663                 goto exit;
 664         }
 665
 666         /* pass on to the driver specific version of this function if it is available */
 667         if (port->serial->type->ioctl)
 668                 retval = port->serial->type->ioctl(port, file, cmd, arg);
 669         else
 670                 retval = -ENOIOCTLCMD;
 671
 672 exit:
 673         return retval;
 674 }
 675
 676 static void serial_set_termios (struct tty_struct *tty, struct termios * old)
 677 {
 678         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 679
 680         dbg("%s - port %d", __FUNCTION__, port->number);
 681
 682         if (!port->open_count) {
 683                 dbg("%s - port not open", __FUNCTION__);
 684                 goto exit;
 685         }
 686
 687         /* pass on to the driver specific version of this function if it is available */
 688         if (port->serial->type->set_termios)
 689                 port->serial->type->set_termios(port, old);
 690
 691 exit:
 692         ;
 693 }
 694
 695 static void serial_break (struct tty_struct *tty, int break_state)
 696 {
 697         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 698
 699         dbg("%s - port %d", __FUNCTION__, port->number);
 700
 701         if (!port->open_count) {
 702                 dbg("%s - port not open", __FUNCTION__);
 703                 goto exit;
 704         }
 705
 706         /* pass on to the driver specific version of this function if it is available */
 707         if (port->serial->type->break_ctl)
 708                 port->serial->type->break_ctl(port, break_state);
 709
 710 exit:
 711         ;
 712 }
 713
 714 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
 715 {
 716         struct usb_serial *serial;
 717         int length = 0;
 718         int i;
 719         off_t begin = 0;
 720         char tmp[40];
 721
 722         dbg("%s", __FUNCTION__);
 723         length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
 724         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
 725                 serial = usb_serial_get_by_index(i);
 726                 if (serial == NULL)
 727                         continue;
 728
 729                 length += sprintf (page+length, "%d:", i);
 730                 if (serial->type->owner)
 731                         length += sprintf (page+length, " module:%s", module_name(serial->type->owner));
 732                 length += sprintf (page+length, " name:\"%s\"", serial->type->name);
 733                 length += sprintf (page+length, " vendor:%04x product:%04x", serial->vendor, serial->product);
 734                 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
 735                 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
 736
 737                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 738                 length += sprintf (page+length, " path:%s", tmp);
 739
 740                 length += sprintf (page+length, "\n");
 741                 if ((length + begin) > (off + count))
 742                         goto done;
 743                 if ((length + begin) < off) {
 744                         begin += length;
 745                         length = 0;
 746                 }
 747                 kref_put(&serial->kref, destroy_serial);
 748         }
 749         *eof = 1;
 750 done:
 751         if (off >= (length + begin))
 752                 return 0;
 753         *start = page + (off-begin);
 754         return ((count < begin+length-off) ? count : begin+length-off);
 755 }
 756
 757 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
 758 {
 759         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 760
 761         dbg("%s - port %d", __FUNCTION__, port->number);
 762
 763         if (!port->open_count) {
 764                 dbg("%s - port not open", __FUNCTION__);
 765                 goto exit;
 766         }
 767
 768         if (port->serial->type->tiocmget)
 769                 return port->serial->type->tiocmget(port, file);
 770
 771 exit:
 772         return -EINVAL;
 773 }
 774
 775 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
 776                             unsigned int set, unsigned int clear)
 777 {
 778         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
 779
 780         dbg("%s - port %d", __FUNCTION__, port->number);
 781
 782         if (!port->open_count) {
 783                 dbg("%s - port not open", __FUNCTION__);
 784                 goto exit;
 785         }
 786
 787         if (port->serial->type->tiocmset)
 788                 return port->serial->type->tiocmset(port, file, set, clear);
 789
 790 exit:
 791         return -EINVAL;
 792 }
 793
 794 void usb_serial_port_softint(void *private)
 795 {
 796         struct usb_serial_port *port = (struct usb_serial_port *)private;
 797         struct tty_struct *tty;
 798
 799         dbg("%s - port %d", __FUNCTION__, port->number);
 800
 801         if (!port)
 802                 return;
 803
 804         tty = port->tty;
 805         if (!tty)
 806                 return;
 807
 808         tty_wakeup(tty);
 809 }
 810
 811 static void port_release(struct device *dev)
 812 {
 813         struct usb_serial_port *port = to_usb_serial_port(dev);
 814
 815         dbg ("%s - %s", __FUNCTION__, dev->bus_id);
 816         if (port->read_urb) {
 817                 usb_unlink_urb(port->read_urb);
 818                 usb_free_urb(port->read_urb);
 819         }
 820         if (port->write_urb) {
 821                 usb_unlink_urb(port->write_urb);
 822                 usb_free_urb(port->write_urb);
 823         }
 824         if (port->interrupt_in_urb) {
 825                 usb_unlink_urb(port->interrupt_in_urb);
 826                 usb_free_urb(port->interrupt_in_urb);
 827         }
 828         kfree(port->bulk_in_buffer);
 829         kfree(port->bulk_out_buffer);
 830         kfree(port->interrupt_in_buffer);
 831         kfree(port);
 832 }
 833
 834 static struct usb_serial * create_serial (struct usb_device *dev,
 835                                           struct usb_interface *interface,
 836                                           struct usb_serial_device_type *type)
 837 {
 838         struct usb_serial *serial;
 839
 840         serial = kmalloc (sizeof (*serial), GFP_KERNEL);
 841         if (!serial) {
 842                 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
 843                 return NULL;
 844         }
 845         memset (serial, 0, sizeof(*serial));
 846         serial->dev = usb_get_dev(dev);
 847         serial->type = type;
 848         serial->interface = interface;
 849         serial->vendor = dev->descriptor.idVendor;
 850         serial->product = dev->descriptor.idProduct;
 851         kref_init(&serial->kref);
 852
 853         return serial;
 854 }
 855
 856 int usb_serial_probe(struct usb_interface *interface,
 857                                const struct usb_device_id *id)
 858 {
 859         struct usb_device *dev = interface_to_usbdev (interface);
 860         struct usb_serial *serial = NULL;
 861         struct usb_serial_port *port;
 862         struct usb_host_interface *iface_desc;
 863         struct usb_endpoint_descriptor *endpoint;
 864         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 865         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 866         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 867         struct usb_serial_device_type *type = NULL;
 868         struct list_head *tmp;
 869         int retval;
 870         int found;
 871         int minor;
 872         int buffer_size;
 873         int i;
 874         int num_interrupt_in = 0;
 875         int num_bulk_in = 0;
 876         int num_bulk_out = 0;
 877         int num_ports = 0;
 878         int max_endpoints;
 879         const struct usb_device_id *id_pattern = NULL;
 880
 881         /* loop through our list of known serial converters, and see if this
 882            device matches. */
 883         found = 0;
 884         list_for_each (tmp, &usb_serial_driver_list) {
 885                 type = list_entry(tmp, struct usb_serial_device_type, driver_list);
 886                 id_pattern = usb_match_id(interface, type->id_table);
 887                 if (id_pattern != NULL) {
 888                         dbg("descriptor matches");
 889                         found = 1;
 890                         break;
 891                 }
 892         }
 893         if (!found) {
 894                 /* no match */
 895                 dbg("none matched");
 896                 return -ENODEV;
 897         }
 898
 899         serial = create_serial (dev, interface, type);
 900         if (!serial) {
 901                 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
 902                 return -ENODEV;
 903         }
 904
 905         /* if this device type has a probe function, call it */
 906         if (type->probe) {
 907                 if (!try_module_get(type->owner)) {
 908                         dev_err(&interface->dev, "module get failed, exiting\n");
 909                         kfree (serial);
 910                         return -EIO;
 911                 }
 912                 retval = type->probe (serial, id_pattern);
 913                 module_put(type->owner);
 914
 915                 if (retval) {
 916                         dbg ("sub driver rejected device");
 917                         kfree (serial);
 918                         return retval;
 919                 }
 920         }
 921
 922         /* descriptor matches, let's find the endpoints needed */
 923         /* check out the endpoints */
 924         iface_desc = interface->cur_altsetting;
 925         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 926                 endpoint = &iface_desc->endpoint[i].desc;
 927
 928                 if ((endpoint->bEndpointAddress & 0x80) &&
 929                     ((endpoint->bmAttributes & 3) == 0x02)) {
 930                         /* we found a bulk in endpoint */
 931                         dbg("found bulk in");
 932                         bulk_in_endpoint[num_bulk_in] = endpoint;
 933                         ++num_bulk_in;
 934                 }
 935
 936                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
 937                     ((endpoint->bmAttributes & 3) == 0x02)) {
 938                         /* we found a bulk out endpoint */
 939                         dbg("found bulk out");
 940                         bulk_out_endpoint[num_bulk_out] = endpoint;
 941                         ++num_bulk_out;
 942                 }
 943
 944                 if ((endpoint->bEndpointAddress & 0x80) &&
 945                     ((endpoint->bmAttributes & 3) == 0x03)) {
 946                         /* we found a interrupt in endpoint */
 947                         dbg("found interrupt in");
 948                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 949                         ++num_interrupt_in;
 950                 }
 951         }
 952
 953 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 954         /* BEGIN HORRIBLE HACK FOR PL2303 */
 955         /* this is needed due to the looney way its endpoints are set up */
 956         if (((dev->descriptor.idVendor == PL2303_VENDOR_ID) &&
 957              (dev->descriptor.idProduct == PL2303_PRODUCT_ID)) ||
 958             ((dev->descriptor.idVendor == ATEN_VENDOR_ID) &&
 959              (dev->descriptor.idProduct == ATEN_PRODUCT_ID))) {
 960                 if (interface != dev->actconfig->interface[0]) {
 961                         /* check out the endpoints of the other interface*/
 962                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 963                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 964                                 endpoint = &iface_desc->endpoint[i].desc;
 965                                 if ((endpoint->bEndpointAddress & 0x80) &&
 966                                     ((endpoint->bmAttributes & 3) == 0x03)) {
 967                                         /* we found a interrupt in endpoint */
 968                                         dbg("found interrupt in for Prolific device on separate interface");
 969                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 970                                         ++num_interrupt_in;
 971                                 }
 972                         }
 973                 }
 974
 975                 /* Now make sure the PL-2303 is configured correctly.
 976                  * If not, give up now and hope this hack will work
 977                  * properly during a later invocation of usb_serial_probe
 978                  */
 979                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 980                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 981                         kfree (serial);
 982                         return -ENODEV;
 983                 }
 984         }
 985         /* END HORRIBLE HACK FOR PL2303 */
 986 #endif
 987
 988         /* found all that we need */
 989         dev_info(&interface->dev, "%s converter detected\n", type->name);
 990
 991 #ifdef CONFIG_USB_SERIAL_GENERIC
 992         if (type == &usb_serial_generic_device) {
 993                 num_ports = num_bulk_out;
 994                 if (num_ports == 0) {
 995                         dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
 996                         kfree (serial);
 997                         return -EIO;
 998                 }
 999         }
1000 #endif
1001         if (!num_ports) {
1002                 /* if this device type has a calc_num_ports function, call it */
1003                 if (type->calc_num_ports) {
1004                         if (!try_module_get(type->owner)) {
1005                                 dev_err(&interface->dev, "module get failed, exiting\n");
1006                                 kfree (serial);
1007                                 return -EIO;
1008                         }
1009                         num_ports = type->calc_num_ports (serial);
1010                         module_put(type->owner);
1011                 }
1012                 if (!num_ports)
1013                         num_ports = type->num_ports;
1014         }
1015
1016         if (get_free_serial (serial, num_ports, &minor) == NULL) {
1017                 dev_err(&interface->dev, "No more free serial devices\n");
1018                 kfree (serial);
1019                 return -ENOMEM;
1020         }
1021
1022         serial->minor = minor;
1023         serial->num_ports = num_ports;
1024         serial->num_bulk_in = num_bulk_in;
1025         serial->num_bulk_out = num_bulk_out;
1026         serial->num_interrupt_in = num_interrupt_in;
1027
1028         /* create our ports, we need as many as the max endpoints */
1029         /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
1030         max_endpoints = max(num_bulk_in, num_bulk_out);
1031         max_endpoints = max(max_endpoints, num_interrupt_in);
1032         max_endpoints = max(max_endpoints, (int)serial->num_ports);
1033         serial->num_port_pointers = max_endpoints;
1034         dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
1035         for (i = 0; i < max_endpoints; ++i) {
1036                 port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
1037                 if (!port)
1038                         goto probe_error;
1039                 memset(port, 0x00, sizeof(struct usb_serial_port));
1040                 port->number = i + serial->minor;
1041                 port->serial = serial;
1042                 INIT_WORK(&port->work, usb_serial_port_softint, port);
1043                 serial->port[i] = port;
1044         }
1045
1046         /* set up the endpoint information */
1047         for (i = 0; i < num_bulk_in; ++i) {
1048                 endpoint = bulk_in_endpoint[i];
1049                 port = serial->port[i];
1050                 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
1051                 if (!port->read_urb) {
1052                         dev_err(&interface->dev, "No free urbs available\n");
1053                         goto probe_error;
1054                 }
1055                 buffer_size = endpoint->wMaxPacketSize;
1056                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
1057                 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1058                 if (!port->bulk_in_buffer) {
1059                         dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
1060                         goto probe_error;
1061                 }
1062                 usb_fill_bulk_urb (port->read_urb, dev,
1063                                    usb_rcvbulkpipe (dev,
1064                                                     endpoint->bEndpointAddress),
1065                                    port->bulk_in_buffer, buffer_size,
1066                                    serial->type->read_bulk_callback,
1067                                    port);
1068         }
1069
1070         for (i = 0; i < num_bulk_out; ++i) {
1071                 endpoint = bulk_out_endpoint[i];
1072                 port = serial->port[i];
1073                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
1074                 if (!port->write_urb) {
1075                         dev_err(&interface->dev, "No free urbs available\n");
1076                         goto probe_error;
1077                 }
1078                 buffer_size = endpoint->wMaxPacketSize;
1079                 port->bulk_out_size = buffer_size;
1080                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
1081                 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
1082                 if (!port->bulk_out_buffer) {
1083                         dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
1084                         goto probe_error;
1085                 }
1086                 usb_fill_bulk_urb (port->write_urb, dev,
1087                                    usb_sndbulkpipe (dev,
1088                                                     endpoint->bEndpointAddress),
1089                                    port->bulk_out_buffer, buffer_size,
1090                                    serial->type->write_bulk_callback,
1091                                    port);
1092         }
1093
1094         for (i = 0; i < num_interrupt_in; ++i) {
1095                 endpoint = interrupt_in_endpoint[i];
1096                 port = serial->port[i];
1097                 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1098                 if (!port->interrupt_in_urb) {
1099                         dev_err(&interface->dev, "No free urbs available\n");
1100                         goto probe_error;
1101                 }
1102                 buffer_size = endpoint->wMaxPacketSize;
1103                 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
1104                 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1105                 if (!port->interrupt_in_buffer) {
1106                         dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
1107                         goto probe_error;
1108                 }
1109                 usb_fill_int_urb (port->interrupt_in_urb, dev,
1110                                   usb_rcvintpipe (dev,
1111                                                   endpoint->bEndpointAddress),
1112                                   port->interrupt_in_buffer, buffer_size,
1113                                   serial->type->read_int_callback, port,
1114                                   endpoint->bInterval);
1115         }
1116
1117         /* if this device type has an attach function, call it */
1118         if (type->attach) {
1119                 if (!try_module_get(type->owner)) {
1120                         dev_err(&interface->dev, "module get failed, exiting\n");
1121                         goto probe_error;
1122                 }
1123                 retval = type->attach (serial);
1124                 module_put(type->owner);
1125                 if (retval < 0)
1126                         goto probe_error;
1127                 if (retval > 0) {
1128                         /* quietly accept this device, but don't bind to a serial port
1129                          * as it's about to disappear */
1130                         goto exit;
1131                 }
1132         }
1133
1134         /* register all of the individual ports with the driver core */
1135         for (i = 0; i < num_ports; ++i) {
1136                 port = serial->port[i];
1137                 port->dev.parent = &interface->dev;
1138                 port->dev.driver = NULL;
1139                 port->dev.bus = &usb_serial_bus_type;
1140                 port->dev.release = &port_release;
1141
1142                 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1143                 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1144                 device_register (&port->dev);
1145         }
1146
1147         usb_serial_console_init (debug, minor);
1148
1149 exit:
1150         /* success */
1151         usb_set_intfdata (interface, serial);
1152         return 0;
1153
1154 probe_error:
1155         for (i = 0; i < num_bulk_in; ++i) {
1156                 port = serial->port[i];
1157                 if (!port)
1158                         continue;
1159                 if (port->read_urb)
1160                         usb_free_urb (port->read_urb);
1161                 kfree(port->bulk_in_buffer);
1162         }
1163         for (i = 0; i < num_bulk_out; ++i) {
1164                 port = serial->port[i];
1165                 if (!port)
1166                         continue;
1167                 if (port->write_urb)
1168                         usb_free_urb (port->write_urb);
1169                 kfree(port->bulk_out_buffer);
1170         }
1171         for (i = 0; i < num_interrupt_in; ++i) {
1172                 port = serial->port[i];
1173                 if (!port)
1174                         continue;
1175                 if (port->interrupt_in_urb)
1176                         usb_free_urb (port->interrupt_in_urb);
1177                 kfree(port->interrupt_in_buffer);
1178         }
1179
1180         /* return the minor range that this device had */
1181         return_serial (serial);
1182
1183         /* free up any memory that we allocated */
1184         for (i = 0; i < serial->num_port_pointers; ++i)
1185                 kfree(serial->port[i]);
1186         kfree (serial);
1187         return -EIO;
1188 }
1189
1190 void usb_serial_disconnect(struct usb_interface *interface)
1191 {
1192         struct usb_serial *serial = usb_get_intfdata (interface);
1193         struct device *dev = &interface->dev;
1194
1195         dbg ("%s", __FUNCTION__);
1196
1197         usb_set_intfdata (interface, NULL);
1198         if (serial) {
1199                 /* let the last holder of this object
1200                  * cause it to be cleaned up */
1201                 kref_put(&serial->kref, destroy_serial);
1202         }
1203         dev_info(dev, "device disconnected\n");
1204 }
1205
1206 static struct tty_operations serial_ops = {
1207         .open =                 serial_open,
1208         .close =                serial_close,
1209         .write =                serial_write,
1210         .write_room =           serial_write_room,
1211         .ioctl =                serial_ioctl,
1212         .set_termios =          serial_set_termios,
1213         .throttle =             serial_throttle,
1214         .unthrottle =           serial_unthrottle,
1215         .break_ctl =            serial_break,
1216         .chars_in_buffer =      serial_chars_in_buffer,
1217         .read_proc =            serial_read_proc,
1218         .tiocmget =             serial_tiocmget,
1219         .tiocmset =             serial_tiocmset,
1220 };
1221
1222 struct tty_driver *usb_serial_tty_driver;
1223
1224 static int __init usb_serial_init(void)
1225 {
1226         int i;
1227         int result = 0;
1228
1229         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1230         if (!usb_serial_tty_driver)
1231                 return -ENOMEM;
1232
1233         /* Initialize our global data */
1234         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1235                 serial_table[i] = NULL;
1236         }
1237
1238         bus_register(&usb_serial_bus_type);
1239
1240         /* register the generic driver, if we should */
1241         result = usb_serial_generic_register(debug);
1242         if (result < 0) {
1243                 err("%s - registering generic driver failed", __FUNCTION__);
1244                 goto exit;
1245         }
1246
1247         usb_serial_tty_driver->owner = THIS_MODULE;
1248         usb_serial_tty_driver->driver_name = "usbserial";
1249         usb_serial_tty_driver->devfs_name = "usb/tts/";
1250         usb_serial_tty_driver->name =   "ttyUSB";
1251         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1252         usb_serial_tty_driver->minor_start = 0;
1253         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1254         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1255         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
1256         usb_serial_tty_driver->init_termios = tty_std_termios;
1257         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1258         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1259         result = tty_register_driver(usb_serial_tty_driver);
1260         if (result) {
1261                 err("%s - tty_register_driver failed", __FUNCTION__);
1262                 goto exit_generic;
1263         }
1264
1265         /* register the USB driver */
1266         result = usb_register(&usb_serial_driver);
1267         if (result < 0) {
1268                 err("%s - usb_register failed", __FUNCTION__);
1269                 goto exit_tty;
1270         }
1271
1272         info(DRIVER_DESC " " DRIVER_VERSION);
1273
1274         return result;
1275
1276 exit_tty:
1277         tty_unregister_driver(usb_serial_tty_driver);
1278
1279 exit_generic:
1280         usb_serial_generic_deregister();
1281
1282 exit:
1283         err ("%s - returning with error %d", __FUNCTION__, result);
1284         put_tty_driver(usb_serial_tty_driver);
1285         return result;
1286 }
1287
1288
1289 static void __exit usb_serial_exit(void)
1290 {
1291         usb_serial_console_exit();
1292
1293         usb_serial_generic_deregister();
1294
1295         usb_deregister(&usb_serial_driver);
1296         tty_unregister_driver(usb_serial_tty_driver);
1297         put_tty_driver(usb_serial_tty_driver);
1298         bus_unregister(&usb_serial_bus_type);
1299 }
1300
1301
1302 module_init(usb_serial_init);
1303 module_exit(usb_serial_exit);
1304
1305 #define set_to_generic_if_null(type, function)                          \
1306         do {                                                            \
1307                 if (!type->function) {                                  \
1308                         type->function = usb_serial_generic_##function; \
1309                         dbg("Had to override the " #function            \
1310                                  " usb serial operation with the generic one.");\
1311                         }                                               \
1312         } while (0)
1313
1314 static void fixup_generic(struct usb_serial_device_type *device)
1315 {
1316         set_to_generic_if_null(device, open);
1317         set_to_generic_if_null(device, write);
1318         set_to_generic_if_null(device, close);
1319         set_to_generic_if_null(device, write_room);
1320         set_to_generic_if_null(device, chars_in_buffer);
1321         set_to_generic_if_null(device, read_bulk_callback);
1322         set_to_generic_if_null(device, write_bulk_callback);
1323         set_to_generic_if_null(device, shutdown);
1324 }
1325
1326 int usb_serial_register(struct usb_serial_device_type *new_device)
1327 {
1328         int retval;
1329
1330         fixup_generic(new_device);
1331
1332         /* Add this device to our list of devices */
1333         list_add(&new_device->driver_list, &usb_serial_driver_list);
1334
1335         retval =  usb_serial_bus_register (new_device);
1336
1337         if (retval)
1338                 goto error;
1339
1340         info("USB Serial support registered for %s", new_device->name);
1341
1342         return retval;
1343 error:
1344         err("problem %d when registering driver %s", retval, new_device->name);
1345         list_del(&new_device->driver_list);
1346
1347         return retval;
1348 }
1349
1350
1351 void usb_serial_deregister(struct usb_serial_device_type *device)
1352 {
1353         info("USB Serial deregistering driver %s", device->name);
1354         list_del(&device->driver_list);
1355         usb_serial_bus_deregister(device);
1356 }
1357
1358
1359
1360 /* If the usb-serial core is built into the core, the usb-serial drivers
1361    need these symbols to load properly as modules. */
1362 EXPORT_SYMBOL(usb_serial_register);
1363 EXPORT_SYMBOL(usb_serial_deregister);
1364 EXPORT_SYMBOL(usb_serial_probe);
1365 EXPORT_SYMBOL(usb_serial_disconnect);
1366 EXPORT_SYMBOL(usb_serial_port_softint);
1367
1368
1369 /* Module information */
1370 MODULE_AUTHOR( DRIVER_AUTHOR );
1371 MODULE_DESCRIPTION( DRIVER_DESC );
1372 MODULE_LICENSE("GPL");
1373
1374 module_param(debug, bool, S_IRUGO | S_IWUSR);
1375 MODULE_PARM_DESC(debug, "Debug enabled or not");