1/*
   2 * USB Serial Converter driver
   3 *
   4 * Copyright (C) 2009 - 2013 Johan Hovold (jhovold@gmail.com)
   5 * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com)
   6 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   7 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   8 *
   9 *	This program is free software; you can redistribute it and/or
  10 *	modify it under the terms of the GNU General Public License version
  11 *	2 as published by the Free Software Foundation.
  12 *
  13 * This driver was originally based on the ACM driver by Armin Fuerst (which was
  14 * based on a driver by Brad Keryan)
  15 *
  16 * See Documentation/usb/usb-serial.txt for more information on using this
  17 * driver
 
  18 */
  19
  20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22#include <linux/kernel.h>
  23#include <linux/errno.h>
  24#include <linux/init.h>
  25#include <linux/slab.h>
  26#include <linux/tty.h>
  27#include <linux/tty_driver.h>
  28#include <linux/tty_flip.h>
  29#include <linux/module.h>
  30#include <linux/moduleparam.h>
  31#include <linux/seq_file.h>
  32#include <linux/spinlock.h>
  33#include <linux/mutex.h>
  34#include <linux/list.h>
  35#include <linux/uaccess.h>
  36#include <linux/serial.h>
  37#include <linux/usb.h>
  38#include <linux/usb/serial.h>
  39#include <linux/kfifo.h>
  40#include <linux/idr.h>
  41#include "pl2303.h"
  42
  43#define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
 
 
 
  44#define DRIVER_DESC "USB Serial Driver core"
  45
  46#define USB_SERIAL_TTY_MAJOR	188
  47#define USB_SERIAL_TTY_MINORS	512	/* should be enough for a while */
  48
  49/* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  50   the MODULE_DEVICE_TABLE declarations in each serial driver
  51   cause the "hotplug" program to pull in whatever module is necessary
  52   via modprobe, and modprobe will load usbserial because the serial
  53   drivers depend on it.
  54*/
  55
  56static DEFINE_IDR(serial_minors);
 
 
  57static DEFINE_MUTEX(table_lock);
  58static LIST_HEAD(usb_serial_driver_list);
  59
  60/*
  61 * Look up the serial port structure.  If it is found and it hasn't been
  62 * disconnected, return with the parent usb_serial structure's disc_mutex held
  63 * and its refcount incremented.  Otherwise return NULL.
  64 */
  65struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor)
  66{
  67	struct usb_serial *serial;
  68	struct usb_serial_port *port;
  69
  70	mutex_lock(&table_lock);
  71	port = idr_find(&serial_minors, minor);
  72	if (!port)
  73		goto exit;
  74
  75	serial = port->serial;
  76	mutex_lock(&serial->disc_mutex);
  77	if (serial->disconnected) {
  78		mutex_unlock(&serial->disc_mutex);
  79		port = NULL;
  80	} else {
  81		kref_get(&serial->kref);
 
  82	}
  83exit:
  84	mutex_unlock(&table_lock);
  85	return port;
  86}
  87
  88static int allocate_minors(struct usb_serial *serial, int num_ports)
 
  89{
  90	struct usb_serial_port *port;
  91	unsigned int i, j;
  92	int minor;
  93
  94	dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
  95
 
  96	mutex_lock(&table_lock);
  97	for (i = 0; i < num_ports; ++i) {
  98		port = serial->port[i];
  99		minor = idr_alloc(&serial_minors, port, 0, 0, GFP_KERNEL);
 100		if (minor < 0)
 101			goto error;
 102		port->minor = minor;
 103		port->port_number = i;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 104	}
 105	serial->minors_reserved = 1;
 106	mutex_unlock(&table_lock);
 107	return 0;
 108error:
 109	/* unwind the already allocated minors */
 110	for (j = 0; j < i; ++j)
 111		idr_remove(&serial_minors, serial->port[j]->minor);
 112	mutex_unlock(&table_lock);
 113	return minor;
 114}
 115
 116static void release_minors(struct usb_serial *serial)
 117{
 118	int i;
 119
 
 
 120	mutex_lock(&table_lock);
 121	for (i = 0; i < serial->num_ports; ++i)
 122		idr_remove(&serial_minors, serial->port[i]->minor);
 123	mutex_unlock(&table_lock);
 124	serial->minors_reserved = 0;
 125}
 126
 127static void destroy_serial(struct kref *kref)
 128{
 129	struct usb_serial *serial;
 130	struct usb_serial_port *port;
 131	int i;
 132
 133	serial = to_usb_serial(kref);
 134
 
 
 135	/* return the minor range that this device had */
 136	if (serial->minors_reserved)
 137		release_minors(serial);
 138
 139	if (serial->attached && serial->type->release)
 140		serial->type->release(serial);
 141
 142	/* Now that nothing is using the ports, they can be freed */
 143	for (i = 0; i < serial->num_port_pointers; ++i) {
 144		port = serial->port[i];
 145		if (port) {
 146			port->serial = NULL;
 147			put_device(&port->dev);
 148		}
 149	}
 150
 151	usb_put_intf(serial->interface);
 152	usb_put_dev(serial->dev);
 153	kfree(serial);
 154}
 155
 156void usb_serial_put(struct usb_serial *serial)
 157{
 158	kref_put(&serial->kref, destroy_serial);
 159}
 160
 161/*****************************************************************************
 162 * Driver tty interface functions
 163 *****************************************************************************/
 164
 165/**
 166 * serial_install - install tty
 167 * @driver: the driver (USB in our case)
 168 * @tty: the tty being created
 169 *
 170 * Create the termios objects for this tty.  We use the default
 171 * USB serial settings but permit them to be overridden by
 172 * serial->type->init_termios.
 173 *
 174 * This is the first place a new tty gets used.  Hence this is where we
 175 * acquire references to the usb_serial structure and the driver module,
 176 * where we store a pointer to the port, and where we do an autoresume.
 177 * All these actions are reversed in serial_cleanup().
 178 */
 179static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 180{
 181	int idx = tty->index;
 182	struct usb_serial *serial;
 183	struct usb_serial_port *port;
 184	int retval = -ENODEV;
 185
 186	port = usb_serial_port_get_by_minor(idx);
 187	if (!port)
 
 
 188		return retval;
 189
 190	serial = port->serial;
 
 
 191	if (!try_module_get(serial->type->driver.owner))
 192		goto error_module_get;
 193
 194	retval = usb_autopm_get_interface(serial->interface);
 195	if (retval)
 196		goto error_get_interface;
 197
 198	retval = tty_port_install(&port->port, 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 settings */
 205	if (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 ASYNCB_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 * @port: port to free 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	mutex_lock(&serial->disc_mutex);
 318	if (!serial->disconnected)
 319		usb_autopm_put_interface(serial->interface);
 320	mutex_unlock(&serial->disc_mutex);
 321
 322	usb_serial_put(serial);
 323	module_put(owner);
 324}
 325
 326static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 327								int count)
 328{
 329	struct usb_serial_port *port = tty->driver_data;
 330	int retval = -ENODEV;
 331
 332	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 333		goto exit;
 334
 335	dev_dbg(tty->dev, "%s - %d byte(s)\n", __func__, count);
 336
 
 337	retval = port->serial->type->write(tty, port, buf, count);
 338	if (retval < 0)
 339		retval = usb_translate_errors(retval);
 340exit:
 341	return retval;
 342}
 343
 344static int serial_write_room(struct tty_struct *tty)
 345{
 346	struct usb_serial_port *port = tty->driver_data;
 347
 348	dev_dbg(tty->dev, "%s\n", __func__);
 349
 350	return port->serial->type->write_room(tty);
 351}
 352
 353static int serial_chars_in_buffer(struct tty_struct *tty)
 354{
 355	struct usb_serial_port *port = tty->driver_data;
 356	struct usb_serial *serial = port->serial;
 357
 358	dev_dbg(tty->dev, "%s\n", __func__);
 359
 360	if (serial->disconnected)
 
 
 361		return 0;
 362
 363	return serial->type->chars_in_buffer(tty);
 364}
 365
 366static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
 367{
 368	struct usb_serial_port *port = tty->driver_data;
 369	struct usb_serial *serial = port->serial;
 370
 371	dev_dbg(tty->dev, "%s\n", __func__);
 372
 373	if (!port->serial->type->wait_until_sent)
 374		return;
 375
 376	mutex_lock(&serial->disc_mutex);
 377	if (!serial->disconnected)
 378		port->serial->type->wait_until_sent(tty, timeout);
 379	mutex_unlock(&serial->disc_mutex);
 380}
 381
 382static void serial_throttle(struct tty_struct *tty)
 383{
 384	struct usb_serial_port *port = tty->driver_data;
 
 385
 386	dev_dbg(tty->dev, "%s\n", __func__);
 387
 388	if (port->serial->type->throttle)
 389		port->serial->type->throttle(tty);
 390}
 391
 392static void serial_unthrottle(struct tty_struct *tty)
 393{
 394	struct usb_serial_port *port = tty->driver_data;
 
 395
 396	dev_dbg(tty->dev, "%s\n", __func__);
 397
 398	if (port->serial->type->unthrottle)
 399		port->serial->type->unthrottle(tty);
 400}
 401
 402static int serial_ioctl(struct tty_struct *tty,
 403					unsigned int cmd, unsigned long arg)
 404{
 405	struct usb_serial_port *port = tty->driver_data;
 406	int retval = -ENOIOCTLCMD;
 407
 408	dev_dbg(tty->dev, "%s - cmd 0x%04x\n", __func__, cmd);
 409
 410	switch (cmd) {
 411	case TIOCMIWAIT:
 412		if (port->serial->type->tiocmiwait)
 413			retval = port->serial->type->tiocmiwait(tty, arg);
 414		break;
 415	default:
 416		if (port->serial->type->ioctl)
 417			retval = port->serial->type->ioctl(tty, cmd, arg);
 418	}
 419
 
 
 
 
 
 
 420	return retval;
 421}
 422
 423static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 424{
 425	struct usb_serial_port *port = tty->driver_data;
 
 426
 427	dev_dbg(tty->dev, "%s\n", __func__);
 428
 429	if (port->serial->type->set_termios)
 430		port->serial->type->set_termios(tty, port, old);
 431	else
 432		tty_termios_copy_hw(&tty->termios, old);
 433}
 434
 435static int serial_break(struct tty_struct *tty, int break_state)
 436{
 437	struct usb_serial_port *port = tty->driver_data;
 438
 439	dev_dbg(tty->dev, "%s\n", __func__);
 440
 
 
 441	if (port->serial->type->break_ctl)
 442		port->serial->type->break_ctl(tty, break_state);
 443
 444	return 0;
 445}
 446
 447static int serial_proc_show(struct seq_file *m, void *v)
 448{
 449	struct usb_serial *serial;
 450	struct usb_serial_port *port;
 451	int i;
 452	char tmp[40];
 453
 
 454	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 455	for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) {
 456		port = usb_serial_port_get_by_minor(i);
 457		if (port == NULL)
 458			continue;
 459		serial = port->serial;
 460
 461		seq_printf(m, "%d:", i);
 462		if (serial->type->driver.owner)
 463			seq_printf(m, " module:%s",
 464				module_name(serial->type->driver.owner));
 465		seq_printf(m, " name:\"%s\"",
 466				serial->type->description);
 467		seq_printf(m, " vendor:%04x product:%04x",
 468			le16_to_cpu(serial->dev->descriptor.idVendor),
 469			le16_to_cpu(serial->dev->descriptor.idProduct));
 470		seq_printf(m, " num_ports:%d", serial->num_ports);
 471		seq_printf(m, " port:%d", port->port_number);
 472		usb_make_path(serial->dev, tmp, sizeof(tmp));
 473		seq_printf(m, " path:%s", tmp);
 474
 475		seq_putc(m, '\n');
 476		usb_serial_put(serial);
 477		mutex_unlock(&serial->disc_mutex);
 478	}
 479	return 0;
 480}
 481
 482static int serial_proc_open(struct inode *inode, struct file *file)
 483{
 484	return single_open(file, serial_proc_show, NULL);
 485}
 486
 487static const struct file_operations serial_proc_fops = {
 488	.owner		= THIS_MODULE,
 489	.open		= serial_proc_open,
 490	.read		= seq_read,
 491	.llseek		= seq_lseek,
 492	.release	= single_release,
 493};
 494
 495static int serial_tiocmget(struct tty_struct *tty)
 496{
 497	struct usb_serial_port *port = tty->driver_data;
 498
 499	dev_dbg(tty->dev, "%s\n", __func__);
 500
 501	if (port->serial->type->tiocmget)
 502		return port->serial->type->tiocmget(tty);
 503	return -EINVAL;
 504}
 505
 506static int serial_tiocmset(struct tty_struct *tty,
 507			    unsigned int set, unsigned int clear)
 508{
 509	struct usb_serial_port *port = tty->driver_data;
 510
 511	dev_dbg(tty->dev, "%s\n", __func__);
 512
 513	if (port->serial->type->tiocmset)
 514		return port->serial->type->tiocmset(tty, set, clear);
 515	return -EINVAL;
 516}
 517
 518static int serial_get_icount(struct tty_struct *tty,
 519				struct serial_icounter_struct *icount)
 520{
 521	struct usb_serial_port *port = tty->driver_data;
 522
 523	dev_dbg(tty->dev, "%s\n", __func__);
 524
 525	if (port->serial->type->get_icount)
 526		return port->serial->type->get_icount(tty, icount);
 527	return -EINVAL;
 528}
 529
 530/*
 531 * We would be calling tty_wakeup here, but unfortunately some line
 532 * disciplines have an annoying habit of calling tty->write from
 533 * the write wakeup callback (e.g. n_hdlc.c).
 534 */
 535void usb_serial_port_softint(struct usb_serial_port *port)
 536{
 537	schedule_work(&port->work);
 538}
 539EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 540
 541static void usb_serial_port_work(struct work_struct *work)
 542{
 543	struct usb_serial_port *port =
 544		container_of(work, struct usb_serial_port, work);
 
 545
 546	tty_port_tty_wakeup(&port->port);
 547}
 548
 549static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
 550{
 551	int i;
 552
 553	for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 554		usb_poison_urb(port->read_urbs[i]);
 555	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 556		usb_poison_urb(port->write_urbs[i]);
 557
 558	usb_poison_urb(port->interrupt_in_urb);
 559	usb_poison_urb(port->interrupt_out_urb);
 560}
 561
 562static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
 563{
 564	int i;
 565
 566	for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 567		usb_unpoison_urb(port->read_urbs[i]);
 568	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 569		usb_unpoison_urb(port->write_urbs[i]);
 570
 571	usb_unpoison_urb(port->interrupt_in_urb);
 572	usb_unpoison_urb(port->interrupt_out_urb);
 
 
 
 
 
 
 
 
 
 
 573}
 574
 575static void usb_serial_port_release(struct device *dev)
 576{
 577	struct usb_serial_port *port = to_usb_serial_port(dev);
 578	int i;
 579
 580	dev_dbg(dev, "%s\n", __func__);
 
 
 
 
 
 
 
 581
 582	usb_free_urb(port->interrupt_in_urb);
 583	usb_free_urb(port->interrupt_out_urb);
 584	for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 585		usb_free_urb(port->read_urbs[i]);
 586		kfree(port->bulk_in_buffers[i]);
 587	}
 588	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 589		usb_free_urb(port->write_urbs[i]);
 590		kfree(port->bulk_out_buffers[i]);
 591	}
 592	kfifo_free(&port->write_fifo);
 593	kfree(port->interrupt_in_buffer);
 594	kfree(port->interrupt_out_buffer);
 595	tty_port_destroy(&port->port);
 596	kfree(port);
 597}
 598
 599static struct usb_serial *create_serial(struct usb_device *dev,
 600					struct usb_interface *interface,
 601					struct usb_serial_driver *driver)
 602{
 603	struct usb_serial *serial;
 604
 605	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 606	if (!serial)
 
 607		return NULL;
 
 608	serial->dev = usb_get_dev(dev);
 609	serial->type = driver;
 610	serial->interface = usb_get_intf(interface);
 611	kref_init(&serial->kref);
 612	mutex_init(&serial->disc_mutex);
 613	serial->minors_reserved = 0;
 614
 615	return serial;
 616}
 617
 618static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 619					    struct usb_serial_driver *drv)
 620{
 621	struct usb_dynid *dynid;
 622
 623	spin_lock(&drv->dynids.lock);
 624	list_for_each_entry(dynid, &drv->dynids.list, node) {
 625		if (usb_match_one_id(intf, &dynid->id)) {
 626			spin_unlock(&drv->dynids.lock);
 627			return &dynid->id;
 628		}
 629	}
 630	spin_unlock(&drv->dynids.lock);
 631	return NULL;
 632}
 633
 634static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 635						struct usb_interface *intf)
 636{
 637	const struct usb_device_id *id;
 638
 639	id = usb_match_id(intf, drv->id_table);
 640	if (id) {
 641		dev_dbg(&intf->dev, "static descriptor matches\n");
 642		goto exit;
 643	}
 644	id = match_dynamic_id(intf, drv);
 645	if (id)
 646		dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 647exit:
 648	return id;
 649}
 650
 651/* Caller must hold table_lock */
 652static struct usb_serial_driver *search_serial_device(
 653					struct usb_interface *iface)
 654{
 655	const struct usb_device_id *id = NULL;
 656	struct usb_serial_driver *drv;
 657	struct usb_driver *driver = to_usb_driver(iface->dev.driver);
 658
 659	/* Check if the usb id matches a known device */
 660	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 661		if (drv->usb_driver == driver)
 662			id = get_iface_id(drv, iface);
 663		if (id)
 664			return drv;
 665	}
 666
 667	return NULL;
 668}
 669
 670static int serial_port_carrier_raised(struct tty_port *port)
 671{
 672	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 673	struct usb_serial_driver *drv = p->serial->type;
 674
 675	if (drv->carrier_raised)
 676		return drv->carrier_raised(p);
 677	/* No carrier control - don't block */
 678	return 1;
 679}
 680
 681static void serial_port_dtr_rts(struct tty_port *port, int on)
 682{
 683	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 684	struct usb_serial_driver *drv = p->serial->type;
 685
 686	if (drv->dtr_rts)
 687		drv->dtr_rts(p, on);
 688}
 689
 690static ssize_t port_number_show(struct device *dev,
 691				struct device_attribute *attr, char *buf)
 692{
 693	struct usb_serial_port *port = to_usb_serial_port(dev);
 694
 695	return sprintf(buf, "%u\n", port->port_number);
 696}
 697static DEVICE_ATTR_RO(port_number);
 698
 699static struct attribute *usb_serial_port_attrs[] = {
 700	&dev_attr_port_number.attr,
 701	NULL
 702};
 703ATTRIBUTE_GROUPS(usb_serial_port);
 704
 705static const struct tty_port_operations serial_port_ops = {
 706	.carrier_raised		= serial_port_carrier_raised,
 707	.dtr_rts		= serial_port_dtr_rts,
 708	.activate		= serial_port_activate,
 709	.shutdown		= serial_port_shutdown,
 710};
 711
 712static int usb_serial_probe(struct usb_interface *interface,
 713			       const struct usb_device_id *id)
 714{
 715	struct device *ddev = &interface->dev;
 716	struct usb_device *dev = interface_to_usbdev(interface);
 717	struct usb_serial *serial = NULL;
 718	struct usb_serial_port *port;
 719	struct usb_host_interface *iface_desc;
 720	struct usb_endpoint_descriptor *endpoint;
 721	struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 722	struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 723	struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 724	struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 725	struct usb_serial_driver *type = NULL;
 726	int retval;
 
 727	int buffer_size;
 728	int i;
 729	int j;
 730	int num_interrupt_in = 0;
 731	int num_interrupt_out = 0;
 732	int num_bulk_in = 0;
 733	int num_bulk_out = 0;
 734	int num_ports = 0;
 735	int max_endpoints;
 736
 737	mutex_lock(&table_lock);
 738	type = search_serial_device(interface);
 739	if (!type) {
 740		mutex_unlock(&table_lock);
 741		dev_dbg(ddev, "none matched\n");
 742		return -ENODEV;
 743	}
 744
 745	if (!try_module_get(type->driver.owner)) {
 746		mutex_unlock(&table_lock);
 747		dev_err(ddev, "module get failed, exiting\n");
 748		return -EIO;
 749	}
 750	mutex_unlock(&table_lock);
 751
 752	serial = create_serial(dev, interface, type);
 753	if (!serial) {
 754		module_put(type->driver.owner);
 
 755		return -ENOMEM;
 756	}
 757
 758	/* if this device type has a probe function, call it */
 759	if (type->probe) {
 760		const struct usb_device_id *id;
 761
 762		id = get_iface_id(type, interface);
 763		retval = type->probe(serial, id);
 764
 765		if (retval) {
 766			dev_dbg(ddev, "sub driver rejected device\n");
 767			usb_serial_put(serial);
 768			module_put(type->driver.owner);
 769			return retval;
 770		}
 771	}
 772
 773	/* descriptor matches, let's find the endpoints needed */
 774	/* check out the endpoints */
 775	iface_desc = interface->cur_altsetting;
 776	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 777		endpoint = &iface_desc->endpoint[i].desc;
 778
 779		if (usb_endpoint_is_bulk_in(endpoint)) {
 780			/* we found a bulk in endpoint */
 781			dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
 782			if (num_bulk_in < MAX_NUM_PORTS) {
 783				bulk_in_endpoint[num_bulk_in] = endpoint;
 784				++num_bulk_in;
 785			}
 786		}
 787
 788		if (usb_endpoint_is_bulk_out(endpoint)) {
 789			/* we found a bulk out endpoint */
 790			dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
 791			if (num_bulk_out < MAX_NUM_PORTS) {
 792				bulk_out_endpoint[num_bulk_out] = endpoint;
 793				++num_bulk_out;
 794			}
 795		}
 796
 797		if (usb_endpoint_is_int_in(endpoint)) {
 798			/* we found a interrupt in endpoint */
 799			dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
 800			if (num_interrupt_in < MAX_NUM_PORTS) {
 801				interrupt_in_endpoint[num_interrupt_in] =
 802						endpoint;
 803				++num_interrupt_in;
 804			}
 805		}
 806
 807		if (usb_endpoint_is_int_out(endpoint)) {
 808			/* we found an interrupt out endpoint */
 809			dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
 810			if (num_interrupt_out < MAX_NUM_PORTS) {
 811				interrupt_out_endpoint[num_interrupt_out] =
 812						endpoint;
 813				++num_interrupt_out;
 814			}
 815		}
 816	}
 817
 818#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 819	/* BEGIN HORRIBLE HACK FOR PL2303 */
 820	/* this is needed due to the looney way its endpoints are set up */
 821	if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 822	     (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 823	    ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 824	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 825	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 826	     (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 827	    ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 828	     (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 829		if (interface != dev->actconfig->interface[0]) {
 830			/* check out the endpoints of the other interface*/
 831			iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 832			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 833				endpoint = &iface_desc->endpoint[i].desc;
 834				if (usb_endpoint_is_int_in(endpoint)) {
 835					/* we found a interrupt in endpoint */
 836					dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
 837					if (num_interrupt_in < MAX_NUM_PORTS) {
 838						interrupt_in_endpoint[num_interrupt_in] = endpoint;
 839						++num_interrupt_in;
 840					}
 841				}
 842			}
 843		}
 844
 845		/* Now make sure the PL-2303 is configured correctly.
 846		 * If not, give up now and hope this hack will work
 847		 * properly during a later invocation of usb_serial_probe
 848		 */
 849		if (num_bulk_in == 0 || num_bulk_out == 0) {
 850			dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 851			usb_serial_put(serial);
 852			module_put(type->driver.owner);
 853			return -ENODEV;
 854		}
 855	}
 856	/* END HORRIBLE HACK FOR PL2303 */
 857#endif
 858
 859#ifdef CONFIG_USB_SERIAL_GENERIC
 860	if (type == &usb_serial_generic_device) {
 861		num_ports = num_bulk_out;
 862		if (num_ports == 0) {
 863			dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
 
 864			usb_serial_put(serial);
 865			module_put(type->driver.owner);
 866			return -EIO;
 867		}
 868		dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
 869		dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
 870	}
 871#endif
 872	if (!num_ports) {
 873		/* if this device type has a calc_num_ports function, call it */
 874		if (type->calc_num_ports)
 875			num_ports = type->calc_num_ports(serial);
 876		if (!num_ports)
 877			num_ports = type->num_ports;
 878	}
 879
 880	if (num_ports > MAX_NUM_PORTS) {
 881		dev_warn(ddev, "too many ports requested: %d\n", num_ports);
 882		num_ports = MAX_NUM_PORTS;
 883	}
 884
 885	serial->num_ports = num_ports;
 886	serial->num_bulk_in = num_bulk_in;
 887	serial->num_bulk_out = num_bulk_out;
 888	serial->num_interrupt_in = num_interrupt_in;
 889	serial->num_interrupt_out = num_interrupt_out;
 890
 891	/* found all that we need */
 892	dev_info(ddev, "%s converter detected\n", type->description);
 
 893
 894	/* create our ports, we need as many as the max endpoints */
 895	/* we don't use num_ports here because some devices have more
 896	   endpoint pairs than ports */
 897	max_endpoints = max(num_bulk_in, num_bulk_out);
 898	max_endpoints = max(max_endpoints, num_interrupt_in);
 899	max_endpoints = max(max_endpoints, num_interrupt_out);
 900	max_endpoints = max(max_endpoints, (int)serial->num_ports);
 901	serial->num_port_pointers = max_endpoints;
 902
 903	dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
 
 904	for (i = 0; i < max_endpoints; ++i) {
 905		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 906		if (!port)
 907			goto probe_error;
 908		tty_port_init(&port->port);
 909		port->port.ops = &serial_port_ops;
 910		port->serial = serial;
 911		spin_lock_init(&port->lock);
 912		/* Keep this for private driver use for the moment but
 913		   should probably go away */
 914		INIT_WORK(&port->work, usb_serial_port_work);
 915		serial->port[i] = port;
 916		port->dev.parent = &interface->dev;
 917		port->dev.driver = NULL;
 918		port->dev.bus = &usb_serial_bus_type;
 919		port->dev.release = &usb_serial_port_release;
 920		port->dev.groups = usb_serial_port_groups;
 921		device_initialize(&port->dev);
 922	}
 923
 924	/* set up the endpoint information */
 925	for (i = 0; i < num_bulk_in; ++i) {
 926		endpoint = bulk_in_endpoint[i];
 927		port = serial->port[i];
 928		buffer_size = max_t(int, serial->type->bulk_in_size,
 929				usb_endpoint_maxp(endpoint));
 930		port->bulk_in_size = buffer_size;
 931		port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 932
 933		for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
 934			set_bit(j, &port->read_urbs_free);
 935			port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 936			if (!port->read_urbs[j])
 
 
 937				goto probe_error;
 
 938			port->bulk_in_buffers[j] = kmalloc(buffer_size,
 939								GFP_KERNEL);
 940			if (!port->bulk_in_buffers[j])
 
 
 941				goto probe_error;
 
 942			usb_fill_bulk_urb(port->read_urbs[j], dev,
 943					usb_rcvbulkpipe(dev,
 944						endpoint->bEndpointAddress),
 945					port->bulk_in_buffers[j], buffer_size,
 946					serial->type->read_bulk_callback,
 947					port);
 948		}
 949
 950		port->read_urb = port->read_urbs[0];
 951		port->bulk_in_buffer = port->bulk_in_buffers[0];
 952	}
 953
 954	for (i = 0; i < num_bulk_out; ++i) {
 955		endpoint = bulk_out_endpoint[i];
 956		port = serial->port[i];
 957		if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 958			goto probe_error;
 959		buffer_size = serial->type->bulk_out_size;
 960		if (!buffer_size)
 961			buffer_size = usb_endpoint_maxp(endpoint);
 962		port->bulk_out_size = buffer_size;
 963		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 964
 965		for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 966			set_bit(j, &port->write_urbs_free);
 967			port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 968			if (!port->write_urbs[j])
 
 
 969				goto probe_error;
 
 970			port->bulk_out_buffers[j] = kmalloc(buffer_size,
 971								GFP_KERNEL);
 972			if (!port->bulk_out_buffers[j])
 
 
 973				goto probe_error;
 
 974			usb_fill_bulk_urb(port->write_urbs[j], dev,
 975					usb_sndbulkpipe(dev,
 976						endpoint->bEndpointAddress),
 977					port->bulk_out_buffers[j], buffer_size,
 978					serial->type->write_bulk_callback,
 979					port);
 980		}
 981
 982		port->write_urb = port->write_urbs[0];
 983		port->bulk_out_buffer = port->bulk_out_buffers[0];
 984	}
 985
 986	if (serial->type->read_int_callback) {
 987		for (i = 0; i < num_interrupt_in; ++i) {
 988			endpoint = interrupt_in_endpoint[i];
 989			port = serial->port[i];
 990			port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 991			if (!port->interrupt_in_urb)
 
 
 992				goto probe_error;
 
 993			buffer_size = usb_endpoint_maxp(endpoint);
 994			port->interrupt_in_endpointAddress =
 995						endpoint->bEndpointAddress;
 996			port->interrupt_in_buffer = kmalloc(buffer_size,
 997								GFP_KERNEL);
 998			if (!port->interrupt_in_buffer)
 
 
 999				goto probe_error;
 
1000			usb_fill_int_urb(port->interrupt_in_urb, dev,
1001				usb_rcvintpipe(dev,
1002						endpoint->bEndpointAddress),
1003				port->interrupt_in_buffer, buffer_size,
1004				serial->type->read_int_callback, port,
1005				endpoint->bInterval);
1006		}
1007	} else if (num_interrupt_in) {
1008		dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1009	}
1010
1011	if (serial->type->write_int_callback) {
1012		for (i = 0; i < num_interrupt_out; ++i) {
1013			endpoint = interrupt_out_endpoint[i];
1014			port = serial->port[i];
1015			port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1016			if (!port->interrupt_out_urb)
 
 
1017				goto probe_error;
 
1018			buffer_size = usb_endpoint_maxp(endpoint);
1019			port->interrupt_out_size = buffer_size;
1020			port->interrupt_out_endpointAddress =
1021						endpoint->bEndpointAddress;
1022			port->interrupt_out_buffer = kmalloc(buffer_size,
1023								GFP_KERNEL);
1024			if (!port->interrupt_out_buffer)
 
 
1025				goto probe_error;
 
1026			usb_fill_int_urb(port->interrupt_out_urb, dev,
1027				usb_sndintpipe(dev,
1028						  endpoint->bEndpointAddress),
1029				port->interrupt_out_buffer, buffer_size,
1030				serial->type->write_int_callback, port,
1031				endpoint->bInterval);
1032		}
1033	} else if (num_interrupt_out) {
1034		dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1035	}
1036
1037	usb_set_intfdata(interface, serial);
1038
1039	/* if this device type has an attach function, call it */
1040	if (type->attach) {
1041		retval = type->attach(serial);
1042		if (retval < 0)
1043			goto probe_error;
1044		serial->attached = 1;
1045		if (retval > 0) {
1046			/* quietly accept this device, but don't bind to a
1047			   serial port as it's about to disappear */
1048			serial->num_ports = 0;
1049			goto exit;
1050		}
1051	} else {
1052		serial->attached = 1;
1053	}
1054
1055	/* Avoid race with tty_open and serial_install by setting the
1056	 * disconnected flag and not clearing it until all ports have been
1057	 * registered.
1058	 */
1059	serial->disconnected = 1;
1060
1061	if (allocate_minors(serial, num_ports)) {
1062		dev_err(ddev, "No more free serial minor numbers\n");
1063		goto probe_error;
1064	}
 
