usb-serial.c 37.4 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 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204

/**
 * 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.
 */
static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
{
	int idx = tty->index;
	struct usb_serial *serial;
	int retval;

	/* If the termios setup has yet to be done */
	if (tty->driver->termios[idx] == NULL) {
		/* perform the standard setup */
		retval = tty_init_termios(tty);
		if (retval)
			return retval;
		/* allow the driver to update it */
		serial = usb_serial_get_by_index(tty->index);
205 206 207 208 209 210
		if (serial) {
			if (serial->type->init_termios)
				serial->type->init_termios(tty);
			usb_serial_put(serial);
			mutex_unlock(&serial->disc_mutex);
		}
211 212 213 214 215 216 217 218
	}
	/* Final install (we use the default method) */
	tty_driver_kref_get(driver);
	tty->count++;
	driver->ttys[idx] = tty;
	return 0;
}

A
Alan Cox 已提交
219
static int serial_open (struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
220 221 222 223
{
	struct usb_serial *serial;
	struct usb_serial_port *port;
	unsigned int portNumber;
224
	int retval = 0;
225
	int first = 0;
A
Alan Cox 已提交
226

227
	dbg("%s", __func__);
L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235 236 237

	/* get the serial object associated with this tty pointer */
	serial = usb_serial_get_by_index(tty->index);
	if (!serial) {
		tty->driver_data = NULL;
		return -ENODEV;
	}

	portNumber = tty->index - serial->minor;
	port = serial->port[portNumber];
238
	if (!port || serial->disconnected)
239
		retval = -ENODEV;
240 241 242 243 244 245 246
	/*
	 * Note: Our locking order requirement does not allow port->mutex
	 * to be acquired while serial->disc_mutex is held.
	 */
	mutex_unlock(&serial->disc_mutex);
	if (retval)
		goto bailout_serial_put;
247

248 249
	if (mutex_lock_interruptible(&port->mutex)) {
		retval = -ERESTARTSYS;
250
		goto bailout_serial_put;
251
	}
A
Alan Cox 已提交
252

A
Alan Cox 已提交
253
	++port->port.count;
L
Linus Torvalds 已提交
254

255 256 257
	/* set up our port structure making the tty driver
	 * remember our port object, and us it */
	tty->driver_data = port;
A
Alan Cox 已提交
258
	tty_port_tty_set(&port->port, tty);
L
Linus Torvalds 已提交
259

260 261
	/* If the console is attached, the device is already open */
	if (port->port.count == 1 && !port->console) {
262
		first = 1;
L
Linus Torvalds 已提交
263 264 265
		/* lock this module before we call it
		 * this may fail, which means we must bail out,
		 * safe because we are called with BKL held */
266
		if (!try_module_get(serial->type->driver.owner)) {
L
Linus Torvalds 已提交
267
			retval = -ENODEV;
268
			goto bailout_mutex_unlock;
L
Linus Torvalds 已提交
269 270
		}

271 272 273 274 275
		mutex_lock(&serial->disc_mutex);
		if (serial->disconnected)
			retval = -ENODEV;
		else
			retval = usb_autopm_get_interface(serial->interface);
276 277
		if (retval)
			goto bailout_module_put;
278

A
Alan Cox 已提交
279
		/* only call the device specific open if this
L
Linus Torvalds 已提交
280
		 * is the first time the port is opened */
281
		retval = serial->type->open(tty, port);
L
Linus Torvalds 已提交
282
		if (retval)
283
			goto bailout_interface_put;
284
		mutex_unlock(&serial->disc_mutex);
285
		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
L
Linus Torvalds 已提交
286
	}
287
	mutex_unlock(&port->mutex);
288 289
	/* Now do the correct tty layer semantics */
	retval = tty_port_block_til_ready(&port->port, tty, filp);
290 291 292
	if (retval == 0) {
		if (!first)
			usb_serial_put(serial);
293
		return 0;
294 295 296 297 298 299
	}
	mutex_lock(&port->mutex);
	if (first == 0)
		goto bailout_mutex_unlock;
	/* Undo the initial port actions */
	mutex_lock(&serial->disc_mutex);
300 301
bailout_interface_put:
	usb_autopm_put_interface(serial->interface);
L
Linus Torvalds 已提交
302
bailout_module_put:
303
	mutex_unlock(&serial->disc_mutex);
304
	module_put(serial->type->driver.owner);
305
bailout_mutex_unlock:
A
Alan Cox 已提交
306
	port->port.count = 0;
307
	tty->driver_data = NULL;
A
Alan Cox 已提交
308
	tty_port_tty_set(&port->port, NULL);
309
	mutex_unlock(&port->mutex);
310
bailout_serial_put:
311
	usb_serial_put(serial);
L
Linus Torvalds 已提交
312 313 314
	return retval;
}

315
/**
316 317
 * serial_do_down - shut down hardware
 * @port: port to shut down
318
 *
319 320
 * 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.
321 322
 */
static void serial_do_down(struct usb_serial_port *port)
L
Linus Torvalds 已提交
323
{
324
	struct usb_serial_driver *drv = port->serial->type;
325 326
	struct usb_serial *serial;
	struct module *owner;
L
Linus Torvalds 已提交
327

328 329 330 331
	/*
	 * The console is magical.  Do not hang up the console hardware
	 * or there will be tears.
	 */
332
	if (port->console)
L
Linus Torvalds 已提交
333 334
		return;

335
	mutex_lock(&port->mutex);
336 337
	serial = port->serial;
	owner = serial->type->driver.owner;
338

339 340
	if (drv->close)
		drv->close(port);
L
Linus Torvalds 已提交
341

342
	mutex_unlock(&port->mutex);
343 344
}

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
static void serial_hangup(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	serial_do_down(port);
	tty_port_hangup(&port->port);
	/* We must not free port yet - the USB serial layer depends on it's
	   continued existence */
}

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

	if (!port)
		return;

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

	if (tty_port_close_start(&port->port, tty, filp) == 0)
		return;
	serial_do_down(port);
	tty_port_close_end(&port->port, tty);
	tty_port_tty_set(&port->port, NULL);

}

