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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	serial = to_usb_serial(kref);

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

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

159 160
	if (serial->attached)
		serial->type->release(serial);
161

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

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

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

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

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

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

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

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

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

226 227
	mutex_unlock(&serial->disc_mutex);

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

232 233
	tty->driver_data = port;

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

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

A
Alan Cox 已提交
250
static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
L
Linus Torvalds 已提交
251
{
A
Alan Cox 已提交
252 253
	struct usb_serial_port *port =
		container_of(tport, struct usb_serial_port, port);
254 255
	struct usb_serial *serial = port->serial;
	int retval;
256

A
Alan Cox 已提交
257 258 259 260 261 262 263 264
	mutex_lock(&serial->disc_mutex);
	if (serial->disconnected)
		retval = -ENODEV;
	else
		retval = port->serial->type->open(tty, port);
	mutex_unlock(&serial->disc_mutex);
	return retval;
}
L
Linus Torvalds 已提交
265

A
Alan Cox 已提交
266 267 268
static int serial_open(struct tty_struct *tty, struct file *filp)
{
	struct usb_serial_port *port = tty->driver_data;
269

A
Alan Cox 已提交
270 271
	dbg("%s - port %d", __func__, port->number);
	return tty_port_open(&port->port, tty, filp);
L
Linus Torvalds 已提交
272 273
}

274
/**
A
Alan Stern 已提交
275
 * serial_down - shut down hardware
276
 * @tport: tty port to shut down
277
 *
278
 * Shut down a USB serial port unless it is the console.  We never
279 280 281
 * shut down the console hardware as it will always be in use. Serialized
 * against activate by the tport mutex and kept to matching open/close pairs
 * of calls by the ASYNCB_INITIALIZED flag.
282
 */
283
static void serial_down(struct tty_port *tport)
L
Linus Torvalds 已提交
284
{
285 286
	struct usb_serial_port *port =
		container_of(tport, struct usb_serial_port, port);
287
	struct usb_serial_driver *drv = port->serial->type;
288 289 290 291
	/*
	 * The console is magical.  Do not hang up the console hardware
	 * or there will be tears.
	 */
292
	if (port->console)
L
Linus Torvalds 已提交
293
		return;
294 295 296 297
	if (drv->close)
		drv->close(port);
}

298 299 300
static void serial_hangup(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
301
	dbg("%s - port %d", __func__, port->number);
302 303 304 305 306 307 308
	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);
309
	tty_port_close(&port->port, tty, filp);
310 311
}

312
/**
313
 * serial_cleanup - free resources post close/hangup
314
 * @port: port to free up
315
 *
316 317
 * Do the resource freeing and refcount dropping for the port.
 * Avoid freeing the console.
318
 *
319 320
 * Called asynchronously after the last tty kref is dropped,
 * and the tty layer has already done the tty_shutdown(tty);
321
 */
322
static void serial_cleanup(struct tty_struct *tty)
323
{
324
	struct usb_serial_port *port = tty->driver_data;
325 326 327
	struct usb_serial *serial;
	struct module *owner;

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

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

336 337
	tty->driver_data = NULL;

338 339
	serial = port->serial;
	owner = serial->type->driver.owner;
340

341 342 343 344
	mutex_lock(&serial->disc_mutex);
	if (!serial->disconnected)
		usb_autopm_put_interface(serial->interface);
	mutex_unlock(&serial->disc_mutex);
345

346
	usb_serial_put(serial);
347 348 349
	module_put(owner);
}

A
Alan Cox 已提交
350 351
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
								int count)
L
Linus Torvalds 已提交
352
{
353
	struct usb_serial_port *port = tty->driver_data;
354
	int retval = -ENODEV;
L
Linus Torvalds 已提交
355

A
Alan Cox 已提交
356
	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
357 358
		goto exit;

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

A
Alan Cox 已提交
361
	/* count is managed under the mutex lock for the tty so cannot
A
Alan Cox 已提交
362
	   drop to zero until after the last close completes */
A
Alan Cox 已提交
363
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
364 365

	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
366
	retval = port->serial->type->write(tty, port, buf, count);
L
Linus Torvalds 已提交
367 368 369 370 371

exit:
	return retval;
}

