usb-serial.c 37.1 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 69 70
static LIST_HEAD(usb_serial_driver_list);

struct usb_serial *usb_serial_get_by_index(unsigned index)
{
71 72
	struct usb_serial *serial;

73
	mutex_lock(&table_lock);
74
	serial = serial_table[index];
L
Linus Torvalds 已提交
75 76 77

	if (serial)
		kref_get(&serial->kref);
78
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
79 80 81
	return serial;
}

A
Alan Cox 已提交
82 83
static struct usb_serial *get_free_serial(struct usb_serial *serial,
					int num_ports, unsigned int *minor)
L
Linus Torvalds 已提交
84 85 86 87
{
	unsigned int i, j;
	int good_spot;

88
	dbg("%s %d", __func__, num_ports);
L
Linus Torvalds 已提交
89 90

	*minor = 0;
91
	mutex_lock(&table_lock);
L
Linus Torvalds 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
	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 已提交
107
		j = 0;
108
		dbg("%s - minor base = %d", __func__, *minor);
O
Oliver Neukum 已提交
109
		for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
L
Linus Torvalds 已提交
110
			serial_table[i] = serial;
O
Oliver Neukum 已提交
111 112
			serial->port[j++]->number = i;
		}
113
		mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
114 115
		return serial;
	}
116
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
117 118 119 120 121 122 123
	return NULL;
}

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

124
	dbg("%s", __func__);
L
Linus Torvalds 已提交
125

A
Alan Cox 已提交
126
	for (i = 0; i < serial->num_ports; ++i)
L
Linus Torvalds 已提交
127 128 129 130 131 132 133 134 135 136 137
		serial_table[serial->minor + i] = NULL;
}

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

	serial = to_usb_serial(kref);

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

J
Jim Radford 已提交
140
	/* return the minor range that this device had */
141 142
	if (serial->minor != SERIAL_TTY_NO_MINOR)
		return_serial(serial);
J
Jim Radford 已提交
143

144 145
	serial->type->release(serial);

146 147
	/* Now that nothing is using the ports, they can be freed */
	for (i = 0; i < serial->num_port_pointers; ++i) {
148
		port = serial->port[i];
149 150
		if (port) {
			port->serial = NULL;
151
			put_device(&port->dev);
L
Linus Torvalds 已提交
152 153 154 155
		}
	}

	usb_put_dev(serial->dev);
A
Alan Cox 已提交
156
	kfree(serial);
L
Linus Torvalds 已提交
157 158
}

159 160
void usb_serial_put(struct usb_serial *serial)
{
161
	mutex_lock(&table_lock);
162
	kref_put(&serial->kref, destroy_serial);
163
	mutex_unlock(&table_lock);
164 165
}

L
Linus Torvalds 已提交
166 167 168
/*****************************************************************************
 * Driver tty interface functions
 *****************************************************************************/
