usb-serial.c 37.8 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>
L
Linus Torvalds 已提交
35
#include <linux/usb.h>
36
#include <linux/usb/serial.h>
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44
#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"

45 46
static void port_free(struct usb_serial_port *port);

L
Linus Torvalds 已提交
47 48 49 50 51
/* 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 70 71
static LIST_HEAD(usb_serial_driver_list);

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

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

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

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

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

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

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

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

A
Alan Cox 已提交
127
	for (i = 0; i < serial->num_ports; ++i)
L
Linus Torvalds 已提交
128 129 130 131 132 133 134 135 136 137 138
		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);

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

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

145 146 147 148 149 150 151 152
	serial->type->release(serial);

	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			put_device(&port->dev);
	}

L
Linus Torvalds 已提交
153 154 155 156
	/* If this is a "fake" port, we have to clean it up here, as it will
	 * not get cleaned up in port_release() as it was never registered with
	 * the driver core */
	if (serial->num_ports < serial->num_port_pointers) {
A
Alan Cox 已提交
157 158
		for (i = serial->num_ports;
					i < serial->num_port_pointers; ++i) {
L
Linus Torvalds 已提交
159
			port = serial->port[i];
160 161
			if (port)
				port_free(port);
L
Linus Torvalds 已提交
162 163 164 165 166 167
		}
	}

	usb_put_dev(serial->dev);

	/* free up any memory that we allocated */
A
Alan Cox 已提交
168
	kfree(serial);
L
Linus Torvalds 已提交
169 170
}

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

L
Linus Torvalds 已提交
178 179 180
/*****************************************************************************
 * Driver tty interface functions
 *****************************************************************************/
A
Alan Cox 已提交
181
static int serial_open (struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
182 183 184 185
{
	struct usb_serial *serial;
	struct usb_serial_port *port;
	unsigned int portNumber;
186
	int retval = 0;
A
Alan Cox 已提交
187

188
	dbg("%s", __func__);
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196

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

197
	mutex_lock(&serial->disc_mutex);
L
Linus Torvalds 已提交
198 199
	portNumber = tty->index - serial->minor;
	port = serial->port[portNumber];
200
	if (!port || serial->disconnected)
201
		retval = -ENODEV;
202 203 204 205 206 207 208 209 210
	else
		get_device(&port->dev);
	/*
	 * 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;
211

212 213
	if (mutex_lock_interruptible(&port->mutex)) {
		retval = -ERESTARTSYS;
214
		goto bailout_port_put;
215
	}
A
Alan Cox 已提交
216

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

219 220 221
	/* set up our port structure making the tty driver
	 * remember our port object, and us it */
	tty->driver_data = port;
A
Alan Cox 已提交
222
	tty_port_tty_set(&port->port, tty);
L
Linus Torvalds 已提交
223

224 225
	/* If the console is attached, the device is already open */
	if (port->port.count == 1 && !port->console) {
L
Linus Torvalds 已提交
226 227 228 229

		/* lock this module before we call it
		 * this may fail, which means we must bail out,
		 * safe because we are called with BKL held */
230
		if (!try_module_get(serial->type->driver.owner)) {
L
Linus Torvalds 已提交
231
			retval = -ENODEV;
232
			goto bailout_mutex_unlock;
L
Linus Torvalds 已提交
233 234
		}

235 236 237 238 239
		mutex_lock(&serial->disc_mutex);
		if (serial->disconnected)
			retval = -ENODEV;
		else
			retval = usb_autopm_get_interface(serial->interface);
240 241
		if (retval)
			goto bailout_module_put;
242

A
Alan Cox 已提交
243
		/* only call the device specific open if this
L
Linus Torvalds 已提交
244
		 * is the first time the port is opened */
A
Alan Cox 已提交
245
		retval = serial->type->open(tty, port, filp);
L
Linus Torvalds 已提交
246
		if (retval)
247
			goto bailout_interface_put;
248
		mutex_unlock(&serial->disc_mutex);
L
Linus Torvalds 已提交
249
	}
250
	mutex_unlock(&port->mutex);
251 252 253 254
	/* Now do the correct tty layer semantics */
	retval = tty_port_block_til_ready(&port->port, tty, filp);
	if (retval == 0)
		return 0;
L
Linus Torvalds 已提交
255

256 257
bailout_interface_put:
	usb_autopm_put_interface(serial->interface);
L
Linus Torvalds 已提交
258
bailout_module_put:
259
	mutex_unlock(&serial->disc_mutex);
260
	module_put(serial->type->driver.owner);
261
bailout_mutex_unlock:
A
Alan Cox 已提交
262
	port->port.count = 0;
263
	tty->driver_data = NULL;
A
Alan Cox 已提交
264
	tty_port_tty_set(&port->port, NULL);
265
	mutex_unlock(&port->mutex);
266 267 268
bailout_port_put:
	put_device(&port->dev);
bailout_serial_put:
269
	usb_serial_put(serial);
L
Linus Torvalds 已提交
270 271 272
	return retval;
}

273 274 275 276 277 278 279 280 281 282
/**
 *	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 已提交
283
{
284
	struct usb_serial_driver *drv = port->serial->type;
285 286
	struct usb_serial *serial;
	struct module *owner;
L
Linus Torvalds 已提交
287

288 289 290
	/* The console is magical, do not hang up the console hardware
	   or there will be tears */
	if (port->console)
L
Linus Torvalds 已提交
291 292
		return;

293
	mutex_lock(&port->mutex);
294 295
	serial = port->serial;
	owner = serial->type->driver.owner;
296

297 298
	if (drv->close)
		drv->close(port);
L
Linus Torvalds 已提交
299

300
	mutex_unlock(&port->mutex);
301 302 303 304 305 306 307 308 309
}

