usb-serial.c 37.3 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->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->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 361

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

exit:
	return retval;
}

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

A
Alan Cox 已提交
376
static int serial_chars_in_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
377
{
378
	struct usb_serial_port *port = tty->driver_data;
379
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
380

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

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

	/* pass on to the driver specific version of this function */
	if (port->serial->type->throttle)
A
Alan Cox 已提交
396
		port->serial->type->throttle(tty);
L
Linus Torvalds 已提交
397 398
}

A
Alan Cox 已提交
399
static void serial_unthrottle(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 404 405

	/* pass on to the driver specific version of this function */
	if (port->serial->type->unthrottle)
A
Alan Cox 已提交
406
		port->serial->type->unthrottle(tty);
L
Linus Torvalds 已提交
407 408
}

A
Alan Cox 已提交
409 410
static int serial_ioctl(struct tty_struct *tty, struct file *file,
					unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
411
{
412
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
413 414
	int retval = -ENODEV;

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

A
Alan Cox 已提交
417 418
	/* pass on to the driver specific version of this function
	   if it is available */
A
Alan Cox 已提交
419
	if (port->serial->type->ioctl) {
A
Alan Cox 已提交
420
		retval = port->serial->type->ioctl(tty, file, cmd, arg);
A
Alan Cox 已提交
421
	} else
L
Linus Torvalds 已提交
422 423 424 425
		retval = -ENOIOCTLCMD;
	return retval;
}

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

A
Alan Cox 已提交
431 432
	/* pass on to the driver specific version of this function
	   if it is available */
L
Linus Torvalds 已提交
433
	if (port->serial->type->set_termios)
A
Alan Cox 已提交
434
		port->serial->type->set_termios(tty, port, old);
435 436
	else
		tty_termios_copy_hw(tty->termios, old);
L
Linus Torvalds 已提交
437 438
}

A
Alan Cox 已提交
439
static int serial_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
440
{
441
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
442

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

A
Alan Cox 已提交
445 446
	/* pass on to the driver specific version of this function
	   if it is available */
447
	if (port->serial->type->break_ctl)
A
Alan Cox 已提交
448
		port->serial->type->break_ctl(tty, break_state);
A
Alan Cox 已提交
449
	return 0;
L
Linus Torvalds 已提交
450 451
}

452
static int serial_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
453 454 455 456 457
{
	struct usb_serial *serial;
	int i;
	char tmp[40];

458
	dbg("%s", __func__);
459 460
	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
L
Linus Torvalds 已提交
461 462 463 464
		serial = usb_serial_get_by_index(i);
		if (serial == NULL)
			continue;

465
		seq_printf(m, "%d:", i);
466
		if (serial->type->driver.owner)
467
			seq_printf(m, " module:%s",
A
Alan Cox 已提交
468
				module_name(serial->type->driver.owner));
469
		seq_printf(m, " name:\"%s\"",
A
Alan Cox 已提交
470
				serial->type->description);
471
		seq_printf(m, " vendor:%04x product:%04x",
A
Alan Cox 已提交
472 473
			le16_to_cpu(serial->dev->descriptor.idVendor),
			le16_to_cpu(serial->dev->descriptor.idProduct));
474 475
		seq_printf(m, " num_ports:%d", serial->num_ports);
		seq_printf(m, " port:%d", i - serial->minor + 1);
L
Linus Torvalds 已提交
476
		usb_make_path(serial->dev, tmp, sizeof(tmp));
477
		seq_printf(m, " path:%s", tmp);
A
Alan Cox 已提交
478

479
		seq_putc(m, '\n');
480
		usb_serial_put(serial);
481
		mutex_unlock(&serial->disc_mutex);
L
Linus Torvalds 已提交
482
	}
483
	return 0;
L
Linus Torvalds 已提交
484 485
}

486 487 488 489 490 491 492 493 494 495 496 497 498
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 已提交
499
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
500
{
501
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
502

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

	if (port->serial->type->tiocmget)
A
Alan Cox 已提交
506
		return port->serial->type->tiocmget(tty, file);
L
Linus Torvalds 已提交
507 508 509
	return -EINVAL;
}

