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                         if (num_bulk_in < MAX_NUM_PORTS) {
 795                                 bulk_in_endpoint[num_bulk_in] = endpoint;
 796                                 ++num_bulk_in;
 797                         }
 798                 }
 799
 800                 if (usb_endpoint_is_bulk_out(endpoint)) {
 801                         /* we found a bulk out endpoint */
 802                         dbg("found bulk out on endpoint %d", i);
 803                         if (num_bulk_out < MAX_NUM_PORTS) {
 804                                 bulk_out_endpoint[num_bulk_out] = endpoint;
 805                                 ++num_bulk_out;
 806                         }
 807                 }
 808
 809                 if (usb_endpoint_is_int_in(endpoint)) {
 810                         /* we found a interrupt in endpoint */
 811                         dbg("found interrupt in on endpoint %d", i);
 812                         if (num_interrupt_in < MAX_NUM_PORTS) {
 813                                 interrupt_in_endpoint[num_interrupt_in] =
 814                                                 endpoint;
 815                                 ++num_interrupt_in;
 816                         }
 817                 }
 818
 819                 if (usb_endpoint_is_int_out(endpoint)) {
 820                         /* we found an interrupt out endpoint */
 821                         dbg("found interrupt out on endpoint %d", i);
 822                         if (num_interrupt_out < MAX_NUM_PORTS) {
 823                                 interrupt_out_endpoint[num_interrupt_out] =
 824                                                 endpoint;
 825                                 ++num_interrupt_out;
 826                         }
 827                 }
 828         }
 829
 830 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 831         /* BEGIN HORRIBLE HACK FOR PL2303 */
 832         /* this is needed due to the looney way its endpoints are set up */
 833         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 834              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 835             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 836              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 837             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 838              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 839             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 840              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 841                 if (interface != dev->actconfig->interface[0]) {
 842                         /* check out the endpoints of the other interface*/
 843                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 844                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 845                                 endpoint = &iface_desc->endpoint[i].desc;
 846                                 if (usb_endpoint_is_int_in(endpoint)) {
 847                                         /* we found a interrupt in endpoint */
 848                                         dbg("found interrupt in for Prolific device on separate interface");
 849                                         if (num_interrupt_in < MAX_NUM_PORTS) {
 850                                                 interrupt_in_endpoint[num_interrupt_in] = endpoint;
 851                                                 ++num_interrupt_in;
 852                                         }
 853                                 }
 854                         }
 855                 }
 856
 857                 /* Now make sure the PL-2303 is configured correctly.
 858                  * If not, give up now and hope this hack will work
 859                  * properly during a later invocation of usb_serial_probe
 860                  */
 861                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 862                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 863                         usb_serial_put(serial);
 864                         module_put(type->driver.owner);
 865                         return -ENODEV;
 866                 }
 867         }
 868         /* END HORRIBLE HACK FOR PL2303 */
 869 #endif
 870
 871 #ifdef CONFIG_USB_SERIAL_GENERIC
 872         if (type == &usb_serial_generic_device) {
 873                 num_ports = num_bulk_out;
 874                 if (num_ports == 0) {
 875                         dev_err(&interface->dev,
 876                             "Generic device with no bulk out, not allowed.\n");
 877                         usb_serial_put(serial);
 878                         module_put(type->driver.owner);
 879                         return -EIO;
 880                 }
 881         }
 882 #endif
 883         if (!num_ports) {
 884                 /* if this device type has a calc_num_ports function, call it */
 885                 if (type->calc_num_ports)
 886                         num_ports = type->calc_num_ports(serial);
 887                 if (!num_ports)
 888                         num_ports = type->num_ports;
 889         }
 890
 891         serial->num_ports = num_ports;
 892         serial->num_bulk_in = num_bulk_in;
 893         serial->num_bulk_out = num_bulk_out;
 894         serial->num_interrupt_in = num_interrupt_in;
 895         serial->num_interrupt_out = num_interrupt_out;
 896
 897         /* found all that we need */
 898         dev_info(&interface->dev, "%s converter detected\n",
 899                         type->description);
 900
 901         /* create our ports, we need as many as the max endpoints */
 902         /* we don't use num_ports here because some devices have more
 903            endpoint pairs than ports */
 904         max_endpoints = max(num_bulk_in, num_bulk_out);
 905         max_endpoints = max(max_endpoints, num_interrupt_in);
 906         max_endpoints = max(max_endpoints, num_interrupt_out);
 907         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 908         serial->num_port_pointers = max_endpoints;
 909
 910         dbg("%s - setting up %d port structures for this device",
 911                                                 __func__, max_endpoints);
 912         for (i = 0; i < max_endpoints; ++i) {
 913                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 914                 if (!port)
 915                         goto probe_error;
 916                 tty_port_init(&port->port);
 917                 port->port.ops = &serial_port_ops;
 918                 port->serial = serial;
 919                 spin_lock_init(&port->lock);
 920                 init_waitqueue_head(&port->delta_msr_wait);
 921                 /* Keep this for private driver use for the moment but
 922                    should probably go away */
 923                 INIT_WORK(&port->work, usb_serial_port_work);
 924                 serial->port[i] = port;
 925                 port->dev.parent = &interface->dev;
 926                 port->dev.driver = NULL;
 927                 port->dev.bus = &usb_serial_bus_type;
 928                 port->dev.release = &port_release;
 929                 device_initialize(&port->dev);
 930         }
 931
 932         /* set up the endpoint information */
 933         for (i = 0; i < num_bulk_in; ++i) {
 934                 endpoint = bulk_in_endpoint[i];
 935                 port = serial->port[i];
 936                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 937                 if (!port->read_urb) {
 938                         dev_err(&interface->dev, "No free urbs available\n");
 939                         goto probe_error;
 940                 }
 941                 buffer_size = max_t(int, serial->type->bulk_in_size,
 942                                 usb_endpoint_maxp(endpoint));
 943                 port->bulk_in_size = buffer_size;
 944                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 945                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 946                 if (!port->bulk_in_buffer) {
 947                         dev_err(&interface->dev,
 948                                         "Couldn't allocate bulk_in_buffer\n");
 949                         goto probe_error;
 950                 }
 951                 usb_fill_bulk_urb(port->read_urb, dev,
 952                                 usb_rcvbulkpipe(dev,
 953                                                 endpoint->bEndpointAddress),
 954                                 port->bulk_in_buffer, buffer_size,
 955                                 serial->type->read_bulk_callback, port);
 956         }
 957
 958         for (i = 0; i < num_bulk_out; ++i) {
 959                 int j;
 960
 961                 endpoint = bulk_out_endpoint[i];
 962                 port = serial->port[i];
 963                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 964                 if (!port->write_urb) {
 965                         dev_err(&interface->dev, "No free urbs available\n");
 966                         goto probe_error;
 967                 }
 968                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 969                         goto probe_error;
 970                 buffer_size = serial->type->bulk_out_size;
 971                 if (!buffer_size)
 972                         buffer_size = usb_endpoint_maxp(endpoint);
 973                 port->bulk_out_size = buffer_size;
 974                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 975                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 976                 if (!port->bulk_out_buffer) {
 977                         dev_err(&interface->dev,
 978                                         "Couldn't allocate bulk_out_buffer\n");
 979                         goto probe_error;
 980                 }
 981                 usb_fill_bulk_urb(port->write_urb, dev,
 982                                 usb_sndbulkpipe(dev,
 983                                         endpoint->bEndpointAddress),
 984                                 port->bulk_out_buffer, buffer_size,
 985                                 serial->type->write_bulk_callback, port);
 986                 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 987                         set_bit(j, &port->write_urbs_free);
 988                         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 989                         if (!port->write_urbs[j]) {
 990                                 dev_err(&interface->dev,
 991                                                 "No free urbs available\n");
 992                                 goto probe_error;
 993                         }
 994                         port->bulk_out_buffers[j] = kmalloc(buffer_size,
 995                                                                 GFP_KERNEL);
 996                         if (!port->bulk_out_buffers[j]) {
 997                                 dev_err(&interface->dev,
 998                                         "Couldn't allocate bulk_out_buffer\n");
 999                                 goto probe_error;
1000                         }
1001                         usb_fill_bulk_urb(port->write_urbs[j], dev,
1002                                         usb_sndbulkpipe(dev,
1003                                                 endpoint->bEndpointAddress),
1004                                         port->bulk_out_buffers[j], buffer_size,
1005                                         serial->type->write_bulk_callback,
1006                                         port);
1007                 }
1008         }
1009
1010         if (serial->type->read_int_callback) {
1011                 for (i = 0; i < num_interrupt_in; ++i) {
1012                         endpoint = interrupt_in_endpoint[i];
1013                         port = serial->port[i];
1014                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1015                         if (!port->interrupt_in_urb) {
1016                                 dev_err(&interface->dev,
1017                                                 "No free urbs available\n");
1018                                 goto probe_error;
1019                         }
1020                         buffer_size = usb_endpoint_maxp(endpoint);
1021                         port->interrupt_in_endpointAddress =
1022                                                 endpoint->bEndpointAddress;
1023                         port->interrupt_in_buffer = kmalloc(buffer_size,
1024                                                                 GFP_KERNEL);
1025                         if (!port->interrupt_in_buffer) {
1026                                 dev_err(&interface->dev,
1027                                     "Couldn't allocate interrupt_in_buffer\n");
1028                                 goto probe_error;
1029                         }
1030                         usb_fill_int_urb(port->interrupt_in_urb, dev,
1031                                 usb_rcvintpipe(dev,
1032                                                 endpoint->bEndpointAddress),
1033                                 port->interrupt_in_buffer, buffer_size,
1034                                 serial->type->read_int_callback, port,
1035                                 endpoint->bInterval);
1036                 }
1037         } else if (num_interrupt_in) {
1038                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1039         }
1040
1041         if (serial->type->write_int_callback) {
1042                 for (i = 0; i < num_interrupt_out; ++i) {
1043                         endpoint = interrupt_out_endpoint[i];
1044                         port = serial->port[i];
1045                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1046                         if (!port->interrupt_out_urb) {
1047                                 dev_err(&interface->dev,
1048                                                 "No free urbs available\n");
1049                                 goto probe_error;
1050                         }
1051                         buffer_size = usb_endpoint_maxp(endpoint);
1052                         port->interrupt_out_size = buffer_size;
1053                         port->interrupt_out_endpointAddress =
1054                                                 endpoint->bEndpointAddress;
1055                         port->interrupt_out_buffer = kmalloc(buffer_size,
1056                                                                 GFP_KERNEL);
1057                         if (!port->interrupt_out_buffer) {
1058                                 dev_err(&interface->dev,
1059                                   "Couldn't allocate interrupt_out_buffer\n");
1060                                 goto probe_error;
1061                         }
1062                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1063                                 usb_sndintpipe(dev,
1064                                                   endpoint->bEndpointAddress),
1065                                 port->interrupt_out_buffer, buffer_size,
1066                                 serial->type->write_int_callback, port,
1067                                 endpoint->bInterval);
1068                 }
1069         } else if (num_interrupt_out) {
1070                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1071         }
1072
1073         /* if this device type has an attach function, call it */
1074         if (type->attach) {
1075                 retval = type->attach(serial);
1076                 if (retval < 0)
1077                         goto probe_error;
1078                 serial->attached = 1;
1079                 if (retval > 0) {
1080                         /* quietly accept this device, but don't bind to a
1081                            serial port as it's about to disappear */
1082                         serial->num_ports = 0;
1083                         goto exit;
1084                 }
1085         } else {
1086                 serial->attached = 1;
1087         }
1088
1089         /* Avoid race with tty_open and serial_install by setting the
1090          * disconnected flag and not clearing it until all ports have been
1091          * registered.
1092          */
1093         serial->disconnected = 1;
1094
1095         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1096                 dev_err(&interface->dev, "No more free serial devices\n");
1097                 goto probe_error;
1098         }
1099         serial->minor = minor;
1100
1101         /* register all of the individual ports with the driver core */
1102         for (i = 0; i < num_ports; ++i) {
1103                 port = serial->port[i];
1104                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1105                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1106                 port->dev_state = PORT_REGISTERING;
1107                 device_enable_async_suspend(&port->dev);
1108
1109                 retval = device_add(&port->dev);
1110                 if (retval) {
1111                         dev_err(&port->dev, "Error registering port device, "
1112                                 "continuing\n");
1113                         port->dev_state = PORT_UNREGISTERED;
1114                 } else {
1115                         port->dev_state = PORT_REGISTERED;
1116                 }
1117         }
1118
1119         serial->disconnected = 0;
1120
1121         usb_serial_console_init(debug, minor);
1122
1123 exit:
1124         /* success */
1125         usb_set_intfdata(interface, serial);
1126         module_put(type->driver.owner);
1127         return 0;
1128
1129 probe_error:
1130         usb_serial_put(serial);
1131         module_put(type->driver.owner);
1132         return -EIO;
1133 }
1134 EXPORT_SYMBOL_GPL(usb_serial_probe);
1135
1136 void usb_serial_disconnect(struct usb_interface *interface)
1137 {
1138         int i;
1139         struct usb_serial *serial = usb_get_intfdata(interface);
1140         struct device *dev = &interface->dev;
1141         struct usb_serial_port *port;
1142
1143         usb_serial_console_disconnect(serial);
1144         dbg("%s", __func__);
1145
1146         mutex_lock(&serial->disc_mutex);
1147         usb_set_intfdata(interface, NULL);
1148         /* must set a flag, to signal subdrivers */
1149         serial->disconnected = 1;
1150         mutex_unlock(&serial->disc_mutex);
1151
1152         for (i = 0; i < serial->num_ports; ++i) {
1153                 port = serial->port[i];
1154                 if (port) {
1155                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1156                         if (tty) {
1157                                 tty_vhangup(tty);
1158                                 tty_kref_put(tty);
1159                         }
1160                         kill_traffic(port);
1161                         cancel_work_sync(&port->work);
1162                         if (port->dev_state == PORT_REGISTERED) {
1163
1164                                 /* Make sure the port is bound so that the
1165                                  * driver's port_remove method is called.
1166                                  */
1167                                 if (!port->dev.driver) {
1168                                         int rc;
1169
1170                                         port->dev.driver =
1171                                                         &serial->type->driver;
1172                                         rc = device_bind_driver(&port->dev);
1173                                 }
1174                                 port->dev_state = PORT_UNREGISTERING;
1175                                 device_del(&port->dev);
1176                                 port->dev_state = PORT_UNREGISTERED;
1177                         }
1178                 }
1179         }
1180         serial->type->disconnect(serial);
1181
1182         /* let the last holder of this object cause it to be cleaned up */
1183         usb_serial_put(serial);
1184         dev_info(dev, "device disconnected\n");
1185 }
1186 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1187
1188 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1189 {
1190         struct usb_serial *serial = usb_get_intfdata(intf);
1191         struct usb_serial_port *port;
1192         int i, r = 0;
1193
1194         serial->suspending = 1;
1195
1196         if (serial->type->suspend) {
1197                 r = serial->type->suspend(serial, message);
1198                 if (r < 0) {
1199                         serial->suspending = 0;
1200                         goto err_out;
1201                 }
1202         }
1203
1204         for (i = 0; i < serial->num_ports; ++i) {
1205                 port = serial->port[i];
1206                 if (port)
1207                         kill_traffic(port);
1208         }
1209
1210 err_out:
1211         return r;
1212 }
1213 EXPORT_SYMBOL(usb_serial_suspend);
1214
1215 int usb_serial_resume(struct usb_interface *intf)
1216 {
1217         struct usb_serial *serial = usb_get_intfdata(intf);
1218         int rv;
1219
1220         serial->suspending = 0;
1221         if (serial->type->resume)
1222                 rv = serial->type->resume(serial);
1223         else
1224                 rv = usb_serial_generic_resume(serial);
1225
1226         return rv;
1227 }
1228 EXPORT_SYMBOL(usb_serial_resume);
1229
1230 static const struct tty_operations serial_ops = {
1231         .open =                 serial_open,
1232         .close =                serial_close,
1233         .write =                serial_write,
1234         .hangup =               serial_hangup,
1235         .write_room =           serial_write_room,
1236         .ioctl =                serial_ioctl,
1237         .set_termios =          serial_set_termios,
1238         .throttle =             serial_throttle,
1239         .unthrottle =           serial_unthrottle,
1240         .break_ctl =            serial_break,
1241         .chars_in_buffer =      serial_chars_in_buffer,
1242         .tiocmget =             serial_tiocmget,
1243         .tiocmset =             serial_tiocmset,
1244         .get_icount =           serial_get_icount,
1245         .cleanup =              serial_cleanup,
1246         .install =              serial_install,
1247         .proc_fops =            &serial_proc_fops,
1248 };
1249
1250
1251 struct tty_driver *usb_serial_tty_driver;
1252
1253 static int __init usb_serial_init(void)
1254 {
1255         int i;
1256         int result;
1257
1258         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1259         if (!usb_serial_tty_driver)
1260                 return -ENOMEM;
1261
1262         /* Initialize our global data */
1263         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1264                 serial_table[i] = NULL;
1265
1266         result = bus_register(&usb_serial_bus_type);
1267         if (result) {
1268                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1269                        "failed\n", __func__);
1270                 goto exit_bus;
1271         }
1272
1273         usb_serial_tty_driver->owner = THIS_MODULE;
1274         usb_serial_tty_driver->driver_name = "usbserial";
1275         usb_serial_tty_driver->name =   "ttyUSB";
1276         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1277         usb_serial_tty_driver->minor_start = 0;
1278         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1279         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1280         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1281                                                 TTY_DRIVER_DYNAMIC_DEV;
1282         usb_serial_tty_driver->init_termios = tty_std_termios;
1283         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1284                                                         | HUPCL | CLOCAL;
1285         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1286         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1287         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1288         result = tty_register_driver(usb_serial_tty_driver);
1289         if (result) {
1290                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1291                        __func__);
1292                 goto exit_reg_driver;
1293         }
1294
1295         /* register the USB driver */
1296         result = usb_register(&usb_serial_driver);
1297         if (result < 0) {
1298                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1299                        __func__);
1300                 goto exit_tty;
1301         }
1302
1303         /* register the generic driver, if we should */
1304         result = usb_serial_generic_register(debug);
1305         if (result < 0) {
1306                 printk(KERN_ERR "usb-serial: %s - registering generic "
1307                        "driver failed\n", __func__);
1308                 goto exit_generic;
1309         }
1310
1311         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1312
1313         return result;
1314
1315 exit_generic:
1316         usb_deregister(&usb_serial_driver);
1317
1318 exit_tty:
1319         tty_unregister_driver(usb_serial_tty_driver);
1320
1321 exit_reg_driver:
1322         bus_unregister(&usb_serial_bus_type);
1323
1324 exit_bus:
1325         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1326                __func__, result);
1327         put_tty_driver(usb_serial_tty_driver);
1328         return result;
1329 }
1330
1331
1332 static void __exit usb_serial_exit(void)
1333 {
1334         usb_serial_console_exit();
1335
1336         usb_serial_generic_deregister();
1337
1338         usb_deregister(&usb_serial_driver);
1339         tty_unregister_driver(usb_serial_tty_driver);
1340         put_tty_driver(usb_serial_tty_driver);
1341         bus_unregister(&usb_serial_bus_type);
1342 }
1343
1344
1345 module_init(usb_serial_init);
1346 module_exit(usb_serial_exit);
1347
1348 #define set_to_generic_if_null(type, function)                          \
1349         do {                                                            \
1350                 if (!type->function) {                                  \
1351                         type->function = usb_serial_generic_##function; \
1352                         dbg("Had to override the " #function            \
1353                                 " usb serial operation with the generic one.");\
1354                         }                                               \
1355         } while (0)
1356
1357 static void fixup_generic(struct usb_serial_driver *device)
1358 {
1359         set_to_generic_if_null(device, open);
1360         set_to_generic_if_null(device, write);
1361         set_to_generic_if_null(device, close);
1362         set_to_generic_if_null(device, write_room);
1363         set_to_generic_if_null(device, chars_in_buffer);
1364         set_to_generic_if_null(device, read_bulk_callback);
1365         set_to_generic_if_null(device, write_bulk_callback);
1366         set_to_generic_if_null(device, disconnect);
1367         set_to_generic_if_null(device, release);
1368         set_to_generic_if_null(device, process_read_urb);
1369         set_to_generic_if_null(device, prepare_write_buffer);
1370 }
1371
1372 int usb_serial_register(struct usb_serial_driver *driver)
1373 {
1374         /* must be called with BKL held */
1375         int retval;
1376
1377         if (usb_disabled())
1378                 return -ENODEV;
1379
1380         fixup_generic(driver);
1381
1382         if (!driver->description)
1383                 driver->description = driver->driver.name;
1384         if (!driver->usb_driver) {
1385                 WARN(1, "Serial driver %s has no usb_driver\n",
1386                                 driver->description);
1387                 return -EINVAL;
1388         }
1389         driver->usb_driver->supports_autosuspend = 1;
1390
1391         /* Add this device to our list of devices */
1392         mutex_lock(&table_lock);
1393         list_add(&driver->driver_list, &usb_serial_driver_list);
1394
1395         retval = usb_serial_bus_register(driver);
1396         if (retval) {
1397                 printk(KERN_ERR "usb-serial: problem %d when registering "
1398                        "driver %s\n", retval, driver->description);
1399                 list_del(&driver->driver_list);
1400         } else
1401                 printk(KERN_INFO "USB Serial support registered for %s\n",
1402                                                 driver->description);
1403
1404         mutex_unlock(&table_lock);
1405         return retval;
1406 }
1407 EXPORT_SYMBOL_GPL(usb_serial_register);
1408
1409
1410 void usb_serial_deregister(struct usb_serial_driver *device)
1411 {
1412         /* must be called with BKL held */
1413         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1414                device->description);
1415
1416         mutex_lock(&table_lock);
1417         list_del(&device->driver_list);
1418         mutex_unlock(&table_lock);
1419
1420         usb_serial_bus_deregister(device);
1421 }
1422 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1423
1424 /* Module information */
1425 MODULE_AUTHOR(DRIVER_AUTHOR);
1426 MODULE_DESCRIPTION(DRIVER_DESC);
1427 MODULE_LICENSE("GPL");
1428
1429 module_param(debug, bool, S_IRUGO | S_IWUSR);
1430 MODULE_PARM_DESC(debug, "Debug enabled or not");