/**
 *	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.
 */
310

311 312 313 314 315 316 317 318 319 320 321 322 323
static void serial_do_free(struct usb_serial_port *port)
{
	struct usb_serial *serial;
	struct module *owner;

	/* The console is magical, do not hang up the console hardware
	   or there will be tears */
	if (port->console)
		return;

	serial = port->serial;
	owner = serial->type->driver.owner;
	put_device(&port->dev);
324
	/* Mustn't dereference port any more */
325 326 327 328
	mutex_lock(&serial->disc_mutex);
	if (!serial->disconnected)
		usb_autopm_put_interface(serial->interface);
	mutex_unlock(&serial->disc_mutex);
329 330
	usb_serial_put(serial);
	/* Mustn't dereference serial any more */
331 332 333 334 335 336 337
	module_put(owner);
}

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

338 339 340
	if (!port)
		return;

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

A
Alan Cox 已提交
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
	/* FIXME:
	   This leaves a very narrow race. Really we should do the
	   serial_do_free() on tty->shutdown(), but tty->shutdown can
	   be called from IRQ context and serial_do_free can sleep.

	   The right fix is probably to make the tty free (which is rare)
	   and thus tty->shutdown() occur via a work queue and simplify all
	   the drivers that use it.
	*/
	if (tty_hung_up_p(filp)) {
		/* serial_hangup already called serial_down at this point.
		   Another user may have already reopened the port but
		   serial_do_free is refcounted */
		serial_do_free(port);
		return;
	}
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373

	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);
	serial_do_free(port);
}

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 已提交
374 375
	/* We must not free port yet - the USB serial layer depends on it's
	   continued existence */
L
Linus Torvalds 已提交
376 377
}

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

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

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

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

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

exit:
	return retval;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

519
		seq_putc(m, '\n');
520
		usb_serial_put(serial);
L
Linus Torvalds 已提交
521
	}
522
	return 0;
L
Linus Torvalds 已提交
523 524
}

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

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

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

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

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

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

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

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

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

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

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

static void port_release(struct device *dev)
{
	struct usb_serial_port *port = to_usb_serial_port(dev);

594
	dbg ("%s - %s", __func__, dev_name(dev));
595 596 597
	port_free(port);
}

