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