1/*
   2 * USB Serial Converter driver
   3 *
   4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
   5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   7 *
   8 *	This program is free software; you can redistribute it and/or
   9 *	modify it under the terms of the GNU General Public License version
  10 *	2 as published by the Free Software Foundation.
  11 *
  12 * This driver was originally based on the ACM driver by Armin Fuerst (which was
  13 * based on a driver by Brad Keryan)
  14 *
  15 * See Documentation/usb/usb-serial.txt for more information on using this
  16 * driver
  17 *
  18 */
  19
  20#include <linux/kernel.h>
  21#include <linux/errno.h>
  22#include <linux/init.h>
  23#include <linux/slab.h>
  24#include <linux/tty.h>
  25#include <linux/tty_driver.h>
  26#include <linux/tty_flip.h>
  27#include <linux/module.h>
  28#include <linux/moduleparam.h>
  29#include <linux/seq_file.h>
  30#include <linux/spinlock.h>
  31#include <linux/mutex.h>
  32#include <linux/list.h>
  33#include <linux/uaccess.h>
  34#include <linux/serial.h>
  35#include <linux/usb.h>
  36#include <linux/usb/serial.h>
  37#include <linux/kfifo.h>
  38#include "pl2303.h"
  39
  40/*
  41 * Version Information
  42 */
  43#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
  44#define DRIVER_DESC "USB Serial Driver core"
  45
  46/* Driver structure we register with the USB core */
  47static struct usb_driver usb_serial_driver = {
  48	.name =		"usbserial",
  49	.probe =	usb_serial_probe,
  50	.disconnect =	usb_serial_disconnect,
  51	.suspend =	usb_serial_suspend,
  52	.resume =	usb_serial_resume,
  53	.no_dynamic_id = 	1,
  54	.supports_autosuspend =	1,
  55};
  56
  57/* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  58   the MODULE_DEVICE_TABLE declarations in each serial driver
  59   cause the "hotplug" program to pull in whatever module is necessary
  60   via modprobe, and modprobe will load usbserial because the serial
  61   drivers depend on it.
  62*/
  63
  64static int debug;
  65/* initially all NULL */
  66static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
  67static DEFINE_MUTEX(table_lock);
  68static LIST_HEAD(usb_serial_driver_list);
  69
  70/*
  71 * Look up the serial structure.  If it is found and it hasn't been
  72 * disconnected, return with its disc_mutex held and its refcount
  73 * incremented.  Otherwise return NULL.
  74 */
  75struct usb_serial *usb_serial_get_by_index(unsigned index)
  76{
  77	struct usb_serial *serial;
  78
  79	mutex_lock(&table_lock);
  80	serial = serial_table[index];
  81
  82	if (serial) {
  83		mutex_lock(&serial->disc_mutex);
  84		if (serial->disconnected) {
  85			mutex_unlock(&serial->disc_mutex);
  86			serial = NULL;
  87		} else {
  88			kref_get(&serial->kref);
  89		}
  90	}
  91	mutex_unlock(&table_lock);
  92	return serial;
  93}
  94
  95static struct usb_serial *get_free_serial(struct usb_serial *serial,
  96					int num_ports, unsigned int *minor)
  97{
  98	unsigned int i, j;
  99	int good_spot;
 100
 101	dbg("%s %d", __func__, num_ports);
 102
 103	*minor = 0;
 104	mutex_lock(&table_lock);
 105	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 106		if (serial_table[i])
 107			continue;
 108
 109		good_spot = 1;
 110		for (j = 1; j <= num_ports-1; ++j)
 111			if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
 112				good_spot = 0;
 113				i += j;
 114				break;
 115			}
 116		if (good_spot == 0)
 117			continue;
 118
 119		*minor = i;
 120		j = 0;
 121		dbg("%s - minor base = %d", __func__, *minor);
 122		for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
 123			serial_table[i] = serial;
 124			serial->port[j++]->number = i;
 125		}
 126		mutex_unlock(&table_lock);
 127		return serial;
 128	}
 129	mutex_unlock(&table_lock);
 130	return NULL;
 131}
 132
 133static void return_serial(struct usb_serial *serial)
 134{
 135	int i;
 136
 137	dbg("%s", __func__);
 138
 139	mutex_lock(&table_lock);
 140	for (i = 0; i < serial->num_ports; ++i)
 141		serial_table[serial->minor + i] = NULL;
 142	mutex_unlock(&table_lock);
 143}
 144
 145static void destroy_serial(struct kref *kref)
 146{
 147	struct usb_serial *serial;
 148	struct usb_serial_port *port;
 149	int i;
 150
 151	serial = to_usb_serial(kref);
 152
 153	dbg("%s - %s", __func__, serial->type->description);
 154
 155	/* return the minor range that this device had */
 156	if (serial->minor != SERIAL_TTY_NO_MINOR)
 157		return_serial(serial);
 158
 159	if (serial->attached)
 160		serial->type->release(serial);
 161
 162	/* Now that nothing is using the ports, they can be freed */
 163	for (i = 0; i < serial->num_port_pointers; ++i) {
 164		port = serial->port[i];
 165		if (port) {
 166			port->serial = NULL;
 167			put_device(&port->dev);
 168		}
 169	}
 170
 171	usb_put_dev(serial->dev);
 172	kfree(serial);
 173}
 174
 175void usb_serial_put(struct usb_serial *serial)
 176{
 177	kref_put(&serial->kref, destroy_serial);
 178}
 179
 180/*****************************************************************************
 181 * Driver tty interface functions
 182 *****************************************************************************/
 183
 184/**
 185 * serial_install - install tty
 186 * @driver: the driver (USB in our case)
 187 * @tty: the tty being created
 188 *
 189 * Create the termios objects for this tty.  We use the default
 190 * USB serial settings but permit them to be overridden by
 191 * serial->type->init_termios.
 192 *
 193 * This is the first place a new tty gets used.  Hence this is where we
 194 * acquire references to the usb_serial structure and the driver module,
 195 * where we store a pointer to the port, and where we do an autoresume.
 196 * All these actions are reversed in serial_cleanup().
 197 */
 198static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 199{
 200	int idx = tty->index;
 201	struct usb_serial *serial;
 202	struct usb_serial_port *port;
 203	int retval = -ENODEV;
 204
 205	dbg("%s", __func__);
 206
 207	serial = usb_serial_get_by_index(idx);
 208	if (!serial)
 209		return retval;
 210
 211	port = serial->port[idx - serial->minor];
 212	if (!port)
 213		goto error_no_port;
 214	if (!try_module_get(serial->type->driver.owner))
 215		goto error_module_get;
 216
 217	/* perform the standard setup */
 218	retval = tty_init_termios(tty);
 219	if (retval)
 220		goto error_init_termios;
 221
 222	retval = usb_autopm_get_interface(serial->interface);
 223	if (retval)
 224		goto error_get_interface;
 225
 
 
 
 
 226	mutex_unlock(&serial->disc_mutex);
 227
 228	/* allow the driver to update the settings */
 229	if (serial->type->init_termios)
 230		serial->type->init_termios(tty);
 231
 232	tty->driver_data = port;
 233
 234	/* Final install (we use the default method) */
 235	tty_driver_kref_get(driver);
 236	tty->count++;
 237	driver->ttys[idx] = tty;
 238	return retval;
 239
 240 error_get_interface:
 241 error_init_termios:
 
 
 242	module_put(serial->type->driver.owner);
 243 error_module_get:
 244 error_no_port:
 245	usb_serial_put(serial);
 246	mutex_unlock(&serial->disc_mutex);
 247	return retval;
 248}
 249
 250static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
 251{
 252	struct usb_serial_port *port =
 253		container_of(tport, struct usb_serial_port, port);
 254	struct usb_serial *serial = port->serial;
 255	int retval;
 256
 257	mutex_lock(&serial->disc_mutex);
 258	if (serial->disconnected)
 259		retval = -ENODEV;
 260	else
 261		retval = port->serial->type->open(tty, port);
 262	mutex_unlock(&serial->disc_mutex);
 
 
 
 
 263	return retval;
 264}
 265
 266static int serial_open(struct tty_struct *tty, struct file *filp)
 267{
 268	struct usb_serial_port *port = tty->driver_data;
 269
 270	dbg("%s - port %d", __func__, port->number);
 271	return tty_port_open(&port->port, tty, filp);
 272}
 273
 274/**
 275 * serial_down - shut down hardware
 276 * @tport: tty port to shut down
 277 *
 278 * Shut down a USB serial port unless it is the console.  We never
 279 * shut down the console hardware as it will always be in use. Serialized
 280 * against activate by the tport mutex and kept to matching open/close pairs
 281 * of calls by the ASYNCB_INITIALIZED flag.
 282 */
 283static void serial_down(struct tty_port *tport)
 284{
 285	struct usb_serial_port *port =
 286		container_of(tport, struct usb_serial_port, port);
 287	struct usb_serial_driver *drv = port->serial->type;
 288	/*
 289	 * The console is magical.  Do not hang up the console hardware
 290	 * or there will be tears.
 291	 */
 292	if (port->port.console)
 293		return;
 294	if (drv->close)
 295		drv->close(port);
 296}
 297
 298static void serial_hangup(struct tty_struct *tty)
 299{
 300	struct usb_serial_port *port = tty->driver_data;
 301	dbg("%s - port %d", __func__, port->number);
 302	tty_port_hangup(&port->port);
 303}
 304
 305static void serial_close(struct tty_struct *tty, struct file *filp)
 306{
 307	struct usb_serial_port *port = tty->driver_data;
 308	dbg("%s - port %d", __func__, port->number);
 309	tty_port_close(&port->port, tty, filp);
 310}
 311
 312/**
 313 * serial_cleanup - free resources post close/hangup
 314 * @port: port to free up
 315 *
 316 * Do the resource freeing and refcount dropping for the port.
 317 * Avoid freeing the console.
 318 *
 319 * Called asynchronously after the last tty kref is dropped,
 320 * and the tty layer has already done the tty_shutdown(tty);
 321 */
 322static void serial_cleanup(struct tty_struct *tty)
 323{
 324	struct usb_serial_port *port = tty->driver_data;
 325	struct usb_serial *serial;
 326	struct module *owner;
 327
 328	/* The console is magical.  Do not hang up the console hardware
 329	 * or there will be tears.
 330	 */
 331	if (port->port.console)
 332		return;
 333
 334	dbg("%s - port %d", __func__, port->number);
 335
 336	tty->driver_data = NULL;
 337
 338	serial = port->serial;
 339	owner = serial->type->driver.owner;
 340
 341	mutex_lock(&serial->disc_mutex);
 342	if (!serial->disconnected)
 343		usb_autopm_put_interface(serial->interface);
 344	mutex_unlock(&serial->disc_mutex);
 345
 346	usb_serial_put(serial);
 347	module_put(owner);
 348}
 349
 350static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 351								int count)
 352{
 353	struct usb_serial_port *port = tty->driver_data;
 354	int retval = -ENODEV;
 355
 356	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 357		goto exit;
 358
 359	dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 360
 361	/* pass on to the driver specific version of this function */
 362	retval = port->serial->type->write(tty, port, buf, count);
 363
 
 364exit:
 365	return retval;
 366}
 367
 368static int serial_write_room(struct tty_struct *tty)
 369{
 370	struct usb_serial_port *port = tty->driver_data;
 371	dbg("%s - port %d", __func__, port->number);
 372	/* pass on to the driver specific version of this function */
 373	return port->serial->type->write_room(tty);
 374}
 375
 376static int serial_chars_in_buffer(struct tty_struct *tty)
 377{
 378	struct usb_serial_port *port = tty->driver_data;
 379	dbg("%s - port %d", __func__, port->number);
 380
 381	/* if the device was unplugged then any remaining characters
 382	   fell out of the connector ;) */
 383	if (port->serial->disconnected)
 384		return 0;
 385	/* pass on to the driver specific version of this function */
 386	return port->serial->type->chars_in_buffer(tty);
 387}
 388
 389static void serial_throttle(struct tty_struct *tty)
 390{
 391	struct usb_serial_port *port = tty->driver_data;
 392	dbg("%s - port %d", __func__, port->number);
 393
 394	/* pass on to the driver specific version of this function */
 395	if (port->serial->type->throttle)
 396		port->serial->type->throttle(tty);
 397}
 398
 399static void serial_unthrottle(struct tty_struct *tty)
 400{
 401	struct usb_serial_port *port = tty->driver_data;
 402	dbg("%s - port %d", __func__, port->number);
 403
 404	/* pass on to the driver specific version of this function */
 405	if (port->serial->type->unthrottle)
 406		port->serial->type->unthrottle(tty);
 407}
 408
 409static int serial_ioctl(struct tty_struct *tty,
 410					unsigned int cmd, unsigned long arg)
 411{
 412	struct usb_serial_port *port = tty->driver_data;
 413	int retval = -ENODEV;
 414
 415	dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 416
 417	/* pass on to the driver specific version of this function
 418	   if it is available */
 419	if (port->serial->type->ioctl) {
 420		retval = port->serial->type->ioctl(tty, cmd, arg);
 421	} else
 422		retval = -ENOIOCTLCMD;
 423	return retval;
 424}
 425
 426static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 427{
 428	struct usb_serial_port *port = tty->driver_data;
 429	dbg("%s - port %d", __func__, port->number);
 430
 431	/* pass on to the driver specific version of this function
 432	   if it is available */
 433	if (port->serial->type->set_termios)
 434		port->serial->type->set_termios(tty, port, old);
 435	else
 436		tty_termios_copy_hw(tty->termios, old);
 437}
 438
 439static int serial_break(struct tty_struct *tty, int break_state)
 440{
 441	struct usb_serial_port *port = tty->driver_data;
 442
 443	dbg("%s - port %d", __func__, port->number);
 444
 445	/* pass on to the driver specific version of this function
 446	   if it is available */
 447	if (port->serial->type->break_ctl)
 448		port->serial->type->break_ctl(tty, break_state);
 449	return 0;
 450}
 451
 452static int serial_proc_show(struct seq_file *m, void *v)
 453{
 454	struct usb_serial *serial;
 455	int i;
 456	char tmp[40];
 457
 458	dbg("%s", __func__);
 459	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 460	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 461		serial = usb_serial_get_by_index(i);
 462		if (serial == NULL)
 463			continue;
 464
 465		seq_printf(m, "%d:", i);
 466		if (serial->type->driver.owner)
 467			seq_printf(m, " module:%s",
 468				module_name(serial->type->driver.owner));
 469		seq_printf(m, " name:\"%s\"",
 470				serial->type->description);
 471		seq_printf(m, " vendor:%04x product:%04x",
 472			le16_to_cpu(serial->dev->descriptor.idVendor),
 473			le16_to_cpu(serial->dev->descriptor.idProduct));
 474		seq_printf(m, " num_ports:%d", serial->num_ports);
 475		seq_printf(m, " port:%d", i - serial->minor + 1);
 476		usb_make_path(serial->dev, tmp, sizeof(tmp));
 477		seq_printf(m, " path:%s", tmp);
 478
 479		seq_putc(m, '\n');
 480		usb_serial_put(serial);
 481		mutex_unlock(&serial->disc_mutex);
 482	}
 483	return 0;
 484}
 485
 486static int serial_proc_open(struct inode *inode, struct file *file)
 487{
 488	return single_open(file, serial_proc_show, NULL);
 489}
 490
 491static const struct file_operations serial_proc_fops = {
 492	.owner		= THIS_MODULE,
 493	.open		= serial_proc_open,
 494	.read		= seq_read,
 495	.llseek		= seq_lseek,
 496	.release	= single_release,
 497};
 498
 499static int serial_tiocmget(struct tty_struct *tty)
 500{
 501	struct usb_serial_port *port = tty->driver_data;
 502
 503	dbg("%s - port %d", __func__, port->number);
 504
 505	if (port->serial->type->tiocmget)
 506		return port->serial->type->tiocmget(tty);
 507	return -EINVAL;
 508}
 509
 510static int serial_tiocmset(struct tty_struct *tty,
 511			    unsigned int set, unsigned int clear)
 512{
 513	struct usb_serial_port *port = tty->driver_data;
 514
 515	dbg("%s - port %d", __func__, port->number);
 516
 517	if (port->serial->type->tiocmset)
 518		return port->serial->type->tiocmset(tty, set, clear);
 519	return -EINVAL;
 520}
 521
 522static int serial_get_icount(struct tty_struct *tty,
 523				struct serial_icounter_struct *icount)
 524{
 525	struct usb_serial_port *port = tty->driver_data;
 526
 527	dbg("%s - port %d", __func__, port->number);
 528
 529	if (port->serial->type->get_icount)
 530		return port->serial->type->get_icount(tty, icount);
 531	return -EINVAL;
 532}
 533
 534/*
 535 * We would be calling tty_wakeup here, but unfortunately some line
 536 * disciplines have an annoying habit of calling tty->write from
 537 * the write wakeup callback (e.g. n_hdlc.c).
 538 */
 539void usb_serial_port_softint(struct usb_serial_port *port)
 540{
 541	schedule_work(&port->work);
 542}
 543EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 544
 545static void usb_serial_port_work(struct work_struct *work)
 546{
 547	struct usb_serial_port *port =
 548		container_of(work, struct usb_serial_port, work);
 549	struct tty_struct *tty;
 550
 551	dbg("%s - port %d", __func__, port->number);
 552
 553	tty = tty_port_tty_get(&port->port);
 554	if (!tty)
 555		return;
 556
 557	tty_wakeup(tty);
 558	tty_kref_put(tty);
 559}
 560
 561static void kill_traffic(struct usb_serial_port *port)
 562{
 563	int i;
 564
 565	usb_kill_urb(port->read_urb);
 566	usb_kill_urb(port->write_urb);
 567	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 568		usb_kill_urb(port->write_urbs[i]);
 569	/*
 570	 * This is tricky.
 571	 * Some drivers submit the read_urb in the
 572	 * handler for the write_urb or vice versa
 573	 * this order determines the order in which
 574	 * usb_kill_urb() must be used to reliably
 575	 * kill the URBs. As it is unknown here,
 576	 * both orders must be used in turn.
 577	 * The call below is not redundant.
 578	 */
 579	usb_kill_urb(port->read_urb);
 580	usb_kill_urb(port->interrupt_in_urb);
 581	usb_kill_urb(port->interrupt_out_urb);
 582}
 583
 584static void port_release(struct device *dev)
 585{
 586	struct usb_serial_port *port = to_usb_serial_port(dev);
 587	int i;
 588
 589	dbg ("%s - %s", __func__, dev_name(dev));
 590
 591	/*
 592	 * Stop all the traffic before cancelling the work, so that
 593	 * nobody will restart it by calling usb_serial_port_softint.
 594	 */
 595	kill_traffic(port);
 596	cancel_work_sync(&port->work);
 597
 598	usb_free_urb(port->read_urb);
 599	usb_free_urb(port->write_urb);
 600	usb_free_urb(port->interrupt_in_urb);
 601	usb_free_urb(port->interrupt_out_urb);
 
 
 
 
 602	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 603		usb_free_urb(port->write_urbs[i]);
 604		kfree(port->bulk_out_buffers[i]);
 605	}
 606	kfifo_free(&port->write_fifo);
 607	kfree(port->bulk_in_buffer);
 608	kfree(port->bulk_out_buffer);
 609	kfree(port->interrupt_in_buffer);
 610	kfree(port->interrupt_out_buffer);
 611	kfree(port);
 612}
 613
 614static struct usb_serial *create_serial(struct usb_device *dev,
 615					struct usb_interface *interface,
 616					struct usb_serial_driver *driver)
 617{
 618	struct usb_serial *serial;
 619
 620	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 621	if (!serial) {
 622		dev_err(&dev->dev, "%s - out of memory\n", __func__);
 623		return NULL;
 624	}
 625	serial->dev = usb_get_dev(dev);
 626	serial->type = driver;
 627	serial->interface = interface;
 628	kref_init(&serial->kref);
 629	mutex_init(&serial->disc_mutex);
 630	serial->minor = SERIAL_TTY_NO_MINOR;
 631
 632	return serial;
 633}
 634
 635static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 636					    struct usb_serial_driver *drv)
 637{
 638	struct usb_dynid *dynid;
 639
 640	spin_lock(&drv->dynids.lock);
 641	list_for_each_entry(dynid, &drv->dynids.list, node) {
 642		if (usb_match_one_id(intf, &dynid->id)) {
 643			spin_unlock(&drv->dynids.lock);
 644			return &dynid->id;
 645		}
 646	}
 647	spin_unlock(&drv->dynids.lock);
 648	return NULL;
 649}
 650
 651static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 652						struct usb_interface *intf)
 653{
 654	const struct usb_device_id *id;
 655
 656	id = usb_match_id(intf, drv->id_table);
 657	if (id) {
 658		dbg("static descriptor matches");
 659		goto exit;
 660	}
 661	id = match_dynamic_id(intf, drv);
 662	if (id)
 663		dbg("dynamic descriptor matches");
 664exit:
 665	return id;
 666}
 667
 668/* Caller must hold table_lock */
 669static struct usb_serial_driver *search_serial_device(
 670					struct usb_interface *iface)
 671{
 672	const struct usb_device_id *id;
 673	struct usb_serial_driver *drv;
 
 674
 675	/* Check if the usb id matches a known device */
 676	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 677		id = get_iface_id(drv, iface);
 
 678		if (id)
 679			return drv;
 680	}
 681
 682	return NULL;
 683}
 684
 685static int serial_carrier_raised(struct tty_port *port)
 686{
 687	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 688	struct usb_serial_driver *drv = p->serial->type;
 
 689	if (drv->carrier_raised)
 690		return drv->carrier_raised(p);
 691	/* No carrier control - don't block */
 692	return 1;	
 693}
 694
 695static void serial_dtr_rts(struct tty_port *port, int on)
 696{
 697	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 698	struct usb_serial_driver *drv = p->serial->type;
 
 699	if (drv->dtr_rts)
 700		drv->dtr_rts(p, on);
 701}
 702
 703static const struct tty_port_operations serial_port_ops = {
 704	.carrier_raised = serial_carrier_raised,
 705	.dtr_rts = serial_dtr_rts,
 706	.activate = serial_activate,
 707	.shutdown = serial_down,
 708};
 709
 710int usb_serial_probe(struct usb_interface *interface,
 711			       const struct usb_device_id *id)
 712{
 713	struct usb_device *dev = interface_to_usbdev(interface);
 714	struct usb_serial *serial = NULL;
 715	struct usb_serial_port *port;
 716	struct usb_host_interface *iface_desc;
 717	struct usb_endpoint_descriptor *endpoint;
 718	struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 719	struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 720	struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 721	struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 722	struct usb_serial_driver *type = NULL;
 723	int retval;
 724	unsigned int minor;
 725	int buffer_size;
 726	int i;
 
 727	int num_interrupt_in = 0;
 728	int num_interrupt_out = 0;
 729	int num_bulk_in = 0;
 730	int num_bulk_out = 0;
 731	int num_ports = 0;
 732	int max_endpoints;
 733
 734	mutex_lock(&table_lock);
 735	type = search_serial_device(interface);
 736	if (!type) {
 737		mutex_unlock(&table_lock);
 738		dbg("none matched");
 739		return -ENODEV;
 740	}
 741
 742	if (!try_module_get(type->driver.owner)) {
 743		mutex_unlock(&table_lock);
 744		dev_err(&interface->dev, "module get failed, exiting\n");
 745		return -EIO;
 746	}
 747	mutex_unlock(&table_lock);
 748
 749	serial = create_serial(dev, interface, type);
 750	if (!serial) {
 751		module_put(type->driver.owner);
 752		dev_err(&interface->dev, "%s - out of memory\n", __func__);
 753		return -ENOMEM;
 754	}
 755
 756	/* if this device type has a probe function, call it */
 757	if (type->probe) {
 758		const struct usb_device_id *id;
 759
 760		id = get_iface_id(type, interface);
 761		retval = type->probe(serial, id);
 762
 763		if (retval) {
 764			dbg("sub driver rejected device");
 765			kfree(serial);
 766			module_put(type->driver.owner);
 767			return retval;
 768		}
 769	}
 770
 771	/* descriptor matches, let's find the endpoints needed */
 772	/* check out the endpoints */
 773	iface_desc = interface->cur_altsetting;
 774	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 775		endpoint = &iface_desc->endpoint[i].desc;
 776
 777		if (usb_endpoint_is_bulk_in(endpoint)) {
 778			/* we found a bulk in endpoint */
 779			dbg("found bulk in on endpoint %d", i);
 780			bulk_in_endpoint[num_bulk_in] = endpoint;
 781			++num_bulk_in;
 782		}
 783
 784		if (usb_endpoint_is_bulk_out(endpoint)) {
 785			/* we found a bulk out endpoint */
 786			dbg("found bulk out on endpoint %d", i);
 787			bulk_out_endpoint[num_bulk_out] = endpoint;
 788			++num_bulk_out;
 789		}
 790
 791		if (usb_endpoint_is_int_in(endpoint)) {
 792			/* we found a interrupt in endpoint */
 793			dbg("found interrupt in on endpoint %d", i);
 794			interrupt_in_endpoint[num_interrupt_in] = endpoint;
 795			++num_interrupt_in;
 796		}
 797
 798		if (usb_endpoint_is_int_out(endpoint)) {
 799			/* we found an interrupt out endpoint */
 800			dbg("found interrupt out on endpoint %d", i);
 801			interrupt_out_endpoint[num_interrupt_out] = endpoint;
 802			++num_interrupt_out;
 803		}
 804	}
 805
 806#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 807	/* BEGIN HORRIBLE HACK FOR PL2303 */
 808	/* this is needed due to the looney way its endpoints are set up */
 809	if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 810	     (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 811	    ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 812	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 813	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 814	     (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 815	    ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 816	     (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 817		if (interface != dev->actconfig->interface[0]) {
 818			/* check out the endpoints of the other interface*/
 819			iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 820			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 821				endpoint = &iface_desc->endpoint[i].desc;
 822				if (usb_endpoint_is_int_in(endpoint)) {
 823					/* we found a interrupt in endpoint */
 824					dbg("found interrupt in for Prolific device on separate interface");
 825					interrupt_in_endpoint[num_interrupt_in] = endpoint;
 826					++num_interrupt_in;
 827				}
 828			}
 829		}
 830
 831		/* Now make sure the PL-2303 is configured correctly.
 832		 * If not, give up now and hope this hack will work
 833		 * properly during a later invocation of usb_serial_probe
 834		 */
 835		if (num_bulk_in == 0 || num_bulk_out == 0) {
 836			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 837			kfree(serial);
 838			module_put(type->driver.owner);
 839			return -ENODEV;
 840		}
 841	}
 842	/* END HORRIBLE HACK FOR PL2303 */
 843#endif
 844
 845#ifdef CONFIG_USB_SERIAL_GENERIC
 846	if (type == &usb_serial_generic_device) {
 847		num_ports = num_bulk_out;
 848		if (num_ports == 0) {
 849			dev_err(&interface->dev,
 850			    "Generic device with no bulk out, not allowed.\n");
 851			kfree(serial);
 852			module_put(type->driver.owner);
 853			return -EIO;
 854		}
 
 
 855	}
 856#endif
 857	if (!num_ports) {
 858		/* if this device type has a calc_num_ports function, call it */
 859		if (type->calc_num_ports)
 860			num_ports = type->calc_num_ports(serial);
 861		if (!num_ports)
 862			num_ports = type->num_ports;
 863	}
 864
 865	serial->num_ports = num_ports;
 866	serial->num_bulk_in = num_bulk_in;
 867	serial->num_bulk_out = num_bulk_out;
 868	serial->num_interrupt_in = num_interrupt_in;
 869	serial->num_interrupt_out = num_interrupt_out;
 870
 871	/* found all that we need */
 872	dev_info(&interface->dev, "%s converter detected\n",
 873			type->description);
 874
 875	/* create our ports, we need as many as the max endpoints */
 876	/* we don't use num_ports here because some devices have more
 877	   endpoint pairs than ports */
 878	max_endpoints = max(num_bulk_in, num_bulk_out);
 879	max_endpoints = max(max_endpoints, num_interrupt_in);
 880	max_endpoints = max(max_endpoints, num_interrupt_out);
 881	max_endpoints = max(max_endpoints, (int)serial->num_ports);
 882	serial->num_port_pointers = max_endpoints;
 883
 884	dbg("%s - setting up %d port structures for this device",
 885						__func__, max_endpoints);
 886	for (i = 0; i < max_endpoints; ++i) {
 887		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 888		if (!port)
 889			goto probe_error;
 890		tty_port_init(&port->port);
 891		port->port.ops = &serial_port_ops;
 892		port->serial = serial;
 893		spin_lock_init(&port->lock);
 894		/* Keep this for private driver use for the moment but
 895		   should probably go away */
 896		INIT_WORK(&port->work, usb_serial_port_work);
 897		serial->port[i] = port;
 898		port->dev.parent = &interface->dev;
 899		port->dev.driver = NULL;
 900		port->dev.bus = &usb_serial_bus_type;
 901		port->dev.release = &port_release;
 902		device_initialize(&port->dev);
 903	}
 904
 905	/* set up the endpoint information */
 906	for (i = 0; i < num_bulk_in; ++i) {
 907		endpoint = bulk_in_endpoint[i];
 908		port = serial->port[i];
 909		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 910		if (!port->read_urb) {
 911			dev_err(&interface->dev, "No free urbs available\n");
 912			goto probe_error;
 913		}
 914		buffer_size = max_t(int, serial->type->bulk_in_size,
 915				le16_to_cpu(endpoint->wMaxPacketSize));
 916		port->bulk_in_size = buffer_size;
 917		port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 918		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 919		if (!port->bulk_in_buffer) {
 920			dev_err(&interface->dev,
 
 
 
 
 
 
 
 
 
 
 921					"Couldn't allocate bulk_in_buffer\n");
 922			goto probe_error;
 923		}
 924		usb_fill_bulk_urb(port->read_urb, dev,
 925				usb_rcvbulkpipe(dev,
 926						endpoint->bEndpointAddress),
 927				port->bulk_in_buffer, buffer_size,
 928				serial->type->read_bulk_callback, port);
 
 
 
 
 
 929	}
 930
 931	for (i = 0; i < num_bulk_out; ++i) {
 932		int j;
 933
 934		endpoint = bulk_out_endpoint[i];
 935		port = serial->port[i];
 936		port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 937		if (!port->write_urb) {
 938			dev_err(&interface->dev, "No free urbs available\n");
 939			goto probe_error;
 940		}
 941		if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 942			goto probe_error;
 943		buffer_size = serial->type->bulk_out_size;
 944		if (!buffer_size)
 945			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 946		port->bulk_out_size = buffer_size;
 947		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 948		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 949		if (!port->bulk_out_buffer) {
 950			dev_err(&interface->dev,
 951					"Couldn't allocate bulk_out_buffer\n");
 952			goto probe_error;
 953		}
 954		usb_fill_bulk_urb(port->write_urb, dev,
 955				usb_sndbulkpipe(dev,
 956					endpoint->bEndpointAddress),
 957				port->bulk_out_buffer, buffer_size,
 958				serial->type->write_bulk_callback, port);
 959		for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 960			set_bit(j, &port->write_urbs_free);
 961			port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 962			if (!port->write_urbs[j]) {
 963				dev_err(&interface->dev,
 964						"No free urbs available\n");
 965				goto probe_error;
 966			}
 967			port->bulk_out_buffers[j] = kmalloc(buffer_size,
 968								GFP_KERNEL);
 969			if (!port->bulk_out_buffers[j]) {
 970				dev_err(&interface->dev,
 971					"Couldn't allocate bulk_out_buffer\n");
 972				goto probe_error;
 973			}
 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
 983	if (serial->type->read_int_callback) {
 984		for (i = 0; i < num_interrupt_in; ++i) {
 985			endpoint = interrupt_in_endpoint[i];
 986			port = serial->port[i];
 987			port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 988			if (!port->interrupt_in_urb) {
 989				dev_err(&interface->dev,
 990						"No free urbs available\n");
 991				goto probe_error;
 992			}
 993			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 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				dev_err(&interface->dev,
1000				    "Couldn't allocate interrupt_in_buffer\n");
1001				goto probe_error;
1002			}
1003			usb_fill_int_urb(port->interrupt_in_urb, dev,
1004				usb_rcvintpipe(dev,
1005						endpoint->bEndpointAddress),
1006				port->interrupt_in_buffer, buffer_size,
1007				serial->type->read_int_callback, port,
1008				endpoint->bInterval);
1009		}
1010	} else if (num_interrupt_in) {
1011		dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1012	}
1013
1014	if (serial->type->write_int_callback) {
1015		for (i = 0; i < num_interrupt_out; ++i) {
1016			endpoint = interrupt_out_endpoint[i];
1017			port = serial->port[i];
1018			port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1019			if (!port->interrupt_out_urb) {
1020				dev_err(&interface->dev,
1021						"No free urbs available\n");
1022				goto probe_error;
1023			}
1024			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1025			port->interrupt_out_size = buffer_size;
1026			port->interrupt_out_endpointAddress =
1027						endpoint->bEndpointAddress;
1028			port->interrupt_out_buffer = kmalloc(buffer_size,
1029								GFP_KERNEL);
1030			if (!port->interrupt_out_buffer) {
1031				dev_err(&interface->dev,
1032				  "Couldn't allocate interrupt_out_buffer\n");
1033				goto probe_error;
1034			}
1035			usb_fill_int_urb(port->interrupt_out_urb, dev,
1036				usb_sndintpipe(dev,
1037						  endpoint->bEndpointAddress),
1038				port->interrupt_out_buffer, buffer_size,
1039				serial->type->write_int_callback, port,
1040				endpoint->bInterval);
1041		}
1042	} else if (num_interrupt_out) {
1043		dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1044	}
1045
 
 
1046	/* if this device type has an attach function, call it */
1047	if (type->attach) {
1048		retval = type->attach(serial);
1049		if (retval < 0)
1050			goto probe_error;
1051		serial->attached = 1;
1052		if (retval > 0) {
1053			/* quietly accept this device, but don't bind to a
1054			   serial port as it's about to disappear */
1055			serial->num_ports = 0;
1056			goto exit;
1057		}
1058	} else {
1059		serial->attached = 1;
1060	}
1061
 
 
 
 
 
 
1062	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1063		dev_err(&interface->dev, "No more free serial devices\n");
1064		goto probe_error;
1065	}
1066	serial->minor = minor;
1067
1068	/* register all of the individual ports with the driver core */
1069	for (i = 0; i < num_ports; ++i) {
1070		port = serial->port[i];
1071		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1072		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1073		port->dev_state = PORT_REGISTERING;
1074		device_enable_async_suspend(&port->dev);
1075
1076		retval = device_add(&port->dev);
1077		if (retval) {
1078			dev_err(&port->dev, "Error registering port device, "
1079				"continuing\n");
1080			port->dev_state = PORT_UNREGISTERED;
1081		} else {
1082			port->dev_state = PORT_REGISTERED;
1083		}
1084	}
1085
1086	usb_serial_console_init(debug, minor);
1087
 
