drivers/usb/serial/usb-serial.c

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