A
Alan Cox 已提交
169
static int serial_open (struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
170 171 172 173
{
	struct usb_serial *serial;
	struct usb_serial_port *port;
	unsigned int portNumber;
174
	int retval = 0;
175
	int first = 0;
A
Alan Cox 已提交
176

177
	dbg("%s", __func__);
L
Linus Torvalds 已提交
178 179 180 181 182 183 184 185

	/* 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;
	}

186
	mutex_lock(&serial->disc_mutex);
L
Linus Torvalds 已提交
187 188
	portNumber = tty->index - serial->minor;
	port = serial->port[portNumber];
189
	if (!port || serial->disconnected)
190
		retval = -ENODEV;
191 192 193 194 195 196 197
	/*
	 * 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;
198

199 200
	if (mutex_lock_interruptible(&port->mutex)) {
		retval = -ERESTARTSYS;
201
		goto bailout_serial_put;
202
	}
A
Alan Cox 已提交
203

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

206 207 208
	/* set up our port structure making the tty driver
	 * remember our port object, and us it */
	tty->driver_data = port;
A
Alan Cox 已提交
209
	tty_port_tty_set(&port->port, tty);
L
Linus Torvalds 已提交
210

211 212
	/* If the console is attached, the device is already open */
	if (port->port.count == 1 && !port->console) {
213
		first = 1;
L
Linus Torvalds 已提交
214 215 216
		/* lock this module before we call it
		 * this may fail, which means we must bail out,
		 * safe because we are called with BKL held */
217
		if (!try_module_get(serial->type->driver.owner)) {
L
Linus Torvalds 已提交
218
			retval = -ENODEV;
219
			goto bailout_mutex_unlock;
L
Linus Torvalds 已提交
220 221
		}

222 223 224 225 226
		mutex_lock(&serial->disc_mutex);
		if (serial->disconnected)
			retval = -ENODEV;
		else
			retval = usb_autopm_get_interface(serial->interface);
227 228
		if (retval)
			goto bailout_module_put;
229

A
Alan Cox 已提交
230
		/* only call the device specific open if this
L
Linus Torvalds 已提交
231
		 * is the first time the port is opened */
232
		retval = serial->type->open(tty, port);
L
Linus Torvalds 已提交
233
		if (retval)
234
			goto bailout_interface_put;
235
		mutex_unlock(&serial->disc_mutex);
236
		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
L
Linus Torvalds 已提交
237
	}
238
	mutex_unlock(&port->mutex);
239 240
	/* Now do the correct tty layer semantics */
	retval = tty_port_block_til_ready(&port->port, tty, filp);
241 242 243
	if (retval == 0) {
		if (!first)
			usb_serial_put(serial);
244
		return 0;
245 246 247 248 249 250
	}
	mutex_lock(&port->mutex);
	if (first == 0)
		goto bailout_mutex_unlock;
	/* Undo the initial port actions */
	mutex_lock(&serial->disc_mutex);
251 252
bailout_interface_put:
	usb_autopm_put_interface(serial->interface);
L
Linus Torvalds 已提交
253
bailout_module_put:
254
	mutex_unlock(&serial->disc_mutex);
255
	module_put(serial->type->driver.owner);
256
bailout_mutex_unlock:
A
Alan Cox 已提交
257
	port->port.count = 0;
258
	tty->driver_data = NULL;
A
Alan Cox 已提交
259
	tty_port_tty_set(&port->port, NULL);
260
	mutex_unlock(&port->mutex);
261
bailout_serial_put:
262
	usb_serial_put(serial);
L
Linus Torvalds 已提交
263 264 265
	return retval;
}

266 267 268 269 270 271 272 273 274 275
/**
 *	serial_do_down		-	shut down hardware
 *	@port: port to shut down
 *
 *	Shut down a USB port unless it is the console. We never shut down the
 *	console hardware as it will always be in use.
 *
 *	Don't free any resources at this point
 */
static void serial_do_down(struct usb_serial_port *port)
L
Linus Torvalds 已提交
276
{
277
	struct usb_serial_driver *drv = port->serial->type;
278 279
	struct usb_serial *serial;
	struct module *owner;
L
Linus Torvalds 已提交
280

281 282 283
	/* The console is magical, do not hang up the console hardware
	   or there will be tears */
	if (port->console)
L
Linus Torvalds 已提交
284 285
		return;

286
	mutex_lock(&port->mutex);
287 288
	serial = port->serial;
	owner = serial->type->driver.owner;
289

290 291
	if (drv->close)
		drv->close(port);
L
Linus Torvalds 已提交
292

293
	mutex_unlock(&port->mutex);
294 295 296 297 298 299 300 301
}

/**
 *	serial_do_free		-	free resources post close/hangup
 *	@port: port to free up
 *
 *	Do the resource freeing and refcount dropping for the port. We must
 *	be careful about ordering and we must avoid freeing up the console.
302 303
 *
 *	Called when the last tty kref is dropped.
304
 */
305

306
static void serial_do_free(struct tty_struct *tty)
307
{
308
	struct usb_serial_port *port = tty->driver_data;
309 310 311 312 313
	struct usb_serial *serial;
	struct module *owner;

	/* The console is magical, do not hang up the console hardware
	   or there will be tears */
314
	if (port == NULL || port->console)
315 316 317 318
		return;

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

320 321 322 323
	mutex_lock(&serial->disc_mutex);
	if (!serial->disconnected)
		usb_autopm_put_interface(serial->interface);
	mutex_unlock(&serial->disc_mutex);
324

325
	usb_serial_put(serial);
326 327 328 329 330 331 332
	module_put(owner);
}

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

333 334 335
	if (!port)
		return;

336 337 338 339 340 341 342
	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);
343

344 345 346 347 348 349 350
}

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);
A
Alan Cox 已提交
351 352
	/* We must not free port yet - the USB serial layer depends on it's
	   continued existence */
L
Linus Torvalds 已提交
353 354
}

A
Alan Cox 已提交
355 356
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
								int count)
L
Linus Torvalds 已提交
357
{
358
	struct usb_serial_port *port = tty->driver_data;
359
	int retval = -ENODEV;
L
Linus Torvalds 已提交
360

A
Alan Cox 已提交
361
	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
362 363
		goto exit;

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

A
Alan Cox 已提交
366
	/* count is managed under the mutex lock for the tty so cannot
A
Alan Cox 已提交
367
	   drop to zero until after the last close completes */
A
Alan Cox 已提交
368
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
369 370

	/* pass on to the driver specific version of this function */
A
Alan Cox 已提交
371
	retval = port->serial->type->write(tty, port, buf, count);
L
Linus Torvalds 已提交
372 373 374 375 376

exit:
	return retval;
}

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