A
Alan Cox 已提交
510
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
511 512
			    unsigned int set, unsigned int clear)
{
513
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
514

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

	if (port->serial->type->tiocmset)
A
Alan Cox 已提交
518
		return port->serial->type->tiocmset(tty, file, set, clear);
L
Linus Torvalds 已提交
519 520 521
	return -EINVAL;
}

522 523 524 525 526 527 528 529 530
/*
 * 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 已提交
531
EXPORT_SYMBOL_GPL(usb_serial_port_softint);
532

D
David Howells 已提交
533
static void usb_serial_port_work(struct work_struct *work)
L
Linus Torvalds 已提交
534
{
D
David Howells 已提交
535 536
	struct usb_serial_port *port =
		container_of(work, struct usb_serial_port, work);
L
Linus Torvalds 已提交
537 538
	struct tty_struct *tty;

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

A
Alan Cox 已提交
541
	tty = tty_port_tty_get(&port->port);
L
Linus Torvalds 已提交
542 543 544 545
	if (!tty)
		return;

	tty_wakeup(tty);
A
Alan Cox 已提交
546
	tty_kref_put(tty);
L
Linus Torvalds 已提交
547 548
}

549
static void kill_traffic(struct usb_serial_port *port)
550
{
551 552
	int i;

L
Linus Torvalds 已提交
553 554
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
555 556
	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
		usb_kill_urb(port->write_urbs[i]);
557 558 559 560 561 562 563 564 565 566 567
	/*
	 * 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 已提交
568 569
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
570 571
}

572
static void port_release(struct device *dev)
573
{
574
	struct usb_serial_port *port = to_usb_serial_port(dev);
575
	int i;
576 577 578

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

579 580 581 582
	/*
	 * Stop all the traffic before cancelling the work, so that
	 * nobody will restart it by calling usb_serial_port_softint.
	 */
583
	kill_traffic(port);
584 585
	cancel_work_sync(&port->work);

586 587 588
	usb_free_urb(port->read_urb);
	usb_free_urb(port->write_urb);
	usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
589
	usb_free_urb(port->interrupt_out_urb);
590 591 592 593
	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
		usb_free_urb(port->write_urbs[i]);
		kfree(port->bulk_out_buffers[i]);
	}
594
	kfifo_free(&port->write_fifo);
L
Linus Torvalds 已提交
595 596 597 598 599 600 601
	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 已提交
602 603 604
static struct usb_serial *create_serial(struct usb_device *dev,
					struct usb_interface *interface,
					struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
605 606 607
{
	struct usb_serial *serial;

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

	return serial;
}

623
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
624
					    struct usb_serial_driver *drv)
625 626 627 628 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
{
	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;
}

656
/* Caller must hold table_lock */
A
Alan Cox 已提交
657 658
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
659 660
{
	const struct usb_device_id *id;
661
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
662

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

	return NULL;
}

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

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

722
	mutex_lock(&table_lock);
L
Linus Torvalds 已提交
723 724
	type = search_serial_device(interface);
	if (!type) {
725
		mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
726 727 728 729
		dbg("none matched");
		return -ENODEV;
	}

730 731 732 733 734 735 736
	if (!try_module_get(type->driver.owner)) {
		mutex_unlock(&table_lock);
		dev_err(&interface->dev, "module get failed, exiting\n");
		return -EIO;
	}
	mutex_unlock(&table_lock);

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

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

747
		id = get_iface_id(type, interface);
L
Linus Torvalds 已提交
748
		retval = type->probe(serial, id);
749
		module_put(type->driver.owner);
