usb-serial.c 37.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * USB Serial Converter driver
 *
4
 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
L
Linus Torvalds 已提交
5 6 7 8 9 10 11
 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 *
12
 * This driver was originally based on the ACM driver by Armin Fuerst (which was
L
Linus Torvalds 已提交
13 14
 * based on a driver by Brad Keryan)
 *
A
Alan Cox 已提交
15 16
 * See Documentation/usb/usb-serial.txt for more information on using this
 * driver
L
Linus Torvalds 已提交
17 18 19 20 21 22 23
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
A
Alexey Dobriyan 已提交
24
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
25 26 27 28 29
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
30
#include <linux/seq_file.h>
L
Linus Torvalds 已提交
31
#include <linux/spinlock.h>
32
#include <linux/mutex.h>
L
Linus Torvalds 已提交
33
#include <linux/list.h>
A
Alan Cox 已提交
34
#include <linux/uaccess.h>
35
#include <linux/serial.h>
L
Linus Torvalds 已提交
36
#include <linux/usb.h>
37
#include <linux/usb/serial.h>
38
#include <linux/kfifo.h>
L
Linus Torvalds 已提交
39 40 41 42 43 44 45 46 47 48 49 50 51
#include "pl2303.h"

/*
 * Version Information
 */
#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
#define DRIVER_DESC "USB Serial Driver core"

/* Driver structure we register with the USB core */
static struct usb_driver usb_serial_driver = {
	.name =		"usbserial",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
52 53
	.suspend =	usb_serial_suspend,
	.resume =	usb_serial_resume,
54
	.no_dynamic_id = 	1,
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63 64
};

/* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
   the MODULE_DEVICE_TABLE declarations in each serial driver
   cause the "hotplug" program to pull in whatever module is necessary
   via modprobe, and modprobe will load usbserial because the serial
   drivers depend on it.
*/

static int debug;
A
Alan Cox 已提交
65 66
/* initially all NULL */
static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
67
static DEFINE_MUTEX(table_lock);
L
Linus Torvalds 已提交
68 69
static LIST_HEAD(usb_serial_driver_list);

70 71 72 73 74
/*
 * Look up the serial structure.  If it is found and it hasn't been
 * disconnected, return with its disc_mutex held and its refcount
 * incremented.  Otherwise return NULL.
 */
L
Linus Torvalds 已提交
75 76
struct usb_serial *usb_serial_get_by_index(unsigned index)
{
77 78
	struct usb_serial *serial;

79
	mutex_lock(&table_lock);
80
	serial = serial_table[index];
L
Linus Torvalds 已提交
81

82 83 84 85 86 87 88 89 90
	if (serial) {
		mutex_lock(&serial->disc_mutex);
		if (serial->disconnected) {
			mutex_unlock(&serial->disc_mutex);
			serial = NULL;
		} else {
			kref_get(&serial->kref);
		}
	}
91
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
92 93 94
	return serial;
}

A
Alan Cox 已提交
95 96
static struct usb_serial *get_free_serial(struct usb_serial *serial,
					int num_ports, unsigned int *minor)
L
Linus Torvalds 已提交
97 98 99 100
{
	unsigned int i, j;
	int good_spot;

101
	dbg("%s %d", __func__, num_ports);
L
Linus Torvalds 已提交
102 103

	*minor = 0;
104
	mutex_lock(&table_lock);
L
Linus Torvalds 已提交
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
		if (serial_table[i])
			continue;

		good_spot = 1;
		for (j = 1; j <= num_ports-1; ++j)
			if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
				good_spot = 0;
				i += j;
				break;
			}
		if (good_spot == 0)
			continue;

		*minor = i;
O
Oliver Neukum 已提交
120
		j = 0;
121
		dbg("%s - minor base = %d", __func__, *minor);
O
Oliver Neukum 已提交
122
		for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
L
Linus Torvalds 已提交
123
			serial_table[i] = serial;
O
Oliver Neukum 已提交
124 125
			serial->port[j++]->number = i;
		}
126
		mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
127 128
		return serial;
	}
129
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
130 131 132 133 134 135 136
	return NULL;
}

static void return_serial(struct usb_serial *serial)
{
	int i;

137
	dbg("%s", __func__);
L
Linus Torvalds 已提交
138

139
	mutex_lock(&table_lock);
A
Alan Cox 已提交
140
	for (i = 0; i < serial->num_ports; ++i)
L
Linus Torvalds 已提交
141
		serial_table[serial->minor + i] = NULL;
142
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
143 144 145 146 147 148 149 150 151 152
}

static void destroy_serial(struct kref *kref)
{
	struct usb_serial *serial;
	struct usb_serial_port *port;
	int i;

	serial = to_usb_serial(kref);

153
	dbg("%s - %s", __func__, serial->type->description);
L
Linus Torvalds 已提交
154

J
Jim Radford 已提交
155
	/* return the minor range that this device had */
156 157
	if (serial->minor != SERIAL_TTY_NO_MINOR)
		return_serial(serial);
J
Jim Radford 已提交
158

159 160
	serial->type->release(serial);

161 162
	/* Now that nothing is using the ports, they can be freed */
	for (i = 0; i < serial->num_port_pointers; ++i) {
163
		port = serial->port[i];
164 165
		if (port) {
			port->serial = NULL;
166
			put_device(&port->dev);
L
Linus Torvalds 已提交
167 168 169 170
		}
	}

	usb_put_dev(serial->dev);
A
Alan Cox 已提交
171
	kfree(serial);
L
Linus Torvalds 已提交
172 173
}

174 175 176 177 178
void usb_serial_put(struct usb_serial *serial)
{
	kref_put(&serial->kref, destroy_serial);
}

L
Linus Torvalds 已提交
179 180 181
/*****************************************************************************
 * Driver tty interface functions
 *****************************************************************************/
182 183 184 185 186 187 188 189 190