1088exit:
1089	/* success */
1090	usb_set_intfdata(interface, serial);
1091	module_put(type->driver.owner);
1092	return 0;
1093
1094probe_error:
1095	usb_serial_put(serial);
1096	module_put(type->driver.owner);
1097	return -EIO;
1098}
1099EXPORT_SYMBOL_GPL(usb_serial_probe);
1100
1101void usb_serial_disconnect(struct usb_interface *interface)
1102{
1103	int i;
1104	struct usb_serial *serial = usb_get_intfdata(interface);
1105	struct device *dev = &interface->dev;
1106	struct usb_serial_port *port;
1107
1108	usb_serial_console_disconnect(serial);
1109	dbg("%s", __func__);
1110
1111	mutex_lock(&serial->disc_mutex);
1112	usb_set_intfdata(interface, NULL);
1113	/* must set a flag, to signal subdrivers */
1114	serial->disconnected = 1;
1115	mutex_unlock(&serial->disc_mutex);
1116
1117	for (i = 0; i < serial->num_ports; ++i) {
1118		port = serial->port[i];
1119		if (port) {
1120			struct tty_struct *tty = tty_port_tty_get(&port->port);
1121			if (tty) {
1122				tty_vhangup(tty);
1123				tty_kref_put(tty);
1124			}
1125			kill_traffic(port);
1126			cancel_work_sync(&port->work);
1127			if (port->dev_state == PORT_REGISTERED) {
1128
1129				/* Make sure the port is bound so that the
1130				 * driver's port_remove method is called.
1131				 */
1132				if (!port->dev.driver) {
1133					int rc;
1134
1135					port->dev.driver =
1136							&serial->type->driver;
1137					rc = device_bind_driver(&port->dev);
1138				}
1139				port->dev_state = PORT_UNREGISTERING;
1140				device_del(&port->dev);
1141				port->dev_state = PORT_UNREGISTERED;
1142			}
1143		}
1144	}
1145	serial->type->disconnect(serial);
1146
1147	/* let the last holder of this object cause it to be cleaned up */
1148	usb_serial_put(serial);
1149	dev_info(dev, "device disconnected\n");
1150}
1151EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1152
1153int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1154{
1155	struct usb_serial *serial = usb_get_intfdata(intf);
1156	struct usb_serial_port *port;
1157	int i, r = 0;
1158
1159	serial->suspending = 1;
1160
1161	if (serial->type->suspend) {
1162		r = serial->type->suspend(serial, message);
1163		if (r < 0) {
1164			serial->suspending = 0;
1165			goto err_out;
1166		}
1167	}
1168
1169	for (i = 0; i < serial->num_ports; ++i) {
1170		port = serial->port[i];
1171		if (port)
1172			kill_traffic(port);
1173	}
1174
1175err_out:
1176	return r;
1177}
1178EXPORT_SYMBOL(usb_serial_suspend);
1179
1180int usb_serial_resume(struct usb_interface *intf)
1181{
1182	struct usb_serial *serial = usb_get_intfdata(intf);
1183	int rv;
1184
1185	serial->suspending = 0;
1186	if (serial->type->resume)
1187		rv = serial->type->resume(serial);
1188	else
1189		rv = usb_serial_generic_resume(serial);
1190
1191	return rv;
1192}
1193EXPORT_SYMBOL(usb_serial_resume);
1194
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1195static const struct tty_operations serial_ops = {
1196	.open =			serial_open,
1197	.close =		serial_close,
1198	.write =		serial_write,
1199	.hangup = 		serial_hangup,
1200	.write_room =		serial_write_room,
1201	.ioctl =		serial_ioctl,
1202	.set_termios =		serial_set_termios,
1203	.throttle =		serial_throttle,
1204	.unthrottle =		serial_unthrottle,
1205	.break_ctl =		serial_break,
1206	.chars_in_buffer =	serial_chars_in_buffer,
1207	.tiocmget =		serial_tiocmget,
1208	.tiocmset =		serial_tiocmset,
1209	.get_icount = 		serial_get_icount,
1210	.cleanup = 		serial_cleanup,
1211	.install = 		serial_install,
1212	.proc_fops =		&serial_proc_fops,
1213};
1214
1215
1216struct tty_driver *usb_serial_tty_driver;
1217
 
 
 
 
 
 
 
 
 
 
 
