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