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