/**
 * serial_install - install tty
 * @driver: the driver (USB in our case)
 * @tty: the tty being created
 *
 * Create the termios objects for this tty.  We use the default
 * USB serial settings but permit them to be overridden by
 * serial->type->init_termios.
191 192 193 194
 *
 * This is the first place a new tty gets used.  Hence this is where we
 * acquire references to the usb_serial structure and the driver module,
 * where we store a pointer to the port, and where we do an autoresume.
A
Alan Stern 已提交
195
 * All these actions are reversed in serial_release().
196 197 198 199 200
 */
static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
{
	int idx = tty->index;
	struct usb_serial *serial;
201 202 203
	struct usb_serial_port *port;
	int retval = -ENODEV;

204 205
	dbg("%s", __func__);

206 207 208 209 210 211 212 213 214 215
	serial = usb_serial_get_by_index(idx);
	if (!serial)
		return retval;

	port = serial->port[idx - serial->minor];
	if (!port)
		goto error_no_port;
	if (!try_module_get(serial->type->driver.owner))
		goto error_module_get;

216 217 218 219 220
	/* perform the standard setup */
	retval = tty_init_termios(tty);
	if (retval)
		goto error_init_termios;

221 222 223
	retval = usb_autopm_get_interface(serial->interface);
	if (retval)
		goto error_get_interface;
224

225 226
	mutex_unlock(&serial->disc_mutex);

227 228 229 230
	/* allow the driver to update the settings */
	if (serial->type->init_termios)
		serial->type->init_termios(tty);

231 232
	tty->driver_data = port;

233 234 235 236
	/* Final install (we use the default method) */
	tty_driver_kref_get(driver);
	tty->count++;
	driver->ttys[idx] = tty;
237 238 239
	return retval;

 error_get_interface:
240
 error_init_termios:
241 242 243 244 245 246
	module_put(serial->type->driver.owner);
 error_module_get:
 error_no_port:
	usb_serial_put(serial);
	mutex_unlock(&serial->disc_mutex);
	return retval;
247 248
}

249
static int serial_open(struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
250
{
251 252 253
	struct usb_serial_port *port = tty->driver_data;
	struct usb_serial *serial = port->serial;
	int retval;
254

255 256
	dbg("%s - port %d", __func__, port->number);

257 258 259 260
	spin_lock_irq(&port->port.lock);
	if (!tty_hung_up_p(filp))
		++port->port.count;
	spin_unlock_irq(&port->port.lock);
A
Alan Cox 已提交
261
	tty_port_tty_set(&port->port, tty);
L
Linus Torvalds 已提交
262

263 264 265 266 267 268
	/* Do the device-specific open only if the hardware isn't
	 * already initialized.
	 */
	if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
		if (mutex_lock_interruptible(&port->mutex))
			return -ERESTARTSYS;
269
		mutex_lock(&serial->disc_mutex);
270 271 272 273
		if (serial->disconnected)
			retval = -ENODEV;
		else
			retval = port->serial->type->open(tty, port);
274
		mutex_unlock(&serial->disc_mutex);
275 276 277
		mutex_unlock(&port->mutex);
		if (retval)
			return retval;
278
		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
L
Linus Torvalds 已提交
279
	}
280

281 282
	/* Now do the correct tty layer semantics */
	retval = tty_port_block_til_ready(&port->port, tty, filp);
L
Linus Torvalds 已提交
283 284 285
	return retval;
}

286
/**
A
Alan Stern 已提交
287
 * serial_down - shut down hardware
288
 * @port: port to shut down
289
 *
290 291
 * Shut down a USB serial port unless it is the console.  We never
 * shut down the console hardware as it will always be in use.
292
 */
A
Alan Stern 已提交
293
static void serial_down(struct usb_serial_port *port)
L
Linus Torvalds 已提交
294
{
295
	struct usb_serial_driver *drv = port->serial->type;
L
Linus Torvalds 已提交
296

297 298 299 300
	/*
	 * The console is magical.  Do not hang up the console hardware
	 * or there will be tears.
	 */
301
	if (port->console)
L
Linus Torvalds 已提交
302 303
		return;

304 305 306 307 308 309
	/* Don't call the close method if the hardware hasn't been
	 * initialized.
	 */
	if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
		return;

310
	mutex_lock(&port->mutex);
311 312
	if (drv->close)
		drv->close(port);
313
	mutex_unlock(&port->mutex);
314 315
}

316 317 318
static void serial_hangup(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
319 320 321

	dbg("%s - port %d", __func__, port->number);

A
Alan Stern 已提交
322
	serial_down(port);
323 324 325 326 327 328 329 330 331
	tty_port_hangup(&port->port);
}

static void serial_close(struct tty_struct *tty, struct file *filp)
{
	struct usb_serial_port *port = tty->driver_data;

	dbg("%s - port %d", __func__, port->number);

332 333
	if (tty_hung_up_p(filp))
		return;
334 335
	if (tty_port_close_start(&port->port, tty, filp) == 0)
		return;
A
Alan Stern 已提交
336
	serial_down(port);
337 338 339 340
	tty_port_close_end(&port->port, tty);
	tty_port_tty_set(&port->port, NULL);
}

341
/**
A
Alan Stern 已提交
342
 * serial_release - free resources post close/hangup
343
 * @port: port to free up
344
 *
345 346
 * Do the resource freeing and refcount dropping for the port.
 * Avoid freeing the console.
347
 *
348
 * Called when the last tty kref is dropped.
349
 */
A
Alan Stern 已提交
350
static void serial_release(struct tty_struct *tty)
351
{
352
	struct usb_serial_port *port = tty->driver_data;
353 354 355
	struct usb_serial *serial;
	struct module *owner;

356 357 358
	/* The console is magical.  Do not hang up the console hardware
	 * or there will be tears.
	 */
359
	if (port->console)
360 361
		return;

362 363
	dbg("%s - port %d", __func__, port->number);

A
Alan Stern 已提交
364 365 366
	/* Standard shutdown processing */
	tty_shutdown(tty);

367 368
	tty->driver_data = NULL;

369 370
	serial = port->serial;
	owner = serial->type->driver.owner;
371

372 373 374 375
	mutex_lock(&serial->disc_mutex);
	if (!serial->disconnected)
		usb_autopm_put_interface(serial->interface);
	mutex_unlock(&serial->disc_mutex);
376

377
	usb_serial_put(serial);
378 379 380
	module_put(owner);
}