598
static void kill_traffic(struct usb_serial_port *port)
599
{
L
Linus Torvalds 已提交
600 601
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
602 603 604 605 606 607 608 609 610 611 612
	/*
	 * 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 已提交
613 614
	usb_kill_urb(port->interrupt_in_urb);
	usb_kill_urb(port->interrupt_out_urb);
615 616 617 618
}

static void port_free(struct usb_serial_port *port)
{
619 620 621 622
	/*
	 * Stop all the traffic before cancelling the work, so that
	 * nobody will restart it by calling usb_serial_port_softint.
	 */
623
	kill_traffic(port);
624 625
	cancel_work_sync(&port->work);

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

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

	return serial;
}

658
static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
A
Alan Cox 已提交
659
					    struct usb_serial_driver *drv)
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
{
	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 已提交
691 692
static struct usb_serial_driver *search_serial_device(
					struct usb_interface *iface)
L
Linus Torvalds 已提交
693 694
{
	const struct usb_device_id *id;
695
	struct usb_serial_driver *drv;
L
Linus Torvalds 已提交
696

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

	return NULL;
}

707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
static int serial_carrier_raised(struct tty_port *port)
{
	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
	struct usb_serial_driver *drv = p->serial->type;
	if (drv->carrier_raised)
		return drv->carrier_raised(p);
	/* No carrier control - don't block */
	return 1;	
}

static void serial_dtr_rts(struct tty_port *port, int on)
{
	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
	struct usb_serial_driver *drv = p->serial->type;
	if (drv->dtr_rts)
		drv->dtr_rts(p, on);
}

static const struct tty_port_operations serial_port_ops = {
	.carrier_raised = serial_carrier_raised,
	.dtr_rts = serial_dtr_rts,
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/* 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 已提交
935
		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
936 937 938 939 940 941 942
		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 已提交
943
		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
944
		if (!port->bulk_in_buffer) {
A
Alan Cox 已提交
945 946
			dev_err(&interface->dev,
					"Couldn't allocate bulk_in_buffer\n");
L
Linus Torvalds 已提交
947 948
			goto probe_error;
		}
A
Alan Cox 已提交
949 950 951 952 953
		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 已提交
954 955 956 957 958 959 960 961 962 963 964 965 966
	}

	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 已提交
967
		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
L
Linus Torvalds 已提交
968
		if (!port->bulk_out_buffer) {
A
Alan Cox 已提交
969 970
			dev_err(&interface->dev,
					"Couldn't allocate bulk_out_buffer\n");
L
Linus Torvalds 已提交
971 972
			goto probe_error;
		}
A
Alan Cox 已提交
973 974 975 976 977
		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 已提交
978 979 980 981 982 983 984 985
	}

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

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

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

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 1071 1072 1073 1074 1075
	/* register all of the individual ports with the driver core */
	for (i = 0; i < num_ports; ++i) {
		port = serial->port[i];
		port->dev.parent = &interface->dev;
		port->dev.driver = NULL;
		port->dev.bus = &usb_serial_bus_type;
		port->dev.release = &port_release;

1076
		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1077
		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1078
		port->dev_state = PORT_REGISTERING;
1079
		retval = device_register(&port->dev);
1080
		if (retval) {
1081 1082
			dev_err(&port->dev, "Error registering port device, "
				"continuing\n");
1083 1084 1085 1086
			port->dev_state = PORT_UNREGISTERED;
		} else {
			port->dev_state = PORT_REGISTERED;
		}
L
Linus Torvalds 已提交
1087 1088
	}

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

exit:
	/* success */
A
Alan Cox 已提交
1093
	usb_set_intfdata(interface, serial);
L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100
	return 0;

probe_error:
	for (i = 0; i < num_bulk_in; ++i) {
		port = serial->port[i];
		if (!port)
			continue;
1101
		usb_free_urb(port->read_urb);
L
Linus Torvalds 已提交
1102 1103 1104 1105 1106 1107
		kfree(port->bulk_in_buffer);
	}
	for (i = 0; i < num_bulk_out; ++i) {
		port = serial->port[i];
		if (!port)
			continue;
1108
		usb_free_urb(port->write_urb);
L
Linus Torvalds 已提交
1109 1110 1111 1112 1113 1114
		kfree(port->bulk_out_buffer);
	}
	for (i = 0; i < num_interrupt_in; ++i) {
		port = serial->port[i];
		if (!port)
			continue;
1115
		usb_free_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
1116 1117 1118 1119 1120 1121
		kfree(port->interrupt_in_buffer);
	}
	for (i = 0; i < num_interrupt_out; ++i) {
		port = serial->port[i];
		if (!port)
			continue;
1122
		usb_free_urb(port->interrupt_out_urb);
L
Linus Torvalds 已提交
1123 1124 1125 1126 1127 1128
		kfree(port->interrupt_out_buffer);
	}

	/* free up any memory that we allocated */
	for (i = 0; i < serial->num_port_pointers; ++i)
		kfree(serial->port[i]);
A
Alan Cox 已提交
1129
	kfree(serial);
L
Linus Torvalds 已提交
1130 1131
	return -EIO;
}
A
Alan Cox 已提交
1132
EXPORT_SYMBOL_GPL(usb_serial_probe);
L
Linus Torvalds 已提交
1133 1134 1135 1136

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

1141
	usb_serial_console_disconnect(serial);
A
Alan Cox 已提交
1142
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1143

1144
	mutex_lock(&serial->disc_mutex);
A
Alan Cox 已提交
1145
	usb_set_intfdata(interface, NULL);
1146 1147
	/* must set a flag, to signal subdrivers */
	serial->disconnected = 1;
1148 1149
	mutex_unlock(&serial->disc_mutex);

1150 1151 1152
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port) {
A
Alan Cox 已提交
1153 1154
			struct tty_struct *tty = tty_port_tty_get(&port->port);
			if (tty) {
1155 1156 1157
				/* The hangup will occur asynchronously but
				   the object refcounts will sort out all the
				   cleanup */
A
Alan Cox 已提交
1158 1159 1160
				tty_hangup(tty);
				tty_kref_put(tty);
			}
1161
			kill_traffic(port);
1162
			cancel_work_sync(&port->work);
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
			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;
			}