A
Alan Cox 已提交
372
static int serial_write_room(struct tty_struct *tty)
L
Linus Torvalds 已提交
373
{
374
	struct usb_serial_port *port = tty->driver_data;
375
	dbg("%s - port %d", __func__, port->number);
A
Alan Cox 已提交
376
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
377
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
378
	return port->serial->type->write_room(tty);
L
Linus Torvalds 已提交
379 380
}

A
Alan Cox 已提交
381
static int serial_chars_in_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
382
{
383
	struct usb_serial_port *port = tty->driver_data;
384
	dbg("%s = port %d", __func__, port->number);
L
Linus Torvalds 已提交
385

386 387 388 389
	/* if the device was unplugged then any remaining characters
	   fell out of the connector ;) */
	if (port->serial->disconnected)
		return 0;
L
Linus Torvalds 已提交
390
	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
391
	return port->serial->type->chars_in_buffer(tty);
L
Linus Torvalds 已提交
392 393
}

A
Alan Cox 已提交
394
static void serial_throttle(struct tty_struct *tty)
L
Linus Torvalds 已提交
395
{
396
	struct usb_serial_port *port = tty->driver_data;
397
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
398

A
Alan Cox 已提交
399
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
400 401
	/* pass on to the driver specific version of this function */
	if (port->serial->type->throttle)
A
Alan Cox 已提交
402
		port->serial->type->throttle(tty);
L
Linus Torvalds 已提交
403 404
}

A
Alan Cox 已提交
405
static void serial_unthrottle(struct tty_struct *tty)
L
Linus Torvalds 已提交
406
{
407
	struct usb_serial_port *port = tty->driver_data;
408
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
409

A
Alan Cox 已提交
410
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
411 412
	/* pass on to the driver specific version of this function */
	if (port->serial->type->unthrottle)
A
Alan Cox 已提交
413
		port->serial->type->unthrottle(tty);
L
Linus Torvalds 已提交
414 415
}

A
Alan Cox 已提交
416 417
static int serial_ioctl(struct tty_struct *tty, struct file *file,
					unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
418
{
419
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
420 421
	int retval = -ENODEV;

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

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

A
Alan Cox 已提交
426 427
	/* pass on to the driver specific version of this function
	   if it is available */
A
Alan Cox 已提交
428
	if (port->serial->type->ioctl) {
A
Alan Cox 已提交
429
		retval = port->serial->type->ioctl(tty, file, cmd, arg);
A
Alan Cox 已提交
430
	} else
L
Linus Torvalds 已提交
431 432 433 434
		retval = -ENOIOCTLCMD;
	return retval;
}

A
Alan Cox 已提交
435
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
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);
A
Alan Cox 已提交
441 442
	/* pass on to the driver specific version of this function
	   if it is available */
L
Linus Torvalds 已提交
443
	if (port->serial->type->set_termios)
A
Alan Cox 已提交
444
		port->serial->type->set_termios(tty, port, old);
445 446
	else
		tty_termios_copy_hw(tty->termios, old);
L
Linus Torvalds 已提交
447 448
}

A
Alan Cox 已提交
449
static int serial_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
450
{
451
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
452

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

A
Alan Cox 已提交
455
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
456 457
	/* pass on to the driver specific version of this function
	   if it is available */
458
	if (port->serial->type->break_ctl)
A
Alan Cox 已提交
459
		port->serial->type->break_ctl(tty, break_state);
A
Alan Cox 已提交
460
	return 0;
L
Linus Torvalds 已提交
461 462
}