371
/**
372 373
 * serial_do_free - free resources post close/hangup
 * @port: port to free up
374
 *
375 376
 * Do the resource freeing and refcount dropping for the port.
 * Avoid freeing the console.
377
 *
378
 * Called when the last tty kref is dropped.
379
 */
380
static void serial_do_free(struct tty_struct *tty)
381
{
382
	struct usb_serial_port *port = tty->driver_data;
383 384 385
	struct usb_serial *serial;
	struct module *owner;

386 387 388
	/* The console is magical.  Do not hang up the console hardware
	 * or there will be tears.
	 */
389
	if (port == NULL || port->console)
390 391 392 393
		return;

	serial = port->serial;
	owner = serial->type->driver.owner;
394

395 396 397 398
	mutex_lock(&serial->disc_mutex);
	if (!serial->disconnected)
		usb_autopm_put_interface(serial->interface);
	mutex_unlock(&serial->disc_mutex);
399

400
	usb_serial_put(serial);
401 402 403
	module_put(owner);
}

A
Alan Cox 已提交
404 405
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
								int count)
L
Linus Torvalds 已提交
406
{
407
	struct usb_serial_port *port = tty->driver_data;
408
	int retval = -ENODEV;
L
Linus Torvalds 已提交
409

A
Alan Cox 已提交
410
	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
411 412
		goto exit;

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

A
Alan Cox 已提交
415
	/* count is managed under the mutex lock for the tty so cannot
A
Alan Cox 已提交
416
	   drop to zero until after the last close completes */
A
Alan Cox 已提交
417
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
418 419

	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
420
	retval = port->serial->type->write(tty, port, buf, count);
L
Linus Torvalds 已提交
421 422 423 424 425

exit:
	return retval;
}

A
Alan Cox 已提交
426
static int serial_write_room(struct tty_struct *tty)
L
Linus Torvalds 已提交
427
{
428
	struct usb_serial_port *port = tty->driver_data;
429
	dbg("%s - port %d", __func__, port->number);
A
Alan Cox 已提交
430
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
431
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
432
	return port->serial->type->write_room(tty);
L
Linus Torvalds 已提交
433 434
}

A
Alan Cox 已提交
435
static int serial_chars_in_buffer(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

440 441 442 443
	/* if the device was unplugged then any remaining characters
	   fell out of the connector ;) */
	if (port->serial->disconnected)
		return 0;
L
Linus Torvalds 已提交
444
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
445
	return port->serial->type->chars_in_buffer(tty);
L
Linus Torvalds 已提交
446 447
}

