usb-serial.c 36.7 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>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50
#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,
51 52
	.suspend =	usb_serial_suspend,
	.resume =	usb_serial_resume,
53
	.no_dynamic_id = 	1,
L
Linus Torvalds 已提交
54 55 56 57 58 59 60 61 62 63
};

/* 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 已提交
64 65
/* initially all NULL */
static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
66
static DEFINE_MUTEX(table_lock);
L
Linus Torvalds 已提交
67 68
static LIST_HEAD(usb_serial_driver_list);

69 70 71 72 73
/*
 * 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 已提交
74 75
struct usb_serial *usb_serial_get_by_index(unsigned index)
{
76 77
	struct usb_serial *serial;

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

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

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

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

	*minor = 0;
103
	mutex_lock(&table_lock);
L
Linus Torvalds 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
	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 已提交
119
		j = 0;
120
		dbg("%s - minor base = %d", __func__, *minor);
O
Oliver Neukum 已提交
121
		for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
L
Linus Torvalds 已提交
122
			serial_table[i] = serial;
O
Oliver Neukum 已提交
123 124
			serial->port[j++]->number = i;
		}
125
		mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
126 127
		return serial;
	}
128
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
129 130 131 132 133 134 135
	return NULL;
}

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

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

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

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

	serial = to_usb_serial(kref);

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

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

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

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

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

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

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

/**
 * 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.
190 191 192 193
 *
 * 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 已提交
194
 * All these actions are reversed in serial_release().
195 196 197 198 199
 */