A
Alan Cox 已提交
381 382
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
								int count)
L
Linus Torvalds 已提交
383
{
384
	struct usb_serial_port *port = tty->driver_data;
385
	int retval = -ENODEV;
L
Linus Torvalds 已提交
386

A
Alan Cox 已提交
387
	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
388 389
		goto exit;

390
	dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
L
Linus Torvalds 已提交
391

A
Alan Cox 已提交
392
	/* count is managed under the mutex lock for the tty so cannot
A
Alan Cox 已提交
393
	   drop to zero until after the last close completes */
A
Alan Cox 已提交
394
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
395 396

	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
397
	retval = port->serial->type->write(tty, port, buf, count);
L
Linus Torvalds 已提交
398 399 400 401 402

exit:
	return retval;
}

A
Alan Cox 已提交
403
static int serial_write_room(struct tty_struct *tty)
L
Linus Torvalds 已提交
404
{
405
	struct usb_serial_port *port = tty->driver_data;
406
	dbg("%s - port %d", __func__, port->number);
A
Alan Cox 已提交
407
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
408
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
409
	return port->serial->type->write_room(tty);
L
Linus Torvalds 已提交
410 411
}

A
Alan Cox 已提交
412
static int serial_chars_in_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
413
{
414
	struct usb_serial_port *port = tty->driver_data;
415
	dbg("%s = port %d", __func__, port->number);
L
Linus Torvalds 已提交
416

417 418 419 420
	/* if the device was unplugged then any remaining characters
	   fell out of the connector ;) */
	if (port->serial->disconnected)
		return 0;
L
Linus Torvalds 已提交
421
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
422
	return port->serial->type->chars_in_buffer(tty);
L
Linus Torvalds 已提交
423 424
}

A
Alan Cox 已提交
425
static void serial_throttle(struct tty_struct *tty)
L
Linus Torvalds 已提交
426
{
427
	struct usb_serial_port *port = tty->driver_data;
428
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
429

A
Alan Cox 已提交
430
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
431 432
	/* pass on to the driver specific version of this function */
	if (port->serial->type->throttle)
A
Alan Cox 已提交
433
		port->serial->type->throttle(tty);
L
Linus Torvalds 已提交
434 435
}

A
Alan Cox 已提交
436
static void serial_unthrottle(struct tty_struct *tty)
L
Linus Torvalds 已提交
437
{
438
	struct usb_serial_port *port = tty->driver_data;
439
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
440

A
Alan Cox 已提交
441
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
442 443
	/* pass on to the driver specific version of this function */
	if (port->serial->type->unthrottle)
A
Alan Cox 已提交
444
		port->serial->type->unthrottle(tty);
L
Linus Torvalds 已提交
445 446
}

A
Alan Cox 已提交
447 448
static int serial_ioctl(struct tty_struct *tty, struct file *file,
					unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
449
{
450
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
451 452
	int retval = -ENODEV;

453
	dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
L
Linus Torvalds 已提交
454

A
Alan Cox 已提交
455
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
456

A
Alan Cox 已提交
457 458
	/* pass on to the driver specific version of this function
	   if it is available */
A
Alan Cox 已提交
459
	if (port->serial->type->ioctl) {
A
Alan Cox 已提交
460
		retval = port->serial->type->ioctl(tty, file, cmd, arg);
A
Alan Cox 已提交
461
	} else
L
Linus Torvalds 已提交
462 463 464 465
		retval = -ENOIOCTLCMD;
	return retval;
}

A
Alan Cox 已提交
466
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
L
Linus Torvalds 已提交
467
{
468
	struct usb_serial_port *port = tty->driver_data;
469
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
470

A
Alan Cox 已提交
471
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
472 473
	/* pass on to the driver specific version of this function
	   if it is available */
L
Linus Torvalds 已提交
474
	if (port->serial->type->set_termios)
A
Alan Cox 已提交
475
		port->serial->type->set_termios(tty, port, old);
476 477
	else
		tty_termios_copy_hw(tty->termios, old);
L
Linus Torvalds 已提交
478 479
}

A
Alan Cox 已提交
480
static int serial_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
481
{
482
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
483

484
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
485

A
Alan Cox 已提交
486
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
487 488
	/* pass on to the driver specific version of this function
	   if it is available */
489
	if (port->serial->type->break_ctl)
A
Alan Cox 已提交
490
		port->serial->type->break_ctl(tty, break_state);
A
Alan Cox 已提交
491
	return 0;
L
Linus Torvalds 已提交
492 493
}

494
static int serial_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
495 496 497 498 499
{
	struct usb_serial *serial;
	int i;
	char tmp[40];

500
	dbg("%s", __func__);
501 502
	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
L
Linus Torvalds 已提交
503 504 505 506
		serial = usb_serial_get_by_index(i);
		if (serial == NULL)
			continue;

507
		seq_printf(m, "%d:", i);
508
		if (serial->type->driver.owner)
509
			seq_printf(m, " module:%s",
A
Alan Cox 已提交
510
				module_name(serial->type->driver.owner));
511
		seq_printf(m, " name:\"%s\"",
A
Alan Cox 已提交
512
				serial->type->description);
513
		seq_printf(m, " vendor:%04x product:%04x",
A
Alan Cox 已提交
514 515
			le16_to_cpu(serial->dev->descriptor.idVendor),
			le16_to_cpu(serial->dev->descriptor.idProduct));
516 517
		seq_printf(m, " num_ports:%d", serial->num_ports);
		seq_printf(m, " port:%d", i - serial->minor + 1);
L
Linus Torvalds 已提交
518
		usb_make_path(serial->dev, tmp, sizeof(tmp));
519
		seq_printf(m, " path:%s", tmp);
A
Alan Cox 已提交
520

521
		seq_putc(m, '\n');
522
		usb_serial_put(serial);
523
		mutex_unlock(&serial->disc_mutex);
L
Linus Torvalds 已提交
524
	}
525
	return 0;
L
Linus Torvalds 已提交
526 527
}

