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