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