463
static int serial_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
464 465 466 467 468
{
	struct usb_serial *serial;
	int i;
	char tmp[40];

469
	dbg("%s", __func__);
470 471
	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
L
Linus Torvalds 已提交
472 473 474 475
		serial = usb_serial_get_by_index(i);
		if (serial == NULL)
			continue;

476
		seq_printf(m, "%d:", i);
477
		if (serial->type->driver.owner)
478
			seq_printf(m, " module:%s",
A
Alan Cox 已提交
479
				module_name(serial->type->driver.owner));
480
		seq_printf(m, " name:\"%s\"",
A
Alan Cox 已提交
481
				serial->type->description);
482
		seq_printf(m, " vendor:%04x product:%04x",
A
Alan Cox 已提交
483 484
			le16_to_cpu(serial->dev->descriptor.idVendor),
			le16_to_cpu(serial->dev->descriptor.idProduct));
485 486
		seq_printf(m, " num_ports:%d", serial->num_ports);
		seq_printf(m, " port:%d", i - serial->minor + 1);
L
Linus Torvalds 已提交
487
		usb_make_path(serial->dev, tmp, sizeof(tmp));
488
		seq_printf(m, " path:%s", tmp);
A
Alan Cox 已提交
489

490
		seq_putc(m, '\n');
491
		usb_serial_put(serial);
492
		mutex_unlock(&serial->disc_mutex);
L
Linus Torvalds 已提交
493
	}
494
	return 0;
L
Linus Torvalds 已提交
495 496
}

497 498 499 500 501 502 503 504 505 506 507 508 509
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 已提交
510
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
511
{
512
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
513

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

A
Alan Cox 已提交
516
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
517
	if (port->serial->type->tiocmget)
A
Alan Cox 已提交
518
		return port->serial->type->tiocmget(tty, file);
L
Linus Torvalds 已提交
519 520 521
	return -EINVAL;
}

A
Alan Cox 已提交
522
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
523 524
			    unsigned int set, unsigned int clear)
{
525
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
526

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

A
Alan Cox 已提交
529
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
530
	if (port->serial->type->tiocmset)
A
Alan Cox 已提交
531
		return port->serial->type->tiocmset(tty, file, set, clear);
L
Linus Torvalds 已提交
532 533 534
	return -EINVAL;
}

535 536 537 538 539 540 541 542 543
/*
 * 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 已提交
544
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
545

D
David Howells 已提交
546
static void usb_serial_port_work(struct work_struct *work)
L
Linus Torvalds 已提交
547
{
D
David Howells 已提交
548 549
	struct usb_serial_port *port =
		container_of(work, struct usb_serial_port, work);
L
Linus Torvalds 已提交
550 551
	struct tty_struct *tty;

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

A
Alan Cox 已提交
554
	tty = tty_port_tty_get(&port->port);
L
Linus Torvalds 已提交
555 556 557 558
	if (!tty)
		return;

	tty_wakeup(tty);
A
Alan Cox 已提交
559
	tty_kref_put(tty);
L
Linus Torvalds 已提交
560 561
}

562
static void kill_traffic(struct usb_serial_port *port)
563
{
L
Linus Torvalds 已提交
564 565
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
566 567 568 569 570 571 572 573 574 575 576
	/*
	 * 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 已提交
577 578
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
579 580
}

581
static void port_release(struct device *dev)
582
{
583 584 585 586
	struct usb_serial_port *port = to_usb_serial_port(dev);

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

587 588 589 590
	/*
	 * Stop all the traffic before cancelling the work, so that
	 * nobody will restart it by calling usb_serial_port_softint.
	 */
591
	kill_traffic(port);
592 593
	cancel_work_sync(&port->work);

594 595 596
	usb_free_urb(port->read_urb);
	usb_free_urb(port->write_urb);
	usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
597
	usb_free_urb(port->interrupt_out_urb);
598
	kfifo_free(&port->write_fifo);
L
Linus Torvalds 已提交
599 600 601 602 603 604 605
	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 已提交