A
Alan Cox 已提交
386
static int serial_chars_in_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
387
{
388
	struct usb_serial_port *port = tty->driver_data;
389
	dbg("%s = port %d", __func__, port->number);
L
Linus Torvalds 已提交
390

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

A
Alan Cox 已提交
399
static void serial_throttle(struct tty_struct *tty)
L
Linus Torvalds 已提交
400
{
401
	struct usb_serial_port *port = tty->driver_data;
402
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
403

A
Alan Cox 已提交
404
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
405 406
	/* pass on to the driver specific version of this function */
	if (port->serial->type->throttle)
A
Alan Cox 已提交
407
		port->serial->type->throttle(tty);
L
Linus Torvalds 已提交
408 409
}

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

A
Alan Cox 已提交
415
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
416 417
	/* pass on to the driver specific version of this function */
	if (port->serial->type->unthrottle)
A
Alan Cox 已提交
418
		port->serial->type->unthrottle(tty);
L
Linus Torvalds 已提交
419 420
}

A
Alan Cox 已提交
421 422
static int serial_ioctl(struct tty_struct *tty, struct file *file,
					unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
423
{
424
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
425 426
	int retval = -ENODEV;

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

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

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

A
Alan Cox 已提交
440
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
L
Linus Torvalds 已提交
441
{
442
	struct usb_serial_port *port = tty->driver_data;
443
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
444

A
Alan Cox 已提交
445
	WARN_ON(!port->port.count);
A
Alan Cox 已提交
446 447
	/* pass on to the driver specific version of this function
	   if it is available */
L
Linus Torvalds 已提交
448
	if (port->serial->type->set_termios)
A
Alan Cox 已提交
449
		port->serial->type->set_termios(tty, port, old);
450 451
	else
		tty_termios_copy_hw(tty->termios, old);
L
Linus Torvalds 已提交
452 453
}

A
Alan Cox 已提交
454
static int serial_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
455
{
456
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
457

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

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

468
static int serial_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
469 470 471 472 473
{
	struct usb_serial *serial;
	int i;
	char tmp[40];

474
	dbg("%s", __func__);
475 476
	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
L
Linus Torvalds 已提交
477 478 479 480
		serial = usb_serial_get_by_index(i);
		if (serial == NULL)
			continue;

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

495
		seq_putc(m, '\n');
496
		usb_serial_put(serial);
L
Linus Torvalds 已提交
497
	}
498
	return 0;
L
Linus Torvalds 已提交
499 500
}

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

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

A
Alan Cox 已提交
520
	WARN_ON(!port->port.count);
L
Linus Torvalds 已提交
521
	if (port->serial->type->tiocmget)
A
Alan Cox 已提交
522
		return port->serial->type->tiocmget(tty, file);
L
Linus Torvalds 已提交
523 524 525
	return -EINVAL;
}

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

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

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

539 540 541 542 543 544 545 546 547
/*
 * 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 已提交
548
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
549

D
David Howells 已提交
550
static void usb_serial_port_work(struct work_struct *work)
L
Linus Torvalds 已提交
551
{
D
David Howells 已提交
552 553
	struct usb_serial_port *port =
		container_of(work, struct usb_serial_port, work);
L
Linus Torvalds 已提交
554 555
	struct tty_struct *tty;

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

A
Alan Cox 已提交
558
	tty = tty_port_tty_get(&port->port);
L
Linus Torvalds 已提交
559 560 561 562
	if (!tty)
		return;

	tty_wakeup(tty);
A
Alan Cox 已提交
563
	tty_kref_put(tty);
L
Linus Torvalds 已提交
564 565
}

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

585
static void port_release(struct device *dev)
586
{
587 588 589 590
	struct usb_serial_port *port = to_usb_serial_port(dev);

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

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

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

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

	return serial;
}

630
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
631
					    struct usb_serial_driver *drv)
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 660 661 662
{
	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 已提交
663 664
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
665 666
{
	const struct usb_device_id *id;
667
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
668

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

	return NULL;
}

679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
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 已提交
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
/**
 *	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 ones but permit them to be overriddenby serial->type->termios.
 *	This lets us remove all the ugly hackery
 */

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);
		if (serial->type->init_termios)
			serial->type->init_termios(tty);
		usb_serial_put(serial);
	}
	/* Final install (we use the default method) */
	tty_driver_kref_get(driver);
	tty->count++;
	driver->ttys[idx] = tty;
	return 0;
}

L
Linus Torvalds 已提交
737 738 739
int usb_serial_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
A
Alan Cox 已提交
740
	struct usb_device *dev = interface_to_usbdev(interface);
L
Linus Torvalds 已提交
741 742 743 744 745 746 747 748
	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];
