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