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