A
Alan Cox 已提交
448
static void serial_throttle(struct tty_struct *tty)
L
Linus Torvalds 已提交
449
{
450
	struct usb_serial_port *port = tty->driver_data;
451
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
452

A
Alan Cox 已提交
453
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
454 455
	/* pass on to the driver specific version of this function */
	if (port->serial->type->throttle)
A
Alan Cox 已提交
456
		port->serial->type->throttle(tty);
L
Linus Torvalds 已提交
457 458
}

A
Alan Cox 已提交
459
static void serial_unthrottle(struct tty_struct *tty)
L
Linus Torvalds 已提交
460
{
461
	struct usb_serial_port *port = tty->driver_data;
462
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
463

A
Alan Cox 已提交
464
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
465 466
	/* pass on to the driver specific version of this function */
	if (port->serial->type->unthrottle)
A
Alan Cox 已提交
467
		port->serial->type->unthrottle(tty);
L
Linus Torvalds 已提交
468 469
}

A
Alan Cox 已提交
470 471
static int serial_ioctl(struct tty_struct *tty, struct file *file,
					unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
472
{
473
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
474 475
	int retval = -ENODEV;

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

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

A
Alan Cox 已提交
480 481
	/* pass on to the driver specific version of this function
	   if it is available */
A
Alan Cox 已提交
482
	if (port->serial->type->ioctl) {
A
Alan Cox 已提交
483
		retval = port->serial->type->ioctl(tty, file, cmd, arg);
A
Alan Cox 已提交
484
	} else
L
Linus Torvalds 已提交
485 486 487 488
		retval = -ENOIOCTLCMD;
	return retval;
}

A
Alan Cox 已提交
489
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
L
Linus Torvalds 已提交
490
{
491
	struct usb_serial_port *port = tty->driver_data;
492
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
493

A
Alan Cox 已提交
494
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
495 496
	/* pass on to the driver specific version of this function
	   if it is available */
L
Linus Torvalds 已提交
497
	if (port->serial->type->set_termios)
A
Alan Cox 已提交
498
		port->serial->type->set_termios(tty, port, old);
499 500
	else
		tty_termios_copy_hw(tty->termios, old);
L
Linus Torvalds 已提交
501 502
}

A
Alan Cox 已提交
503
static int serial_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
504
{
505
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
506

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

A
Alan Cox 已提交
509
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
510 511
	/* pass on to the driver specific version of this function
	   if it is available */
512
	if (port->serial->type->break_ctl)
A
Alan Cox 已提交
513
		port->serial->type->break_ctl(tty, break_state);
A
Alan Cox 已提交
514
	return 0;
L
Linus Torvalds 已提交
515 516
}

517
static int serial_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
518 519 520 521 522
{
	struct usb_serial *serial;
	int i;
	char tmp[40];

523
	dbg("%s", __func__);
524 525
	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
L
Linus Torvalds 已提交
526 527 528 529
		serial = usb_serial_get_by_index(i);
		if (serial == NULL)
			continue;

530
		seq_printf(m, "%d:", i);
531
		if (serial->type->driver.owner)
532
			seq_printf(m, " module:%s",
A
Alan Cox 已提交
533
				module_name(serial->type->driver.owner));
534
		seq_printf(m, " name:\"%s\"",
A
Alan Cox 已提交
535
				serial->type->description);
536
		seq_printf(m, " vendor:%04x product:%04x",
A
Alan Cox 已提交
537 538
			le16_to_cpu(serial->dev->descriptor.idVendor),
			le16_to_cpu(serial->dev->descriptor.idProduct));
539 540
		seq_printf(m, " num_ports:%d", serial->num_ports);
		seq_printf(m, " port:%d", i - serial->minor + 1);
L
Linus Torvalds 已提交
541
		usb_make_path(serial->dev, tmp, sizeof(tmp));
542
		seq_printf(m, " path:%s", tmp);
A
Alan Cox 已提交
543

544
		seq_putc(m, '\n');
545
		usb_serial_put(serial);
546
		mutex_unlock(&serial->disc_mutex);
L
Linus Torvalds 已提交
547
	}
548
	return 0;
L
Linus Torvalds 已提交
549 550
}

