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
  52static DEFINE_IDR(serial_minors);
  53static DEFINE_MUTEX(table_lock);
  54static 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 */
  61struct 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	}
  79exit:
  80	mutex_unlock(&table_lock);
  81	return port;
  82}
  83
  84static 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;
 105error:
 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
 113static 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
 124int 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}
 143EXPORT_SYMBOL_GPL(usb_serial_claim_interface);
 144
 145static 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
 162static 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
 191void 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 */
 214static 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
 246err_put_module:
 247	module_put(serial->type->driver.owner);
 248err_put_serial:
 249	usb_serial_put(serial);
 250	mutex_unlock(&serial->disc_mutex);
 251	return retval;
 252}
 253
 254static 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);
 274out_unlock:
 275	mutex_unlock(&serial->disc_mutex);
 276
 277	if (retval < 0)
 278		retval = usb_translate_errors(retval);
 279
 280	return retval;
 281}
 282
 283static 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 */
 302static 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
 314static 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
 323static 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 */
 341static 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
 364static 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);
 378exit:
 379	return retval;
 380}
 381
 382static 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
 391static 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
 404static 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
 420static 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
 430static 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
 440static 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
 465static 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;
 495out_unlock:
 496	mutex_unlock(&tport->mutex);
 497
 498	return ret;
 499}
 500
 501static 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
 522static 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
 535static 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
 547static 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
 582static 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
 593static 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
 605static 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 */
 622void usb_serial_port_softint(struct usb_serial_port *port)
 623{
 624	schedule_work(&port->work);
 625}
 626EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 627
 628static 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
 636static 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
 649static 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
 662static 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
 686static 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
 705static 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
 721static 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");
 734exit:
 735	return id;
 736}
 737
 738/* Caller must hold table_lock */
 739static 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
 757static 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
 768static 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
 777static 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}
 784static DEVICE_ATTR_RO(port_number);
 785
 786static struct attribute *usb_serial_port_attrs[] = {
 787	&dev_attr_port_number.attr,
 788	NULL
 789};
 790ATTRIBUTE_GROUPS(usb_serial_port);
 791
 792static 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
 799static 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
 829static 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
 844static 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
 876static 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
 913static 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
 937static 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
 962static 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);
1160exit:
1161	kfree(epds);
1162	module_put(type->driver.owner);
1163	return 0;
1164
1165err_free_epds:
1166	kfree(epds);
1167err_release_sibling:
1168	release_sibling(serial, interface);
1169	usb_serial_put(serial);
1170err_put_module:
1171	module_put(type->driver.owner);
1172
1173	return retval;
1174}
1175
1176static 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
1218int 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}
1245EXPORT_SYMBOL(usb_serial_suspend);
1246
1247static 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
1255int 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}
1273EXPORT_SYMBOL(usb_serial_resume);
1274
1275static 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
1296static 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
1320struct tty_driver *usb_serial_tty_driver;
1321
1322static 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
1365err_unregister_driver:
1366	tty_unregister_driver(usb_serial_tty_driver);
1367err_unregister_bus:
1368	bus_unregister(&usb_serial_bus_type);
1369err_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
1376static 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
1389module_init(usb_serial_init);
1390module_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
1401static 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
1416static 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
1451static 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 */
1471int 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
1528err_deregister_drivers:
1529	while (sd-- > serial_drivers)
1530		usb_serial_deregister(*sd);
1531	usb_deregister(udriver);
1532err_free_driver:
1533	kfree(udriver);
1534	return rc;
1535}
1536EXPORT_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 */
1546void 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}
1555EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1556
1557MODULE_AUTHOR(DRIVER_AUTHOR);
1558MODULE_DESCRIPTION(DRIVER_DESC);
1559MODULE_LICENSE("GPL v2");