drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2005 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
  16  * driver
  17  *
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/tty.h>
  26 #include <linux/tty_driver.h>
  27 #include <linux/tty_flip.h>
  28 #include <linux/module.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/seq_file.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/mutex.h>
  33 #include <linux/list.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/serial.h>
  36 #include <linux/usb.h>
  37 #include <linux/usb/serial.h>
  38 #include "pl2303.h"
  39
  40 /*
  41  * Version Information
  42  */
  43 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
  44 #define DRIVER_DESC "USB Serial Driver core"
  45
  46 /* Driver structure we register with the USB core */
  47 static struct usb_driver usb_serial_driver = {
  48         .name =         "usbserial",
  49         .probe =        usb_serial_probe,
  50         .disconnect =   usb_serial_disconnect,
  51         .suspend =      usb_serial_suspend,
  52         .resume =       usb_serial_resume,
  53         .no_dynamic_id =        1,
  54 };
  55
  56 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  57    the MODULE_DEVICE_TABLE declarations in each serial driver
  58    cause the "hotplug" program to pull in whatever module is necessary
  59    via modprobe, and modprobe will load usbserial because the serial
  60    drivers depend on it.
  61 */
  62
  63 static int debug;
  64 /* initially all NULL */
  65 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
  66 static DEFINE_MUTEX(table_lock);
  67 static LIST_HEAD(usb_serial_driver_list);
  68
  69 /*
  70  * Look up the serial structure.  If it is found and it hasn't been
  71  * disconnected, return with its disc_mutex held and its refcount
  72  * incremented.  Otherwise return NULL.
  73  */
  74 struct usb_serial *usb_serial_get_by_index(unsigned index)
  75 {
  76         struct usb_serial *serial;
  77
  78         mutex_lock(&table_lock);
  79         serial = serial_table[index];
  80
  81         if (serial) {
  82                 mutex_lock(&serial->disc_mutex);
  83                 if (serial->disconnected) {
  84                         mutex_unlock(&serial->disc_mutex);
  85                         serial = NULL;
  86                 } else {
  87                         kref_get(&serial->kref);
  88                 }
  89         }
  90         mutex_unlock(&table_lock);
  91         return serial;
  92 }
  93
  94 static struct usb_serial *get_free_serial(struct usb_serial *serial,
  95                                         int num_ports, unsigned int *minor)
  96 {
  97         unsigned int i, j;
  98         int good_spot;
  99
 100         dbg("%s %d", __func__, num_ports);
 101
 102         *minor = 0;
 103         mutex_lock(&table_lock);
 104         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 105                 if (serial_table[i])
 106                         continue;
 107
 108                 good_spot = 1;
 109                 for (j = 1; j <= num_ports-1; ++j)
 110                         if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
 111                                 good_spot = 0;
 112                                 i += j;
 113                                 break;
 114                         }
 115                 if (good_spot == 0)
 116                         continue;
 117
 118                 *minor = i;
 119                 j = 0;
 120                 dbg("%s - minor base = %d", __func__, *minor);
 121                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
 122                         serial_table[i] = serial;
 123                         serial->port[j++]->number = i;
 124                 }
 125                 mutex_unlock(&table_lock);
 126                 return serial;
 127         }
 128         mutex_unlock(&table_lock);
 129         return NULL;
 130 }
 131
 132 static void return_serial(struct usb_serial *serial)
 133 {
 134         int i;
 135
 136         dbg("%s", __func__);
 137
 138         mutex_lock(&table_lock);
 139         for (i = 0; i < serial->num_ports; ++i)
 140                 serial_table[serial->minor + i] = NULL;
 141         mutex_unlock(&table_lock);
 142 }
 143
 144 static void destroy_serial(struct kref *kref)
 145 {
 146         struct usb_serial *serial;
 147         struct usb_serial_port *port;
 148         int i;
 149
 150         serial = to_usb_serial(kref);
 151
 152         dbg("%s - %s", __func__, serial->type->description);
 153
 154         /* return the minor range that this device had */
 155         if (serial->minor != SERIAL_TTY_NO_MINOR)
 156                 return_serial(serial);
 157
 158         serial->type->release(serial);
 159
 160         /* Now that nothing is using the ports, they can be freed */
 161         for (i = 0; i < serial->num_port_pointers; ++i) {
 162                 port = serial->port[i];
 163                 if (port) {
 164                         port->serial = NULL;
 165                         put_device(&port->dev);
 166                 }
 167         }
 168
 169         usb_put_dev(serial->dev);
 170         kfree(serial);
 171 }
 172
 173 void usb_serial_put(struct usb_serial *serial)
 174 {
 175         kref_put(&serial->kref, destroy_serial);
 176 }
 177
 178 /*****************************************************************************
 179  * Driver tty interface functions
 180  *****************************************************************************/
 181
 182 /**
 183  * serial_install - install tty
 184  * @driver: the driver (USB in our case)
 185  * @tty: the tty being created
 186  *
 187  * Create the termios objects for this tty.  We use the default
 188  * USB serial settings but permit them to be overridden by
 189  * serial->type->init_termios.
 190  */
 191 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 192 {
 193         int idx = tty->index;
 194         struct usb_serial *serial;
 195         int retval;
 196
 197         /* If the termios setup has yet to be done */
 198         if (tty->driver->termios[idx] == NULL) {
 199                 /* perform the standard setup */
 200                 retval = tty_init_termios(tty);
 201                 if (retval)
 202                         return retval;
 203                 /* allow the driver to update it */
 204                 serial = usb_serial_get_by_index(tty->index);
 205                 if (serial) {
 206                         if (serial->type->init_termios)
 207                                 serial->type->init_termios(tty);
 208                         usb_serial_put(serial);
 209                         mutex_unlock(&serial->disc_mutex);
 210                 }
 211         }
 212         /* Final install (we use the default method) */
 213         tty_driver_kref_get(driver);
 214         tty->count++;
 215         driver->ttys[idx] = tty;
 216         return 0;
 217 }
 218
 219 static int serial_open (struct tty_struct *tty, struct file *filp)
 220 {
 221         struct usb_serial *serial;
 222         struct usb_serial_port *port;
 223         unsigned int portNumber;
 224         int retval = 0;
 225         int first = 0;
 226
 227         dbg("%s", __func__);
 228
 229         /* get the serial object associated with this tty pointer */
 230         serial = usb_serial_get_by_index(tty->index);
 231         if (!serial) {
 232                 tty->driver_data = NULL;
 233                 return -ENODEV;
 234         }
 235
 236         portNumber = tty->index - serial->minor;
 237         port = serial->port[portNumber];
 238         if (!port || serial->disconnected)
 239                 retval = -ENODEV;
 240         /*
 241          * Note: Our locking order requirement does not allow port->mutex
 242          * to be acquired while serial->disc_mutex is held.
 243          */
 244         mutex_unlock(&serial->disc_mutex);
 245         if (retval)
 246                 goto bailout_serial_put;
 247
 248         if (mutex_lock_interruptible(&port->mutex)) {
 249                 retval = -ERESTARTSYS;
 250                 goto bailout_serial_put;
 251         }
 252
 253         ++port->port.count;
 254
 255         /* set up our port structure making the tty driver
 256          * remember our port object, and us it */
 257         tty->driver_data = port;
 258         tty_port_tty_set(&port->port, tty);
 259
 260         /* If the console is attached, the device is already open */
 261         if (port->port.count == 1 && !port->console) {
 262                 first = 1;
 263                 /* lock this module before we call it
 264                  * this may fail, which means we must bail out,
 265                  * safe because we are called with BKL held */
 266                 if (!try_module_get(serial->type->driver.owner)) {
 267                         retval = -ENODEV;
 268                         goto bailout_mutex_unlock;
 269                 }
 270
 271                 mutex_lock(&serial->disc_mutex);
 272                 if (serial->disconnected)
 273                         retval = -ENODEV;
 274                 else
 275                         retval = usb_autopm_get_interface(serial->interface);
 276                 if (retval)
 277                         goto bailout_module_put;
 278
 279                 /* only call the device specific open if this
 280                  * is the first time the port is opened */
 281                 retval = serial->type->open(tty, port);
 282                 if (retval)
 283                         goto bailout_interface_put;
 284                 mutex_unlock(&serial->disc_mutex);
 285                 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
 286         }
 287         mutex_unlock(&port->mutex);
 288         /* Now do the correct tty layer semantics */
 289         retval = tty_port_block_til_ready(&port->port, tty, filp);
 290         if (retval == 0) {
 291                 if (!first)
 292                         usb_serial_put(serial);
 293                 return 0;
 294         }
 295         mutex_lock(&port->mutex);
 296         if (first == 0)
 297                 goto bailout_mutex_unlock;
 298         /* Undo the initial port actions */
 299         mutex_lock(&serial->disc_mutex);
 300 bailout_interface_put:
 301         usb_autopm_put_interface(serial->interface);
 302 bailout_module_put:
 303         mutex_unlock(&serial->disc_mutex);
 304         module_put(serial->type->driver.owner);
 305 bailout_mutex_unlock:
 306         port->port.count = 0;
 307         tty->driver_data = NULL;
 308         tty_port_tty_set(&port->port, NULL);
 309         mutex_unlock(&port->mutex);
 310 bailout_serial_put:
 311         usb_serial_put(serial);
 312         return retval;
 313 }
 314
 315 /**
 316  * serial_do_down - shut down hardware
 317  * @port: port to shut down
 318  *
 319  * Shut down a USB serial port unless it is the console.  We never
 320  * shut down the console hardware as it will always be in use.
 321  */
 322 static void serial_do_down(struct usb_serial_port *port)
 323 {
 324         struct usb_serial_driver *drv = port->serial->type;
 325         struct usb_serial *serial;
 326         struct module *owner;
 327
 328         /*
 329          * The console is magical.  Do not hang up the console hardware
 330          * or there will be tears.
 331          */
 332         if (port->console)
 333                 return;
 334
 335         mutex_lock(&port->mutex);
 336         serial = port->serial;
 337         owner = serial->type->driver.owner;
 338
 339         if (drv->close)
 340                 drv->close(port);
 341
 342         mutex_unlock(&port->mutex);
 343 }
 344
 345 static void serial_hangup(struct tty_struct *tty)
 346 {
 347         struct usb_serial_port *port = tty->driver_data;
 348         serial_do_down(port);
 349         tty_port_hangup(&port->port);
 350         /* We must not free port yet - the USB serial layer depends on it's
 351            continued existence */
 352 }
 353
 354 static void serial_close(struct tty_struct *tty, struct file *filp)
 355 {
 356         struct usb_serial_port *port = tty->driver_data;
 357
 358         if (!port)
 359                 return;
 360
 361         dbg("%s - port %d", __func__, port->number);
 362
 363         if (tty_port_close_start(&port->port, tty, filp) == 0)
 364                 return;
 365         serial_do_down(port);
 366         tty_port_close_end(&port->port, tty);
 367         tty_port_tty_set(&port->port, NULL);
 368
 369 }
 370
 371 /**
 372  * serial_do_free - free resources post close/hangup
 373  * @port: port to free up
 374  *
 375  * Do the resource freeing and refcount dropping for the port.
 376  * Avoid freeing the console.
 377  *
 378  * Called when the last tty kref is dropped.
 379  */
 380 static void serial_do_free(struct tty_struct *tty)
 381 {
 382         struct usb_serial_port *port = tty->driver_data;
 383         struct usb_serial *serial;
 384         struct module *owner;
 385
 386         /* The console is magical.  Do not hang up the console hardware
 387          * or there will be tears.
 388          */
 389         if (port == NULL || port->console)
 390                 return;
 391
 392         serial = port->serial;
 393         owner = serial->type->driver.owner;
 394
 395         mutex_lock(&serial->disc_mutex);
 396         if (!serial->disconnected)
 397                 usb_autopm_put_interface(serial->interface);
 398         mutex_unlock(&serial->disc_mutex);
 399
 400         usb_serial_put(serial);
 401         module_put(owner);
 402 }
 403
 404 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 405                                                                 int count)
 406 {
 407         struct usb_serial_port *port = tty->driver_data;
 408         int retval = -ENODEV;
 409
 410         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 411                 goto exit;
 412
 413         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 414
 415         /* count is managed under the mutex lock for the tty so cannot
 416            drop to zero until after the last close completes */
 417         WARN_ON(!port->port.count);
 418
 419         /* pass on to the driver specific version of this function */
 420         retval = port->serial->type->write(tty, port, buf, count);
 421
 422 exit:
 423         return retval;
 424 }
 425
 426 static int serial_write_room(struct tty_struct *tty)
 427 {
 428         struct usb_serial_port *port = tty->driver_data;
 429         dbg("%s - port %d", __func__, port->number);
 430         WARN_ON(!port->port.count);
 431         /* pass on to the driver specific version of this function */
 432         return port->serial->type->write_room(tty);
 433 }
 434
 435 static int serial_chars_in_buffer(struct tty_struct *tty)
 436 {
 437         struct usb_serial_port *port = tty->driver_data;
 438         dbg("%s = port %d", __func__, port->number);
 439
 440         /* if the device was unplugged then any remaining characters
 441            fell out of the connector ;) */
 442         if (port->serial->disconnected)
 443                 return 0;
 444         /* pass on to the driver specific version of this function */
 445         return port->serial->type->chars_in_buffer(tty);
 446 }
 447
 448 static void serial_throttle(struct tty_struct *tty)
 449 {
 450         struct usb_serial_port *port = tty->driver_data;
 451         dbg("%s - port %d", __func__, port->number);
 452
 453         WARN_ON(!port->port.count);
 454         /* pass on to the driver specific version of this function */
 455         if (port->serial->type->throttle)
 456                 port->serial->type->throttle(tty);
 457 }
 458
 459 static void serial_unthrottle(struct tty_struct *tty)
 460 {
 461         struct usb_serial_port *port = tty->driver_data;
 462         dbg("%s - port %d", __func__, port->number);
 463
 464         WARN_ON(!port->port.count);
 465         /* pass on to the driver specific version of this function */
 466         if (port->serial->type->unthrottle)
 467                 port->serial->type->unthrottle(tty);
 468 }
 469
 470 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 471                                         unsigned int cmd, unsigned long arg)
 472 {
 473         struct usb_serial_port *port = tty->driver_data;
 474         int retval = -ENODEV;
 475
 476         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 477
 478         WARN_ON(!port->port.count);
 479
 480         /* pass on to the driver specific version of this function
 481            if it is available */
 482         if (port->serial->type->ioctl) {
 483                 retval = port->serial->type->ioctl(tty, file, cmd, arg);
 484         } else
 485                 retval = -ENOIOCTLCMD;
 486         return retval;
 487 }
 488
 489 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 490 {
 491         struct usb_serial_port *port = tty->driver_data;
 492         dbg("%s - port %d", __func__, port->number);
 493
 494         WARN_ON(!port->port.count);
 495         /* pass on to the driver specific version of this function
 496            if it is available */
 497         if (port->serial->type->set_termios)
 498                 port->serial->type->set_termios(tty, port, old);
 499         else
 500                 tty_termios_copy_hw(tty->termios, old);
 501 }
 502
 503 static int serial_break(struct tty_struct *tty, int break_state)
 504 {
 505         struct usb_serial_port *port = tty->driver_data;
 506
 507         dbg("%s - port %d", __func__, port->number);
 508
 509         WARN_ON(!port->port.count);
 510         /* pass on to the driver specific version of this function
 511            if it is available */
 512         if (port->serial->type->break_ctl)
 513                 port->serial->type->break_ctl(tty, break_state);
 514         return 0;
 515 }
 516
 517 static int serial_proc_show(struct seq_file *m, void *v)
 518 {
 519         struct usb_serial *serial;
 520         int i;
 521         char tmp[40];
 522
 523         dbg("%s", __func__);
 524         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 525         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 526                 serial = usb_serial_get_by_index(i);
 527                 if (serial == NULL)
 528                         continue;
 529
 530                 seq_printf(m, "%d:", i);
 531                 if (serial->type->driver.owner)
 532                         seq_printf(m, " module:%s",
 533                                 module_name(serial->type->driver.owner));
 534                 seq_printf(m, " name:\"%s\"",
 535                                 serial->type->description);
 536                 seq_printf(m, " vendor:%04x product:%04x",
 537                         le16_to_cpu(serial->dev->descriptor.idVendor),
 538                         le16_to_cpu(serial->dev->descriptor.idProduct));
 539                 seq_printf(m, " num_ports:%d", serial->num_ports);
 540                 seq_printf(m, " port:%d", i - serial->minor + 1);
 541                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 542                 seq_printf(m, " path:%s", tmp);
 543
 544                 seq_putc(m, '\n');
 545                 usb_serial_put(serial);
 546                 mutex_unlock(&serial->disc_mutex);
 547         }
 548         return 0;
 549 }
 550
 551 static int serial_proc_open(struct inode *inode, struct file *file)
 552 {
 553         return single_open(file, serial_proc_show, NULL);
 554 }
 555
 556 static const struct file_operations serial_proc_fops = {
 557         .owner          = THIS_MODULE,
 558         .open           = serial_proc_open,
 559         .read           = seq_read,
 560         .llseek         = seq_lseek,
 561         .release        = single_release,
 562 };
 563
 564 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 565 {
 566         struct usb_serial_port *port = tty->driver_data;
 567
 568         dbg("%s - port %d", __func__, port->number);
 569
 570         WARN_ON(!port->port.count);
 571         if (port->serial->type->tiocmget)
 572                 return port->serial->type->tiocmget(tty, file);
 573         return -EINVAL;
 574 }
 575
 576 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 577                             unsigned int set, unsigned int clear)
 578 {
 579         struct usb_serial_port *port = tty->driver_data;
 580
 581         dbg("%s - port %d", __func__, port->number);
 582
 583         WARN_ON(!port->port.count);
 584         if (port->serial->type->tiocmset)
 585                 return port->serial->type->tiocmset(tty, file, set, clear);
 586         return -EINVAL;
 587 }
 588
 589 /*
 590  * We would be calling tty_wakeup here, but unfortunately some line
 591  * disciplines have an annoying habit of calling tty->write from
 592  * the write wakeup callback (e.g. n_hdlc.c).
 593  */
 594 void usb_serial_port_softint(struct usb_serial_port *port)
 595 {
 596         schedule_work(&port->work);
 597 }
 598 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 599
 600 static void usb_serial_port_work(struct work_struct *work)
 601 {
 602         struct usb_serial_port *port =
 603                 container_of(work, struct usb_serial_port, work);
 604         struct tty_struct *tty;
 605
 606         dbg("%s - port %d", __func__, port->number);
 607
 608         tty = tty_port_tty_get(&port->port);
 609         if (!tty)
 610                 return;
 611
 612         tty_wakeup(tty);
 613         tty_kref_put(tty);
 614 }
 615
 616 static void kill_traffic(struct usb_serial_port *port)
 617 {
 618         usb_kill_urb(port->read_urb);
 619         usb_kill_urb(port->write_urb);
 620         /*
 621          * This is tricky.
 622          * Some drivers submit the read_urb in the
 623          * handler for the write_urb or vice versa
 624          * this order determines the order in which
 625          * usb_kill_urb() must be used to reliably
 626          * kill the URBs. As it is unknown here,
 627          * both orders must be used in turn.
 628          * The call below is not redundant.
 629          */
 630         usb_kill_urb(port->read_urb);
 631         usb_kill_urb(port->interrupt_in_urb);
 632         usb_kill_urb(port->interrupt_out_urb);
 633 }
 634
 635 static void port_release(struct device *dev)
 636 {
 637         struct usb_serial_port *port = to_usb_serial_port(dev);
 638
 639         dbg ("%s - %s", __func__, dev_name(dev));
 640
 641         /*
 642          * Stop all the traffic before cancelling the work, so that
 643          * nobody will restart it by calling usb_serial_port_softint.
 644          */
 645         kill_traffic(port);
 646         cancel_work_sync(&port->work);
 647
 648         usb_free_urb(port->read_urb);
 649         usb_free_urb(port->write_urb);
 650         usb_free_urb(port->interrupt_in_urb);
 651         usb_free_urb(port->interrupt_out_urb);
 652         kfree(port->bulk_in_buffer);
 653         kfree(port->bulk_out_buffer);
 654         kfree(port->interrupt_in_buffer);
 655         kfree(port->interrupt_out_buffer);
 656         kfree(port);
 657 }
 658
 659 static struct usb_serial *create_serial(struct usb_device *dev,
 660                                         struct usb_interface *interface,
 661                                         struct usb_serial_driver *driver)
 662 {
 663         struct usb_serial *serial;
 664
 665         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 666         if (!serial) {
 667                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 668                 return NULL;
 669         }
 670         serial->dev = usb_get_dev(dev);
 671         serial->type = driver;
 672         serial->interface = interface;
 673         kref_init(&serial->kref);
 674         mutex_init(&serial->disc_mutex);
 675         serial->minor = SERIAL_TTY_NO_MINOR;
 676
 677         return serial;
 678 }
 679
 680 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 681                                             struct usb_serial_driver *drv)
 682 {
 683         struct usb_dynid *dynid;
 684
 685         spin_lock(&drv->dynids.lock);
 686         list_for_each_entry(dynid, &drv->dynids.list, node) {
 687                 if (usb_match_one_id(intf, &dynid->id)) {
 688                         spin_unlock(&drv->dynids.lock);
 689                         return &dynid->id;
 690                 }
 691         }
 692         spin_unlock(&drv->dynids.lock);
 693         return NULL;
 694 }
 695
 696 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 697                                                 struct usb_interface *intf)
 698 {
 699         const struct usb_device_id *id;
 700
 701         id = usb_match_id(intf, drv->id_table);
 702         if (id) {
 703                 dbg("static descriptor matches");
 704                 goto exit;
 705         }
 706         id = match_dynamic_id(intf, drv);
 707         if (id)
 708                 dbg("dynamic descriptor matches");
 709 exit:
 710         return id;
 711 }
 712
 713 static struct usb_serial_driver *search_serial_device(
 714                                         struct usb_interface *iface)
 715 {
 716         const struct usb_device_id *id;
 717         struct usb_serial_driver *drv;
 718
 719         /* Check if the usb id matches a known device */
 720         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 721                 id = get_iface_id(drv, iface);
 722                 if (id)
 723                         return drv;
 724         }
 725
 726         return NULL;
 727 }
 728
 729 static int serial_carrier_raised(struct tty_port *port)
 730 {
 731         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 732         struct usb_serial_driver *drv = p->serial->type;
 733         if (drv->carrier_raised)
 734                 return drv->carrier_raised(p);
 735         /* No carrier control - don't block */
 736         return 1;
 737 }
 738
 739 static void serial_dtr_rts(struct tty_port *port, int on)
 740 {
 741         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 742         struct usb_serial_driver *drv = p->serial->type;
 743         if (drv->dtr_rts)
 744                 drv->dtr_rts(p, on);
 745 }
 746
 747 static const struct tty_port_operations serial_port_ops = {
 748         .carrier_raised = serial_carrier_raised,
 749         .dtr_rts = serial_dtr_rts,
 750 };
 751
 752 int usb_serial_probe(struct usb_interface *interface,
 753                                const struct usb_device_id *id)
 754 {
 755         struct usb_device *dev = interface_to_usbdev(interface);
 756         struct usb_serial *serial = NULL;
 757         struct usb_serial_port *port;
 758         struct usb_host_interface *iface_desc;
 759         struct usb_endpoint_descriptor *endpoint;
 760         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 761         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 762         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 763         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 764         struct usb_serial_driver *type = NULL;
 765         int retval;
 766         unsigned int minor;
 767         int buffer_size;
 768         int i;
 769         int num_interrupt_in = 0;
 770         int num_interrupt_out = 0;
 771         int num_bulk_in = 0;
 772         int num_bulk_out = 0;
 773         int num_ports = 0;
 774         int max_endpoints;
 775
 776         lock_kernel(); /* guard against unloading a serial driver module */
 777         type = search_serial_device(interface);
 778         if (!type) {
 779                 unlock_kernel();
 780                 dbg("none matched");
 781                 return -ENODEV;
 782         }
 783
 784         serial = create_serial(dev, interface, type);
 785         if (!serial) {
 786                 unlock_kernel();
 787                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 788                 return -ENOMEM;
 789         }
 790
 791         /* if this device type has a probe function, call it */
 792         if (type->probe) {
 793                 const struct usb_device_id *id;
 794
 795                 if (!try_module_get(type->driver.owner)) {
 796                         unlock_kernel();
 797                         dev_err(&interface->dev,
 798                                 "module get failed, exiting\n");
 799                         kfree(serial);
 800                         return -EIO;
 801                 }
 802
 803                 id = get_iface_id(type, interface);
 804                 retval = type->probe(serial, id);
 805                 module_put(type->driver.owner);
 806
 807                 if (retval) {
 808                         unlock_kernel();
 809                         dbg("sub driver rejected device");
 810                         kfree(serial);
 811                         return retval;
 812                 }
 813         }
 814
 815         /* descriptor matches, let's find the endpoints needed */
 816         /* check out the endpoints */
 817         iface_desc = interface->cur_altsetting;
 818         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 819                 endpoint = &iface_desc->endpoint[i].desc;
 820
 821                 if (usb_endpoint_is_bulk_in(endpoint)) {
 822                         /* we found a bulk in endpoint */
 823                         dbg("found bulk in on endpoint %d", i);
 824                         bulk_in_endpoint[num_bulk_in] = endpoint;
 825                         ++num_bulk_in;
 826                 }
 827
 828                 if (usb_endpoint_is_bulk_out(endpoint)) {
 829                         /* we found a bulk out endpoint */
 830                         dbg("found bulk out on endpoint %d", i);
 831                         bulk_out_endpoint[num_bulk_out] = endpoint;
 832                         ++num_bulk_out;
 833                 }
 834
 835                 if (usb_endpoint_is_int_in(endpoint)) {
 836                         /* we found a interrupt in endpoint */
 837                         dbg("found interrupt in on endpoint %d", i);
 838                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 839                         ++num_interrupt_in;
 840                 }
 841
 842                 if (usb_endpoint_is_int_out(endpoint)) {
 843                         /* we found an interrupt out endpoint */
 844                         dbg("found interrupt out on endpoint %d", i);
 845                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 846                         ++num_interrupt_out;
 847                 }
 848         }
 849
 850 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 851         /* BEGIN HORRIBLE HACK FOR PL2303 */
 852         /* this is needed due to the looney way its endpoints are set up */
 853         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 854              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 855             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 856              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 857             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 858              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 859             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 860              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 861                 if (interface != dev->actconfig->interface[0]) {
 862                         /* check out the endpoints of the other interface*/
 863                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 864                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 865                                 endpoint = &iface_desc->endpoint[i].desc;
 866                                 if (usb_endpoint_is_int_in(endpoint)) {
 867                                         /* we found a interrupt in endpoint */
 868                                         dbg("found interrupt in for Prolific device on separate interface");
 869                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 870                                         ++num_interrupt_in;
 871                                 }
 872                         }
 873                 }
 874
 875                 /* Now make sure the PL-2303 is configured correctly.
 876                  * If not, give up now and hope this hack will work
 877                  * properly during a later invocation of usb_serial_probe
 878                  */
 879                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 880                         unlock_kernel();
 881                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 882                         kfree(serial);
 883                         return -ENODEV;
 884                 }
 885         }
 886         /* END HORRIBLE HACK FOR PL2303 */
 887 #endif
 888
 889 #ifdef CONFIG_USB_SERIAL_GENERIC
 890         if (type == &usb_serial_generic_device) {
 891                 num_ports = num_bulk_out;
 892                 if (num_ports == 0) {
 893                         unlock_kernel();
 894                         dev_err(&interface->dev,
 895                             "Generic device with no bulk out, not allowed.\n");
 896                         kfree(serial);
 897                         return -EIO;
 898                 }
 899         }
 900 #endif
 901         if (!num_ports) {
 902                 /* if this device type has a calc_num_ports function, call it */
 903                 if (type->calc_num_ports) {
 904                         if (!try_module_get(type->driver.owner)) {
 905                                 unlock_kernel();
 906                                 dev_err(&interface->dev,
 907                                         "module get failed, exiting\n");
 908                                 kfree(serial);
 909                                 return -EIO;
 910                         }
 911                         num_ports = type->calc_num_ports(serial);
 912                         module_put(type->driver.owner);
 913                 }
 914                 if (!num_ports)
 915                         num_ports = type->num_ports;
 916         }
 917
 918         serial->num_ports = num_ports;
 919         serial->num_bulk_in = num_bulk_in;
 920         serial->num_bulk_out = num_bulk_out;
 921         serial->num_interrupt_in = num_interrupt_in;
 922         serial->num_interrupt_out = num_interrupt_out;
 923
 924         /* found all that we need */
 925         dev_info(&interface->dev, "%s converter detected\n",
 926                         type->description);
 927
 928         /* create our ports, we need as many as the max endpoints */
 929         /* we don't use num_ports here because some devices have more
 930            endpoint pairs than ports */
 931         max_endpoints = max(num_bulk_in, num_bulk_out);
 932         max_endpoints = max(max_endpoints, num_interrupt_in);
 933         max_endpoints = max(max_endpoints, num_interrupt_out);
 934         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 935         serial->num_port_pointers = max_endpoints;
 936         unlock_kernel();
 937
 938         dbg("%s - setting up %d port structures for this device",
 939                                                 __func__, max_endpoints);
 940         for (i = 0; i < max_endpoints; ++i) {
 941                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 942                 if (!port)
 943                         goto probe_error;
 944                 tty_port_init(&port->port);
 945                 port->port.ops = &serial_port_ops;
 946                 port->serial = serial;
 947                 spin_lock_init(&port->lock);
 948                 mutex_init(&port->mutex);
 949                 INIT_WORK(&port->work, usb_serial_port_work);
 950                 serial->port[i] = port;
 951                 port->dev.parent = &interface->dev;
 952                 port->dev.driver = NULL;
 953                 port->dev.bus = &usb_serial_bus_type;
 954                 port->dev.release = &port_release;
 955                 device_initialize(&port->dev);
 956         }
 957
 958         /* set up the endpoint information */
 959         for (i = 0; i < num_bulk_in; ++i) {
 960                 endpoint = bulk_in_endpoint[i];
 961                 port = serial->port[i];
 962                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 963                 if (!port->read_urb) {
 964                         dev_err(&interface->dev, "No free urbs available\n");
 965                         goto probe_error;
 966                 }
 967                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 968                 port->bulk_in_size = buffer_size;
 969                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 970                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 971                 if (!port->bulk_in_buffer) {
 972                         dev_err(&interface->dev,
 973                                         "Couldn't allocate bulk_in_buffer\n");
 974                         goto probe_error;
 975                 }
 976                 usb_fill_bulk_urb(port->read_urb, dev,
 977                                 usb_rcvbulkpipe(dev,
 978                                                 endpoint->bEndpointAddress),
 979                                 port->bulk_in_buffer, buffer_size,
 980                                 serial->type->read_bulk_callback, port);
 981         }
 982
 983         for (i = 0; i < num_bulk_out; ++i) {
 984                 endpoint = bulk_out_endpoint[i];
 985                 port = serial->port[i];
 986                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 987                 if (!port->write_urb) {
 988                         dev_err(&interface->dev, "No free urbs available\n");
 989                         goto probe_error;
 990                 }
 991                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 992                 port->bulk_out_size = buffer_size;
 993                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 994                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 995                 if (!port->bulk_out_buffer) {
 996                         dev_err(&interface->dev,
 997                                         "Couldn't allocate bulk_out_buffer\n");
 998                         goto probe_error;
 999                 }
1000                 usb_fill_bulk_urb(port->write_urb, dev,
1001                                 usb_sndbulkpipe(dev,
1002                                         endpoint->bEndpointAddress),
1003                                 port->bulk_out_buffer, buffer_size,
1004                                 serial->type->write_bulk_callback, port);
1005         }
1006
1007         if (serial->type->read_int_callback) {
1008                 for (i = 0; i < num_interrupt_in; ++i) {
1009                         endpoint = interrupt_in_endpoint[i];
1010                         port = serial->port[i];
1011                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1012                         if (!port->interrupt_in_urb) {
1013                                 dev_err(&interface->dev,
1014                                                 "No free urbs available\n");
1015                                 goto probe_error;
1016                         }
1017                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1018                         port->interrupt_in_endpointAddress =
1019                                                 endpoint->bEndpointAddress;
1020                         port->interrupt_in_buffer = kmalloc(buffer_size,
1021                                                                 GFP_KERNEL);
1022                         if (!port->interrupt_in_buffer) {
1023                                 dev_err(&interface->dev,
1024                                     "Couldn't allocate interrupt_in_buffer\n");
1025                                 goto probe_error;
1026                         }
1027                         usb_fill_int_urb(port->interrupt_in_urb, dev,
1028                                 usb_rcvintpipe(dev,
1029                                                 endpoint->bEndpointAddress),
1030                                 port->interrupt_in_buffer, buffer_size,
1031                                 serial->type->read_int_callback, port,
1032                                 endpoint->bInterval);
1033                 }
1034         } else if (num_interrupt_in) {
1035                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1036         }
1037
1038         if (serial->type->write_int_callback) {
1039                 for (i = 0; i < num_interrupt_out; ++i) {
1040                         endpoint = interrupt_out_endpoint[i];
1041                         port = serial->port[i];
1042                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1043                         if (!port->interrupt_out_urb) {
1044                                 dev_err(&interface->dev,
1045                                                 "No free urbs available\n");
1046                                 goto probe_error;
1047                         }
1048                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1049                         port->interrupt_out_size = buffer_size;
1050                         port->interrupt_out_endpointAddress =
1051                                                 endpoint->bEndpointAddress;
1052                         port->interrupt_out_buffer = kmalloc(buffer_size,
1053                                                                 GFP_KERNEL);
1054                         if (!port->interrupt_out_buffer) {
1055                                 dev_err(&interface->dev,
1056                                   "Couldn't allocate interrupt_out_buffer\n");
1057                                 goto probe_error;
1058                         }
1059                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1060                                 usb_sndintpipe(dev,
1061                                                   endpoint->bEndpointAddress),
1062                                 port->interrupt_out_buffer, buffer_size,
1063                                 serial->type->write_int_callback, port,
1064                                 endpoint->bInterval);
1065                 }
1066         } else if (num_interrupt_out) {
1067                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1068         }
1069
1070         /* if this device type has an attach function, call it */
1071         if (type->attach) {
1072                 if (!try_module_get(type->driver.owner)) {
1073                         dev_err(&interface->dev,
1074                                         "module get failed, exiting\n");
1075                         goto probe_error;
1076                 }
1077                 retval = type->attach(serial);
1078                 module_put(type->driver.owner);
1079                 if (retval < 0)
1080                         goto probe_error;
1081                 if (retval > 0) {
1082                         /* quietly accept this device, but don't bind to a
1083                            serial port as it's about to disappear */
1084                         serial->num_ports = 0;
1085                         goto exit;
1086                 }
1087         }
1088
1089         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1090                 dev_err(&interface->dev, "No more free serial devices\n");
1091                 goto probe_error;
1092         }
1093         serial->minor = minor;
1094
1095         /* register all of the individual ports with the driver core */
1096         for (i = 0; i < num_ports; ++i) {
1097                 port = serial->port[i];
1098                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1099                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1100                 port->dev_state = PORT_REGISTERING;
1101                 retval = device_add(&port->dev);
1102                 if (retval) {
1103                         dev_err(&port->dev, "Error registering port device, "
1104                                 "continuing\n");
1105                         port->dev_state = PORT_UNREGISTERED;
1106                 } else {
1107                         port->dev_state = PORT_REGISTERED;
1108                 }
1109         }
1110
1111         usb_serial_console_init(debug, minor);
1112
1113 exit:
1114         /* success */
1115         usb_set_intfdata(interface, serial);
1116         return 0;
1117
1118 probe_error:
1119         usb_serial_put(serial);
1120         return -EIO;
1121 }
1122 EXPORT_SYMBOL_GPL(usb_serial_probe);
1123
1124 void usb_serial_disconnect(struct usb_interface *interface)
1125 {
1126         int i;
1127         struct usb_serial *serial = usb_get_intfdata(interface);
1128         struct device *dev = &interface->dev;
1129         struct usb_serial_port *port;
1130
1131         usb_serial_console_disconnect(serial);
1132         dbg("%s", __func__);
1133
1134         mutex_lock(&serial->disc_mutex);
1135         usb_set_intfdata(interface, NULL);
1136         /* must set a flag, to signal subdrivers */
1137         serial->disconnected = 1;
1138         mutex_unlock(&serial->disc_mutex);
1139
1140         for (i = 0; i < serial->num_ports; ++i) {
1141                 port = serial->port[i];
1142                 if (port) {
1143                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1144                         if (tty) {
1145                                 tty_vhangup(tty);
1146                                 tty_kref_put(tty);
1147                         }
1148                         kill_traffic(port);
1149                         cancel_work_sync(&port->work);
1150                         if (port->dev_state == PORT_REGISTERED) {
1151
1152                                 /* Make sure the port is bound so that the
1153                                  * driver's port_remove method is called.
1154                                  */
1155                                 if (!port->dev.driver) {
1156                                         int rc;
1157
1158                                         port->dev.driver =
1159                                                         &serial->type->driver;
1160                                         rc = device_bind_driver(&port->dev);
1161                                 }
1162                                 port->dev_state = PORT_UNREGISTERING;
1163                                 device_del(&port->dev);
1164                                 port->dev_state = PORT_UNREGISTERED;
1165                         }
1166                 }
1167         }
1168         serial->type->disconnect(serial);
1169
1170         /* let the last holder of this object cause it to be cleaned up */
1171         usb_serial_put(serial);
1172         dev_info(dev, "device disconnected\n");
1173 }
1174 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1175
1176 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1177 {
1178         struct usb_serial *serial = usb_get_intfdata(intf);
1179         struct usb_serial_port *port;
1180         int i, r = 0;
1181
1182         serial->suspending = 1;
1183
1184         for (i = 0; i < serial->num_ports; ++i) {
1185                 port = serial->port[i];
1186                 if (port)
1187                         kill_traffic(port);
1188         }
1189
1190         if (serial->type->suspend)
1191                 r = serial->type->suspend(serial, message);
1192
1193         return r;
1194 }
1195 EXPORT_SYMBOL(usb_serial_suspend);
1196
1197 int usb_serial_resume(struct usb_interface *intf)
1198 {
1199         struct usb_serial *serial = usb_get_intfdata(intf);
1200         int rv;
1201
1202         serial->suspending = 0;
1203         if (serial->type->resume)
1204                 rv = serial->type->resume(serial);
1205         else
1206                 rv = usb_serial_generic_resume(serial);
1207
1208         return rv;
1209 }
1210 EXPORT_SYMBOL(usb_serial_resume);
1211
1212 static const struct tty_operations serial_ops = {
1213         .open =                 serial_open,
1214         .close =                serial_close,
1215         .write =                serial_write,
1216         .hangup =               serial_hangup,
1217         .write_room =           serial_write_room,
1218         .ioctl =                serial_ioctl,
1219         .set_termios =          serial_set_termios,
1220         .throttle =             serial_throttle,
1221         .unthrottle =           serial_unthrottle,
1222         .break_ctl =            serial_break,
1223         .chars_in_buffer =      serial_chars_in_buffer,
1224         .tiocmget =             serial_tiocmget,
1225         .tiocmset =             serial_tiocmset,
1226         .shutdown =             serial_do_free,
1227         .install =              serial_install,
1228         .proc_fops =            &serial_proc_fops,
1229 };
1230
1231
1232 struct tty_driver *usb_serial_tty_driver;
1233
1234 static int __init usb_serial_init(void)
1235 {
1236         int i;
1237         int result;
1238
1239         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1240         if (!usb_serial_tty_driver)
1241                 return -ENOMEM;
1242
1243         /* Initialize our global data */
1244         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1245                 serial_table[i] = NULL;
1246
1247         result = bus_register(&usb_serial_bus_type);
1248         if (result) {
1249                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1250                        "failed\n", __func__);
1251                 goto exit_bus;
1252         }
1253
1254         usb_serial_tty_driver->owner = THIS_MODULE;
1255         usb_serial_tty_driver->driver_name = "usbserial";
1256         usb_serial_tty_driver->name =   "ttyUSB";
1257         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1258         usb_serial_tty_driver->minor_start = 0;
1259         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1260         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1261         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1262                                                 TTY_DRIVER_DYNAMIC_DEV;
1263         usb_serial_tty_driver->init_termios = tty_std_termios;
1264         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1265                                                         | HUPCL | CLOCAL;
1266         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1267         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1268         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1269         result = tty_register_driver(usb_serial_tty_driver);
1270         if (result) {
1271                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1272                        __func__);
1273                 goto exit_reg_driver;
1274         }
1275
1276         /* register the USB driver */
1277         result = usb_register(&usb_serial_driver);
1278         if (result < 0) {
1279                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1280                        __func__);
1281                 goto exit_tty;
1282         }
1283
1284         /* register the generic driver, if we should */
1285         result = usb_serial_generic_register(debug);
1286         if (result < 0) {
1287                 printk(KERN_ERR "usb-serial: %s - registering generic "
1288                        "driver failed\n", __func__);
1289                 goto exit_generic;
1290         }
1291
1292         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1293
1294         return result;
1295
1296 exit_generic:
1297         usb_deregister(&usb_serial_driver);
1298
1299 exit_tty:
1300         tty_unregister_driver(usb_serial_tty_driver);
1301
1302 exit_reg_driver:
1303         bus_unregister(&usb_serial_bus_type);
1304
1305 exit_bus:
1306         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1307                __func__, result);
1308         put_tty_driver(usb_serial_tty_driver);
1309         return result;
1310 }
1311
1312
1313 static void __exit usb_serial_exit(void)
1314 {
1315         usb_serial_console_exit();
1316
1317         usb_serial_generic_deregister();
1318
1319         usb_deregister(&usb_serial_driver);
1320         tty_unregister_driver(usb_serial_tty_driver);
1321         put_tty_driver(usb_serial_tty_driver);
1322         bus_unregister(&usb_serial_bus_type);
1323 }
1324
1325
1326 module_init(usb_serial_init);
1327 module_exit(usb_serial_exit);
1328
1329 #define set_to_generic_if_null(type, function)                          \
1330         do {                                                            \
1331                 if (!type->function) {                                  \
1332                         type->function = usb_serial_generic_##function; \
1333                         dbg("Had to override the " #function            \
1334                                 " usb serial operation with the generic one.");\
1335                         }                                               \
1336         } while (0)
1337
1338 static void fixup_generic(struct usb_serial_driver *device)
1339 {
1340         set_to_generic_if_null(device, open);
1341         set_to_generic_if_null(device, write);
1342         set_to_generic_if_null(device, close);
1343         set_to_generic_if_null(device, write_room);
1344         set_to_generic_if_null(device, chars_in_buffer);
1345         set_to_generic_if_null(device, read_bulk_callback);
1346         set_to_generic_if_null(device, write_bulk_callback);
1347         set_to_generic_if_null(device, disconnect);
1348         set_to_generic_if_null(device, release);
1349 }
1350
1351 int usb_serial_register(struct usb_serial_driver *driver)
1352 {
1353         /* must be called with BKL held */
1354         int retval;
1355
1356         if (usb_disabled())
1357                 return -ENODEV;
1358
1359         fixup_generic(driver);
1360
1361         if (!driver->description)
1362                 driver->description = driver->driver.name;
1363
1364         /* Add this device to our list of devices */
1365         list_add(&driver->driver_list, &usb_serial_driver_list);
1366
1367         retval = usb_serial_bus_register(driver);
1368         if (retval) {
1369                 printk(KERN_ERR "usb-serial: problem %d when registering "
1370                        "driver %s\n", retval, driver->description);
1371                 list_del(&driver->driver_list);
1372         } else
1373                 printk(KERN_INFO "USB Serial support registered for %s\n",
1374                                                 driver->description);
1375
1376         return retval;
1377 }
1378 EXPORT_SYMBOL_GPL(usb_serial_register);
1379
1380
1381 void usb_serial_deregister(struct usb_serial_driver *device)
1382 {
1383         /* must be called with BKL held */
1384         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1385                device->description);
1386         list_del(&device->driver_list);
1387         usb_serial_bus_deregister(device);
1388 }
1389 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1390
1391 /* Module information */
1392 MODULE_AUTHOR(DRIVER_AUTHOR);
1393 MODULE_DESCRIPTION(DRIVER_DESC);
1394 MODULE_LICENSE("GPL");
1395
1396 module_param(debug, bool, S_IRUGO | S_IWUSR);
1397 MODULE_PARM_DESC(debug, "Debug enabled or not");