551 552 553 554 555 556 557 558 559 560 561 562 563
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 已提交
564
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
565
{
566
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
567

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

A
Alan Cox 已提交
570
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
571
	if (port->serial->type->tiocmget)
A
Alan Cox 已提交
572
		return port->serial->type->tiocmget(tty, file);
L
Linus Torvalds 已提交
573 574 575
	return -EINVAL;
}

A
Alan Cox 已提交
576
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
577 578
			    unsigned int set, unsigned int clear)
{
579
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
580

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

A
Alan Cox 已提交
583
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
584
	if (port->serial->type->tiocmset)
A
Alan Cox 已提交
585
		return port->serial->type->tiocmset(tty, file, set, clear);
L
Linus Torvalds 已提交
586 587 588
	return -EINVAL;
}

589 590 591 592 593 594 595 596 597
/*
 * 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 已提交
598
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
599

D
David Howells 已提交
600
static void usb_serial_port_work(struct work_struct *work)
L
Linus Torvalds 已提交
601
{
D
David Howells 已提交
602 603
	struct usb_serial_port *port =
		container_of(work, struct usb_serial_port, work);
L
Linus Torvalds 已提交
604 605
	struct tty_struct *tty;

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

A
Alan Cox 已提交
608
	tty = tty_port_tty_get(&port->port);
L
Linus Torvalds 已提交
609 610 611 612
	if (!tty)
		return;

	tty_wakeup(tty);
A
Alan Cox 已提交
613
	tty_kref_put(tty);
L
Linus Torvalds 已提交
614 615
}

616
static void kill_traffic(struct usb_serial_port *port)
617
{
L
Linus Torvalds 已提交
618 619
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
620 621 622 623 624 625 626 627 628 629 630
	/*
	 * 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 已提交
631 632
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
633 634
}

635
static void port_release(struct device *dev)
636
{
637 638 639 640
	struct usb_serial_port *port = to_usb_serial_port(dev);

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

641 642 643 644
	/*
	 * Stop all the traffic before cancelling the work, so that
	 * nobody will restart it by calling usb_serial_port_softint.
	 */
645
	kill_traffic(port);
646 647
	cancel_work_sync(&port->work);

648 649 650
	usb_free_urb(port->read_urb);
	usb_free_urb(port->write_urb);
	usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
651 652 653 654 655 656 657 658
	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 已提交
659 660 661
static struct usb_serial *create_serial(struct usb_device *dev,
					struct usb_interface *interface,
					struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
662 663 664
{
	struct usb_serial *serial;

665
	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
L
Linus Torvalds 已提交
666
	if (!serial) {
667
		dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
668 669 670
		return NULL;
	}
	serial->dev = usb_get_dev(dev);
671
	serial->type = driver;
L
Linus Torvalds 已提交
672 673
	serial->interface = interface;
	kref_init(&serial->kref);
674
	mutex_init(&serial->disc_mutex);
675
	serial->minor = SERIAL_TTY_NO_MINOR;
L
Linus Torvalds 已提交
676 677 678 679

	return serial;
}

680
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
681
					    struct usb_serial_driver *drv)
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
{
	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 已提交
713 714
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
715 716
{
	const struct usb_device_id *id;
717
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
718

A
Adrian Bunk 已提交
719
	/* Check if the usb id matches a known device */
720 721
	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
		id = get_iface_id(drv, iface);
722
		if (id)
723
			return drv;
L
Linus Torvalds 已提交
724 725 726 727 728
	}

	return NULL;
}

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
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 已提交
752 753 754
int usb_serial_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
A
Alan Cox 已提交
755
	struct usb_device *dev = interface_to_usbdev(interface);
L
Linus Torvalds 已提交
756 757 758 759 760 761 762 763
	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];
764
	struct usb_serial_driver *type = NULL;
L
Linus Torvalds 已提交
765
	int retval;
766
	unsigned int minor;
L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774 775
	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;

776
	lock_kernel(); /* guard against unloading a serial driver module */
L
Linus Torvalds 已提交
777 778
	type = search_serial_device(interface);
	if (!type) {
779
		unlock_kernel();
L
Linus Torvalds 已提交
780 781 782 783
		dbg("none matched");
		return -ENODEV;
	}

A
Alan Cox 已提交
784
	serial = create_serial(dev, interface, type);