606 607 608
static struct usb_serial *create_serial(struct usb_device *dev,
					struct usb_interface *interface,
					struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
609 610 611
{
	struct usb_serial *serial;

612
	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
L
Linus Torvalds 已提交
613
	if (!serial) {
614
		dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
615 616 617
		return NULL;
	}
	serial->dev = usb_get_dev(dev);
618
	serial->type = driver;
L
Linus Torvalds 已提交
619 620
	serial->interface = interface;
	kref_init(&serial->kref);
621
	mutex_init(&serial->disc_mutex);
622
	serial->minor = SERIAL_TTY_NO_MINOR;
L
Linus Torvalds 已提交
623 624 625 626

	return serial;
}

627
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
628
					    struct usb_serial_driver *drv)
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
{
	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 已提交
660 661
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
662 663
{
	const struct usb_device_id *id;
664
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
665

A
Adrian Bunk 已提交
666
	/* Check if the usb id matches a known device */
667 668
	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
		id = get_iface_id(drv, iface);
669
		if (id)
670
			return drv;
L
Linus Torvalds 已提交
671 672 673 674 675
	}

	return NULL;
}

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
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,
A
Alan Cox 已提交
697
	.activate = serial_activate,
698
	.shutdown = serial_down,
699 700
};

L
Linus Torvalds 已提交
701 702 703
int usb_serial_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
A
Alan Cox 已提交
704
	struct usb_device *dev = interface_to_usbdev(interface);
L
Linus Torvalds 已提交
705 706 707 708 709 710 711 712
	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];
713
	struct usb_serial_driver *type = NULL;
L
Linus Torvalds 已提交
714
	int retval;
715
	unsigned int minor;
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724
	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;

725
	lock_kernel(); /* guard against unloading a serial driver module */
L
Linus Torvalds 已提交
726 727
	type = search_serial_device(interface);
	if (!type) {
728
		unlock_kernel();
L
Linus Torvalds 已提交
729 730 731 732
		dbg("none matched");
		return -ENODEV;
	}

A
Alan Cox 已提交
733
	serial = create_serial(dev, interface, type);