749
	struct usb_serial_driver *type = NULL;
L
Linus Torvalds 已提交
750
	int retval;
751
	unsigned int minor;
L
Linus Torvalds 已提交
752 753 754 755 756 757 758 759 760
	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;

761
	lock_kernel(); /* guard against unloading a serial driver module */
L
Linus Torvalds 已提交
762 763
	type = search_serial_device(interface);
	if (!type) {
764
		unlock_kernel();
L
Linus Torvalds 已提交
765 766 767 768
		dbg("none matched");
		return -ENODEV;
	}

A
Alan Cox 已提交
769
	serial = create_serial(dev, interface, type);
L
Linus Torvalds 已提交
770
	if (!serial) {
771
		unlock_kernel();
772
		dev_err(&interface->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
773 774 775 776 777 778 779
		return -ENOMEM;
	}

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

780
		if (!try_module_get(type->driver.owner)) {
781
			unlock_kernel();
A
Alan Cox 已提交
782 783 784
			dev_err(&interface->dev,
				"module get failed, exiting\n");
			kfree(serial);
L
Linus Torvalds 已提交
785 786 787
			return -EIO;
		}

788
		id = get_iface_id(type, interface);
L
Linus Torvalds 已提交
789
		retval = type->probe(serial, id);
790
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
791 792

		if (retval) {
793
			unlock_kernel();
A
Alan Cox 已提交
794 795
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
796 797 798 799 800 801 802 803 804
			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;
805 806

		if (usb_endpoint_is_bulk_in(endpoint)) {
L
Linus Torvalds 已提交
807 808 809 810 811 812
			/* we found a bulk in endpoint */
			dbg("found bulk in on endpoint %d", i);
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;
		}

813
		if (usb_endpoint_is_bulk_out(endpoint)) {
L
Linus Torvalds 已提交
814 815 816 817 818
			/* we found a bulk out endpoint */
			dbg("found bulk out on endpoint %d", i);
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
		}
819 820

		if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
821 822 823 824 825 826
			/* we found a interrupt in endpoint */
			dbg("found interrupt in on endpoint %d", i);
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
		}

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

909 910 911 912
	/* found all that we need */
	dev_info(&interface->dev, "%s converter detected\n",
			type->description);

L
Linus Torvalds 已提交
913
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
914 915
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
916 917 918 919 920
	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;
921 922
	unlock_kernel();

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

	/* 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 已提交
947
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
948 949 950 951 952 953 954
		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 已提交
955
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
956
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
957 958
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
959 960
			goto probe_error;
		}
A
Alan Cox 已提交
961 962 963 964 965
		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 已提交
966 967 968 969 970 971 972 973 974 975 976 977 978
	}

	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 已提交
979
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
980
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
981 982
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
983 984
			goto probe_error;
		}
A
Alan Cox 已提交
985 986 987 988 989
		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 已提交
990 991 992 993 994 995 996 997
	}

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

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

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

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

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

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

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

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

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

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

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

1125 1126 1127
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1128 1129
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
A
Alan Cox 已提交
1130
				tty_vhangup(tty);
A
Alan Cox 已提交
1131 1132
				tty_kref_put(tty);
			}
1133
			kill_traffic(port);
1134
			cancel_work_sync(&port->work);
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
			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;
			}
1151 1152
		}
	}
1153
	serial->type->disconnect(serial);
1154

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

1161 1162 1163 1164 1165 1166
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;

1167 1168
	serial->suspending = 1;

1169 1170 1171 1172
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1173 1174 1175
	}

	if (serial->type->suspend)
1176
		r = serial->type->suspend(serial, message);
1177 1178 1179 1180 1181 1182 1183 1184

	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1185
	int rv;
1186

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

1193
	return rv;
1194 1195 1196
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1197
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1198 1199 1200
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1201
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1202 1203 1204 1205 1206 1207 1208 1209 1210
	.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 已提交
1211 1212
	.shutdown = 		serial_do_free,
	.install = 		serial_install,
1213
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1214 1215
};

1216

L
Linus Torvalds 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
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 已提交
1229
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1230 1231 1232 1233
		serial_table[i] = NULL;

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

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

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

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

	return result;

1281 1282 1283
exit_generic:
	usb_deregister(&usb_serial_driver);

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

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1291 1292
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
	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 已提交
1319
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1320 1321 1322
			}						\
	} while (0)

1323
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1324 1325 1326 1327 1328 1329 1330 1331
{
	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);
1332 1333
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1334 1335
}

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

1341 1342 1343
	if (usb_disabled())
		return -ENODEV;

1344
	fixup_generic(driver);
L
Linus Torvalds 已提交
1345

1346 1347 1348
	if (!driver->description)
		driver->description = driver->driver.name;

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

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

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


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

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

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