L
Linus Torvalds 已提交
785
	if (!serial) {
786
		unlock_kernel();
787
		dev_err(&interface->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
788 789 790 791 792 793 794
		return -ENOMEM;
	}

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

795
		if (!try_module_get(type->driver.owner)) {
796
			unlock_kernel();
A
Alan Cox 已提交
797 798 799
			dev_err(&interface->dev,
				"module get failed, exiting\n");
			kfree(serial);
L
Linus Torvalds 已提交
800 801 802
			return -EIO;
		}

803
		id = get_iface_id(type, interface);
L
Linus Torvalds 已提交
804
		retval = type->probe(serial, id);
805
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
806 807

		if (retval) {
808
			unlock_kernel();
A
Alan Cox 已提交
809 810
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
811 812 813 814 815 816 817 818 819
			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;
820 821

		if (usb_endpoint_is_bulk_in(endpoint)) {
L
Linus Torvalds 已提交
822 823 824 825 826 827
			/* we found a bulk in endpoint */
			dbg("found bulk in on endpoint %d", i);
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;
		}

828
		if (usb_endpoint_is_bulk_out(endpoint)) {
L
Linus Torvalds 已提交
829 830 831 832 833
			/* we found a bulk out endpoint */
			dbg("found bulk out on endpoint %d", i);
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
		}
834 835

		if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
836 837 838 839 840 841
			/* we found a interrupt in endpoint */
			dbg("found interrupt in on endpoint %d", i);
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
		}

842
		if (usb_endpoint_is_int_out(endpoint)) {
L
Linus Torvalds 已提交
843 844 845 846 847 848 849 850
			/* 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 已提交
851
	/* BEGIN HORRIBLE HACK FOR PL2303 */
L
Linus Torvalds 已提交
852 853 854 855
	/* 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) &&
856 857
	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
858 859 860
	     (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 已提交
861 862 863 864 865
		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;
866
				if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
867 868 869 870 871 872 873 874 875 876 877 878 879
					/* 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) {
880
			unlock_kernel();
L
Linus Torvalds 已提交
881
			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
A
Alan Cox 已提交
882
			kfree(serial);
L
Linus Torvalds 已提交
883 884 885 886 887 888 889 890 891 892
			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) {
893
			unlock_kernel();
A
Alan Cox 已提交
894 895 896
			dev_err(&interface->dev,
			    "Generic device with no bulk out, not allowed.\n");
			kfree(serial);
L
Linus Torvalds 已提交
897 898 899 900 901 902 903
			return -EIO;
		}
	}
#endif
	if (!num_ports) {
		/* if this device type has a calc_num_ports function, call it */
		if (type->calc_num_ports) {
904
			if (!try_module_get(type->driver.owner)) {
905
				unlock_kernel();
A
Alan Cox 已提交
906 907 908
				dev_err(&interface->dev,
					"module get failed, exiting\n");
				kfree(serial);
L
Linus Torvalds 已提交
909 910
				return -EIO;
			}
A
Alan Cox 已提交
911
			num_ports = type->calc_num_ports(serial);
912
			module_put(type->driver.owner);
L
Linus Torvalds 已提交
913 914 915 916 917 918 919 920 921 922 923
		}
		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;

924 925 926 927
	/* found all that we need */
	dev_info(&interface->dev, "%s converter detected\n",
			type->description);

L
Linus Torvalds 已提交
928
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
929 930
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
931 932 933 934 935
	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;
936 937
	unlock_kernel();

A
Alan Cox 已提交
938 939
	dbg("%s - setting up %d port structures for this device",
						__func__, max_endpoints);
L
Linus Torvalds 已提交
940
	for (i = 0; i < max_endpoints; ++i) {
941
		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
L
Linus Torvalds 已提交
942 943
		if (!port)
			goto probe_error;
A
Alan Cox 已提交
944
		tty_port_init(&port->port);
945
		port->port.ops = &serial_port_ops;
L
Linus Torvalds 已提交
946
		port->serial = serial;
947
		spin_lock_init(&port->lock);
948
		mutex_init(&port->mutex);
D
David Howells 已提交
949
		INIT_WORK(&port->work, usb_serial_port_work);
L
Linus Torvalds 已提交
950
		serial->port[i] = port;
951 952 953 954 955
		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 已提交
956 957 958 959 960 961
	}

	/* 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 已提交
962
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
963 964 965 966 967 968 969
		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 已提交
970
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
971
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
972 973
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
974 975
			goto probe_error;
		}
A
Alan Cox 已提交
976 977 978 979 980
		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 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993
	}

	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 已提交
994
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
995
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
996 997
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
998 999
			goto probe_error;
		}
A
Alan Cox 已提交
1000 1001 1002 1003 1004
		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 已提交
1005 1006 1007 1008 1009 1010 1011 1012
	}

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

L
Linus Torvalds 已提交
1038 1039 1040 1041 1042 1043
	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 已提交
1044 1045
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
1046 1047 1048 1049
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
			port->interrupt_out_size = buffer_size;
A
Alan Cox 已提交
1050 1051 1052 1053
			port->interrupt_out_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_out_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
1054
			if (!port->interrupt_out_buffer) {
A
Alan Cox 已提交
1055 1056
				dev_err(&interface->dev,
				  "Couldn't allocate interrupt_out_buffer\n");
L
Linus Torvalds 已提交
1057 1058
				goto probe_error;
			}
A
Alan Cox 已提交
1059 1060 1061 1062 1063 1064
			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 已提交
1065 1066 1067 1068
		}
	} else if (num_interrupt_out) {
		dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
	}
A
Alan Cox 已提交
1069

L
Linus Torvalds 已提交
1070 1071
	/* if this device type has an attach function, call it */
	if (type->attach) {
1072
		if (!try_module_get(type->driver.owner)) {
A
Alan Cox 已提交
1073 1074
			dev_err(&interface->dev,
					"module get failed, exiting\n");
L
Linus Torvalds 已提交
1075 1076
			goto probe_error;
		}
A
Alan Cox 已提交
1077
		retval = type->attach(serial);
1078
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
1079 1080 1081
		if (retval < 0)
			goto probe_error;
		if (retval > 0) {
A
Alan Cox 已提交
1082 1083
			/* quietly accept this device, but don't bind to a
			   serial port as it's about to disappear */
1084
			serial->num_ports = 0;
L
Linus Torvalds 已提交
1085 1086 1087 1088
			goto exit;
		}
	}

A
Alan Cox 已提交
1089
	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1090 1091 1092
		dev_err(&interface->dev, "No more free serial devices\n");
		goto probe_error;
	}
1093
	serial->minor = minor;
1094

L
Linus Torvalds 已提交
1095 1096 1097
	/* register all of the individual ports with the driver core */
	for (i = 0; i < num_ports; ++i) {
		port = serial->port[i];
1098
		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1099
		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1100
		port->dev_state = PORT_REGISTERING;
1101
		retval = device_add(&port->dev);
1102
		if (retval) {
1103 1104
			dev_err(&port->dev, "Error registering port device, "
				"continuing\n");
1105 1106 1107 1108
			port->dev_state = PORT_UNREGISTERED;
		} else {
			port->dev_state = PORT_REGISTERED;
		}
L
Linus Torvalds 已提交
1109 1110
	}

A
Alan Cox 已提交
1111
	usb_serial_console_init(debug, minor);
L
Linus Torvalds 已提交
1112 1113 1114

exit:
	/* success */
A
Alan Cox 已提交
1115
	usb_set_intfdata(interface, serial);
L
Linus Torvalds 已提交
1116 1117 1118
	return 0;

probe_error:
1119
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1120 1121
	return -EIO;
}
A
Alan Cox 已提交
1122
EXPORT_SYMBOL_GPL(usb_serial_probe);
L
Linus Torvalds 已提交
1123 1124 1125 1126

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