1218static int __init usb_serial_init(void)
1219{
1220	int i;
1221	int result;
1222
1223	usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1224	if (!usb_serial_tty_driver)
1225		return -ENOMEM;
1226
1227	/* Initialize our global data */
1228	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1229		serial_table[i] = NULL;
1230
1231	result = bus_register(&usb_serial_bus_type);
1232	if (result) {
1233		printk(KERN_ERR "usb-serial: %s - registering bus driver "
1234		       "failed\n", __func__);
1235		goto exit_bus;
1236	}
1237
1238	usb_serial_tty_driver->owner = THIS_MODULE;
1239	usb_serial_tty_driver->driver_name = "usbserial";
1240	usb_serial_tty_driver->name = 	"ttyUSB";
1241	usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1242	usb_serial_tty_driver->minor_start = 0;
1243	usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1244	usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1245	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1246						TTY_DRIVER_DYNAMIC_DEV;
1247	usb_serial_tty_driver->init_termios = tty_std_termios;
1248	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1249							| HUPCL | CLOCAL;
1250	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1251	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1252	tty_set_operations(usb_serial_tty_driver, &serial_ops);
1253	result = tty_register_driver(usb_serial_tty_driver);
1254	if (result) {
1255		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1256		       __func__);
1257		goto exit_reg_driver;
1258	}
1259
1260	/* register the USB driver */
1261	result = usb_register(&usb_serial_driver);
1262	if (result < 0) {
1263		printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1264		       __func__);
1265		goto exit_tty;
1266	}
1267
1268	/* register the generic driver, if we should */
1269	result = usb_serial_generic_register(debug);
1270	if (result < 0) {
1271		printk(KERN_ERR "usb-serial: %s - registering generic "
1272		       "driver failed\n", __func__);
1273		goto exit_generic;
1274	}
1275
1276	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1277
1278	return result;
1279
1280exit_generic:
1281	usb_deregister(&usb_serial_driver);
1282
1283exit_tty:
1284	tty_unregister_driver(usb_serial_tty_driver);
1285
1286exit_reg_driver:
1287	bus_unregister(&usb_serial_bus_type);
1288
1289exit_bus:
1290	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1291	       __func__, result);
1292	put_tty_driver(usb_serial_tty_driver);
1293	return result;
1294}
1295
1296
1297static void __exit usb_serial_exit(void)
1298{
1299	usb_serial_console_exit();
1300
1301	usb_serial_generic_deregister();
1302
1303	usb_deregister(&usb_serial_driver);
1304	tty_unregister_driver(usb_serial_tty_driver);
1305	put_tty_driver(usb_serial_tty_driver);
1306	bus_unregister(&usb_serial_bus_type);
1307}
1308
1309
1310module_init(usb_serial_init);
1311module_exit(usb_serial_exit);
1312
1313#define set_to_generic_if_null(type, function)				\
1314	do {								\
1315		if (!type->function) {					\
1316			type->function = usb_serial_generic_##function;	\
1317			dbg("Had to override the " #function		\
1318				" usb serial operation with the generic one.");\
1319			}						\
1320	} while (0)
1321
1322static void fixup_generic(struct usb_serial_driver *device)
1323{
1324	set_to_generic_if_null(device, open);
1325	set_to_generic_if_null(device, write);
1326	set_to_generic_if_null(device, close);
1327	set_to_generic_if_null(device, write_room);
1328	set_to_generic_if_null(device, chars_in_buffer);
1329	set_to_generic_if_null(device, read_bulk_callback);
1330	set_to_generic_if_null(device, write_bulk_callback);
1331	set_to_generic_if_null(device, disconnect);
1332	set_to_generic_if_null(device, release);
1333	set_to_generic_if_null(device, process_read_urb);
1334	set_to_generic_if_null(device, prepare_write_buffer);
1335}
1336
1337int usb_serial_register(struct usb_serial_driver *driver)
1338{
1339	/* must be called with BKL held */
1340	int retval;
1341
1342	if (usb_disabled())
1343		return -ENODEV;
1344
1345	fixup_generic(driver);
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	driver->usb_driver->supports_autosuspend = 1;
1355
1356	/* Add this device to our list of devices */
1357	mutex_lock(&table_lock);
1358	list_add(&driver->driver_list, &usb_serial_driver_list);
1359
1360	retval = usb_serial_bus_register(driver);
1361	if (retval) {
1362		printk(KERN_ERR "usb-serial: problem %d when registering "
1363		       "driver %s\n", retval, driver->description);
1364		list_del(&driver->driver_list);
1365	} else
1366		printk(KERN_INFO "USB Serial support registered for %s\n",
1367						driver->description);
1368
1369	mutex_unlock(&table_lock);
1370	return retval;
1371}
1372EXPORT_SYMBOL_GPL(usb_serial_register);
1373
1374
1375void usb_serial_deregister(struct usb_serial_driver *device)
1376{
1377	/* must be called with BKL held */
1378	printk(KERN_INFO "USB Serial deregistering driver %s\n",
1379	       device->description);
1380	mutex_lock(&table_lock);
1381	list_del(&device->driver_list);
1382	usb_serial_bus_deregister(device);
1383	mutex_unlock(&table_lock);
1384}
1385EXPORT_SYMBOL_GPL(usb_serial_deregister);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1386
1387/* Module information */
1388MODULE_AUTHOR(DRIVER_AUTHOR);
1389MODULE_DESCRIPTION(DRIVER_DESC);
1390MODULE_LICENSE("GPL");
1391
1392module_param(debug, bool, S_IRUGO | S_IWUSR);
1393MODULE_PARM_DESC(debug, "Debug enabled or not");