static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
{
	int idx = tty->index;
	struct usb_serial *serial;
200 201 202
	struct usb_serial_port *port;
	int retval = -ENODEV;

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

205 206 207 208 209 210 211 212 213 214
	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;

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

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

224 225
	mutex_unlock(&serial->disc_mutex);

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

230 231
	tty->driver_data = port;

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

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

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

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

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

262 263 264 265 266 267
	/* 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;
268
		mutex_lock(&serial->disc_mutex);
269 270 271 272
		if (serial->disconnected)
			retval = -ENODEV;
		else
			retval = port->serial->type->open(tty, port);
273
		mutex_unlock(&serial->disc_mutex);
274 275 276
		mutex_unlock(&port->mutex);
		if (retval)
			return retval;
277
		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
L
Linus Torvalds 已提交
278
	}
279

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

285
/**
A
Alan Stern 已提交
286
 * serial_down - shut down hardware
287
 * @port: port to shut down
288
 *
289 290
 * 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.
291
 */
A
Alan Stern 已提交
292
static void serial_down(struct usb_serial_port *port)
L
Linus Torvalds 已提交
293
{
294
	struct usb_serial_driver *drv = port->serial->type;
L
Linus Torvalds 已提交
295

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

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

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

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

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

A
Alan Stern 已提交
321
	serial_down(port);
322 323 324 325 326 327 328 329 330
	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);

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

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

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

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

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

366 367
	tty->driver_data = NULL;

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

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

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

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

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

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

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

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

exit:
	return retval;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

527 528 529 530 531 532 533 534 535 536 537 538 539
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 已提交
540
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
541
{
542
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
543

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

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

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

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

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

565 566 567 568 569 570 571 572 573
/*
 * 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 已提交
574
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
575

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

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

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

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

592
static void kill_traffic(struct usb_serial_port *port)
593
{
L
Linus Torvalds 已提交
594 595
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
596 597 598 599 600 601 602 603 604 605 606
	/*
	 * 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 已提交
607 608
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
609 610
}

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

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

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

624 625 626
	usb_free_urb(port->read_urb);
	usb_free_urb(port->write_urb);
	usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
627 628 629 630 631 632 633 634
	usb_free_urb(port->interrupt_out_urb);
	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 已提交
635 636 637
static struct usb_serial *create_serial(struct usb_device *dev,
					struct usb_interface *interface,
					struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
638 639 640
{
	struct usb_serial *serial;

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

	return serial;
}

656
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
657
					    struct usb_serial_driver *drv)
658 659 660 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
{
	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 已提交
689 690
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
691 692
{
	const struct usb_device_id *id;
693
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
694

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

	return NULL;
}

705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
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 已提交
728 729 730
int usb_serial_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
A
Alan Cox 已提交
731
	struct usb_device *dev = interface_to_usbdev(interface);
L
Linus Torvalds 已提交
732 733 734 735 736 737 738 739
	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];
740
	struct usb_serial_driver *type = NULL;
L
Linus Torvalds 已提交
741
	int retval;
742
	unsigned int minor;
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750 751
	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;

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

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

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

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

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

		if (retval) {
784
			unlock_kernel();
A
Alan Cox 已提交
785 786
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
787 788 789 790 791 792 793 794 795
			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;
796 797

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

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

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

818
		if (usb_endpoint_is_int_out(endpoint)) {
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826
			/* 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 已提交
827
	/* BEGIN HORRIBLE HACK FOR PL2303 */
L
Linus Torvalds 已提交
828 829 830 831
	/* 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) &&
832 833
	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
834 835 836
	     (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 已提交
837 838 839 840 841
		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;
842
				if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
843 844 845 846 847 848 849 850 851 852 853 854 855
					/* 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) {
856
			unlock_kernel();
L
Linus Torvalds 已提交
857
			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
A
Alan Cox 已提交
858
			kfree(serial);
L
Linus Torvalds 已提交
859 860 861 862 863 864 865 866 867 868
			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) {
869
			unlock_kernel();
A
Alan Cox 已提交
870 871 872
			dev_err(&interface->dev,
			    "Generic device with no bulk out, not allowed.\n");
			kfree(serial);
L
Linus Torvalds 已提交
873 874 875 876 877 878 879
			return -EIO;
		}
	}
#endif
	if (!num_ports) {
		/* if this device type has a calc_num_ports function, call it */
		if (type->calc_num_ports) {
880
			if (!try_module_get(type->driver.owner)) {
881
				unlock_kernel();
A
Alan Cox 已提交
882 883 884
				dev_err(&interface->dev,
					"module get failed, exiting\n");
				kfree(serial);
L
Linus Torvalds 已提交
885 886
				return -EIO;
			}
A
Alan Cox 已提交
887
			num_ports = type->calc_num_ports(serial);
888
			module_put(type->driver.owner);
L
Linus Torvalds 已提交
889 890 891 892 893 894 895 896 897 898 899
		}
		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;

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

L
Linus Torvalds 已提交
904
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
905 906
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
907 908 909 910 911
	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;
912 913
	unlock_kernel();

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

	/* 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 已提交
938
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
939 940 941 942 943 944 945
		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 已提交
946
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
947
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
948 949
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
950 951
			goto probe_error;
		}
A
Alan Cox 已提交
952 953 954 955 956
		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 已提交
957 958 959 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;
		}
		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
		port->bulk_out_size = buffer_size;
		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
970
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
971
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
972 973
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
974 975
			goto probe_error;
		}
A
Alan Cox 已提交
976 977 978 979 980
		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 已提交
981 982 983 984 985 986 987 988
	}

	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 已提交
989 990
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
991 992 993
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
A
Alan Cox 已提交
994 995 996 997
			port->interrupt_in_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_in_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
998
			if (!port->interrupt_in_buffer) {
A
Alan Cox 已提交
999 1000
				dev_err(&interface->dev,
				    "Couldn't allocate interrupt_in_buffer\n");
L
Linus Torvalds 已提交
1001 1002
				goto probe_error;
			}
A
Alan Cox 已提交
1003 1004 1005 1006 1007 1008
			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 已提交
1009 1010 1011 1012
		}
	} else if (num_interrupt_in) {
		dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
	}
A
Alan Cox 已提交
1013

L
Linus Torvalds 已提交
1014 1015 1016 1017 1018 1019
	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 已提交
1020 1021
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
1022 1023 1024 1025
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
			port->interrupt_out_size = buffer_size;
A
Alan Cox 已提交
1026 1027 1028 1029
			port->interrupt_out_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_out_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
1030
			if (!port->interrupt_out_buffer) {
A
Alan Cox 已提交
1031 1032
				dev_err(&interface->dev,
				  "Couldn't allocate interrupt_out_buffer\n");
L
Linus Torvalds 已提交
1033 1034
				goto probe_error;
			}
A
Alan Cox 已提交
1035 1036 1037 1038 1039 1040
			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 已提交
1041 1042 1043 1044
		}
	} else if (num_interrupt_out) {
		dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
	}
A
Alan Cox 已提交
1045

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

A
Alan Cox 已提交
1065
	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1066 1067 1068
		dev_err(&interface->dev, "No more free serial devices\n");
		goto probe_error;
	}
1069
	serial->minor = minor;
1070

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

A
Alan Cox 已提交
1087
	usb_serial_console_init(debug, minor);
L
Linus Torvalds 已提交
1088 1089 1090

exit:
	/* success */
A
Alan Cox 已提交
1091
	usb_set_intfdata(interface, serial);
L
Linus Torvalds 已提交
1092 1093 1094
	return 0;

probe_error:
1095
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1096 1097
	return -EIO;
}
A
Alan Cox 已提交
1098
EXPORT_SYMBOL_GPL(usb_serial_probe);
L
Linus Torvalds 已提交
1099 1100 1101 1102

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

1107
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1108
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1109

1110
	mutex_lock(&serial->disc_mutex);
A
Alan Cox 已提交
1111
	usb_set_intfdata(interface, NULL);
1112 1113
	/* must set a flag, to signal subdrivers */
	serial->disconnected = 1;
1114 1115
	mutex_unlock(&serial->disc_mutex);

1116 1117 1118
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1119 1120
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
A
Alan Cox 已提交
1121
				tty_vhangup(tty);
A
Alan Cox 已提交
1122 1123
				tty_kref_put(tty);
			}
