1 // SPDX-License-Identifier: GPL-2.0
3 * USB Serial Converter driver
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)
10 * This driver was originally based on the ACM driver by Armin Fuerst (which was
11 * based on a driver by Brad Keryan)
13 * See Documentation/usb/usb-serial.rst for more information on using this
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
39 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
40 #define DRIVER_DESC "USB Serial Driver core"
42 #define USB_SERIAL_TTY_MAJOR 188
43 #define USB_SERIAL_TTY_MINORS 512 /* should be enough for a while */
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
52 static DEFINE_IDR(serial_minors);
53 static DEFINE_MUTEX(table_lock);
54 static LIST_HEAD(usb_serial_driver_list);
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.
61 struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor)
63 struct usb_serial *serial;
64 struct usb_serial_port *port;
66 mutex_lock(&table_lock);
67 port = idr_find(&serial_minors, minor);
71 serial = port->serial;
72 mutex_lock(&serial->disc_mutex);
73 if (serial->disconnected) {
74 mutex_unlock(&serial->disc_mutex);
77 kref_get(&serial->kref);
80 mutex_unlock(&table_lock);
84 static int allocate_minors(struct usb_serial *serial, int num_ports)
86 struct usb_serial_port *port;
90 dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
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);
100 port->port_number = i;
102 serial->minors_reserved = 1;
103 mutex_unlock(&table_lock);
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);
113 static void release_minors(struct usb_serial *serial)
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;
124 int usb_serial_claim_interface(struct usb_serial *serial, struct usb_interface *intf)
126 struct usb_driver *driver = serial->type->usb_driver;
132 ret = usb_driver_claim_interface(driver, intf, serial);
134 dev_err(&serial->interface->dev,
135 "failed to claim sibling interface: %d\n", ret);
139 serial->sibling = intf;
143 EXPORT_SYMBOL_GPL(usb_serial_claim_interface);
145 static void release_sibling(struct usb_serial *serial, struct usb_interface *intf)
147 struct usb_driver *driver = serial->type->usb_driver;
148 struct usb_interface *sibling;
150 if (!serial->sibling)
153 if (intf == serial->sibling)
154 sibling = serial->interface;
156 sibling = serial->sibling;
158 usb_set_intfdata(sibling, NULL);
159 usb_driver_release_interface(driver, sibling);
162 static void destroy_serial(struct kref *kref)
164 struct usb_serial *serial;
165 struct usb_serial_port *port;
168 serial = to_usb_serial(kref);
170 /* return the minor range that this device had */
171 if (serial->minors_reserved)
172 release_minors(serial);
174 if (serial->attached && serial->type->release)
175 serial->type->release(serial);
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];
182 put_device(&port->dev);
186 usb_put_intf(serial->interface);
187 usb_put_dev(serial->dev);
191 void usb_serial_put(struct usb_serial *serial)
193 kref_put(&serial->kref, destroy_serial);
196 /*****************************************************************************
197 * Driver tty interface functions
198 *****************************************************************************/
201 * serial_install - install tty
202 * @driver: the driver (USB in our case)
203 * @tty: the tty being created
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.
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, and where we do an autoresume.
212 * All these actions are reversed in serial_cleanup().
214 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
216 int idx = tty->index;
217 struct usb_serial *serial;
218 struct usb_serial_port *port;
220 int retval = -ENODEV;
222 port = usb_serial_port_get_by_minor(idx);
226 serial = port->serial;
227 if (!try_module_get(serial->type->driver.owner))
228 goto error_module_get;
230 retval = usb_autopm_get_interface(serial->interface);
232 goto error_get_interface;
234 init_termios = (driver->termios[idx] == NULL);
236 retval = tty_standard_install(driver, tty);
238 goto error_init_termios;
240 mutex_unlock(&serial->disc_mutex);
242 /* allow the driver to update the initial settings */
243 if (init_termios && serial->type->init_termios)
244 serial->type->init_termios(tty);
246 tty->driver_data = port;
251 usb_autopm_put_interface(serial->interface);
253 module_put(serial->type->driver.owner);
255 usb_serial_put(serial);
256 mutex_unlock(&serial->disc_mutex);
260 static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
262 struct usb_serial_port *port =
263 container_of(tport, struct usb_serial_port, port);
264 struct usb_serial *serial = port->serial;
267 mutex_lock(&serial->disc_mutex);
268 if (serial->disconnected)
271 retval = port->serial->type->open(tty, port);
272 mutex_unlock(&serial->disc_mutex);
275 retval = usb_translate_errors(retval);
280 static int serial_open(struct tty_struct *tty, struct file *filp)
282 struct usb_serial_port *port = tty->driver_data;
284 dev_dbg(&port->dev, "%s\n", __func__);
286 return tty_port_open(&port->port, tty, filp);
290 * serial_port_shutdown - shut down hardware
291 * @tport: tty port to shut down
293 * Shut down a USB serial port. Serialized against activate by the
294 * tport mutex and kept to matching open/close pairs
295 * of calls by the initialized flag.
297 * Not called if tty is console.
299 static void serial_port_shutdown(struct tty_port *tport)
301 struct usb_serial_port *port =
302 container_of(tport, struct usb_serial_port, port);
303 struct usb_serial_driver *drv = port->serial->type;
309 static void serial_hangup(struct tty_struct *tty)
311 struct usb_serial_port *port = tty->driver_data;
313 dev_dbg(&port->dev, "%s\n", __func__);
315 tty_port_hangup(&port->port);
318 static void serial_close(struct tty_struct *tty, struct file *filp)
320 struct usb_serial_port *port = tty->driver_data;
322 dev_dbg(&port->dev, "%s\n", __func__);
324 tty_port_close(&port->port, tty, filp);
328 * serial_cleanup - free resources post close/hangup
329 * @tty: tty to clean up
331 * Do the resource freeing and refcount dropping for the port.
332 * Avoid freeing the console.
334 * Called asynchronously after the last tty kref is dropped.
336 static void serial_cleanup(struct tty_struct *tty)
338 struct usb_serial_port *port = tty->driver_data;
339 struct usb_serial *serial;
340 struct module *owner;
342 dev_dbg(&port->dev, "%s\n", __func__);
344 /* The console is magical. Do not hang up the console hardware
345 * or there will be tears.
347 if (port->port.console)
350 tty->driver_data = NULL;
352 serial = port->serial;
353 owner = serial->type->driver.owner;
355 usb_autopm_put_interface(serial->interface);
357 usb_serial_put(serial);
361 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
364 struct usb_serial_port *port = tty->driver_data;
365 int retval = -ENODEV;
367 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
370 dev_dbg(&port->dev, "%s - %d byte(s)\n", __func__, count);
372 retval = port->serial->type->write(tty, port, buf, count);
374 retval = usb_translate_errors(retval);
379 static unsigned int serial_write_room(struct tty_struct *tty)
381 struct usb_serial_port *port = tty->driver_data;
383 dev_dbg(&port->dev, "%s\n", __func__);
385 return port->serial->type->write_room(tty);
388 static unsigned int serial_chars_in_buffer(struct tty_struct *tty)
390 struct usb_serial_port *port = tty->driver_data;
391 struct usb_serial *serial = port->serial;
393 dev_dbg(&port->dev, "%s\n", __func__);
395 if (serial->disconnected)
398 return serial->type->chars_in_buffer(tty);
401 static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
403 struct usb_serial_port *port = tty->driver_data;
404 struct usb_serial *serial = port->serial;
406 dev_dbg(&port->dev, "%s\n", __func__);
408 if (!port->serial->type->wait_until_sent)
411 mutex_lock(&serial->disc_mutex);
412 if (!serial->disconnected)
413 port->serial->type->wait_until_sent(tty, timeout);
414 mutex_unlock(&serial->disc_mutex);
417 static void serial_throttle(struct tty_struct *tty)
419 struct usb_serial_port *port = tty->driver_data;
421 dev_dbg(&port->dev, "%s\n", __func__);
423 if (port->serial->type->throttle)
424 port->serial->type->throttle(tty);
427 static void serial_unthrottle(struct tty_struct *tty)
429 struct usb_serial_port *port = tty->driver_data;
431 dev_dbg(&port->dev, "%s\n", __func__);
433 if (port->serial->type->unthrottle)
434 port->serial->type->unthrottle(tty);
437 static int serial_get_serial(struct tty_struct *tty, struct serial_struct *ss)
439 struct usb_serial_port *port = tty->driver_data;
440 struct tty_port *tport = &port->port;
441 unsigned int close_delay, closing_wait;
443 mutex_lock(&tport->mutex);
445 close_delay = jiffies_to_msecs(tport->close_delay) / 10;
446 closing_wait = tport->closing_wait;
447 if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
448 closing_wait = jiffies_to_msecs(closing_wait) / 10;
450 ss->line = port->minor;
451 ss->close_delay = close_delay;
452 ss->closing_wait = closing_wait;
454 if (port->serial->type->get_serial)
455 port->serial->type->get_serial(tty, ss);
457 mutex_unlock(&tport->mutex);
462 static int serial_set_serial(struct tty_struct *tty, struct serial_struct *ss)
464 struct usb_serial_port *port = tty->driver_data;
465 struct tty_port *tport = &port->port;
466 unsigned int close_delay, closing_wait;
469 close_delay = msecs_to_jiffies(ss->close_delay * 10);
470 closing_wait = ss->closing_wait;
471 if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
472 closing_wait = msecs_to_jiffies(closing_wait * 10);
474 mutex_lock(&tport->mutex);
476 if (!capable(CAP_SYS_ADMIN)) {
477 if (close_delay != tport->close_delay ||
478 closing_wait != tport->closing_wait) {
484 if (port->serial->type->set_serial) {
485 ret = port->serial->type->set_serial(tty, ss);
490 tport->close_delay = close_delay;
491 tport->closing_wait = closing_wait;
493 mutex_unlock(&tport->mutex);
498 static int serial_ioctl(struct tty_struct *tty,
499 unsigned int cmd, unsigned long arg)
501 struct usb_serial_port *port = tty->driver_data;
502 int retval = -ENOIOCTLCMD;
504 dev_dbg(&port->dev, "%s - cmd 0x%04x\n", __func__, cmd);
508 if (port->serial->type->tiocmiwait)
509 retval = port->serial->type->tiocmiwait(tty, arg);
512 if (port->serial->type->ioctl)
513 retval = port->serial->type->ioctl(tty, cmd, arg);
519 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
521 struct usb_serial_port *port = tty->driver_data;
523 dev_dbg(&port->dev, "%s\n", __func__);
525 if (port->serial->type->set_termios)
526 port->serial->type->set_termios(tty, port, old);
528 tty_termios_copy_hw(&tty->termios, old);
531 static int serial_break(struct tty_struct *tty, int break_state)
533 struct usb_serial_port *port = tty->driver_data;
535 dev_dbg(&port->dev, "%s\n", __func__);
537 if (port->serial->type->break_ctl)
538 port->serial->type->break_ctl(tty, break_state);
543 static int serial_proc_show(struct seq_file *m, void *v)
545 struct usb_serial *serial;
546 struct usb_serial_port *port;
550 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
551 for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) {
552 port = usb_serial_port_get_by_minor(i);
555 serial = port->serial;
557 seq_printf(m, "%d:", i);
558 if (serial->type->driver.owner)
559 seq_printf(m, " module:%s",
560 module_name(serial->type->driver.owner));
561 seq_printf(m, " name:\"%s\"",
562 serial->type->description);
563 seq_printf(m, " vendor:%04x product:%04x",
564 le16_to_cpu(serial->dev->descriptor.idVendor),
565 le16_to_cpu(serial->dev->descriptor.idProduct));
566 seq_printf(m, " num_ports:%d", serial->num_ports);
567 seq_printf(m, " port:%d", port->port_number);
568 usb_make_path(serial->dev, tmp, sizeof(tmp));
569 seq_printf(m, " path:%s", tmp);
572 usb_serial_put(serial);
573 mutex_unlock(&serial->disc_mutex);
578 static int serial_tiocmget(struct tty_struct *tty)
580 struct usb_serial_port *port = tty->driver_data;
582 dev_dbg(&port->dev, "%s\n", __func__);
584 if (port->serial->type->tiocmget)
585 return port->serial->type->tiocmget(tty);
589 static int serial_tiocmset(struct tty_struct *tty,
590 unsigned int set, unsigned int clear)
592 struct usb_serial_port *port = tty->driver_data;
594 dev_dbg(&port->dev, "%s\n", __func__);
596 if (port->serial->type->tiocmset)
597 return port->serial->type->tiocmset(tty, set, clear);
601 static int serial_get_icount(struct tty_struct *tty,
602 struct serial_icounter_struct *icount)
604 struct usb_serial_port *port = tty->driver_data;
606 dev_dbg(&port->dev, "%s\n", __func__);
608 if (port->serial->type->get_icount)
609 return port->serial->type->get_icount(tty, icount);
614 * We would be calling tty_wakeup here, but unfortunately some line
615 * disciplines have an annoying habit of calling tty->write from
616 * the write wakeup callback (e.g. n_hdlc.c).
618 void usb_serial_port_softint(struct usb_serial_port *port)
620 schedule_work(&port->work);
622 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
624 static void usb_serial_port_work(struct work_struct *work)
626 struct usb_serial_port *port =
627 container_of(work, struct usb_serial_port, work);
629 tty_port_tty_wakeup(&port->port);
632 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
636 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
637 usb_poison_urb(port->read_urbs[i]);
638 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
639 usb_poison_urb(port->write_urbs[i]);
641 usb_poison_urb(port->interrupt_in_urb);
642 usb_poison_urb(port->interrupt_out_urb);
645 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
649 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
650 usb_unpoison_urb(port->read_urbs[i]);
651 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
652 usb_unpoison_urb(port->write_urbs[i]);
654 usb_unpoison_urb(port->interrupt_in_urb);
655 usb_unpoison_urb(port->interrupt_out_urb);
658 static void usb_serial_port_release(struct device *dev)
660 struct usb_serial_port *port = to_usb_serial_port(dev);
663 dev_dbg(dev, "%s\n", __func__);
665 usb_free_urb(port->interrupt_in_urb);
666 usb_free_urb(port->interrupt_out_urb);
667 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
668 usb_free_urb(port->read_urbs[i]);
669 kfree(port->bulk_in_buffers[i]);
671 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
672 usb_free_urb(port->write_urbs[i]);
673 kfree(port->bulk_out_buffers[i]);
675 kfifo_free(&port->write_fifo);
676 kfree(port->interrupt_in_buffer);
677 kfree(port->interrupt_out_buffer);
678 tty_port_destroy(&port->port);
682 static struct usb_serial *create_serial(struct usb_device *dev,
683 struct usb_interface *interface,
684 struct usb_serial_driver *driver)
686 struct usb_serial *serial;
688 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
691 serial->dev = usb_get_dev(dev);
692 serial->type = driver;
693 serial->interface = usb_get_intf(interface);
694 kref_init(&serial->kref);
695 mutex_init(&serial->disc_mutex);
696 serial->minors_reserved = 0;
701 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
702 struct usb_serial_driver *drv)
704 struct usb_dynid *dynid;
706 spin_lock(&drv->dynids.lock);
707 list_for_each_entry(dynid, &drv->dynids.list, node) {
708 if (usb_match_one_id(intf, &dynid->id)) {
709 spin_unlock(&drv->dynids.lock);
713 spin_unlock(&drv->dynids.lock);
717 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
718 struct usb_interface *intf)
720 const struct usb_device_id *id;
722 id = usb_match_id(intf, drv->id_table);
724 dev_dbg(&intf->dev, "static descriptor matches\n");
727 id = match_dynamic_id(intf, drv);
729 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
734 /* Caller must hold table_lock */
735 static struct usb_serial_driver *search_serial_device(
736 struct usb_interface *iface)
738 const struct usb_device_id *id = NULL;
739 struct usb_serial_driver *drv;
740 struct usb_driver *driver = to_usb_driver(iface->dev.driver);
742 /* Check if the usb id matches a known device */
743 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
744 if (drv->usb_driver == driver)
745 id = get_iface_id(drv, iface);
753 static int serial_port_carrier_raised(struct tty_port *port)
755 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
756 struct usb_serial_driver *drv = p->serial->type;
758 if (drv->carrier_raised)
759 return drv->carrier_raised(p);
760 /* No carrier control - don't block */
764 static void serial_port_dtr_rts(struct tty_port *port, int on)
766 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
767 struct usb_serial_driver *drv = p->serial->type;
773 static ssize_t port_number_show(struct device *dev,
774 struct device_attribute *attr, char *buf)
776 struct usb_serial_port *port = to_usb_serial_port(dev);
778 return sprintf(buf, "%u\n", port->port_number);
780 static DEVICE_ATTR_RO(port_number);
782 static struct attribute *usb_serial_port_attrs[] = {
783 &dev_attr_port_number.attr,
786 ATTRIBUTE_GROUPS(usb_serial_port);
788 static const struct tty_port_operations serial_port_ops = {
789 .carrier_raised = serial_port_carrier_raised,
790 .dtr_rts = serial_port_dtr_rts,
791 .activate = serial_port_activate,
792 .shutdown = serial_port_shutdown,
795 static void store_endpoint(struct usb_serial *serial,
796 struct usb_serial_endpoints *epds,
797 struct usb_endpoint_descriptor *epd)
799 struct device *dev = &serial->interface->dev;
800 u8 addr = epd->bEndpointAddress;
802 if (usb_endpoint_is_bulk_in(epd)) {
803 if (epds->num_bulk_in == ARRAY_SIZE(epds->bulk_in))
805 dev_dbg(dev, "found bulk in endpoint %02x\n", addr);
806 epds->bulk_in[epds->num_bulk_in++] = epd;
807 } else if (usb_endpoint_is_bulk_out(epd)) {
808 if (epds->num_bulk_out == ARRAY_SIZE(epds->bulk_out))
810 dev_dbg(dev, "found bulk out endpoint %02x\n", addr);
811 epds->bulk_out[epds->num_bulk_out++] = epd;
812 } else if (usb_endpoint_is_int_in(epd)) {
813 if (epds->num_interrupt_in == ARRAY_SIZE(epds->interrupt_in))
815 dev_dbg(dev, "found interrupt in endpoint %02x\n", addr);
816 epds->interrupt_in[epds->num_interrupt_in++] = epd;
817 } else if (usb_endpoint_is_int_out(epd)) {
818 if (epds->num_interrupt_out == ARRAY_SIZE(epds->interrupt_out))
820 dev_dbg(dev, "found interrupt out endpoint %02x\n", addr);
821 epds->interrupt_out[epds->num_interrupt_out++] = epd;
825 static void find_endpoints(struct usb_serial *serial,
826 struct usb_serial_endpoints *epds,
827 struct usb_interface *intf)
829 struct usb_host_interface *iface_desc;
830 struct usb_endpoint_descriptor *epd;
833 iface_desc = intf->cur_altsetting;
834 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
835 epd = &iface_desc->endpoint[i].desc;
836 store_endpoint(serial, epds, epd);
840 static int setup_port_bulk_in(struct usb_serial_port *port,
841 struct usb_endpoint_descriptor *epd)
843 struct usb_serial_driver *type = port->serial->type;
844 struct usb_device *udev = port->serial->dev;
848 buffer_size = max_t(int, type->bulk_in_size, usb_endpoint_maxp(epd));
849 port->bulk_in_size = buffer_size;
850 port->bulk_in_endpointAddress = epd->bEndpointAddress;
852 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
853 set_bit(i, &port->read_urbs_free);
854 port->read_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
855 if (!port->read_urbs[i])
857 port->bulk_in_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
858 if (!port->bulk_in_buffers[i])
860 usb_fill_bulk_urb(port->read_urbs[i], udev,
861 usb_rcvbulkpipe(udev, epd->bEndpointAddress),
862 port->bulk_in_buffers[i], buffer_size,
863 type->read_bulk_callback, port);
866 port->read_urb = port->read_urbs[0];
867 port->bulk_in_buffer = port->bulk_in_buffers[0];
872 static int setup_port_bulk_out(struct usb_serial_port *port,
873 struct usb_endpoint_descriptor *epd)
875 struct usb_serial_driver *type = port->serial->type;
876 struct usb_device *udev = port->serial->dev;
880 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
882 if (type->bulk_out_size)
883 buffer_size = type->bulk_out_size;
885 buffer_size = usb_endpoint_maxp(epd);
886 port->bulk_out_size = buffer_size;
887 port->bulk_out_endpointAddress = epd->bEndpointAddress;
889 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
890 set_bit(i, &port->write_urbs_free);
891 port->write_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
892 if (!port->write_urbs[i])
894 port->bulk_out_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
895 if (!port->bulk_out_buffers[i])
897 usb_fill_bulk_urb(port->write_urbs[i], udev,
898 usb_sndbulkpipe(udev, epd->bEndpointAddress),
899 port->bulk_out_buffers[i], buffer_size,
900 type->write_bulk_callback, port);
903 port->write_urb = port->write_urbs[0];
904 port->bulk_out_buffer = port->bulk_out_buffers[0];
909 static int setup_port_interrupt_in(struct usb_serial_port *port,
910 struct usb_endpoint_descriptor *epd)
912 struct usb_serial_driver *type = port->serial->type;
913 struct usb_device *udev = port->serial->dev;
916 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
917 if (!port->interrupt_in_urb)
919 buffer_size = usb_endpoint_maxp(epd);
920 port->interrupt_in_endpointAddress = epd->bEndpointAddress;
921 port->interrupt_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
922 if (!port->interrupt_in_buffer)
924 usb_fill_int_urb(port->interrupt_in_urb, udev,
925 usb_rcvintpipe(udev, epd->bEndpointAddress),
926 port->interrupt_in_buffer, buffer_size,
927 type->read_int_callback, port,
933 static int setup_port_interrupt_out(struct usb_serial_port *port,
934 struct usb_endpoint_descriptor *epd)
936 struct usb_serial_driver *type = port->serial->type;
937 struct usb_device *udev = port->serial->dev;
940 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
941 if (!port->interrupt_out_urb)
943 buffer_size = usb_endpoint_maxp(epd);
944 port->interrupt_out_size = buffer_size;
945 port->interrupt_out_endpointAddress = epd->bEndpointAddress;
946 port->interrupt_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
947 if (!port->interrupt_out_buffer)
949 usb_fill_int_urb(port->interrupt_out_urb, udev,
950 usb_sndintpipe(udev, epd->bEndpointAddress),
951 port->interrupt_out_buffer, buffer_size,
952 type->write_int_callback, port,
958 static int usb_serial_probe(struct usb_interface *interface,
959 const struct usb_device_id *id)
961 struct device *ddev = &interface->dev;
962 struct usb_device *dev = interface_to_usbdev(interface);
963 struct usb_serial *serial = NULL;
964 struct usb_serial_port *port;
965 struct usb_serial_endpoints *epds;
966 struct usb_serial_driver *type = NULL;
970 unsigned char max_endpoints;
972 mutex_lock(&table_lock);
973 type = search_serial_device(interface);
975 mutex_unlock(&table_lock);
976 dev_dbg(ddev, "none matched\n");
980 if (!try_module_get(type->driver.owner)) {
981 mutex_unlock(&table_lock);
982 dev_err(ddev, "module get failed, exiting\n");
985 mutex_unlock(&table_lock);
987 serial = create_serial(dev, interface, type);
993 /* if this device type has a probe function, call it */
995 const struct usb_device_id *id;
997 id = get_iface_id(type, interface);
998 retval = type->probe(serial, id);
1001 dev_dbg(ddev, "sub driver rejected device\n");
1002 goto err_release_sibling;
1006 /* descriptor matches, let's find the endpoints needed */
1007 epds = kzalloc(sizeof(*epds), GFP_KERNEL);
1010 goto err_release_sibling;
1013 find_endpoints(serial, epds, interface);
1014 if (serial->sibling)
1015 find_endpoints(serial, epds, serial->sibling);
1017 if (epds->num_bulk_in < type->num_bulk_in ||
1018 epds->num_bulk_out < type->num_bulk_out ||
1019 epds->num_interrupt_in < type->num_interrupt_in ||
1020 epds->num_interrupt_out < type->num_interrupt_out) {
1021 dev_err(ddev, "required endpoints missing\n");
1026 if (type->calc_num_ports) {
1027 retval = type->calc_num_ports(serial, epds);
1034 num_ports = type->num_ports;
1036 if (num_ports > MAX_NUM_PORTS) {
1037 dev_warn(ddev, "too many ports requested: %d\n", num_ports);
1038 num_ports = MAX_NUM_PORTS;
1041 serial->num_ports = (unsigned char)num_ports;
1042 serial->num_bulk_in = epds->num_bulk_in;
1043 serial->num_bulk_out = epds->num_bulk_out;
1044 serial->num_interrupt_in = epds->num_interrupt_in;
1045 serial->num_interrupt_out = epds->num_interrupt_out;
1047 /* found all that we need */
1048 dev_info(ddev, "%s converter detected\n", type->description);
1050 /* create our ports, we need as many as the max endpoints */
1051 /* we don't use num_ports here because some devices have more
1052 endpoint pairs than ports */
1053 max_endpoints = max(epds->num_bulk_in, epds->num_bulk_out);
1054 max_endpoints = max(max_endpoints, epds->num_interrupt_in);
1055 max_endpoints = max(max_endpoints, epds->num_interrupt_out);
1056 max_endpoints = max(max_endpoints, serial->num_ports);
1057 serial->num_port_pointers = max_endpoints;
1059 dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
1060 for (i = 0; i < max_endpoints; ++i) {
1061 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
1066 tty_port_init(&port->port);
1067 port->port.ops = &serial_port_ops;
1068 port->serial = serial;
1069 spin_lock_init(&port->lock);
1070 /* Keep this for private driver use for the moment but
1071 should probably go away */
1072 INIT_WORK(&port->work, usb_serial_port_work);
1073 serial->port[i] = port;
1074 port->dev.parent = &interface->dev;
1075 port->dev.driver = NULL;
1076 port->dev.bus = &usb_serial_bus_type;
1077 port->dev.release = &usb_serial_port_release;
1078 port->dev.groups = usb_serial_port_groups;
1079 device_initialize(&port->dev);
1082 /* set up the endpoint information */
1083 for (i = 0; i < epds->num_bulk_in; ++i) {
1084 retval = setup_port_bulk_in(serial->port[i], epds->bulk_in[i]);
1089 for (i = 0; i < epds->num_bulk_out; ++i) {
1090 retval = setup_port_bulk_out(serial->port[i],
1096 if (serial->type->read_int_callback) {
1097 for (i = 0; i < epds->num_interrupt_in; ++i) {
1098 retval = setup_port_interrupt_in(serial->port[i],
1099 epds->interrupt_in[i]);
1103 } else if (epds->num_interrupt_in) {
1104 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1107 if (serial->type->write_int_callback) {
1108 for (i = 0; i < epds->num_interrupt_out; ++i) {
1109 retval = setup_port_interrupt_out(serial->port[i],
1110 epds->interrupt_out[i]);
1114 } else if (epds->num_interrupt_out) {
1115 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1118 usb_set_intfdata(interface, serial);
1120 /* if this device type has an attach function, call it */
1122 retval = type->attach(serial);
1125 serial->attached = 1;
1127 /* quietly accept this device, but don't bind to a
1128 serial port as it's about to disappear */
1129 serial->num_ports = 0;
1133 serial->attached = 1;
1136 retval = allocate_minors(serial, num_ports);
1138 dev_err(ddev, "No more free serial minor numbers\n");
1142 /* register all of the individual ports with the driver core */
1143 for (i = 0; i < num_ports; ++i) {
1144 port = serial->port[i];
1145 dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1146 dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1147 device_enable_async_suspend(&port->dev);
1149 retval = device_add(&port->dev);
1151 dev_err(ddev, "Error registering port device, continuing\n");
1155 usb_serial_console_init(serial->port[0]->minor);
1158 module_put(type->driver.owner);
1163 err_release_sibling:
1164 release_sibling(serial, interface);
1165 usb_serial_put(serial);
1167 module_put(type->driver.owner);
1172 static void usb_serial_disconnect(struct usb_interface *interface)
1175 struct usb_serial *serial = usb_get_intfdata(interface);
1176 struct device *dev = &interface->dev;
1177 struct usb_serial_port *port;
1178 struct tty_struct *tty;
1180 /* sibling interface is cleaning up */
1184 usb_serial_console_disconnect(serial);
1186 mutex_lock(&serial->disc_mutex);
1187 /* must set a flag, to signal subdrivers */
1188 serial->disconnected = 1;
1189 mutex_unlock(&serial->disc_mutex);
1191 for (i = 0; i < serial->num_ports; ++i) {
1192 port = serial->port[i];
1193 tty = tty_port_tty_get(&port->port);
1198 usb_serial_port_poison_urbs(port);
1199 wake_up_interruptible(&port->port.delta_msr_wait);
1200 cancel_work_sync(&port->work);
1201 if (device_is_registered(&port->dev))
1202 device_del(&port->dev);
1204 if (serial->type->disconnect)
1205 serial->type->disconnect(serial);
1207 release_sibling(serial, interface);
1209 /* let the last holder of this object cause it to be cleaned up */
1210 usb_serial_put(serial);
1211 dev_info(dev, "device disconnected\n");
1214 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1216 struct usb_serial *serial = usb_get_intfdata(intf);
1219 /* suspend when called for first sibling interface */
1220 if (serial->suspend_count++)
1224 * serial->type->suspend() MUST return 0 in system sleep context,
1225 * otherwise, the resume callback has to recover device from
1226 * previous suspend failure.
1228 if (serial->type->suspend) {
1229 r = serial->type->suspend(serial, message);
1231 serial->suspend_count--;
1236 for (i = 0; i < serial->num_ports; ++i)
1237 usb_serial_port_poison_urbs(serial->port[i]);
1241 EXPORT_SYMBOL(usb_serial_suspend);
1243 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1247 for (i = 0; i < serial->num_ports; ++i)
1248 usb_serial_port_unpoison_urbs(serial->port[i]);
1251 int usb_serial_resume(struct usb_interface *intf)
1253 struct usb_serial *serial = usb_get_intfdata(intf);
1256 /* resume when called for last sibling interface */
1257 if (--serial->suspend_count)
1260 usb_serial_unpoison_port_urbs(serial);
1262 if (serial->type->resume)
1263 rv = serial->type->resume(serial);
1265 rv = usb_serial_generic_resume(serial);
1269 EXPORT_SYMBOL(usb_serial_resume);
1271 static int usb_serial_reset_resume(struct usb_interface *intf)
1273 struct usb_serial *serial = usb_get_intfdata(intf);
1276 /* resume when called for last sibling interface */
1277 if (--serial->suspend_count)
1280 usb_serial_unpoison_port_urbs(serial);
1282 if (serial->type->reset_resume) {
1283 rv = serial->type->reset_resume(serial);
1286 intf->needs_binding = 1;
1292 static const struct tty_operations serial_ops = {
1293 .open = serial_open,
1294 .close = serial_close,
1295 .write = serial_write,
1296 .hangup = serial_hangup,
1297 .write_room = serial_write_room,
1298 .ioctl = serial_ioctl,
1299 .set_termios = serial_set_termios,
1300 .throttle = serial_throttle,
1301 .unthrottle = serial_unthrottle,
1302 .break_ctl = serial_break,
1303 .chars_in_buffer = serial_chars_in_buffer,
1304 .wait_until_sent = serial_wait_until_sent,
1305 .tiocmget = serial_tiocmget,
1306 .tiocmset = serial_tiocmset,
1307 .get_icount = serial_get_icount,
1308 .set_serial = serial_set_serial,
1309 .get_serial = serial_get_serial,
1310 .cleanup = serial_cleanup,
1311 .install = serial_install,
1312 .proc_show = serial_proc_show,
1316 struct tty_driver *usb_serial_tty_driver;
1318 static int __init usb_serial_init(void)
1322 usb_serial_tty_driver = tty_alloc_driver(USB_SERIAL_TTY_MINORS,
1323 TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV);
1324 if (IS_ERR(usb_serial_tty_driver))
1325 return PTR_ERR(usb_serial_tty_driver);
1327 /* Initialize our global data */
1328 result = bus_register(&usb_serial_bus_type);
1330 pr_err("%s - registering bus driver failed\n", __func__);
1334 usb_serial_tty_driver->driver_name = "usbserial";
1335 usb_serial_tty_driver->name = "ttyUSB";
1336 usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1337 usb_serial_tty_driver->minor_start = 0;
1338 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1339 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1340 usb_serial_tty_driver->init_termios = tty_std_termios;
1341 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1343 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1344 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1345 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1346 result = tty_register_driver(usb_serial_tty_driver);
1348 pr_err("%s - tty_register_driver failed\n", __func__);
1349 goto exit_reg_driver;
1352 /* register the generic driver, if we should */
1353 result = usb_serial_generic_register();
1355 pr_err("%s - registering generic driver failed\n", __func__);
1362 tty_unregister_driver(usb_serial_tty_driver);
1365 bus_unregister(&usb_serial_bus_type);
1368 pr_err("%s - returning with error %d\n", __func__, result);
1369 tty_driver_kref_put(usb_serial_tty_driver);
1374 static void __exit usb_serial_exit(void)
1376 usb_serial_console_exit();
1378 usb_serial_generic_deregister();
1380 tty_unregister_driver(usb_serial_tty_driver);
1381 tty_driver_kref_put(usb_serial_tty_driver);
1382 bus_unregister(&usb_serial_bus_type);
1383 idr_destroy(&serial_minors);
1387 module_init(usb_serial_init);
1388 module_exit(usb_serial_exit);
1390 #define set_to_generic_if_null(type, function) \
1392 if (!type->function) { \
1393 type->function = usb_serial_generic_##function; \
1394 pr_debug("%s: using generic " #function "\n", \
1395 type->driver.name); \
1399 static void usb_serial_operations_init(struct usb_serial_driver *device)
1401 set_to_generic_if_null(device, open);
1402 set_to_generic_if_null(device, write);
1403 set_to_generic_if_null(device, close);
1404 set_to_generic_if_null(device, write_room);
1405 set_to_generic_if_null(device, chars_in_buffer);
1406 if (device->tx_empty)
1407 set_to_generic_if_null(device, wait_until_sent);
1408 set_to_generic_if_null(device, read_bulk_callback);
1409 set_to_generic_if_null(device, write_bulk_callback);
1410 set_to_generic_if_null(device, process_read_urb);
1411 set_to_generic_if_null(device, prepare_write_buffer);
1414 static int usb_serial_register(struct usb_serial_driver *driver)
1421 if (!driver->description)
1422 driver->description = driver->driver.name;
1423 if (!driver->usb_driver) {
1424 WARN(1, "Serial driver %s has no usb_driver\n",
1425 driver->description);
1429 /* Prevent individual ports from being unbound. */
1430 driver->driver.suppress_bind_attrs = true;
1432 usb_serial_operations_init(driver);
1434 /* Add this device to our list of devices */
1435 mutex_lock(&table_lock);
1436 list_add(&driver->driver_list, &usb_serial_driver_list);
1438 retval = usb_serial_bus_register(driver);
1440 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1441 list_del(&driver->driver_list);
1443 pr_info("USB Serial support registered for %s\n", driver->description);
1445 mutex_unlock(&table_lock);
1449 static void usb_serial_deregister(struct usb_serial_driver *device)
1451 pr_info("USB Serial deregistering driver %s\n", device->description);
1453 mutex_lock(&table_lock);
1454 list_del(&device->driver_list);
1455 mutex_unlock(&table_lock);
1457 usb_serial_bus_deregister(device);
1461 * usb_serial_register_drivers - register drivers for a usb-serial module
1462 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1463 * @name: name of the usb_driver for this set of @serial_drivers
1464 * @id_table: list of all devices this @serial_drivers set binds to
1466 * Registers all the drivers in the @serial_drivers array, and dynamically
1467 * creates a struct usb_driver with the name @name and id_table of @id_table.
1469 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1471 const struct usb_device_id *id_table)
1474 struct usb_driver *udriver;
1475 struct usb_serial_driver * const *sd;
1478 * udriver must be registered before any of the serial drivers,
1479 * because the store_new_id() routine for the serial drivers (in
1480 * bus.c) probes udriver.
1482 * Performance hack: We don't want udriver to be probed until
1483 * the serial drivers are registered, because the probe would
1484 * simply fail for lack of a matching serial driver.
1485 * So we leave udriver's id_table set to NULL until we are all set.
1487 * Suspend/resume support is implemented in the usb-serial core,
1488 * so fill in the PM-related fields in udriver.
1490 udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1494 udriver->name = name;
1495 udriver->no_dynamic_id = 1;
1496 udriver->supports_autosuspend = 1;
1497 udriver->suspend = usb_serial_suspend;
1498 udriver->resume = usb_serial_resume;
1499 udriver->probe = usb_serial_probe;
1500 udriver->disconnect = usb_serial_disconnect;
1502 /* we only set the reset_resume field if the serial_driver has one */
1503 for (sd = serial_drivers; *sd; ++sd) {
1504 if ((*sd)->reset_resume) {
1505 udriver->reset_resume = usb_serial_reset_resume;
1510 rc = usb_register(udriver);
1512 goto failed_usb_register;
1514 for (sd = serial_drivers; *sd; ++sd) {
1515 (*sd)->usb_driver = udriver;
1516 rc = usb_serial_register(*sd);
1521 /* Now set udriver's id_table and look for matches */
1522 udriver->id_table = id_table;
1523 rc = driver_attach(&udriver->drvwrap.driver);
1527 while (sd-- > serial_drivers)
1528 usb_serial_deregister(*sd);
1529 usb_deregister(udriver);
1530 failed_usb_register:
1534 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1537 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1538 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1540 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1541 * frees the struct usb_driver that was created by the call to
1542 * usb_serial_register_drivers().
1544 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1546 struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1548 for (; *serial_drivers; ++serial_drivers)
1549 usb_serial_deregister(*serial_drivers);
1550 usb_deregister(udriver);
1553 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1555 MODULE_AUTHOR(DRIVER_AUTHOR);
1556 MODULE_DESCRIPTION(DRIVER_DESC);
1557 MODULE_LICENSE("GPL v2");