528 529 530 531 532 533 534 535 536 537 538 539 540
static int serial_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, serial_proc_show, NULL);
}

static const struct file_operations serial_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= serial_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

A
Alan Cox 已提交
541
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
542
{
543
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
544

545
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
546

A
Alan Cox 已提交
547
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
548
	if (port->serial->type->tiocmget)
A
Alan Cox 已提交
549
		return port->serial->type->tiocmget(tty, file);
L
Linus Torvalds 已提交
550 551 552
	return -EINVAL;
}

A
Alan Cox 已提交
553
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
554 555
			    unsigned int set, unsigned int clear)
{
556
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
557

558
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
559

A
Alan Cox 已提交
560
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
561
	if (port->serial->type->tiocmset)
A
Alan Cox 已提交
562
		return port->serial->type->tiocmset(tty, file, set, clear);
L
Linus Torvalds 已提交
563 564 565
	return -EINVAL;
}

566 567 568 569 570 571 572 573 574
/*
 * We would be calling tty_wakeup here, but unfortunately some line
 * disciplines have an annoying habit of calling tty->write from
 * the write wakeup callback (e.g. n_hdlc.c).
 */
void usb_serial_port_softint(struct usb_serial_port *port)
{
	schedule_work(&port->work);
}
A
Alan Cox 已提交
575
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
576

D
David Howells 已提交
577
static void usb_serial_port_work(struct work_struct *work)
L
Linus Torvalds 已提交
578
{
D
David Howells 已提交
579 580
	struct usb_serial_port *port =
		container_of(work, struct usb_serial_port, work);
L
Linus Torvalds 已提交
581 582
	struct tty_struct *tty;

583
	dbg("%s - port %d", __func__, port->number);
A
Alan Cox 已提交
584

A
Alan Cox 已提交
585
	tty = tty_port_tty_get(&port->port);
L
Linus Torvalds 已提交
586 587 588 589
	if (!tty)
		return;

	tty_wakeup(tty);
A
Alan Cox 已提交
590
	tty_kref_put(tty);
L
Linus Torvalds 已提交
591 592
}

593
static void kill_traffic(struct usb_serial_port *port)
594
{
L
Linus Torvalds 已提交
595 596
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
597 598 599 600 601 602 603 604 605 606 607
	/*
	 * This is tricky.
	 * Some drivers submit the read_urb in the
	 * handler for the write_urb or vice versa
	 * this order determines the order in which
	 * usb_kill_urb() must be used to reliably
	 * kill the URBs. As it is unknown here,
	 * both orders must be used in turn.
	 * The call below is not redundant.
	 */
	usb_kill_urb(port->read_urb);
L
Linus Torvalds 已提交
608 609
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
610 611
}

612
static void port_release(struct device *dev)
613
{
614 615 616 617
	struct usb_serial_port *port = to_usb_serial_port(dev);

	dbg ("%s - %s", __func__, dev_name(dev));

618 619 620 621
	/*
	 * Stop all the traffic before cancelling the work, so that
	 * nobody will restart it by calling usb_serial_port_softint.
	 */
622
	kill_traffic(port);
623 624
	cancel_work_sync(&port->work);

625 626 627
	usb_free_urb(port->read_urb);
	usb_free_urb(port->write_urb);
	usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
628
	usb_free_urb(port->interrupt_out_urb);
629 630
	if (!IS_ERR(port->write_fifo) && port->write_fifo)
		kfifo_free(port->write_fifo);
L
Linus Torvalds 已提交
631 632 633 634 635 636 637
	kfree(port->bulk_in_buffer);
	kfree(port->bulk_out_buffer);
	kfree(port->interrupt_in_buffer);
	kfree(port->interrupt_out_buffer);
	kfree(port);
}

A
Alan Cox 已提交
638 639 640
static struct usb_serial *create_serial(struct usb_device *dev,
					struct usb_interface *interface,
					struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
641 642 643
{
	struct usb_serial *serial;

644
	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
L
Linus Torvalds 已提交
645
	if (!serial) {
646
		dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
647 648 649
		return NULL;
	}
	serial->dev = usb_get_dev(dev);
650
	serial->type = driver;
L
Linus Torvalds 已提交
651 652
	serial->interface = interface;
	kref_init(&serial->kref);
653
	mutex_init(&serial->disc_mutex);
654
	serial->minor = SERIAL_TTY_NO_MINOR;
L
Linus Torvalds 已提交
655 656 657 658

	return serial;
}

659
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
660
					    struct usb_serial_driver *drv)
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
{
	struct usb_dynid *dynid;

	spin_lock(&drv->dynids.lock);
	list_for_each_entry(dynid, &drv->dynids.list, node) {
		if (usb_match_one_id(intf, &dynid->id)) {
			spin_unlock(&drv->dynids.lock);
			return &dynid->id;
		}
	}
	spin_unlock(&drv->dynids.lock);
	return NULL;
}

static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
						struct usb_interface *intf)
{
	const struct usb_device_id *id;

	id = usb_match_id(intf, drv->id_table);
	if (id) {
		dbg("static descriptor matches");
		goto exit;
	}
	id = match_dynamic_id(intf, drv);
	if (id)
		dbg("dynamic descriptor matches");
exit:
	return id;
}

A
Alan Cox 已提交
692 693
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
694 695
{
	const struct usb_device_id *id;
696
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
697

A
Adrian Bunk 已提交
698
	/* Check if the usb id matches a known device */
699 700
	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
		id = get_iface_id(drv, iface);
701
		if (id)
702
			return drv;
L
Linus Torvalds 已提交
703 704 705 706 707
	}

	return NULL;
}