1131
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1132
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1133

1134
	mutex_lock(&serial->disc_mutex);
A
Alan Cox 已提交
1135
	usb_set_intfdata(interface, NULL);
1136 1137
	/* must set a flag, to signal subdrivers */
	serial->disconnected = 1;
1138 1139
	mutex_unlock(&serial->disc_mutex);

1140 1141 1142
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1143 1144
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
A
Alan Cox 已提交
1145
				tty_vhangup(tty);
A
Alan Cox 已提交
1146 1147
				tty_kref_put(tty);
			}
1148
			kill_traffic(port);
1149
			cancel_work_sync(&port->work);
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
			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;
			}
1166 1167
		}
	}
1168
	serial->type->disconnect(serial);
1169

1170
	/* let the last holder of this object cause it to be cleaned up */
1171
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1172 1173
	dev_info(dev, "device disconnected\n");
}
A
Alan Cox 已提交
1174
EXPORT_SYMBOL_GPL(usb_serial_disconnect);
L
Linus Torvalds 已提交
1175

1176 1177 1178 1179 1180 1181
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;

1182 1183
	serial->suspending = 1;

1184 1185 1186 1187
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1188 1189 1190
	}

	if (serial->type->suspend)
1191
		r = serial->type->suspend(serial, message);
1192 1193 1194 1195 1196 1197 1198 1199

	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1200
	int rv;