L
Linus Torvalds 已提交
734
	if (!serial) {
735
		unlock_kernel();
736
		dev_err(&interface->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
737 738 739 740 741 742 743
		return -ENOMEM;
	}

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

744
		if (!try_module_get(type->driver.owner)) {
745
			unlock_kernel();
A
Alan Cox 已提交
746 747 748
			dev_err(&interface->dev,
				"module get failed, exiting\n");
			kfree(serial);
L
Linus Torvalds 已提交
749 750 751
			return -EIO;
		}

752
		id = get_iface_id(type, interface);
L
Linus Torvalds 已提交
753
		retval = type->probe(serial, id);
754
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
755 756

		if (retval) {
757
			unlock_kernel();
A
Alan Cox 已提交
758 759
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
760 761 762 763 764 765 766 767 768
			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;
769 770

		if (usb_endpoint_is_bulk_in(endpoint)) {
L
Linus Torvalds 已提交
771 772 773 774 775 776
			/* we found a bulk in endpoint */
			dbg("found bulk in on endpoint %d", i);
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;
		}

777
		if (usb_endpoint_is_bulk_out(endpoint)) {
L
Linus Torvalds 已提交
778 779 780 781 782
			/* we found a bulk out endpoint */
			dbg("found bulk out on endpoint %d", i);
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
		}
783 784

		if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
785 786 787 788 789 790
			/* we found a interrupt in endpoint */
			dbg("found interrupt in on endpoint %d", i);
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
		}

791
		if (usb_endpoint_is_int_out(endpoint)) {
L
Linus Torvalds 已提交
792 793 794 795 796 797 798 799
			/* 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 已提交
800
	/* BEGIN HORRIBLE HACK FOR PL2303 */
L
Linus Torvalds 已提交
801 802 803 804
	/* 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) &&
805 806
	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
807 808 809
	     (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 已提交
810 811 812 813 814
		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;
815
				if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
816 817 818 819 820 821 822 823 824 825 826 827 828
					/* 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) {
829
			unlock_kernel();
L
Linus Torvalds 已提交
830
			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
A
Alan Cox 已提交
831
			kfree(serial);
L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839 840 841
			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) {
842
			unlock_kernel();
A
Alan Cox 已提交
843 844 845
			dev_err(&interface->dev,
			    "Generic device with no bulk out, not allowed.\n");
			kfree(serial);
L
Linus Torvalds 已提交
846 847 848 849 850 851 852
			return -EIO;
		}
	}
#endif
	if (!num_ports) {
		/* if this device type has a calc_num_ports function, call it */
		if (type->calc_num_ports) {
853
			if (!try_module_get(type->driver.owner)) {
854
				unlock_kernel();
A
Alan Cox 已提交
855 856 857
				dev_err(&interface->dev,
					"module get failed, exiting\n");
				kfree(serial);
L
Linus Torvalds 已提交
858 859
				return -EIO;
			}
A
Alan Cox 已提交
860
			num_ports = type->calc_num_ports(serial);
861
			module_put(type->driver.owner);
L
Linus Torvalds 已提交
862 863 864 865 866 867 868 869 870 871 872
		}
		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;

873 874 875 876
	/* found all that we need */
	dev_info(&interface->dev, "%s converter detected\n",
			type->description);

L
Linus Torvalds 已提交
877
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
878 879
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
880 881 882 883 884
	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;
885 886
	unlock_kernel();

A
Alan Cox 已提交
887 888
	dbg("%s - setting up %d port structures for this device",
						__func__, max_endpoints);
L
Linus Torvalds 已提交
889
	for (i = 0; i < max_endpoints; ++i) {
890
		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
L
Linus Torvalds 已提交
891 892
		if (!port)
			goto probe_error;
A
Alan Cox 已提交
893
		tty_port_init(&port->port);
894
		port->port.ops = &serial_port_ops;
L
Linus Torvalds 已提交
895
		port->serial = serial;
896
		spin_lock_init(&port->lock);
897 898
		/* Keep this for private driver use for the moment but
		   should probably go away */
D
David Howells 已提交
899
		INIT_WORK(&port->work, usb_serial_port_work);
L
Linus Torvalds 已提交
900
		serial->port[i] = port;
901 902 903 904 905
		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 已提交
906 907 908 909 910 911
	}

	/* 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 已提交
912
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
913 914 915 916 917 918 919
		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 已提交
920
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
921
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
922 923
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
924 925
			goto probe_error;
		}
A
Alan Cox 已提交
926 927 928 929 930
		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 已提交
931 932 933 934 935 936 937 938 939 940
	}

	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;
		}
941
		if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
942
			goto probe_error;
L
Linus Torvalds 已提交
943 944 945
		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
		port->bulk_out_size = buffer_size;
		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
946
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
947
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
948 949
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
950 951
			goto probe_error;
		}
A
Alan Cox 已提交
952 953 954 955 956
		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 已提交
957 958 959 960 961 962 963 964
	}

	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 已提交
965 966
				dev_err(&interface->dev,
						"No free urbs available\n");
L
Linus Torvalds 已提交
967 968 969
				goto probe_error;
			}
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
A
Alan Cox 已提交
970 971 972 973
			port->interrupt_in_endpointAddress =
						endpoint->bEndpointAddress;
			port->interrupt_in_buffer = kmalloc(buffer_size,
								GFP_KERNEL);
L
Linus Torvalds 已提交
974
			if (!port->interrupt_in_buffer) {
A
Alan Cox 已提交
975 976
				dev_err(&interface->dev,
				    "Couldn't allocate interrupt_in_buffer\n");
L
Linus Torvalds 已提交
977 978
				goto probe_error;
			}
A
Alan Cox 已提交
979 980 981 982 983 984
			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 已提交
985 986 987 988
		}
	} else if (num_interrupt_in) {
		dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
	}
A
Alan Cox 已提交
989

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

L
Linus Torvalds 已提交
1022 1023
	/* if this device type has an attach function, call it */
	if (type->attach) {
1024
		if (!try_module_get(type->driver.owner)) {
A
Alan Cox 已提交
1025 1026
			dev_err(&interface->dev,
					"module get failed, exiting\n");
L
Linus Torvalds 已提交
1027 1028
			goto probe_error;
		}
A
Alan Cox 已提交
1029
		retval = type->attach(serial);
1030
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
1031 1032
		if (retval < 0)
			goto probe_error;
1033
		serial->attached = 1;
L
Linus Torvalds 已提交
1034
		if (retval > 0) {
A
Alan Cox 已提交
1035 1036
			/* quietly accept this device, but don't bind to a
			   serial port as it's about to disappear */
1037
			serial->num_ports = 0;
L
Linus Torvalds 已提交
1038 1039
			goto exit;
		}
1040 1041
	} else {
		serial->attached = 1;
L
Linus Torvalds 已提交
1042 1043
	}

A
Alan Cox 已提交
1044
	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1045 1046 1047
		dev_err(&interface->dev, "No more free serial devices\n");
		goto probe_error;
	}
1048
	serial->minor = minor;
1049

L
Linus Torvalds 已提交
1050 1051 1052
	/* register all of the individual ports with the driver core */
	for (i = 0; i < num_ports; ++i) {
		port = serial->port[i];
1053
		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1054
		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1055
		port->dev_state = PORT_REGISTERING;
1056
		retval = device_add(&port->dev);
1057
		if (retval) {
1058 1059
			dev_err(&port->dev, "Error registering port device, "
				"continuing\n");
1060 1061 1062 1063
			port->dev_state = PORT_UNREGISTERED;
		} else {
			port->dev_state = PORT_REGISTERED;
		}
L
Linus Torvalds 已提交
1064 1065
	}

A
Alan Cox 已提交
1066
	usb_serial_console_init(debug, minor);
L
Linus Torvalds 已提交
1067 1068 1069

exit:
	/* success */
A
Alan Cox 已提交
1070
	usb_set_intfdata(interface, serial);
L
Linus Torvalds 已提交
1071 1072 1073
	return 0;

probe_error:
1074
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1075 1076
	return -EIO;
}
A
Alan Cox 已提交
1077
EXPORT_SYMBOL_GPL(usb_serial_probe);
L
Linus Torvalds 已提交
1078 1079 1080 1081

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