708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
static int serial_carrier_raised(struct tty_port *port)
{
	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
	struct usb_serial_driver *drv = p->serial->type;
	if (drv->carrier_raised)
		return drv->carrier_raised(p);
	/* No carrier control - don't block */
	return 1;	
}

static void serial_dtr_rts(struct tty_port *port, int on)
{
	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
	struct usb_serial_driver *drv = p->serial->type;
	if (drv->dtr_rts)
		drv->dtr_rts(p, on);
}

static const struct tty_port_operations serial_port_ops = {
	.carrier_raised = serial_carrier_raised,
	.dtr_rts = serial_dtr_rts,
};

L
Linus Torvalds 已提交
731 732 733
int usb_serial_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
A
Alan Cox 已提交
734
	struct usb_device *dev = interface_to_usbdev(interface);
L
Linus Torvalds 已提交
735 736 737 738 739 740 741 742
	struct usb_serial *serial = NULL;
	struct usb_serial_port *port;
	struct usb_host_interface *iface_desc;
	struct usb_endpoint_descriptor *endpoint;
	struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
	struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
	struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
	struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
743
	struct usb_serial_driver *type = NULL;
L
Linus Torvalds 已提交
744
	int retval;
745
	unsigned int minor;
L
Linus Torvalds 已提交
746 747 748 749 750 751 752 753 754
	int buffer_size;
	int i;
	int num_interrupt_in = 0;
	int num_interrupt_out = 0;
	int num_bulk_in = 0;
	int num_bulk_out = 0;
	int num_ports = 0;
	int max_endpoints;

755
	lock_kernel(); /* guard against unloading a serial driver module */
L
Linus Torvalds 已提交
756 757
	type = search_serial_device(interface);
	if (!type) {
758
		unlock_kernel();
L
Linus Torvalds 已提交
759 760 761 762
		dbg("none matched");
		return -ENODEV;
	}

A
Alan Cox 已提交
763
	serial = create_serial(dev, interface, type);
L
Linus Torvalds 已提交
764
	if (!serial) {
765
		unlock_kernel();
766
		dev_err(&interface->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
767 768 769 770 771 772 773
		return -ENOMEM;
	}

	/* if this device type has a probe function, call it */
	if (type->probe) {
		const struct usb_device_id *id;

774
		if (!try_module_get(type->driver.owner)) {
775
			unlock_kernel();
A
Alan Cox 已提交
776 777 778
			dev_err(&interface->dev,
				"module get failed, exiting\n");
			kfree(serial);
L
Linus Torvalds 已提交
779 780 781
			return -EIO;
		}

782
		id = get_iface_id(type, interface);
L
Linus Torvalds 已提交
783
		retval = type->probe(serial, id);
784
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
785 786

		if (retval) {
787
			unlock_kernel();
A
Alan Cox 已提交
788 789
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
790 791 792 793 794 795 796 797 798
			return retval;
		}
	}

	/* descriptor matches, let's find the endpoints needed */
	/* check out the endpoints */
	iface_desc = interface->cur_altsetting;
	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
		endpoint = &iface_desc->endpoint[i].desc;
799 800

		if (usb_endpoint_is_bulk_in(endpoint)) {
L
Linus Torvalds 已提交
801 802 803 804 805 806
			/* we found a bulk in endpoint */
			dbg("found bulk in on endpoint %d", i);
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;
		}

807
		if (usb_endpoint_is_bulk_out(endpoint)) {
L
Linus Torvalds 已提交
808 809 810 811 812
			/* we found a bulk out endpoint */
			dbg("found bulk out on endpoint %d", i);
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
		}
813 814

		if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
815 816 817 818 819 820
			/* we found a interrupt in endpoint */
			dbg("found interrupt in on endpoint %d", i);
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
		}

821
		if (usb_endpoint_is_int_out(endpoint)) {
L
Linus Torvalds 已提交
822 823 824 825 826 827 828 829
			/* we found an interrupt out endpoint */
			dbg("found interrupt out on endpoint %d", i);
			interrupt_out_endpoint[num_interrupt_out] = endpoint;
			++num_interrupt_out;
		}
	}

#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
A
Alan Cox 已提交
830
	/* BEGIN HORRIBLE HACK FOR PL2303 */
L
Linus Torvalds 已提交
831 832 833 834
	/* this is needed due to the looney way its endpoints are set up */
	if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
835 836
	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
837 838 839
	     (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
L
Linus Torvalds 已提交
840 841 842 843 844
		if (interface != dev->actconfig->interface[0]) {
			/* check out the endpoints of the other interface*/
			iface_desc = dev->actconfig->interface[0]->cur_altsetting;
			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
				endpoint = &iface_desc->endpoint[i].desc;
845
				if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
846 847 848 849 850 851 852 853 854 855 856 857 858
					/* we found a interrupt in endpoint */
					dbg("found interrupt in for Prolific device on separate interface");
					interrupt_in_endpoint[num_interrupt_in] = endpoint;
					++num_interrupt_in;
				}
			}
		}

		/* Now make sure the PL-2303 is configured correctly.
		 * If not, give up now and hope this hack will work
		 * properly during a later invocation of usb_serial_probe
		 */
		if (num_bulk_in == 0 || num_bulk_out == 0) {
859
			unlock_kernel();
L
Linus Torvalds 已提交
860
			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
A
Alan Cox 已提交
861
			kfree(serial);
L
Linus Torvalds 已提交
862 863 864 865 866 867 868 869 870 871
			return -ENODEV;
		}
	}
	/* END HORRIBLE HACK FOR PL2303 */
#endif

