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