1086
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1087
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1088

1089
	mutex_lock(&serial->disc_mutex);
A
Alan Cox 已提交
1090
	usb_set_intfdata(interface, NULL);
1091 1092
	/* must set a flag, to signal subdrivers */
	serial->disconnected = 1;
1093 1094
	mutex_unlock(&serial->disc_mutex);

1095 1096 1097
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1098 1099
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
A
Alan Cox 已提交
1100
				tty_vhangup(tty);
A
Alan Cox 已提交
1101 1102
				tty_kref_put(tty);
			}
1103
			kill_traffic(port);
1104
			cancel_work_sync(&port->work);
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
			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;
			}
1121 1122
		}
	}
1123
	serial->type->disconnect(serial);
1124

1125
	/* let the last holder of this object cause it to be cleaned up */
1126
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1127 1128
	dev_info(dev, "device disconnected\n");
}
A
Alan Cox 已提交
1129
EXPORT_SYMBOL_GPL(usb_serial_disconnect);
L
Linus Torvalds 已提交
1130

1131 1132 1133 1134 1135 1136
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;

1137 1138
	serial->suspending = 1;

1139 1140
	if (serial->type->suspend) {
		r = serial->type->suspend(serial, message);
1141 1142
		if (r < 0) {
			serial->suspending = 0;
1143
			goto err_out;
1144
		}
1145 1146
	}