#ifdef CONFIG_USB_SERIAL_GENERIC
	if (type == &usb_serial_generic_device) {
		num_ports = num_bulk_out;
		if (num_ports == 0) {
872
			unlock_kernel();
A
Alan Cox 已提交
873 874 875
			dev_err(&interface->dev,
			    "Generic device with no bulk out, not allowed.\n");
			kfree(serial);
L
Linus Torvalds 已提交
876 877 878 879 880 881 882
			return -EIO;
		}
	}
#endif
	if (!num_ports) {
		/* if this device type has a calc_num_ports function, call it */
		if (type->calc_num_ports) {
883
			if (!try_module_get(type->driver.owner)) {
884
				unlock_kernel();
A
Alan Cox 已提交
885 886 887
				dev_err(&interface->dev,
					"module get failed, exiting\n");
				kfree(serial);
L
Linus Torvalds 已提交
888 889
				return -EIO;
			}
A
Alan Cox 已提交
890
			num_ports = type->calc_num_ports(serial);
891
			module_put(type->driver.owner);
L
Linus Torvalds 已提交
892 893 894 895 896 897 898 899 900 901 902
		}
		if (!num_ports)
			num_ports = type->num_ports;
	}

	serial->num_ports = num_ports;
	serial->num_bulk_in = num_bulk_in;
	serial->num_bulk_out = num_bulk_out;
	serial->num_interrupt_in = num_interrupt_in;
	serial->num_interrupt_out = num_interrupt_out;

903 904 905 906
	/* found all that we need */
	dev_info(&interface->dev, "%s converter detected\n",
			type->description);

L
Linus Torvalds 已提交
907
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
908 909
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
910 911 912 913 914
	max_endpoints = max(num_bulk_in, num_bulk_out);
	max_endpoints = max(max_endpoints, num_interrupt_in);
	max_endpoints = max(max_endpoints, num_interrupt_out);
	max_endpoints = max(max_endpoints, (int)serial->num_ports);
	serial->num_port_pointers = max_endpoints;
915 916
	unlock_kernel();

A
Alan Cox 已提交
917 918
	dbg("%s - setting up %d port structures for this device",
						__func__, max_endpoints);
L
Linus Torvalds 已提交
919
	for (i = 0; i < max_endpoints; ++i) {
920
		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
L
Linus Torvalds 已提交
921 922
		if (!port)
			goto probe_error;
A
Alan Cox 已提交
923
		tty_port_init(&port->port);
924
		port->port.ops = &serial_port_ops;
L
Linus Torvalds 已提交
925
		port->serial = serial;
926
		spin_lock_init(&port->lock);
927
		mutex_init(&port->mutex);
D
David Howells 已提交
928
		INIT_WORK(&port->work, usb_serial_port_work);
L
Linus Torvalds 已提交
929
		serial->port[i] = port;
930 931 932 933 934
		port->dev.parent = &interface->dev;
		port->dev.driver = NULL;
		port->dev.bus = &usb_serial_bus_type;
		port->dev.release = &port_release;
		device_initialize(&port->dev);
L
Linus Torvalds 已提交
935 936 937 938 939 940
	}

	/* set up the endpoint information */
	for (i = 0; i < num_bulk_in; ++i) {
		endpoint = bulk_in_endpoint[i];
		port = serial->port[i];
A
Alan Cox 已提交
941
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
942 943 944 945 946 947 948
		if (!port->read_urb) {
			dev_err(&interface->dev, "No free urbs available\n");
			goto probe_error;
		}
		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
		port->bulk_in_size = buffer_size;
		port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
949
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
950
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
951 952
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
953 954
			goto probe_error;
		}
A
Alan Cox 已提交
955 956 957 958 959
		usb_fill_bulk_urb(port->read_urb, dev,
				usb_rcvbulkpipe(dev,
						endpoint->bEndpointAddress),
				port->bulk_in_buffer, buffer_size,
				serial->type->read_bulk_callback, port);
L
Linus Torvalds 已提交
960 961 962 963 964 965 966 967 968 969
	}

	for (i = 0; i < num_bulk_out; ++i) {
		endpoint = bulk_out_endpoint[i];
		port = serial->port[i];
		port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
		if (!port->write_urb) {
			dev_err(&interface->dev, "No free urbs available\n");
			goto probe_error;
		}
970 971 972 973
		port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
			&port->lock);
		if (IS_ERR(port->write_fifo))
			goto probe_error;
L
Linus Torvalds 已提交
974 975 976
		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
		port->bulk_out_size = buffer_size;
		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
977
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
978
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
979 980
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
981 982
			goto probe_error;
		}
A
Alan Cox 已提交
983 984 985 986 987
		usb_fill_bulk_urb(port->write_urb, dev,
				usb_sndbulkpipe(dev,
					endpoint->bEndpointAddress),
				port->bulk_out_buffer, buffer_size,
				serial->type->write_bulk_callback, port);
