drivers/usb/serial/usb-serial.c

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