1147 1148 1149 1150
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1151 1152
	}

1153
err_out:
1154 1155 1156 1157 1158 1159 1160
	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1161
	int rv;
1162

1163
	serial->suspending = 0;
S
Sarah Sharp 已提交
1164
	if (serial->type->resume)
1165 1166 1167
		rv = serial->type->resume(serial);
	else
		rv = usb_serial_generic_resume(serial);
1168

1169
	return rv;
1170 1171 1172
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1173
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1174 1175 1176
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1177
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1178 1179 1180 1181 1182 1183 1184 1185 1186
	.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,
1187
	.cleanup = 		serial_cleanup,
A
Alan Cox 已提交
1188
	.install = 		serial_install,
1189
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1190 1191
};

1192

L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
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 已提交
1205
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1206 1207 1208 1209
		serial_table[i] = NULL;

	result = bus_register(&usb_serial_bus_type);
	if (result) {
1210 1211
		printk(KERN_ERR "usb-serial: %s - registering bus driver "
		       "failed\n", __func__);
L
Linus Torvalds 已提交
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
		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 已提交
1222 1223
	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
						TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
1224
	usb_serial_tty_driver->init_termios = tty_std_termios;
A
Alan Cox 已提交
1225 1226
	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
							| HUPCL | CLOCAL;
1227 1228
	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1229 1230 1231
	tty_set_operations(usb_serial_tty_driver, &serial_ops);
	result = tty_register_driver(usb_serial_tty_driver);
	if (result) {
1232 1233
		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
		       __func__);
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239
		goto exit_reg_driver;
	}

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

1245 1246 1247
	/* register the generic driver, if we should */
	result = usb_serial_generic_register(debug);
	if (result < 0) {
1248 1249
		printk(KERN_ERR "usb-serial: %s - registering generic "
		       "driver failed\n", __func__);
1250 1251 1252
		goto exit_generic;
	}

1253
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1254 1255 1256

	return result;

1257 1258 1259
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1260 1261 1262 1263 1264 1265 1266
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1267 1268
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	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 已提交
1295
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1296 1297 1298
			}						\
	} while (0)

1299
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1300 1301 1302 1303 1304 1305 1306 1307
{
	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);
1308 1309
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1310 1311
}

A
Alan Cox 已提交
1312
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1313
{
A
Alan Cox 已提交
1314
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1315 1316
	int retval;

1317 1318 1319
	if (usb_disabled())
		return -ENODEV;

1320
	fixup_generic(driver);
L
Linus Torvalds 已提交
1321

1322 1323 1324
	if (!driver->description)
		driver->description = driver->driver.name;

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

1328
	retval = usb_serial_bus_register(driver);
L
Linus Torvalds 已提交
1329
	if (retval) {
1330 1331
		printk(KERN_ERR "usb-serial: problem %d when registering "
		       "driver %s\n", retval, driver->description);
1332
		list_del(&driver->driver_list);
A
Alan Cox 已提交
1333
	} else
1334
		printk(KERN_INFO "USB Serial support registered for %s\n",
A
Alan Cox 已提交
1335
						driver->description);
L
Linus Torvalds 已提交
1336 1337 1338

	return retval;
}
A
Alan Cox 已提交
1339
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1340 1341


A
Alan Cox 已提交
1342
void usb_serial_deregister(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1343
{
A
Alan Cox 已提交
1344
	/* must be called with BKL held */
1345 1346
	printk(KERN_INFO "USB Serial deregistering driver %s\n",
	       device->description);
L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352
	list_del(&device->driver_list);
	usb_serial_bus_deregister(device);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister);

/* Module information */
A
Alan Cox 已提交
1353 1354
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1355 1356 1357 1358
MODULE_LICENSE("GPL");

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