L
Linus Torvalds 已提交
988 989 990 991 992 993 994 995
	}

	if (serial->type->read_int_callback) {
		for (i = 0; i < num_interrupt_in; ++i) {
			endpoint = interrupt_in_endpoint[i];
			port = serial->port[i];
			port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
			if (!port->interrupt_in_urb) {
A
Alan Cox 已提交
996 997
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
998 999 1000
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
A
Alan Cox 已提交
1001 1002 1003 1004
			port->interrupt_in_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_in_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
1005
			if (!port->interrupt_in_buffer) {
A
Alan Cox 已提交
1006 1007
				dev_err(&interface->dev,
				    "Couldn't allocate interrupt_in_buffer\n");
L
Linus Torvalds 已提交
1008 1009
				goto probe_error;
			}
A
Alan Cox 已提交
1010 1011 1012 1013 1014 1015
			usb_fill_int_urb(port->interrupt_in_urb, dev,
				usb_rcvintpipe(dev,
						endpoint->bEndpointAddress),
				port->interrupt_in_buffer, buffer_size,
				serial->type->read_int_callback, port,
				endpoint->bInterval);
L
Linus Torvalds 已提交
1016 1017 1018 1019
		}
	} else if (num_interrupt_in) {
		dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
	}
A
Alan Cox 已提交
1020

L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026
	if (serial->type->write_int_callback) {
		for (i = 0; i < num_interrupt_out; ++i) {
			endpoint = interrupt_out_endpoint[i];
			port = serial->port[i];
			port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
			if (!port->interrupt_out_urb) {
A
Alan Cox 已提交
1027 1028
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
1029 1030 1031 1032
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
			port->interrupt_out_size = buffer_size;
A
Alan Cox 已提交
1033 1034 1035 1036
			port->interrupt_out_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_out_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
1037
			if (!port->interrupt_out_buffer) {
A
Alan Cox 已提交
1038 1039
				dev_err(&interface->dev,
				  "Couldn't allocate interrupt_out_buffer\n");
L
Linus Torvalds 已提交
1040 1041
				goto probe_error;
			}
A
Alan Cox 已提交
1042 1043 1044 1045 1046 1047
			usb_fill_int_urb(port->interrupt_out_urb, dev,
				usb_sndintpipe(dev,
						  endpoint->bEndpointAddress),
				port->interrupt_out_buffer, buffer_size,
				serial->type->write_int_callback, port,
				endpoint->bInterval);
L
Linus Torvalds 已提交
1048 1049 1050 1051
		}
	} else if (num_interrupt_out) {
		dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
	}
A
Alan Cox 已提交
1052

L
Linus Torvalds 已提交
1053 1054
	/* if this device type has an attach function, call it */
	if (type->attach) {
1055
		if (!try_module_get(type->driver.owner)) {
A
Alan Cox 已提交
1056 1057
			dev_err(&interface->dev,
					"module get failed, exiting\n");
L
Linus Torvalds 已提交
1058 1059
			goto probe_error;
		}
A
Alan Cox 已提交
1060
		retval = type->attach(serial);
1061
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
1062 1063 1064
		if (retval < 0)
			goto probe_error;
		if (retval > 0) {
A
Alan Cox 已提交
1065 1066
			/* quietly accept this device, but don't bind to a
			   serial port as it's about to disappear */
1067
			serial->num_ports = 0;
L
Linus Torvalds 已提交
1068 1069 1070 1071
			goto exit;
		}
	}

A
Alan Cox 已提交
1072
	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1073 1074 1075
		dev_err(&interface->dev, "No more free serial devices\n");
		goto probe_error;
	}
1076
	serial->minor = minor;
1077

L
Linus Torvalds 已提交
1078 1079 1080
	/* register all of the individual ports with the driver core */
	for (i = 0; i < num_ports; ++i) {
		port = serial->port[i];
1081
		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1082
		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1083
		port->dev_state = PORT_REGISTERING;
1084
		retval = device_add(&port->dev);
1085
		if (retval) {
1086 1087
			dev_err(&port->dev, "Error registering port device, "
				"continuing\n");
1088 1089 1090 1091
			port->dev_state = PORT_UNREGISTERED;
		} else {
			port->dev_state = PORT_REGISTERED;
		}
L
Linus Torvalds 已提交
1092 1093
	}

A
Alan Cox 已提交
1094
	usb_serial_console_init(debug, minor);
L
Linus Torvalds 已提交
1095 1096 1097

exit:
	/* success */
A
Alan Cox 已提交
1098
	usb_set_intfdata(interface, serial);
L
Linus Torvalds 已提交
1099 1100 1101
	return 0;

probe_error:
1102
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1103 1104
	return -EIO;
}
A
Alan Cox 已提交
1105
EXPORT_SYMBOL_GPL(usb_serial_probe);
L
Linus Torvalds 已提交
1106 1107 1108 1109

void usb_serial_disconnect(struct usb_interface *interface)
{
	int i;
A
Alan Cox 已提交
1110
	struct usb_serial *serial = usb_get_intfdata(interface);
L
Linus Torvalds 已提交
1111 1112 1113
	struct device *dev = &interface->dev;
	struct usb_serial_port *port;

1114
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1115
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1116

1117
	mutex_lock(&serial->disc_mutex);
A
Alan Cox 已提交
1118
	usb_set_intfdata(interface, NULL);
1119 1120
	/* must set a flag, to signal subdrivers */
	serial->disconnected = 1;
1121 1122
	mutex_unlock(&serial->disc_mutex);

1123 1124 1125
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1126 1127
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
A
Alan Cox 已提交
1128
				tty_vhangup(tty);
A
Alan Cox 已提交
1129 1130
				tty_kref_put(tty);
			}
1131
			kill_traffic(port);
1132
			cancel_work_sync(&port->work);
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
			if (port->dev_state == PORT_REGISTERED) {

				/* Make sure the port is bound so that the
				 * driver's port_remove method is called.
				 */
				if (!port->dev.driver) {
					int rc;

					port->dev.driver =
							&serial->type->driver;
					rc = device_bind_driver(&port->dev);
				}
				port->dev_state = PORT_UNREGISTERING;
				device_del(&port->dev);
				port->dev_state = PORT_UNREGISTERED;
			}
1149 1150
		}
	}
1151
	serial->type->disconnect(serial);
1152

1153
	/* let the last holder of this object cause it to be cleaned up */
1154
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1155 1156
	dev_info(dev, "device disconnected\n");
}
A
Alan Cox 已提交
1157
EXPORT_SYMBOL_GPL(usb_serial_disconnect);
L
Linus Torvalds 已提交
1158

1159 1160 1161 1162 1163 1164
int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
	struct usb_serial_port *port;
	int i, r = 0;

1165 1166
	serial->suspending = 1;

1167 1168 1169 1170 1171 1172
	if (serial->type->suspend) {
		r = serial->type->suspend(serial, message);
		if (r < 0)
			goto err_out;
	}

1173 1174 1175 1176
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1177 1178
	}

1179
err_out:
1180 1181 1182 1183 1184 1185 1186
	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1187
	int rv;
1188

1189
	serial->suspending = 0;