1201

1202
	serial->suspending = 0;
S
Sarah Sharp 已提交
1203
	if (serial->type->resume)
1204 1205 1206
		rv = serial->type->resume(serial);
	else
		rv = usb_serial_generic_resume(serial);
1207

1208
	return rv;
1209 1210 1211
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1212
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1213 1214 1215
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1216
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225
	.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 Cox 已提交
1226 1227
	.shutdown = 		serial_do_free,
	.install = 		serial_install,
1228
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1229 1230
};

1231

L
Linus Torvalds 已提交
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
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 已提交
1244
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1245 1246 1247 1248
		serial_table[i] = NULL;

	result = bus_register(&usb_serial_bus_type);
	if (result) {
1249 1250
		printk(KERN_ERR "usb-serial: %s - registering bus driver "
		       "failed\n", __func__);
L
Linus Torvalds 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
		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 已提交
1261 1262
	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
						TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
1263
	usb_serial_tty_driver->init_termios = tty_std_termios;
A
Alan Cox 已提交
1264 1265
	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
							| HUPCL | CLOCAL;
1266 1267
	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1268 1269 1270
	tty_set_operations(usb_serial_tty_driver, &serial_ops);
	result = tty_register_driver(usb_serial_tty_driver);
	if (result) {
1271 1272
		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
		       __func__);
L
Linus Torvalds 已提交
1273 1274 1275 1276 1277 1278
		goto exit_reg_driver;
	}

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

1284 1285 1286
	/* register the generic driver, if we should */
	result = usb_serial_generic_register(debug);
	if (result < 0) {
1287 1288
		printk(KERN_ERR "usb-serial: %s - registering generic "
		       "driver failed\n", __func__);
1289 1290 1291
		goto exit_generic;
	}

1292
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1293 1294 1295

	return result;

1296 1297 1298
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1299 1300 1301 1302 1303 1304 1305
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1306 1307
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
	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 已提交
1334
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1335 1336 1337
			}						\
	} while (0)

1338
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1339 1340 1341 1342 1343 1344 1345 1346
{
	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);
1347 1348
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1349 1350
}

A
Alan Cox 已提交
1351
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1352
{
A
Alan Cox 已提交
1353
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1354 1355
	int retval;

1356 1357 1358
	if (usb_disabled())
		return -ENODEV;

1359
	fixup_generic(driver);
L
Linus Torvalds 已提交
1360

1361 1362 1363
	if (!driver->description)
		driver->description = driver->driver.name;

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

1367
	retval = usb_serial_bus_register(driver);
L
Linus Torvalds 已提交
1368
	if (retval) {
1369 1370
		printk(KERN_ERR "usb-serial: problem %d when registering "
		       "driver %s\n", retval, driver->description);
1371
		list_del(&driver->driver_list);
A
Alan Cox 已提交
1372
	} else
1373
		printk(KERN_INFO "USB Serial support registered for %s\n",
A
Alan Cox 已提交
1374
						driver->description);
L
Linus Torvalds 已提交
1375 1376 1377

	return retval;
}
A
Alan Cox 已提交
1378
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1379 1380


A
Alan Cox 已提交
1381
void usb_serial_deregister(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1382
{
A
Alan Cox 已提交
1383
	/* must be called with BKL held */
1384 1385
	printk(KERN_INFO "USB Serial deregistering driver %s\n",
	       device->description);
L
Linus Torvalds 已提交
1386 1387 1388 1389 1390 1391
	list_del(&device->driver_list);
	usb_serial_bus_deregister(device);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister);

/* Module information */
A
Alan Cox 已提交
1392 1393
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1394 1395 1396 1397
MODULE_LICENSE("GPL");

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