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