S
Sarah Sharp 已提交
1190
	if (serial->type->resume)
1191 1192 1193
		rv = serial->type->resume(serial);
	else
		rv = usb_serial_generic_resume(serial);
1194

1195
	return rv;
1196 1197 1198
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1199
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1200 1201 1202
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1203
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212
	.write_room =		serial_write_room,
	.ioctl =		serial_ioctl,
	.set_termios =		serial_set_termios,
	.throttle =		serial_throttle,
	.unthrottle =		serial_unthrottle,
	.break_ctl =		serial_break,
	.chars_in_buffer =	serial_chars_in_buffer,
	.tiocmget =		serial_tiocmget,
	.tiocmset =		serial_tiocmset,
A
Alan Stern 已提交
1213
	.shutdown = 		serial_release,
A
Alan Cox 已提交
1214
	.install = 		serial_install,
1215
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1216 1217
};

1218

L
Linus Torvalds 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
struct tty_driver *usb_serial_tty_driver;

static int __init usb_serial_init(void)
{
	int i;
	int result;

	usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
	if (!usb_serial_tty_driver)
		return -ENOMEM;

	/* Initialize our global data */
A
Alan Cox 已提交
1231
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1232 1233 1234 1235
		serial_table[i] = NULL;

	result = bus_register(&usb_serial_bus_type);
	if (result) {
1236 1237
		printk(KERN_ERR "usb-serial: %s - registering bus driver "
		       "failed\n", __func__);
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
		goto exit_bus;
	}

	usb_serial_tty_driver->owner = THIS_MODULE;
	usb_serial_tty_driver->driver_name = "usbserial";
	usb_serial_tty_driver->name = 	"ttyUSB";
	usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
	usb_serial_tty_driver->minor_start = 0;
	usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
	usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
A
Alan Cox 已提交
1248 1249
	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
						TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
1250
	usb_serial_tty_driver->init_termios = tty_std_termios;
A
Alan Cox 已提交
1251 1252
	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
							| HUPCL | CLOCAL;
1253 1254
	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1255 1256 1257
	tty_set_operations(usb_serial_tty_driver, &serial_ops);
	result = tty_register_driver(usb_serial_tty_driver);
	if (result) {
1258 1259
		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
		       __func__);
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264 1265
		goto exit_reg_driver;
	}

	/* register the USB driver */
	result = usb_register(&usb_serial_driver);
	if (result < 0) {
1266 1267
		printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
		       __func__);
L
Linus Torvalds 已提交
1268 1269 1270
		goto exit_tty;
	}

1271 1272 1273
	/* register the generic driver, if we should */
	result = usb_serial_generic_register(debug);
	if (result < 0) {
1274 1275
		printk(KERN_ERR "usb-serial: %s - registering generic "
		       "driver failed\n", __func__);
1276 1277 1278
		goto exit_generic;
	}

1279
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1280 1281 1282

	return result;

1283 1284 1285
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1286 1287 1288 1289 1290 1291 1292
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1293 1294
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
	put_tty_driver(usb_serial_tty_driver);
	return result;
}


static void __exit usb_serial_exit(void)
{
	usb_serial_console_exit();

	usb_serial_generic_deregister();

	usb_deregister(&usb_serial_driver);
	tty_unregister_driver(usb_serial_tty_driver);
	put_tty_driver(usb_serial_tty_driver);
	bus_unregister(&usb_serial_bus_type);
}


module_init(usb_serial_init);
module_exit(usb_serial_exit);

#define set_to_generic_if_null(type, function)				\
	do {								\
		if (!type->function) {					\
			type->function = usb_serial_generic_##function;	\
			dbg("Had to override the " #function		\
A
Alan Cox 已提交
1321
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1322 1323 1324
			}						\
	} while (0)

1325
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1326 1327 1328 1329 1330 1331 1332 1333
{
	set_to_generic_if_null(device, open);
	set_to_generic_if_null(device, write);
	set_to_generic_if_null(device, close);
	set_to_generic_if_null(device, write_room);
	set_to_generic_if_null(device, chars_in_buffer);
	set_to_generic_if_null(device, read_bulk_callback);
	set_to_generic_if_null(device, write_bulk_callback);
1334 1335
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1336 1337
}

A
Alan Cox 已提交
1338
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1339
{
A
Alan Cox 已提交
1340
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1341 1342
	int retval;

1343 1344 1345
	if (usb_disabled())
		return -ENODEV;

1346
	fixup_generic(driver);
L
Linus Torvalds 已提交
1347

1348 1349 1350
	if (!driver->description)
		driver->description = driver->driver.name;

L
Linus Torvalds 已提交
1351
	/* Add this device to our list of devices */
1352
	list_add(&driver->driver_list, &usb_serial_driver_list);
L
Linus Torvalds 已提交
1353

1354
	retval = usb_serial_bus_register(driver);
L
Linus Torvalds 已提交
1355
	if (retval) {
1356 1357
		printk(KERN_ERR "usb-serial: problem %d when registering "
		       "driver %s\n", retval, driver->description);
1358
		list_del(&driver->driver_list);
A
Alan Cox 已提交
1359
	} else
1360
		printk(KERN_INFO "USB Serial support registered for %s\n",
A
Alan Cox 已提交
1361
						driver->description);
L
Linus Torvalds 已提交
1362 1363 1364

	return retval;
}
A
Alan Cox 已提交
1365
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1366 1367


A
Alan Cox 已提交
1368
void usb_serial_deregister(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1369
{
A
Alan Cox 已提交
1370
	/* must be called with BKL held */
1371 1372
	printk(KERN_INFO "USB Serial deregistering driver %s\n",
	       device->description);
L
Linus Torvalds 已提交
1373 1374 1375 1376 1377 1378
	list_del(&device->driver_list);
	usb_serial_bus_deregister(device);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister);

/* Module information */
A
Alan Cox 已提交
1379 1380
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1381 1382 1383 1384
MODULE_LICENSE("GPL");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");