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