1179 1180
		}
	}
1181
	serial->type->disconnect(serial);
1182

1183 1184 1185
	/* let the last holder of this object
	 * cause it to be cleaned up */
	usb_serial_put(serial);
L
Linus Torvalds 已提交
1186 1187
	dev_info(dev, "device disconnected\n");
}
A
Alan Cox 已提交
1188
EXPORT_SYMBOL_GPL(usb_serial_disconnect);
L
Linus Torvalds 已提交
1189

1190 1191 1192 1193 1194 1195
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;

1196 1197
	serial->suspending = 1;

1198 1199 1200 1201
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		if (port)
			kill_traffic(port);
1202 1203 1204
	}

	if (serial->type->suspend)
1205
		r = serial->type->suspend(serial, message);
1206 1207 1208 1209 1210 1211 1212 1213

	return r;
}
EXPORT_SYMBOL(usb_serial_suspend);

int usb_serial_resume(struct usb_interface *intf)
{
	struct usb_serial *serial = usb_get_intfdata(intf);
1214
	int rv;
1215

1216
	serial->suspending = 0;
S
Sarah Sharp 已提交
1217
	if (serial->type->resume)
1218 1219 1220
		rv = serial->type->resume(serial);
	else
		rv = usb_serial_generic_resume(serial);
1221

1222
	return rv;
1223 1224 1225
}
EXPORT_SYMBOL(usb_serial_resume);

J
Jeff Dike 已提交
1226
static const struct tty_operations serial_ops = {
L
Linus Torvalds 已提交
1227 1228 1229
	.open =			serial_open,
	.close =		serial_close,
	.write =		serial_write,
1230
	.hangup = 		serial_hangup,
L
Linus Torvalds 已提交
1231 1232 1233 1234 1235 1236 1237 1238 1239
	.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,
1240
	.proc_fops =		&serial_proc_fops,
L
Linus Torvalds 已提交
1241 1242
};

1243

L
Linus Torvalds 已提交
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
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 已提交
1256
	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