L
Linus Torvalds 已提交
750 751

		if (retval) {
A
Alan Cox 已提交
752 753
			dbg("sub driver rejected device");
			kfree(serial);
L
Linus Torvalds 已提交
754 755 756 757 758 759 760 761 762
			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;
763 764

		if (usb_endpoint_is_bulk_in(endpoint)) {
L
Linus Torvalds 已提交
765 766 767 768 769 770
			/* we found a bulk in endpoint */
			dbg("found bulk in on endpoint %d", i);
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;
		}

771
		if (usb_endpoint_is_bulk_out(endpoint)) {
L
Linus Torvalds 已提交
772 773 774 775 776
			/* we found a bulk out endpoint */
			dbg("found bulk out on endpoint %d", i);
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
		}
777 778

		if (usb_endpoint_is_int_in(endpoint)) {
L
Linus Torvalds 已提交
779 780 781 782 783 784
			/* we found a interrupt in endpoint */
			dbg("found interrupt in on endpoint %d", i);
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
		}

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

864 865 866 867
	/* found all that we need */
	dev_info(&interface->dev, "%s converter detected\n",
			type->description);

L
Linus Torvalds 已提交
868
	/* create our ports, we need as many as the max endpoints */
A
Alan Cox 已提交
869 870
	/* we don't use num_ports here because some devices have more
	   endpoint pairs than ports */
L
Linus Torvalds 已提交
871 872 873 874 875
	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;
876

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

	/* 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 已提交
902
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
903 904 905 906
		if (!port->read_urb) {
			dev_err(&interface->dev, "No free urbs available\n");
			goto probe_error;
		}
907 908 909
		buffer_size = serial->type->bulk_in_size;
		if (!buffer_size)
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
L
Linus Torvalds 已提交
910 911
		port->bulk_in_size = buffer_size;
		port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
912
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
913
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
914 915
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
916 917
			goto probe_error;
		}
A
Alan Cox 已提交
918 919 920 921 922
		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 已提交
923 924 925
	}

	for (i = 0; i < num_bulk_out; ++i) {
926 927
		int j;

L
Linus Torvalds 已提交
928 929 930 931 932 933 934
		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;
		}
935
		if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
936
			goto probe_error;
937 938 939
		buffer_size = serial->type->bulk_out_size;
		if (!buffer_size)
			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
L
Linus Torvalds 已提交
940 941
		port->bulk_out_size = buffer_size;
		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
A
Alan Cox 已提交
942
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
943
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
944 945
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
946 947
			goto probe_error;
		}
A
Alan Cox 已提交
948 949 950 951 952
		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);
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974
		for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
			set_bit(j, &port->write_urbs_free);
			port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
			if (!port->write_urbs[j]) {
				dev_err(&interface->dev,
						"No free urbs available\n");
				goto probe_error;
			}
			port->bulk_out_buffers[j] = kmalloc(buffer_size,
								GFP_KERNEL);
			if (!port->bulk_out_buffers[j]) {
				dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
				goto probe_error;
			}
			usb_fill_bulk_urb(port->write_urbs[j], dev,
					usb_sndbulkpipe(dev,
						endpoint->bEndpointAddress),
					port->bulk_out_buffers[j], buffer_size,
					serial->type->write_bulk_callback,
					port);
		}
L
Linus Torvalds 已提交
975 976 977 978 979 980 981 982
	}

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

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

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

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

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

A
Alan Cox 已提交
1084
	usb_serial_console_init(debug, minor);
L
Linus Torvalds 已提交
1085 1086 1087

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

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

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

1104
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1105
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1106

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

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

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

1149 1150 1151 1152 1153 1154
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;

1155 1156
	serial->suspending = 1;

1157 1158
	if (serial->type->suspend) {
		r = serial->type->suspend(serial, message);
1159 1160
		if (r < 0) {
			serial->suspending = 0;
1161
			goto err_out;
1162
		}
1163 1164
	}

1165 1166 1167 1168
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1169 1170
	}

1171
err_out:
1172 1173 1174 1175 1176 1177 1178
	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1179
	int rv;
1180

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

1187
	return rv;
1188 1189 1190
}
EXPORT_SYMBOL(usb_serial_resume);

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

1210

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

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

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

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

1271
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1272 1273 1274

	return result;

1275 1276 1277
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1278 1279 1280 1281 1282 1283 1284
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

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

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

A
Alan Cox 已提交
1332
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1333
{
A
Alan Cox 已提交
1334
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1335 1336
	int retval;

1337 1338 1339
	if (usb_disabled())
		return -ENODEV;

1340
	fixup_generic(driver);
L
Linus Torvalds 已提交
1341

1342 1343 1344
	if (!driver->description)
		driver->description = driver->driver.name;

L
Linus Torvalds 已提交
1345
	/* Add this device to our list of devices */
1346
	mutex_lock(&table_lock);
1347
	list_add(&driver->driver_list, &usb_serial_driver_list);
L
Linus Torvalds 已提交
1348

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

1358
	mutex_unlock(&table_lock);
L
Linus Torvalds 已提交
1359 1360
	return retval;
}
A
Alan Cox 已提交
1361
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1362 1363


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