xref: /linux/drivers/usb/serial/usb-serial.c (revision 2f229a31aac86ea6911d70ec4c79196ca711d625)
1 /*
2  * USB Serial Converter driver
3  *
4  * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
5  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
7  *
8  *	This program is free software; you can redistribute it and/or
9  *	modify it under the terms of the GNU General Public License version
10  *	2 as published by the Free Software Foundation.
11  *
12  * This driver was originally based on the ACM driver by Armin Fuerst (which was
13  * based on a driver by Brad Keryan)
14  *
15  * See Documentation/usb/usb-serial.txt for more information on using this
16  * driver
17  *
18  */
19 
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/smp_lock.h>
25 #include <linux/tty.h>
26 #include <linux/tty_driver.h>
27 #include <linux/tty_flip.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/seq_file.h>
31 #include <linux/spinlock.h>
32 #include <linux/mutex.h>
33 #include <linux/list.h>
34 #include <linux/uaccess.h>
35 #include <linux/serial.h>
36 #include <linux/usb.h>
37 #include <linux/usb/serial.h>
38 #include "pl2303.h"
39 
40 /*
41  * Version Information
42  */
43 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
44 #define DRIVER_DESC "USB Serial Driver core"
45 
46 static void port_free(struct usb_serial_port *port);
47 
48 /* Driver structure we register with the USB core */
49 static struct usb_driver usb_serial_driver = {
50 	.name =		"usbserial",
51 	.probe =	usb_serial_probe,
52 	.disconnect =	usb_serial_disconnect,
53 	.suspend =	usb_serial_suspend,
54 	.resume =	usb_serial_resume,
55 	.no_dynamic_id = 	1,
56 };
57 
58 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
59    the MODULE_DEVICE_TABLE declarations in each serial driver
60    cause the "hotplug" program to pull in whatever module is necessary
61    via modprobe, and modprobe will load usbserial because the serial
62    drivers depend on it.
63 */
64 
65 static int debug;
66 /* initially all NULL */
67 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
68 static DEFINE_MUTEX(table_lock);
69 static LIST_HEAD(usb_serial_driver_list);
70 
71 struct usb_serial *usb_serial_get_by_index(unsigned index)
72 {
73 	struct usb_serial *serial;
74 
75 	mutex_lock(&table_lock);
76 	serial = serial_table[index];
77 
78 	if (serial)
79 		kref_get(&serial->kref);
80 	mutex_unlock(&table_lock);
81 	return serial;
82 }
83 
84 static struct usb_serial *get_free_serial(struct usb_serial *serial,
85 					int num_ports, unsigned int *minor)
86 {
87 	unsigned int i, j;
88 	int good_spot;
89 
90 	dbg("%s %d", __func__, num_ports);
91 
92 	*minor = 0;
93 	mutex_lock(&table_lock);
94 	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
95 		if (serial_table[i])
96 			continue;
97 
98 		good_spot = 1;
99 		for (j = 1; j <= num_ports-1; ++j)
100 			if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
101 				good_spot = 0;
102 				i += j;
103 				break;
104 			}
105 		if (good_spot == 0)
106 			continue;
107 
108 		*minor = i;
109 		j = 0;
110 		dbg("%s - minor base = %d", __func__, *minor);
111 		for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
112 			serial_table[i] = serial;
113 			serial->port[j++]->number = i;
114 		}
115 		mutex_unlock(&table_lock);
116 		return serial;
117 	}
118 	mutex_unlock(&table_lock);
119 	return NULL;
120 }
121 
122 static void return_serial(struct usb_serial *serial)
123 {
124 	int i;
125 
126 	dbg("%s", __func__);
127 
128 	for (i = 0; i < serial->num_ports; ++i)
129 		serial_table[serial->minor + i] = NULL;
130 }
131 
132 static void destroy_serial(struct kref *kref)
133 {
134 	struct usb_serial *serial;
135 	struct usb_serial_port *port;
136 	int i;
137 
138 	serial = to_usb_serial(kref);
139 
140 	dbg("%s - %s", __func__, serial->type->description);
141 
142 	/* return the minor range that this device had */
143 	if (serial->minor != SERIAL_TTY_NO_MINOR)
144 		return_serial(serial);
145 
146 	serial->type->release(serial);
147 
148 	for (i = 0; i < serial->num_ports; ++i) {
149 		port = serial->port[i];
150 		if (port)
151 			put_device(&port->dev);
152 	}
153 
154 	/* If this is a "fake" port, we have to clean it up here, as it will
155 	 * not get cleaned up in port_release() as it was never registered with
156 	 * the driver core */
157 	if (serial->num_ports < serial->num_port_pointers) {
158 		for (i = serial->num_ports;
159 					i < serial->num_port_pointers; ++i) {
160 			port = serial->port[i];
161 			if (port)
162 				port_free(port);
163 		}
164 	}
165 
166 	usb_put_dev(serial->dev);
167 
168 	/* free up any memory that we allocated */
169 	kfree(serial);
170 }
171 
172 void usb_serial_put(struct usb_serial *serial)
173 {
174 	mutex_lock(&table_lock);
175 	kref_put(&serial->kref, destroy_serial);
176 	mutex_unlock(&table_lock);
177 }
178 
179 /*****************************************************************************
180  * Driver tty interface functions
181  *****************************************************************************/
182 static int serial_open (struct tty_struct *tty, struct file *filp)
183 {
184 	struct usb_serial *serial;
185 	struct usb_serial_port *port;
186 	unsigned int portNumber;
187 	int retval = 0;
188 	int first = 0;
189 
190 	dbg("%s", __func__);
191 
192 	/* get the serial object associated with this tty pointer */
193 	serial = usb_serial_get_by_index(tty->index);
194 	if (!serial) {
195 		tty->driver_data = NULL;
196 		return -ENODEV;
197 	}
198 
199 	mutex_lock(&serial->disc_mutex);
200 	portNumber = tty->index - serial->minor;
201 	port = serial->port[portNumber];
202 	if (!port || serial->disconnected)
203 		retval = -ENODEV;
204 	else
205 		get_device(&port->dev);
206 	/*
207 	 * Note: Our locking order requirement does not allow port->mutex
208 	 * to be acquired while serial->disc_mutex is held.
209 	 */
210 	mutex_unlock(&serial->disc_mutex);
211 	if (retval)
212 		goto bailout_serial_put;
213 
214 	if (mutex_lock_interruptible(&port->mutex)) {
215 		retval = -ERESTARTSYS;
216 		goto bailout_port_put;
217 	}
218 
219 	++port->port.count;
220 
221 	/* set up our port structure making the tty driver
222 	 * remember our port object, and us it */
223 	tty->driver_data = port;
224 	tty_port_tty_set(&port->port, tty);
225 
226 	/* If the console is attached, the device is already open */
227 	if (port->port.count == 1 && !port->console) {
228 		first = 1;
229 		/* lock this module before we call it
230 		 * this may fail, which means we must bail out,
231 		 * safe because we are called with BKL held */
232 		if (!try_module_get(serial->type->driver.owner)) {
233 			retval = -ENODEV;
234 			goto bailout_mutex_unlock;
235 		}
236 
237 		mutex_lock(&serial->disc_mutex);
238 		if (serial->disconnected)
239 			retval = -ENODEV;
240 		else
241 			retval = usb_autopm_get_interface(serial->interface);
242 		if (retval)
243 			goto bailout_module_put;
244 
245 		/* only call the device specific open if this
246 		 * is the first time the port is opened */
247 		retval = serial->type->open(tty, port, filp);
248 		if (retval)
249 			goto bailout_interface_put;
250 		mutex_unlock(&serial->disc_mutex);
251 		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
252 	}
253 	mutex_unlock(&port->mutex);
254 	/* Now do the correct tty layer semantics */
255 	retval = tty_port_block_til_ready(&port->port, tty, filp);
256 	if (retval == 0) {
257 		if (!first)
258 			usb_serial_put(serial);
259 		return 0;
260 	}
261 	mutex_lock(&port->mutex);
262 	if (first == 0)
263 		goto bailout_mutex_unlock;
264 	/* Undo the initial port actions */
265 	mutex_lock(&serial->disc_mutex);
266 bailout_interface_put:
267 	usb_autopm_put_interface(serial->interface);
268 bailout_module_put:
269 	mutex_unlock(&serial->disc_mutex);
270 	module_put(serial->type->driver.owner);
271 bailout_mutex_unlock:
272 	port->port.count = 0;
273 	tty->driver_data = NULL;
274 	tty_port_tty_set(&port->port, NULL);
275 	mutex_unlock(&port->mutex);
276 bailout_port_put:
277 	put_device(&port->dev);
278 bailout_serial_put:
279 	usb_serial_put(serial);
280 	return retval;
281 }
282 
283 /**
284  *	serial_do_down		-	shut down hardware
285  *	@port: port to shut down
286  *
287  *	Shut down a USB port unless it is the console. We never shut down the
288  *	console hardware as it will always be in use.
289  *
290  *	Don't free any resources at this point
291  */
292 static void serial_do_down(struct usb_serial_port *port)
293 {
294 	struct usb_serial_driver *drv = port->serial->type;
295 	struct usb_serial *serial;
296 	struct module *owner;
297 
298 	/* The console is magical, do not hang up the console hardware
299 	   or there will be tears */
300 	if (port->console)
301 		return;
302 
303 	mutex_lock(&port->mutex);
304 	serial = port->serial;
305 	owner = serial->type->driver.owner;
306 
307 	if (drv->close)
308 		drv->close(port);
309 
310 	mutex_unlock(&port->mutex);
311 }
312 
313 /**
314  *	serial_do_free		-	free resources post close/hangup
315  *	@port: port to free up
316  *
317  *	Do the resource freeing and refcount dropping for the port. We must
318  *	be careful about ordering and we must avoid freeing up the console.
319  */
320 
321 static void serial_do_free(struct usb_serial_port *port)
322 {
323 	struct usb_serial *serial;
324 	struct module *owner;
325 
326 	/* The console is magical, do not hang up the console hardware
327 	   or there will be tears */
328 	if (port->console)
329 		return;
330 
331 	serial = port->serial;
332 	owner = serial->type->driver.owner;
333 	put_device(&port->dev);
334 	/* Mustn't dereference port any more */
335 	mutex_lock(&serial->disc_mutex);
336 	if (!serial->disconnected)
337 		usb_autopm_put_interface(serial->interface);
338 	mutex_unlock(&serial->disc_mutex);
339 	usb_serial_put(serial);
340 	/* Mustn't dereference serial any more */
341 	module_put(owner);
342 }
343 
344 static void serial_close(struct tty_struct *tty, struct file *filp)
345 {
346 	struct usb_serial_port *port = tty->driver_data;
347 
348 	if (!port)
349 		return;
350 
351 	dbg("%s - port %d", __func__, port->number);
352 
353 	/* FIXME:
354 	   This leaves a very narrow race. Really we should do the
355 	   serial_do_free() on tty->shutdown(), but tty->shutdown can
356 	   be called from IRQ context and serial_do_free can sleep.
357 
358 	   The right fix is probably to make the tty free (which is rare)
359 	   and thus tty->shutdown() occur via a work queue and simplify all
360 	   the drivers that use it.
361 	*/
362 	if (tty_hung_up_p(filp)) {
363 		/* serial_hangup already called serial_down at this point.
364 		   Another user may have already reopened the port but
365 		   serial_do_free is refcounted */
366 		serial_do_free(port);
367 		return;
368 	}
369 
370 	if (tty_port_close_start(&port->port, tty, filp) == 0)
371 		return;
372 
373 	serial_do_down(port);
374 	tty_port_close_end(&port->port, tty);
375 	tty_port_tty_set(&port->port, NULL);
376 	serial_do_free(port);
377 }
378 
379 static void serial_hangup(struct tty_struct *tty)
380 {
381 	struct usb_serial_port *port = tty->driver_data;
382 	serial_do_down(port);
383 	tty_port_hangup(&port->port);
384 	/* We must not free port yet - the USB serial layer depends on it's
385 	   continued existence */
386 }
387 
388 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
389 								int count)
390 {
391 	struct usb_serial_port *port = tty->driver_data;
392 	int retval = -ENODEV;
393 
394 	if (port->serial->dev->state == USB_STATE_NOTATTACHED)
395 		goto exit;
396 
397 	dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
398 
399 	/* count is managed under the mutex lock for the tty so cannot
400 	   drop to zero until after the last close completes */
401 	WARN_ON(!port->port.count);
402 
403 	/* pass on to the driver specific version of this function */
404 	retval = port->serial->type->write(tty, port, buf, count);
405 
406 exit:
407 	return retval;
408 }
409 
410 static int serial_write_room(struct tty_struct *tty)
411 {
412 	struct usb_serial_port *port = tty->driver_data;
413 	dbg("%s - port %d", __func__, port->number);
414 	WARN_ON(!port->port.count);
415 	/* pass on to the driver specific version of this function */
416 	return port->serial->type->write_room(tty);
417 }
418 
419 static int serial_chars_in_buffer(struct tty_struct *tty)
420 {
421 	struct usb_serial_port *port = tty->driver_data;
422 	dbg("%s = port %d", __func__, port->number);
423 
424 	/* if the device was unplugged then any remaining characters
425 	   fell out of the connector ;) */
426 	if (port->serial->disconnected)
427 		return 0;
428 	/* pass on to the driver specific version of this function */
429 	return port->serial->type->chars_in_buffer(tty);
430 }
431 
432 static void serial_throttle(struct tty_struct *tty)
433 {
434 	struct usb_serial_port *port = tty->driver_data;
435 	dbg("%s - port %d", __func__, port->number);
436 
437 	WARN_ON(!port->port.count);
438 	/* pass on to the driver specific version of this function */
439 	if (port->serial->type->throttle)
440 		port->serial->type->throttle(tty);
441 }
442 
443 static void serial_unthrottle(struct tty_struct *tty)
444 {
445 	struct usb_serial_port *port = tty->driver_data;
446 	dbg("%s - port %d", __func__, port->number);
447 
448 	WARN_ON(!port->port.count);
449 	/* pass on to the driver specific version of this function */
450 	if (port->serial->type->unthrottle)
451 		port->serial->type->unthrottle(tty);
452 }
453 
454 static int serial_ioctl(struct tty_struct *tty, struct file *file,
455 					unsigned int cmd, unsigned long arg)
456 {
457 	struct usb_serial_port *port = tty->driver_data;
458 	int retval = -ENODEV;
459 
460 	dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
461 
462 	WARN_ON(!port->port.count);
463 
464 	/* pass on to the driver specific version of this function
465 	   if it is available */
466 	if (port->serial->type->ioctl) {
467 		retval = port->serial->type->ioctl(tty, file, cmd, arg);
468 	} else
469 		retval = -ENOIOCTLCMD;
470 	return retval;
471 }
472 
473 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
474 {
475 	struct usb_serial_port *port = tty->driver_data;
476 	dbg("%s - port %d", __func__, port->number);
477 
478 	WARN_ON(!port->port.count);
479 	/* pass on to the driver specific version of this function
480 	   if it is available */
481 	if (port->serial->type->set_termios)
482 		port->serial->type->set_termios(tty, port, old);
483 	else
484 		tty_termios_copy_hw(tty->termios, old);
485 }
486 
487 static int serial_break(struct tty_struct *tty, int break_state)
488 {
489 	struct usb_serial_port *port = tty->driver_data;
490 
491 	dbg("%s - port %d", __func__, port->number);
492 
493 	WARN_ON(!port->port.count);
494 	/* pass on to the driver specific version of this function
495 	   if it is available */
496 	if (port->serial->type->break_ctl)
497 		port->serial->type->break_ctl(tty, break_state);
498 	return 0;
499 }
500 
501 static int serial_proc_show(struct seq_file *m, void *v)
502 {
503 	struct usb_serial *serial;
504 	int i;
505 	char tmp[40];
506 
507 	dbg("%s", __func__);
508 	seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
509 	for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
510 		serial = usb_serial_get_by_index(i);
511 		if (serial == NULL)
512 			continue;
513 
514 		seq_printf(m, "%d:", i);
515 		if (serial->type->driver.owner)
516 			seq_printf(m, " module:%s",
517 				module_name(serial->type->driver.owner));
518 		seq_printf(m, " name:\"%s\"",
519 				serial->type->description);
520 		seq_printf(m, " vendor:%04x product:%04x",
521 			le16_to_cpu(serial->dev->descriptor.idVendor),
522 			le16_to_cpu(serial->dev->descriptor.idProduct));
523 		seq_printf(m, " num_ports:%d", serial->num_ports);
524 		seq_printf(m, " port:%d", i - serial->minor + 1);
525 		usb_make_path(serial->dev, tmp, sizeof(tmp));
526 		seq_printf(m, " path:%s", tmp);
527 
528 		seq_putc(m, '\n');
529 		usb_serial_put(serial);
530 	}
531 	return 0;
532 }
533 
534 static int serial_proc_open(struct inode *inode, struct file *file)
535 {
536 	return single_open(file, serial_proc_show, NULL);
537 }
538 
539 static const struct file_operations serial_proc_fops = {
540 	.owner		= THIS_MODULE,
541 	.open		= serial_proc_open,
542 	.read		= seq_read,
543 	.llseek		= seq_lseek,
544 	.release	= single_release,
545 };
546 
547 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
548 {
549 	struct usb_serial_port *port = tty->driver_data;
550 
551 	dbg("%s - port %d", __func__, port->number);
552 
553 	WARN_ON(!port->port.count);
554 	if (port->serial->type->tiocmget)
555 		return port->serial->type->tiocmget(tty, file);
556 	return -EINVAL;
557 }
558 
559 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
560 			    unsigned int set, unsigned int clear)
561 {
562 	struct usb_serial_port *port = tty->driver_data;
563 
564 	dbg("%s - port %d", __func__, port->number);
565 
566 	WARN_ON(!port->port.count);
567 	if (port->serial->type->tiocmset)
568 		return port->serial->type->tiocmset(tty, file, set, clear);
569 	return -EINVAL;
570 }
571 
572 /*
573  * We would be calling tty_wakeup here, but unfortunately some line
574  * disciplines have an annoying habit of calling tty->write from
575  * the write wakeup callback (e.g. n_hdlc.c).
576  */
577 void usb_serial_port_softint(struct usb_serial_port *port)
578 {
579 	schedule_work(&port->work);
580 }
581 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
582 
583 static void usb_serial_port_work(struct work_struct *work)
584 {
585 	struct usb_serial_port *port =
586 		container_of(work, struct usb_serial_port, work);
587 	struct tty_struct *tty;
588 
589 	dbg("%s - port %d", __func__, port->number);
590 
591 	tty = tty_port_tty_get(&port->port);
592 	if (!tty)
593 		return;
594 
595 	tty_wakeup(tty);
596 	tty_kref_put(tty);
597 }
598 
599 static void port_release(struct device *dev)
600 {
601 	struct usb_serial_port *port = to_usb_serial_port(dev);
602 
603 	dbg ("%s - %s", __func__, dev_name(dev));
604 	port_free(port);
605 }
606 
607 static void kill_traffic(struct usb_serial_port *port)
608 {
609 	usb_kill_urb(port->read_urb);
610 	usb_kill_urb(port->write_urb);
611 	/*
612 	 * This is tricky.
613 	 * Some drivers submit the read_urb in the
614 	 * handler for the write_urb or vice versa
615 	 * this order determines the order in which
616 	 * usb_kill_urb() must be used to reliably
617 	 * kill the URBs. As it is unknown here,
618 	 * both orders must be used in turn.
619 	 * The call below is not redundant.
620 	 */
621 	usb_kill_urb(port->read_urb);
622 	usb_kill_urb(port->interrupt_in_urb);
623 	usb_kill_urb(port->interrupt_out_urb);
624 }
625 
626 static void port_free(struct usb_serial_port *port)
627 {
628 	/*
629 	 * Stop all the traffic before cancelling the work, so that
630 	 * nobody will restart it by calling usb_serial_port_softint.
631 	 */
632 	kill_traffic(port);
633 	cancel_work_sync(&port->work);
634 
635 	usb_free_urb(port->read_urb);
636 	usb_free_urb(port->write_urb);
637 	usb_free_urb(port->interrupt_in_urb);
638 	usb_free_urb(port->interrupt_out_urb);
639 	kfree(port->bulk_in_buffer);
640 	kfree(port->bulk_out_buffer);
641 	kfree(port->interrupt_in_buffer);
642 	kfree(port->interrupt_out_buffer);
643 	kfree(port);
644 }
645 
646 static struct usb_serial *create_serial(struct usb_device *dev,
647 					struct usb_interface *interface,
648 					struct usb_serial_driver *driver)
649 {
650 	struct usb_serial *serial;
651 
652 	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
653 	if (!serial) {
654 		dev_err(&dev->dev, "%s - out of memory\n", __func__);
655 		return NULL;
656 	}
657 	serial->dev = usb_get_dev(dev);
658 	serial->type = driver;
659 	serial->interface = interface;
660 	kref_init(&serial->kref);
661 	mutex_init(&serial->disc_mutex);
662 	serial->minor = SERIAL_TTY_NO_MINOR;
663 
664 	return serial;
665 }
666 
667 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
668 					    struct usb_serial_driver *drv)
669 {
670 	struct usb_dynid *dynid;
671 
672 	spin_lock(&drv->dynids.lock);
673 	list_for_each_entry(dynid, &drv->dynids.list, node) {
674 		if (usb_match_one_id(intf, &dynid->id)) {
675 			spin_unlock(&drv->dynids.lock);
676 			return &dynid->id;
677 		}
678 	}
679 	spin_unlock(&drv->dynids.lock);
680 	return NULL;
681 }
682 
683 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
684 						struct usb_interface *intf)
685 {
686 	const struct usb_device_id *id;
687 
688 	id = usb_match_id(intf, drv->id_table);
689 	if (id) {
690 		dbg("static descriptor matches");
691 		goto exit;
692 	}
693 	id = match_dynamic_id(intf, drv);
694 	if (id)
695 		dbg("dynamic descriptor matches");
696 exit:
697 	return id;
698 }
699 
700 static struct usb_serial_driver *search_serial_device(
701 					struct usb_interface *iface)
702 {
703 	const struct usb_device_id *id;
704 	struct usb_serial_driver *drv;
705 
706 	/* Check if the usb id matches a known device */
707 	list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
708 		id = get_iface_id(drv, iface);
709 		if (id)
710 			return drv;
711 	}
712 
713 	return NULL;
714 }
715 
716 static int serial_carrier_raised(struct tty_port *port)
717 {
718 	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
719 	struct usb_serial_driver *drv = p->serial->type;
720 	if (drv->carrier_raised)
721 		return drv->carrier_raised(p);
722 	/* No carrier control - don't block */
723 	return 1;
724 }
725 
726 static void serial_dtr_rts(struct tty_port *port, int on)
727 {
728 	struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
729 	struct usb_serial_driver *drv = p->serial->type;
730 	if (drv->dtr_rts)
731 		drv->dtr_rts(p, on);
732 }
733 
734 static const struct tty_port_operations serial_port_ops = {
735 	.carrier_raised = serial_carrier_raised,
736 	.dtr_rts = serial_dtr_rts,
737 };
738 
739 int usb_serial_probe(struct usb_interface *interface,
740 			       const struct usb_device_id *id)
741 {
742 	struct usb_device *dev = interface_to_usbdev(interface);
743 	struct usb_serial *serial = NULL;
744 	struct usb_serial_port *port;
745 	struct usb_host_interface *iface_desc;
746 	struct usb_endpoint_descriptor *endpoint;
747 	struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
748 	struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
749 	struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
750 	struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
751 	struct usb_serial_driver *type = NULL;
752 	int retval;
753 	unsigned int minor;
754 	int buffer_size;
755 	int i;
756 	int num_interrupt_in = 0;
757 	int num_interrupt_out = 0;
758 	int num_bulk_in = 0;
759 	int num_bulk_out = 0;
760 	int num_ports = 0;
761 	int max_endpoints;
762 
763 	lock_kernel(); /* guard against unloading a serial driver module */
764 	type = search_serial_device(interface);
765 	if (!type) {
766 		unlock_kernel();
767 		dbg("none matched");
768 		return -ENODEV;
769 	}
770 
771 	serial = create_serial(dev, interface, type);
772 	if (!serial) {
773 		unlock_kernel();
774 		dev_err(&interface->dev, "%s - out of memory\n", __func__);
775 		return -ENOMEM;
776 	}
777 
778 	/* if this device type has a probe function, call it */
779 	if (type->probe) {
780 		const struct usb_device_id *id;
781 
782 		if (!try_module_get(type->driver.owner)) {
783 			unlock_kernel();
784 			dev_err(&interface->dev,
785 				"module get failed, exiting\n");
786 			kfree(serial);
787 			return -EIO;
788 		}
789 
790 		id = get_iface_id(type, interface);
791 		retval = type->probe(serial, id);
792 		module_put(type->driver.owner);
793 
794 		if (retval) {
795 			unlock_kernel();
796 			dbg("sub driver rejected device");
797 			kfree(serial);
798 			return retval;
799 		}
800 	}
801 
802 	/* descriptor matches, let's find the endpoints needed */
803 	/* check out the endpoints */
804 	iface_desc = interface->cur_altsetting;
805 	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
806 		endpoint = &iface_desc->endpoint[i].desc;
807 
808 		if (usb_endpoint_is_bulk_in(endpoint)) {
809 			/* we found a bulk in endpoint */
810 			dbg("found bulk in on endpoint %d", i);
811 			bulk_in_endpoint[num_bulk_in] = endpoint;
812 			++num_bulk_in;
813 		}
814 
815 		if (usb_endpoint_is_bulk_out(endpoint)) {
816 			/* we found a bulk out endpoint */
817 			dbg("found bulk out on endpoint %d", i);
818 			bulk_out_endpoint[num_bulk_out] = endpoint;
819 			++num_bulk_out;
820 		}
821 
822 		if (usb_endpoint_is_int_in(endpoint)) {
823 			/* we found a interrupt in endpoint */
824 			dbg("found interrupt in on endpoint %d", i);
825 			interrupt_in_endpoint[num_interrupt_in] = endpoint;
826 			++num_interrupt_in;
827 		}
828 
829 		if (usb_endpoint_is_int_out(endpoint)) {
830 			/* we found an interrupt out endpoint */
831 			dbg("found interrupt out on endpoint %d", i);
832 			interrupt_out_endpoint[num_interrupt_out] = endpoint;
833 			++num_interrupt_out;
834 		}
835 	}
836 
837 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
838 	/* BEGIN HORRIBLE HACK FOR PL2303 */
839 	/* this is needed due to the looney way its endpoints are set up */
840 	if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
841 	     (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
842 	    ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
843 	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
844 	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
845 	     (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
846 	    ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
847 	     (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
848 		if (interface != dev->actconfig->interface[0]) {
849 			/* check out the endpoints of the other interface*/
850 			iface_desc = dev->actconfig->interface[0]->cur_altsetting;
851 			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
852 				endpoint = &iface_desc->endpoint[i].desc;
853 				if (usb_endpoint_is_int_in(endpoint)) {
854 					/* we found a interrupt in endpoint */
855 					dbg("found interrupt in for Prolific device on separate interface");
856 					interrupt_in_endpoint[num_interrupt_in] = endpoint;
857 					++num_interrupt_in;
858 				}
859 			}
860 		}
861 
862 		/* Now make sure the PL-2303 is configured correctly.
863 		 * If not, give up now and hope this hack will work
864 		 * properly during a later invocation of usb_serial_probe
865 		 */
866 		if (num_bulk_in == 0 || num_bulk_out == 0) {
867 			unlock_kernel();
868 			dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
869 			kfree(serial);
870 			return -ENODEV;
871 		}
872 	}
873 	/* END HORRIBLE HACK FOR PL2303 */
874 #endif
875 
876 #ifdef CONFIG_USB_SERIAL_GENERIC
877 	if (type == &usb_serial_generic_device) {
878 		num_ports = num_bulk_out;
879 		if (num_ports == 0) {
880 			unlock_kernel();
881 			dev_err(&interface->dev,
882 			    "Generic device with no bulk out, not allowed.\n");
883 			kfree(serial);
884 			return -EIO;
885 		}
886 	}
887 #endif
888 	if (!num_ports) {
889 		/* if this device type has a calc_num_ports function, call it */
890 		if (type->calc_num_ports) {
891 			if (!try_module_get(type->driver.owner)) {
892 				unlock_kernel();
893 				dev_err(&interface->dev,
894 					"module get failed, exiting\n");
895 				kfree(serial);
896 				return -EIO;
897 			}
898 			num_ports = type->calc_num_ports(serial);
899 			module_put(type->driver.owner);
900 		}
901 		if (!num_ports)
902 			num_ports = type->num_ports;
903 	}
904 
905 	serial->num_ports = num_ports;
906 	serial->num_bulk_in = num_bulk_in;
907 	serial->num_bulk_out = num_bulk_out;
908 	serial->num_interrupt_in = num_interrupt_in;
909 	serial->num_interrupt_out = num_interrupt_out;
910 
911 	/* found all that we need */
912 	dev_info(&interface->dev, "%s converter detected\n",
913 			type->description);
914 
915 	/* create our ports, we need as many as the max endpoints */
916 	/* we don't use num_ports here because some devices have more
917 	   endpoint pairs than ports */
918 	max_endpoints = max(num_bulk_in, num_bulk_out);
919 	max_endpoints = max(max_endpoints, num_interrupt_in);
920 	max_endpoints = max(max_endpoints, num_interrupt_out);
921 	max_endpoints = max(max_endpoints, (int)serial->num_ports);
922 	serial->num_port_pointers = max_endpoints;
923 	unlock_kernel();
924 
925 	dbg("%s - setting up %d port structures for this device",
926 						__func__, max_endpoints);
927 	for (i = 0; i < max_endpoints; ++i) {
928 		port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
929 		if (!port)
930 			goto probe_error;
931 		tty_port_init(&port->port);
932 		port->port.ops = &serial_port_ops;
933 		port->serial = serial;
934 		spin_lock_init(&port->lock);
935 		mutex_init(&port->mutex);
936 		INIT_WORK(&port->work, usb_serial_port_work);
937 		serial->port[i] = port;
938 	}
939 
940 	/* set up the endpoint information */
941 	for (i = 0; i < num_bulk_in; ++i) {
942 		endpoint = bulk_in_endpoint[i];
943 		port = serial->port[i];
944 		port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
945 		if (!port->read_urb) {
946 			dev_err(&interface->dev, "No free urbs available\n");
947 			goto probe_error;
948 		}
949 		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
950 		port->bulk_in_size = buffer_size;
951 		port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
952 		port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
953 		if (!port->bulk_in_buffer) {
954 			dev_err(&interface->dev,
955 					"Couldn't allocate bulk_in_buffer\n");
956 			goto probe_error;
957 		}
958 		usb_fill_bulk_urb(port->read_urb, dev,
959 				usb_rcvbulkpipe(dev,
960 						endpoint->bEndpointAddress),
961 				port->bulk_in_buffer, buffer_size,
962 				serial->type->read_bulk_callback, port);
963 	}
964 
965 	for (i = 0; i < num_bulk_out; ++i) {
966 		endpoint = bulk_out_endpoint[i];
967 		port = serial->port[i];
968 		port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
969 		if (!port->write_urb) {
970 			dev_err(&interface->dev, "No free urbs available\n");
971 			goto probe_error;
972 		}
973 		buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
974 		port->bulk_out_size = buffer_size;
975 		port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
976 		port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
977 		if (!port->bulk_out_buffer) {
978 			dev_err(&interface->dev,
979 					"Couldn't allocate bulk_out_buffer\n");
980 			goto probe_error;
981 		}
982 		usb_fill_bulk_urb(port->write_urb, dev,
983 				usb_sndbulkpipe(dev,
984 					endpoint->bEndpointAddress),
985 				port->bulk_out_buffer, buffer_size,
986 				serial->type->write_bulk_callback, port);
987 	}
988 
989 	if (serial->type->read_int_callback) {
990 		for (i = 0; i < num_interrupt_in; ++i) {
991 			endpoint = interrupt_in_endpoint[i];
992 			port = serial->port[i];
993 			port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
994 			if (!port->interrupt_in_urb) {
995 				dev_err(&interface->dev,
996 						"No free urbs available\n");
997 				goto probe_error;
998 			}
999 			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1000 			port->interrupt_in_endpointAddress =
1001 						endpoint->bEndpointAddress;
1002 			port->interrupt_in_buffer = kmalloc(buffer_size,
1003 								GFP_KERNEL);
1004 			if (!port->interrupt_in_buffer) {
1005 				dev_err(&interface->dev,
1006 				    "Couldn't allocate interrupt_in_buffer\n");
1007 				goto probe_error;
1008 			}
1009 			usb_fill_int_urb(port->interrupt_in_urb, dev,
1010 				usb_rcvintpipe(dev,
1011 						endpoint->bEndpointAddress),
1012 				port->interrupt_in_buffer, buffer_size,
1013 				serial->type->read_int_callback, port,
1014 				endpoint->bInterval);
1015 		}
1016 	} else if (num_interrupt_in) {
1017 		dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1018 	}
1019 
1020 	if (serial->type->write_int_callback) {
1021 		for (i = 0; i < num_interrupt_out; ++i) {
1022 			endpoint = interrupt_out_endpoint[i];
1023 			port = serial->port[i];
1024 			port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1025 			if (!port->interrupt_out_urb) {
1026 				dev_err(&interface->dev,
1027 						"No free urbs available\n");
1028 				goto probe_error;
1029 			}
1030 			buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1031 			port->interrupt_out_size = buffer_size;
1032 			port->interrupt_out_endpointAddress =
1033 						endpoint->bEndpointAddress;
1034 			port->interrupt_out_buffer = kmalloc(buffer_size,
1035 								GFP_KERNEL);
1036 			if (!port->interrupt_out_buffer) {
1037 				dev_err(&interface->dev,
1038 				  "Couldn't allocate interrupt_out_buffer\n");
1039 				goto probe_error;
1040 			}
1041 			usb_fill_int_urb(port->interrupt_out_urb, dev,
1042 				usb_sndintpipe(dev,
1043 						  endpoint->bEndpointAddress),
1044 				port->interrupt_out_buffer, buffer_size,
1045 				serial->type->write_int_callback, port,
1046 				endpoint->bInterval);
1047 		}
1048 	} else if (num_interrupt_out) {
1049 		dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1050 	}
1051 
1052 	/* if this device type has an attach function, call it */
1053 	if (type->attach) {
1054 		if (!try_module_get(type->driver.owner)) {
1055 			dev_err(&interface->dev,
1056 					"module get failed, exiting\n");
1057 			goto probe_error;
1058 		}
1059 		retval = type->attach(serial);
1060 		module_put(type->driver.owner);
1061 		if (retval < 0)
1062 			goto probe_error;
1063 		if (retval > 0) {
1064 			/* quietly accept this device, but don't bind to a
1065 			   serial port as it's about to disappear */
1066 			serial->num_ports = 0;
1067 			goto exit;
1068 		}
1069 	}
1070 
1071 	if (get_free_serial(serial, num_ports, &minor) == NULL) {
1072 		dev_err(&interface->dev, "No more free serial devices\n");
1073 		goto probe_error;
1074 	}
1075 	serial->minor = minor;
1076 
1077 	/* register all of the individual ports with the driver core */
1078 	for (i = 0; i < num_ports; ++i) {
1079 		port = serial->port[i];
1080 		port->dev.parent = &interface->dev;
1081 		port->dev.driver = NULL;
1082 		port->dev.bus = &usb_serial_bus_type;
1083 		port->dev.release = &port_release;
1084 
1085 		dev_set_name(&port->dev, "ttyUSB%d", port->number);
1086 		dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1087 		port->dev_state = PORT_REGISTERING;
1088 		retval = device_register(&port->dev);
1089 		if (retval) {
1090 			dev_err(&port->dev, "Error registering port device, "
1091 				"continuing\n");
1092 			port->dev_state = PORT_UNREGISTERED;
1093 		} else {
1094 			port->dev_state = PORT_REGISTERED;
1095 		}
1096 	}
1097 
1098 	usb_serial_console_init(debug, minor);
1099 
1100 exit:
1101 	/* success */
1102 	usb_set_intfdata(interface, serial);
1103 	return 0;
1104 
1105 probe_error:
1106 	for (i = 0; i < num_bulk_in; ++i) {
1107 		port = serial->port[i];
1108 		if (!port)
1109 			continue;
1110 		usb_free_urb(port->read_urb);
1111 		kfree(port->bulk_in_buffer);
1112 	}
1113 	for (i = 0; i < num_bulk_out; ++i) {
1114 		port = serial->port[i];
1115 		if (!port)
1116 			continue;
1117 		usb_free_urb(port->write_urb);
1118 		kfree(port->bulk_out_buffer);
1119 	}
1120 	for (i = 0; i < num_interrupt_in; ++i) {
1121 		port = serial->port[i];
1122 		if (!port)
1123 			continue;
1124 		usb_free_urb(port->interrupt_in_urb);
1125 		kfree(port->interrupt_in_buffer);
1126 	}
1127 	for (i = 0; i < num_interrupt_out; ++i) {
1128 		port = serial->port[i];
1129 		if (!port)
1130 			continue;
1131 		usb_free_urb(port->interrupt_out_urb);
1132 		kfree(port->interrupt_out_buffer);
1133 	}
1134 
1135 	/* free up any memory that we allocated */
1136 	for (i = 0; i < serial->num_port_pointers; ++i)
1137 		kfree(serial->port[i]);
1138 	kfree(serial);
1139 	return -EIO;
1140 }
1141 EXPORT_SYMBOL_GPL(usb_serial_probe);
1142 
1143 void usb_serial_disconnect(struct usb_interface *interface)
1144 {
1145 	int i;
1146 	struct usb_serial *serial = usb_get_intfdata(interface);
1147 	struct device *dev = &interface->dev;
1148 	struct usb_serial_port *port;
1149 
1150 	usb_serial_console_disconnect(serial);
1151 	dbg("%s", __func__);
1152 
1153 	mutex_lock(&serial->disc_mutex);
1154 	usb_set_intfdata(interface, NULL);
1155 	/* must set a flag, to signal subdrivers */
1156 	serial->disconnected = 1;
1157 	mutex_unlock(&serial->disc_mutex);
1158 
1159 	for (i = 0; i < serial->num_ports; ++i) {
1160 		port = serial->port[i];
1161 		if (port) {
1162 			struct tty_struct *tty = tty_port_tty_get(&port->port);
1163 			if (tty) {
1164 				/* The hangup will occur asynchronously but
1165 				   the object refcounts will sort out all the
1166 				   cleanup */
1167 				tty_hangup(tty);
1168 				tty_kref_put(tty);
1169 			}
1170 			kill_traffic(port);
1171 			cancel_work_sync(&port->work);
1172 			if (port->dev_state == PORT_REGISTERED) {
1173 
1174 				/* Make sure the port is bound so that the
1175 				 * driver's port_remove method is called.
1176 				 */
1177 				if (!port->dev.driver) {
1178 					int rc;
1179 
1180 					port->dev.driver =
1181 							&serial->type->driver;
1182 					rc = device_bind_driver(&port->dev);
1183 				}
1184 				port->dev_state = PORT_UNREGISTERING;
1185 				device_del(&port->dev);
1186 				port->dev_state = PORT_UNREGISTERED;
1187 			}
1188 		}
1189 	}
1190 	serial->type->disconnect(serial);
1191 
1192 	/* let the last holder of this object
1193 	 * cause it to be cleaned up */
1194 	usb_serial_put(serial);
1195 	dev_info(dev, "device disconnected\n");
1196 }
1197 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1198 
1199 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1200 {
1201 	struct usb_serial *serial = usb_get_intfdata(intf);
1202 	struct usb_serial_port *port;
1203 	int i, r = 0;
1204 
1205 	serial->suspending = 1;
1206 
1207 	for (i = 0; i < serial->num_ports; ++i) {
1208 		port = serial->port[i];
1209 		if (port)
1210 			kill_traffic(port);
1211 	}
1212 
1213 	if (serial->type->suspend)
1214 		r = serial->type->suspend(serial, message);
1215 
1216 	return r;
1217 }
1218 EXPORT_SYMBOL(usb_serial_suspend);
1219 
1220 int usb_serial_resume(struct usb_interface *intf)
1221 {
1222 	struct usb_serial *serial = usb_get_intfdata(intf);
1223 	int rv;
1224 
1225 	serial->suspending = 0;
1226 	if (serial->type->resume)
1227 		rv = serial->type->resume(serial);
1228 	else
1229 		rv = usb_serial_generic_resume(serial);
1230 
1231 	return rv;
1232 }
1233 EXPORT_SYMBOL(usb_serial_resume);
1234 
1235 static const struct tty_operations serial_ops = {
1236 	.open =			serial_open,
1237 	.close =		serial_close,
1238 	.write =		serial_write,
1239 	.hangup = 		serial_hangup,
1240 	.write_room =		serial_write_room,
1241 	.ioctl =		serial_ioctl,
1242 	.set_termios =		serial_set_termios,
1243 	.throttle =		serial_throttle,
1244 	.unthrottle =		serial_unthrottle,
1245 	.break_ctl =		serial_break,
1246 	.chars_in_buffer =	serial_chars_in_buffer,
1247 	.tiocmget =		serial_tiocmget,
1248 	.tiocmset =		serial_tiocmset,
1249 	.proc_fops =		&serial_proc_fops,
1250 };
1251 
1252 
1253 struct tty_driver *usb_serial_tty_driver;
1254 
1255 static int __init usb_serial_init(void)
1256 {
1257 	int i;
1258 	int result;
1259 
1260 	usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1261 	if (!usb_serial_tty_driver)
1262 		return -ENOMEM;
1263 
1264 	/* Initialize our global data */
1265 	for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1266 		serial_table[i] = NULL;
1267 
1268 	result = bus_register(&usb_serial_bus_type);
1269 	if (result) {
1270 		printk(KERN_ERR "usb-serial: %s - registering bus driver "
1271 		       "failed\n", __func__);
1272 		goto exit_bus;
1273 	}
1274 
1275 	usb_serial_tty_driver->owner = THIS_MODULE;
1276 	usb_serial_tty_driver->driver_name = "usbserial";
1277 	usb_serial_tty_driver->name = 	"ttyUSB";
1278 	usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1279 	usb_serial_tty_driver->minor_start = 0;
1280 	usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1281 	usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1282 	usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1283 						TTY_DRIVER_DYNAMIC_DEV;
1284 	usb_serial_tty_driver->init_termios = tty_std_termios;
1285 	usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1286 							| HUPCL | CLOCAL;
1287 	usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1288 	usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1289 	tty_set_operations(usb_serial_tty_driver, &serial_ops);
1290 	result = tty_register_driver(usb_serial_tty_driver);
1291 	if (result) {
1292 		printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1293 		       __func__);
1294 		goto exit_reg_driver;
1295 	}
1296 
1297 	/* register the USB driver */
1298 	result = usb_register(&usb_serial_driver);
1299 	if (result < 0) {
1300 		printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1301 		       __func__);
1302 		goto exit_tty;
1303 	}
1304 
1305 	/* register the generic driver, if we should */
1306 	result = usb_serial_generic_register(debug);
1307 	if (result < 0) {
1308 		printk(KERN_ERR "usb-serial: %s - registering generic "
1309 		       "driver failed\n", __func__);
1310 		goto exit_generic;
1311 	}
1312 
1313 	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1314 
1315 	return result;
1316 
1317 exit_generic:
1318 	usb_deregister(&usb_serial_driver);
1319 
1320 exit_tty:
1321 	tty_unregister_driver(usb_serial_tty_driver);
1322 
1323 exit_reg_driver:
1324 	bus_unregister(&usb_serial_bus_type);
1325 
1326 exit_bus:
1327 	printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1328 	       __func__, result);
1329 	put_tty_driver(usb_serial_tty_driver);
1330 	return result;
1331 }
1332 
1333 
1334 static void __exit usb_serial_exit(void)
1335 {
1336 	usb_serial_console_exit();
1337 
1338 	usb_serial_generic_deregister();
1339 
1340 	usb_deregister(&usb_serial_driver);
1341 	tty_unregister_driver(usb_serial_tty_driver);
1342 	put_tty_driver(usb_serial_tty_driver);
1343 	bus_unregister(&usb_serial_bus_type);
1344 }
1345 
1346 
1347 module_init(usb_serial_init);
1348 module_exit(usb_serial_exit);
1349 
1350 #define set_to_generic_if_null(type, function)				\
1351 	do {								\
1352 		if (!type->function) {					\
1353 			type->function = usb_serial_generic_##function;	\
1354 			dbg("Had to override the " #function		\
1355 				" usb serial operation with the generic one.");\
1356 			}						\
1357 	} while (0)
1358 
1359 static void fixup_generic(struct usb_serial_driver *device)
1360 {
1361 	set_to_generic_if_null(device, open);
1362 	set_to_generic_if_null(device, write);
1363 	set_to_generic_if_null(device, close);
1364 	set_to_generic_if_null(device, write_room);
1365 	set_to_generic_if_null(device, chars_in_buffer);
1366 	set_to_generic_if_null(device, read_bulk_callback);
1367 	set_to_generic_if_null(device, write_bulk_callback);
1368 	set_to_generic_if_null(device, disconnect);
1369 	set_to_generic_if_null(device, release);
1370 }
1371 
1372 int usb_serial_register(struct usb_serial_driver *driver)
1373 {
1374 	/* must be called with BKL held */
1375 	int retval;
1376 
1377 	if (usb_disabled())
1378 		return -ENODEV;
1379 
1380 	fixup_generic(driver);
1381 
1382 	if (!driver->description)
1383 		driver->description = driver->driver.name;
1384 
1385 	/* Add this device to our list of devices */
1386 	list_add(&driver->driver_list, &usb_serial_driver_list);
1387 
1388 	retval = usb_serial_bus_register(driver);
1389 	if (retval) {
1390 		printk(KERN_ERR "usb-serial: problem %d when registering "
1391 		       "driver %s\n", retval, driver->description);
1392 		list_del(&driver->driver_list);
1393 	} else
1394 		printk(KERN_INFO "USB Serial support registered for %s\n",
1395 						driver->description);
1396 
1397 	return retval;
1398 }
1399 EXPORT_SYMBOL_GPL(usb_serial_register);
1400 
1401 
1402 void usb_serial_deregister(struct usb_serial_driver *device)
1403 {
1404 	/* must be called with BKL held */
1405 	printk(KERN_INFO "USB Serial deregistering driver %s\n",
1406 	       device->description);
1407 	list_del(&device->driver_list);
1408 	usb_serial_bus_deregister(device);
1409 }
1410 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1411 
1412 /* Module information */
1413 MODULE_AUTHOR(DRIVER_AUTHOR);
1414 MODULE_DESCRIPTION(DRIVER_DESC);
1415 MODULE_LICENSE("GPL");
1416 
1417 module_param(debug, bool, S_IRUGO | S_IWUSR);
1418 MODULE_PARM_DESC(debug, "Debug enabled or not");
1419