usb-serial.c

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