1124
			kill_traffic(port);
1125
			cancel_work_sync(&port->work);
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
			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;
			}
1142 1143
		}
	}
1144
	serial->type->disconnect(serial);
1145

1146
	/* let the last holder of this object cause it to be cleaned up */
1147
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1148 1149
	dev_info(dev, "device disconnected\n");
}
A
Alan Cox 已提交
1150
EXPORT_SYMBOL_GPL(usb_serial_disconnect);
L
Linus Torvalds 已提交
1151

1152 1153 1154 1155 1156 1157
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;

1158 1159
	serial->suspending = 1;

1160 1161 1162 1163
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1164 1165 1166
	}

	if (serial->type->suspend)
1167
		r = serial->type->suspend(serial, message);
1168 1169 1170 1171 1172 1173 1174 1175

	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1176
	int rv;
1177

1178
	serial->suspending = 0;
S
Sarah Sharp 已提交
1179
	if (serial->type->resume)
1180 1181 1182
		rv = serial->type->resume(serial);
	else
		rv = usb_serial_generic_resume(serial);
1183

1184
	return rv;
1185 1186 1187
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1188
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1189 1190 1191
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1192
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198 1199 1200 1201
	.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 已提交
1202
	.shutdown = 		serial_release,
A
Alan Cox 已提交
1203
	.install = 		serial_install,
1204
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1205 1206
};

1207

L
Linus Torvalds 已提交
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
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 已提交
1220
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1221 1222 1223 1224
		serial_table[i] = NULL;

	result = bus_register(&usb_serial_bus_type);
	if (result) {
1225 1226
		printk(KERN_ERR "usb-serial: %s - registering bus driver "
		       "failed\n", __func__);
L
Linus Torvalds 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
		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 已提交
1237 1238
	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
						TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
1239
	usb_serial_tty_driver->init_termios = tty_std_termios;
A
Alan Cox 已提交
1240 1241
	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
							| HUPCL | CLOCAL;
1242 1243
	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1244 1245 1246
	tty_set_operations(usb_serial_tty_driver, &serial_ops);
	result = tty_register_driver(usb_serial_tty_driver);
	if (result) {
1247 1248
		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
		       __func__);
L
Linus Torvalds 已提交
1249 1250 1251 1252 1253 1254
		goto exit_reg_driver;
	}

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

1260 1261 1262
	/* register the generic driver, if we should */
	result = usb_serial_generic_register(debug);
	if (result < 0) {
1263 1264
		printk(KERN_ERR "usb-serial: %s - registering generic "
		       "driver failed\n", __func__);
1265 1266 1267
		goto exit_generic;
	}

1268
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1269 1270 1271

	return result;

1272 1273 1274
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280 1281
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1282 1283
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
	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 已提交
1310
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1311 1312 1313
			}						\
	} while (0)

1314
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1315 1316 1317 1318 1319 1320 1321 1322
{
	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);
1323 1324
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1325 1326
}

A
Alan Cox 已提交
1327
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1328
{
A
Alan Cox 已提交
1329
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1330 1331
	int retval;

1332 1333 1334
	if (usb_disabled())
		return -ENODEV;

1335
	fixup_generic(driver);
L
Linus Torvalds 已提交
1336

1337 1338 1339
	if (!driver->description)
		driver->description = driver->driver.name;

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

1343
	retval = usb_serial_bus_register(driver);
L
Linus Torvalds 已提交
1344
	if (retval) {
1345 1346
		printk(KERN_ERR "usb-serial: problem %d when registering "
		       "driver %s\n", retval, driver->description);
1347
		list_del(&driver->driver_list);
A
Alan Cox 已提交
1348
	} else
1349
		printk(KERN_INFO "USB Serial support registered for %s\n",
A
Alan Cox 已提交
1350
						driver->description);
L
Linus Torvalds 已提交
1351 1352 1353

	return retval;
}
A
Alan Cox 已提交
1354
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1355 1356


A
Alan Cox 已提交
1357
void usb_serial_deregister(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1358
{
A
Alan Cox 已提交
1359
	/* must be called with BKL held */
1360 1361
	printk(KERN_INFO "USB Serial deregistering driver %s\n",
	       device->description);
L
Linus Torvalds 已提交
1362 1363 1364 1365 1366 1367
	list_del(&device->driver_list);
	usb_serial_bus_deregister(device);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister);

/* Module information */
A
Alan Cox 已提交
1368 1369
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1370 1371 1372 1373
MODULE_LICENSE("GPL");

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