L
Linus Torvalds 已提交
1257 1258 1259 1260
		serial_table[i] = NULL;

	result = bus_register(&usb_serial_bus_type);
	if (result) {
1261 1262
		printk(KERN_ERR "usb-serial: %s - registering bus driver "
		       "failed\n", __func__);
L
Linus Torvalds 已提交
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
		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 已提交
1273 1274
	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
						TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
1275
	usb_serial_tty_driver->init_termios = tty_std_termios;
A
Alan Cox 已提交
1276 1277
	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
							| HUPCL | CLOCAL;
1278 1279
	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1280 1281 1282
	tty_set_operations(usb_serial_tty_driver, &serial_ops);
	result = tty_register_driver(usb_serial_tty_driver);
	if (result) {
1283 1284
		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
		       __func__);
L
Linus Torvalds 已提交
1285 1286 1287 1288 1289 1290
		goto exit_reg_driver;
	}

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

1296 1297 1298
	/* register the generic driver, if we should */
	result = usb_serial_generic_register(debug);
	if (result < 0) {
1299 1300
		printk(KERN_ERR "usb-serial: %s - registering generic "
		       "driver failed\n", __func__);
1301 1302 1303
		goto exit_generic;
	}

1304
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
L
Linus Torvalds 已提交
1305 1306 1307

	return result;

1308 1309 1310
exit_generic:
	usb_deregister(&usb_serial_driver);

L
Linus Torvalds 已提交
1311 1312 1313 1314 1315 1316 1317
exit_tty:
	tty_unregister_driver(usb_serial_tty_driver);

exit_reg_driver:
	bus_unregister(&usb_serial_bus_type);

exit_bus:
1318 1319
	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
	       __func__, result);
L
Linus Torvalds 已提交
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
	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 已提交
1346
				" usb serial operation with the generic one.");\
L
Linus Torvalds 已提交
1347 1348 1349
			}						\
	} while (0)

1350
static void fixup_generic(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1351 1352 1353 1354 1355 1356 1357 1358
{
	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);
1359 1360
	set_to_generic_if_null(device, disconnect);
	set_to_generic_if_null(device, release);
L
Linus Torvalds 已提交
1361 1362
}

A
Alan Cox 已提交
1363
int usb_serial_register(struct usb_serial_driver *driver)
L
Linus Torvalds 已提交
1364
{
A
Alan Cox 已提交
1365
	/* must be called with BKL held */
L
Linus Torvalds 已提交
1366 1367
	int retval;

1368 1369 1370
	if (usb_disabled())
		return -ENODEV;

1371
	fixup_generic(driver);
L
Linus Torvalds 已提交
1372

1373 1374 1375
	if (!driver->description)
		driver->description = driver->driver.name;

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

1379
	retval = usb_serial_bus_register(driver);
L
Linus Torvalds 已提交
1380
	if (retval) {
1381 1382
		printk(KERN_ERR "usb-serial: problem %d when registering "
		       "driver %s\n", retval, driver->description);
1383
		list_del(&driver->driver_list);
A
Alan Cox 已提交
1384
	} else
1385
		printk(KERN_INFO "USB Serial support registered for %s\n",
A
Alan Cox 已提交
1386
						driver->description);
L
Linus Torvalds 已提交
1387 1388 1389

	return retval;
}
A
Alan Cox 已提交
1390
EXPORT_SYMBOL_GPL(usb_serial_register);
L
Linus Torvalds 已提交
1391 1392


A
Alan Cox 已提交
1393
void usb_serial_deregister(struct usb_serial_driver *device)
L
Linus Torvalds 已提交
1394
{
A
Alan Cox 已提交
1395
	/* must be called with BKL held */
1396 1397
	printk(KERN_INFO "USB Serial deregistering driver %s\n",
	       device->description);
L
Linus Torvalds 已提交
1398 1399 1400 1401 1402 1403
	list_del(&device->driver_list);
	usb_serial_bus_deregister(device);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister);

/* Module information */
A
Alan Cox 已提交
1404 1405
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1406 1407 1408 1409
MODULE_LICENSE("GPL");

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