1065
1066	/* register all of the individual ports with the driver core */
1067	for (i = 0; i < num_ports; ++i) {
1068		port = serial->port[i];
1069		dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1070		dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1071		device_enable_async_suspend(&port->dev);
1072
1073		retval = device_add(&port->dev);
1074		if (retval)
1075			dev_err(ddev, "Error registering port device, continuing\n");
 
1076	}
1077
1078	serial->disconnected = 0;
1079
1080	usb_serial_console_init(serial->port[0]->minor);
1081exit:
1082	module_put(type->driver.owner);
1083	return 0;
1084
1085probe_error:
1086	usb_serial_put(serial);
1087	module_put(type->driver.owner);
1088	return -EIO;
1089}
1090
1091static void usb_serial_disconnect(struct usb_interface *interface)
1092{
1093	int i;
1094	struct usb_serial *serial = usb_get_intfdata(interface);
1095	struct device *dev = &interface->dev;
1096	struct usb_serial_port *port;
1097	struct tty_struct *tty;
1098
1099	usb_serial_console_disconnect(serial);
 
1100
1101	mutex_lock(&serial->disc_mutex);
1102	/* must set a flag, to signal subdrivers */
1103	serial->disconnected = 1;
1104	mutex_unlock(&serial->disc_mutex);
1105
1106	for (i = 0; i < serial->num_ports; ++i) {
1107		port = serial->port[i];
1108		tty = tty_port_tty_get(&port->port);
1109		if (tty) {
1110			tty_vhangup(tty);
1111			tty_kref_put(tty);
 
 
 
 
 
 
1112		}
1113		usb_serial_port_poison_urbs(port);
1114		wake_up_interruptible(&port->port.delta_msr_wait);
1115		cancel_work_sync(&port->work);
1116		if (device_is_registered(&port->dev))
1117			device_del(&port->dev);
1118	}
1119	if (serial->type->disconnect)
1120		serial->type->disconnect(serial);
1121
1122	/* let the last holder of this object cause it to be cleaned up */
1123	usb_serial_put(serial);
1124	dev_info(dev, "device disconnected\n");
1125}
1126
1127int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1128{
1129	struct usb_serial *serial = usb_get_intfdata(intf);
 
1130	int i, r = 0;
1131
1132	serial->suspending = 1;
1133
1134	/*
1135	 * serial->type->suspend() MUST return 0 in system sleep context,
1136	 * otherwise, the resume callback has to recover device from
1137	 * previous suspend failure.
1138	 */
1139	if (serial->type->suspend) {
1140		r = serial->type->suspend(serial, message);
1141		if (r < 0) {
1142			serial->suspending = 0;
1143			goto err_out;
1144		}
1145	}
1146
1147	for (i = 0; i < serial->num_ports; ++i)
1148		usb_serial_port_poison_urbs(serial->port[i]);
 
 
 
 
1149err_out:
1150	return r;
1151}
1152EXPORT_SYMBOL(usb_serial_suspend);
1153
1154static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1155{
1156	int i;
1157
1158	for (i = 0; i < serial->num_ports; ++i)
1159		usb_serial_port_unpoison_urbs(serial->port[i]);
1160}
1161
1162int usb_serial_resume(struct usb_interface *intf)
1163{
1164	struct usb_serial *serial = usb_get_intfdata(intf);
1165	int rv;
1166
1167	usb_serial_unpoison_port_urbs(serial);
1168
1169	serial->suspending = 0;
1170	if (serial->type->resume)
1171		rv = serial->type->resume(serial);
1172	else
1173		rv = usb_serial_generic_resume(serial);
1174
1175	return rv;
1176}
1177EXPORT_SYMBOL(usb_serial_resume);
1178
1179static int usb_serial_reset_resume(struct usb_interface *intf)
1180{
1181	struct usb_serial *serial = usb_get_intfdata(intf);
1182	int rv;
1183
1184	usb_serial_unpoison_port_urbs(serial);
1185
1186	serial->suspending = 0;
1187	if (serial->type->reset_resume) {
1188		rv = serial->type->reset_resume(serial);
1189	} else {
1190		rv = -EOPNOTSUPP;
1191		intf->needs_binding = 1;
1192	}
1193
1194	return rv;
1195}
1196
1197static const struct tty_operations serial_ops = {
1198	.open =			serial_open,
1199	.close =		serial_close,
1200	.write =		serial_write,
1201	.hangup =		serial_hangup,
1202	.write_room =		serial_write_room,
1203	.ioctl =		serial_ioctl,
1204	.set_termios =		serial_set_termios,
1205	.throttle =		serial_throttle,
1206	.unthrottle =		serial_unthrottle,
1207	.break_ctl =		serial_break,
1208	.chars_in_buffer =	serial_chars_in_buffer,
1209	.wait_until_sent =	serial_wait_until_sent,
1210	.tiocmget =		serial_tiocmget,
1211	.tiocmset =		serial_tiocmset,
1212	.get_icount =		serial_get_icount,
1213	.cleanup =		serial_cleanup,
1214	.install =		serial_install,
1215	.proc_fops =		&serial_proc_fops,
1216};
1217
1218
1219struct tty_driver *usb_serial_tty_driver;
1220
1221/* Driver structure we register with the USB core */
1222static struct usb_driver usb_serial_driver = {
1223	.name =		"usbserial",
1224	.probe =	usb_serial_probe,
1225	.disconnect =	usb_serial_disconnect,
1226	.suspend =	usb_serial_suspend,
1227	.resume =	usb_serial_resume,
1228	.no_dynamic_id =	1,
1229	.supports_autosuspend =	1,
1230};
1231
1232static int __init usb_serial_init(void)
1233{
 
1234	int result;
1235
1236	usb_serial_tty_driver = alloc_tty_driver(USB_SERIAL_TTY_MINORS);
1237	if (!usb_serial_tty_driver)
1238		return -ENOMEM;
1239
1240	/* Initialize our global data */
 
 
 
1241	result = bus_register(&usb_serial_bus_type);
1242	if (result) {
1243		pr_err("%s - registering bus driver failed\n", __func__);
 
1244		goto exit_bus;
1245	}
1246
1247	usb_serial_tty_driver->driver_name = "usbserial";
1248	usb_serial_tty_driver->name = "ttyUSB";
1249	usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1250	usb_serial_tty_driver->minor_start = 0;
1251	usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1252	usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1253	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1254						TTY_DRIVER_DYNAMIC_DEV;
1255	usb_serial_tty_driver->init_termios = tty_std_termios;
1256	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1257							| HUPCL | CLOCAL;
1258	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1259	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1260	tty_set_operations(usb_serial_tty_driver, &serial_ops);
1261	result = tty_register_driver(usb_serial_tty_driver);
1262	if (result) {
1263		pr_err("%s - tty_register_driver failed\n", __func__);
 
1264		goto exit_reg_driver;
1265	}
1266
1267	/* register the USB driver */
1268	result = usb_register(&usb_serial_driver);
1269	if (result < 0) {
1270		pr_err("%s - usb_register failed\n", __func__);
 
1271		goto exit_tty;
1272	}
1273
1274	/* register the generic driver, if we should */
1275	result = usb_serial_generic_register();
1276	if (result < 0) {
1277		pr_err("%s - registering generic driver failed\n", __func__);
 
1278		goto exit_generic;
1279	}
1280
 
 
1281	return result;
1282
1283exit_generic:
1284	usb_deregister(&usb_serial_driver);
1285
1286exit_tty:
1287	tty_unregister_driver(usb_serial_tty_driver);
1288
1289exit_reg_driver:
1290	bus_unregister(&usb_serial_bus_type);
1291
1292exit_bus:
1293	pr_err("%s - returning with error %d\n", __func__, result);
 
1294	put_tty_driver(usb_serial_tty_driver);
1295	return result;
1296}
1297
1298
1299static void __exit usb_serial_exit(void)
1300{
1301	usb_serial_console_exit();
1302
1303	usb_serial_generic_deregister();
1304
1305	usb_deregister(&usb_serial_driver);
1306	tty_unregister_driver(usb_serial_tty_driver);
1307	put_tty_driver(usb_serial_tty_driver);
1308	bus_unregister(&usb_serial_bus_type);
1309	idr_destroy(&serial_minors);
1310}
1311
1312
1313module_init(usb_serial_init);
1314module_exit(usb_serial_exit);
1315
1316#define set_to_generic_if_null(type, function)				\
1317	do {								\
1318		if (!type->function) {					\
1319			type->function = usb_serial_generic_##function;	\
1320			pr_debug("%s: using generic " #function	"\n",	\
1321						type->driver.name);	\
1322		}							\
1323	} while (0)
1324
1325static void usb_serial_operations_init(struct usb_serial_driver *device)
1326{
1327	set_to_generic_if_null(device, open);
1328	set_to_generic_if_null(device, write);
1329	set_to_generic_if_null(device, close);
1330	set_to_generic_if_null(device, write_room);
1331	set_to_generic_if_null(device, chars_in_buffer);
1332	if (device->tx_empty)
1333		set_to_generic_if_null(device, wait_until_sent);
1334	set_to_generic_if_null(device, read_bulk_callback);
1335	set_to_generic_if_null(device, write_bulk_callback);
 
 
1336	set_to_generic_if_null(device, process_read_urb);
1337	set_to_generic_if_null(device, prepare_write_buffer);
1338}
1339
1340static int usb_serial_register(struct usb_serial_driver *driver)
1341{
1342	int retval;
1343
1344	if (usb_disabled())
1345		return -ENODEV;
1346
 
 
1347	if (!driver->description)
1348		driver->description = driver->driver.name;
1349	if (!driver->usb_driver) {
1350		WARN(1, "Serial driver %s has no usb_driver\n",
1351				driver->description);
1352		return -EINVAL;
1353	}
1354
1355	usb_serial_operations_init(driver);
1356
1357	/* Add this device to our list of devices */
1358	mutex_lock(&table_lock);
1359	list_add(&driver->driver_list, &usb_serial_driver_list);
1360
1361	retval = usb_serial_bus_register(driver);
1362	if (retval) {
1363		pr_err("problem %d when registering driver %s\n", retval, driver->description);
 
1364		list_del(&driver->driver_list);
1365	} else {
1366		pr_info("USB Serial support registered for %s\n", driver->description);
1367	}
 
1368	mutex_unlock(&table_lock);
1369	return retval;
1370}
1371
1372static void usb_serial_deregister(struct usb_serial_driver *device)
1373{
1374	pr_info("USB Serial deregistering driver %s\n", device->description);
1375
1376	mutex_lock(&table_lock);
1377	list_del(&device->driver_list);
1378	mutex_unlock(&table_lock);
1379
1380	usb_serial_bus_deregister(device);
 
1381}
1382
1383/**
1384 * usb_serial_register_drivers - register drivers for a usb-serial module
1385 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1386 * @name: name of the usb_driver for this set of @serial_drivers
1387 * @id_table: list of all devices this @serial_drivers set binds to
1388 *
1389 * Registers all the drivers in the @serial_drivers array, and dynamically
1390 * creates a struct usb_driver with the name @name and id_table of @id_table.
1391 */
1392int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1393				const char *name,
1394				const struct usb_device_id *id_table)
1395{
1396	int rc;
1397	struct usb_driver *udriver;
1398	struct usb_serial_driver * const *sd;
1399
1400	/*
1401	 * udriver must be registered before any of the serial drivers,
1402	 * because the store_new_id() routine for the serial drivers (in
1403	 * bus.c) probes udriver.
1404	 *
1405	 * Performance hack: We don't want udriver to be probed until
1406	 * the serial drivers are registered, because the probe would
1407	 * simply fail for lack of a matching serial driver.
1408	 * So we leave udriver's id_table set to NULL until we are all set.
1409	 *
1410	 * Suspend/resume support is implemented in the usb-serial core,
1411	 * so fill in the PM-related fields in udriver.
1412	 */
1413	udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1414	if (!udriver)
1415		return -ENOMEM;
1416
1417	udriver->name = name;
1418	udriver->no_dynamic_id = 1;
1419	udriver->supports_autosuspend = 1;
1420	udriver->suspend = usb_serial_suspend;
1421	udriver->resume = usb_serial_resume;
1422	udriver->probe = usb_serial_probe;
1423	udriver->disconnect = usb_serial_disconnect;
1424
1425	/* we only set the reset_resume field if the serial_driver has one */
1426	for (sd = serial_drivers; *sd; ++sd) {
1427		if ((*sd)->reset_resume) {
1428			udriver->reset_resume = usb_serial_reset_resume;
1429			break;
1430		}
1431	}
1432
1433	rc = usb_register(udriver);
1434	if (rc)
1435		return rc;
1436
1437	for (sd = serial_drivers; *sd; ++sd) {
1438		(*sd)->usb_driver = udriver;
1439		rc = usb_serial_register(*sd);
1440		if (rc)
1441			goto failed;
1442	}
1443
1444	/* Now set udriver's id_table and look for matches */
1445	udriver->id_table = id_table;
1446	rc = driver_attach(&udriver->drvwrap.driver);
1447	return 0;
1448
1449 failed:
1450	while (sd-- > serial_drivers)
1451		usb_serial_deregister(*sd);
1452	usb_deregister(udriver);
1453	return rc;
1454}
1455EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1456
1457/**
1458 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1459 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1460 *
1461 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1462 * frees the struct usb_driver that was created by the call to
1463 * usb_serial_register_drivers().
1464 */
1465void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1466{
1467	struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1468
1469	for (; *serial_drivers; ++serial_drivers)
1470		usb_serial_deregister(*serial_drivers);
1471	usb_deregister(udriver);
1472	kfree(udriver);
1473}
1474EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1475
 
1476MODULE_AUTHOR(DRIVER_AUTHOR);
1477MODULE_DESCRIPTION(DRIVER_DESC);
1478MODULE_LICENSE("GPL");