2 * USB Serial Converter driver
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)
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.
13 * This driver was originally based on the ACM driver by Armin Fuerst (which was
14 * based on a driver by Brad Keryan)
16 * See Documentation/usb/usb-serial.txt for more information on using this
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
43 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
44 #define DRIVER_DESC "USB Serial Driver core"
46 #define USB_SERIAL_TTY_MAJOR 188
47 #define USB_SERIAL_TTY_MINORS 512 /* should be enough for a while */
49 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
50 the MODULE_DEVICE_TABLE declarations in each serial driver
51 cause the "hotplug" program to pull in whatever module is necessary
52 via modprobe, and modprobe will load usbserial because the serial
56 static DEFINE_IDR(serial_minors);
57 static DEFINE_MUTEX(table_lock);
58 static LIST_HEAD(usb_serial_driver_list);
61 * Look up the serial port structure. If it is found and it hasn't been
62 * disconnected, return with the parent usb_serial structure's disc_mutex held
63 * and its refcount incremented. Otherwise return NULL.
65 struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor)
67 struct usb_serial *serial;
68 struct usb_serial_port *port;
70 mutex_lock(&table_lock);
71 port = idr_find(&serial_minors, minor);
75 serial = port->serial;
76 mutex_lock(&serial->disc_mutex);
77 if (serial->disconnected) {
78 mutex_unlock(&serial->disc_mutex);
81 kref_get(&serial->kref);
84 mutex_unlock(&table_lock);
88 static int allocate_minors(struct usb_serial *serial, int num_ports)
90 struct usb_serial_port *port;
94 dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
96 mutex_lock(&table_lock);
97 for (i = 0; i < num_ports; ++i) {
98 port = serial->port[i];
99 minor = idr_alloc(&serial_minors, port, 0, 0, GFP_KERNEL);
103 port->port_number = i;
105 serial->minors_reserved = 1;
106 mutex_unlock(&table_lock);
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);
116 static void release_minors(struct usb_serial *serial)
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;
127 static void destroy_serial(struct kref *kref)
129 struct usb_serial *serial;
130 struct usb_serial_port *port;
133 serial = to_usb_serial(kref);
135 /* return the minor range that this device had */
136 if (serial->minors_reserved)
137 release_minors(serial);
139 if (serial->attached && serial->type->release)
140 serial->type->release(serial);
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];
147 put_device(&port->dev);
151 usb_put_intf(serial->interface);
152 usb_put_dev(serial->dev);
156 void usb_serial_put(struct usb_serial *serial)
158 kref_put(&serial->kref, destroy_serial);
161 /*****************************************************************************
162 * Driver tty interface functions
163 *****************************************************************************/
166 * serial_install - install tty
167 * @driver: the driver (USB in our case)
168 * @tty: the tty being created
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.
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().
179 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
181 int idx = tty->index;
182 struct usb_serial *serial;
183 struct usb_serial_port *port;
184 int retval = -ENODEV;
186 port = usb_serial_port_get_by_minor(idx);
190 serial = port->serial;
191 if (!try_module_get(serial->type->driver.owner))
192 goto error_module_get;
194 retval = usb_autopm_get_interface(serial->interface);
196 goto error_get_interface;
198 retval = tty_port_install(&port->port, driver, tty);
200 goto error_init_termios;
202 mutex_unlock(&serial->disc_mutex);
204 /* allow the driver to update the settings */
205 if (serial->type->init_termios)
206 serial->type->init_termios(tty);
208 tty->driver_data = port;
213 usb_autopm_put_interface(serial->interface);
215 module_put(serial->type->driver.owner);
217 usb_serial_put(serial);
218 mutex_unlock(&serial->disc_mutex);
222 static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
224 struct usb_serial_port *port =
225 container_of(tport, struct usb_serial_port, port);
226 struct usb_serial *serial = port->serial;
229 mutex_lock(&serial->disc_mutex);
230 if (serial->disconnected)
233 retval = port->serial->type->open(tty, port);
234 mutex_unlock(&serial->disc_mutex);
237 retval = usb_translate_errors(retval);
242 static int serial_open(struct tty_struct *tty, struct file *filp)
244 struct usb_serial_port *port = tty->driver_data;
246 dev_dbg(tty->dev, "%s\n", __func__);
248 return tty_port_open(&port->port, tty, filp);
252 * serial_port_shutdown - shut down hardware
253 * @tport: tty port to shut down
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 ASYNCB_INITIALIZED flag.
259 * Not called if tty is console.
261 static void serial_port_shutdown(struct tty_port *tport)
263 struct usb_serial_port *port =
264 container_of(tport, struct usb_serial_port, port);
265 struct usb_serial_driver *drv = port->serial->type;
271 static void serial_hangup(struct tty_struct *tty)
273 struct usb_serial_port *port = tty->driver_data;
275 dev_dbg(tty->dev, "%s\n", __func__);
277 tty_port_hangup(&port->port);
280 static void serial_close(struct tty_struct *tty, struct file *filp)
282 struct usb_serial_port *port = tty->driver_data;
284 dev_dbg(tty->dev, "%s\n", __func__);
286 tty_port_close(&port->port, tty, filp);
290 * serial_cleanup - free resources post close/hangup
291 * @port: port to free up
293 * Do the resource freeing and refcount dropping for the port.
294 * Avoid freeing the console.
296 * Called asynchronously after the last tty kref is dropped.
298 static void serial_cleanup(struct tty_struct *tty)
300 struct usb_serial_port *port = tty->driver_data;
301 struct usb_serial *serial;
302 struct module *owner;
304 dev_dbg(tty->dev, "%s\n", __func__);
306 /* The console is magical. Do not hang up the console hardware
307 * or there will be tears.
309 if (port->port.console)
312 tty->driver_data = NULL;
314 serial = port->serial;
315 owner = serial->type->driver.owner;
317 usb_autopm_put_interface(serial->interface);
319 usb_serial_put(serial);
323 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
326 struct usb_serial_port *port = tty->driver_data;
327 int retval = -ENODEV;
329 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
332 dev_dbg(tty->dev, "%s - %d byte(s)\n", __func__, count);
334 retval = port->serial->type->write(tty, port, buf, count);
336 retval = usb_translate_errors(retval);
341 static int serial_write_room(struct tty_struct *tty)
343 struct usb_serial_port *port = tty->driver_data;
345 dev_dbg(tty->dev, "%s\n", __func__);
347 return port->serial->type->write_room(tty);
350 static int serial_chars_in_buffer(struct tty_struct *tty)
352 struct usb_serial_port *port = tty->driver_data;
353 struct usb_serial *serial = port->serial;
355 dev_dbg(tty->dev, "%s\n", __func__);
357 if (serial->disconnected)
360 return serial->type->chars_in_buffer(tty);
363 static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
365 struct usb_serial_port *port = tty->driver_data;
366 struct usb_serial *serial = port->serial;
368 dev_dbg(tty->dev, "%s\n", __func__);
370 if (!port->serial->type->wait_until_sent)
373 mutex_lock(&serial->disc_mutex);
374 if (!serial->disconnected)
375 port->serial->type->wait_until_sent(tty, timeout);
376 mutex_unlock(&serial->disc_mutex);
379 static void serial_throttle(struct tty_struct *tty)
381 struct usb_serial_port *port = tty->driver_data;
383 dev_dbg(tty->dev, "%s\n", __func__);
385 if (port->serial->type->throttle)
386 port->serial->type->throttle(tty);
389 static void serial_unthrottle(struct tty_struct *tty)
391 struct usb_serial_port *port = tty->driver_data;
393 dev_dbg(tty->dev, "%s\n", __func__);
395 if (port->serial->type->unthrottle)
396 port->serial->type->unthrottle(tty);
399 static int serial_ioctl(struct tty_struct *tty,
400 unsigned int cmd, unsigned long arg)
402 struct usb_serial_port *port = tty->driver_data;
403 int retval = -ENOIOCTLCMD;
405 dev_dbg(tty->dev, "%s - cmd 0x%04x\n", __func__, cmd);
409 if (port->serial->type->tiocmiwait)
410 retval = port->serial->type->tiocmiwait(tty, arg);
413 if (port->serial->type->ioctl)
414 retval = port->serial->type->ioctl(tty, cmd, arg);
420 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
422 struct usb_serial_port *port = tty->driver_data;
424 dev_dbg(tty->dev, "%s\n", __func__);
426 if (port->serial->type->set_termios)
427 port->serial->type->set_termios(tty, port, old);
429 tty_termios_copy_hw(&tty->termios, old);
432 static int serial_break(struct tty_struct *tty, int break_state)
434 struct usb_serial_port *port = tty->driver_data;
436 dev_dbg(tty->dev, "%s\n", __func__);
438 if (port->serial->type->break_ctl)
439 port->serial->type->break_ctl(tty, break_state);
444 static int serial_proc_show(struct seq_file *m, void *v)
446 struct usb_serial *serial;
447 struct usb_serial_port *port;
451 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
452 for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) {
453 port = usb_serial_port_get_by_minor(i);
456 serial = port->serial;
458 seq_printf(m, "%d:", i);
459 if (serial->type->driver.owner)
460 seq_printf(m, " module:%s",
461 module_name(serial->type->driver.owner));
462 seq_printf(m, " name:\"%s\"",
463 serial->type->description);
464 seq_printf(m, " vendor:%04x product:%04x",
465 le16_to_cpu(serial->dev->descriptor.idVendor),
466 le16_to_cpu(serial->dev->descriptor.idProduct));
467 seq_printf(m, " num_ports:%d", serial->num_ports);
468 seq_printf(m, " port:%d", port->port_number);
469 usb_make_path(serial->dev, tmp, sizeof(tmp));
470 seq_printf(m, " path:%s", tmp);
473 usb_serial_put(serial);
474 mutex_unlock(&serial->disc_mutex);
479 static int serial_proc_open(struct inode *inode, struct file *file)
481 return single_open(file, serial_proc_show, NULL);
484 static const struct file_operations serial_proc_fops = {
485 .owner = THIS_MODULE,
486 .open = serial_proc_open,
489 .release = single_release,
492 static int serial_tiocmget(struct tty_struct *tty)
494 struct usb_serial_port *port = tty->driver_data;
496 dev_dbg(tty->dev, "%s\n", __func__);
498 if (port->serial->type->tiocmget)
499 return port->serial->type->tiocmget(tty);
503 static int serial_tiocmset(struct tty_struct *tty,
504 unsigned int set, unsigned int clear)
506 struct usb_serial_port *port = tty->driver_data;
508 dev_dbg(tty->dev, "%s\n", __func__);
510 if (port->serial->type->tiocmset)
511 return port->serial->type->tiocmset(tty, set, clear);
515 static int serial_get_icount(struct tty_struct *tty,
516 struct serial_icounter_struct *icount)
518 struct usb_serial_port *port = tty->driver_data;
520 dev_dbg(tty->dev, "%s\n", __func__);
522 if (port->serial->type->get_icount)
523 return port->serial->type->get_icount(tty, icount);
528 * We would be calling tty_wakeup here, but unfortunately some line
529 * disciplines have an annoying habit of calling tty->write from
530 * the write wakeup callback (e.g. n_hdlc.c).
532 void usb_serial_port_softint(struct usb_serial_port *port)
534 schedule_work(&port->work);
536 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
538 static void usb_serial_port_work(struct work_struct *work)
540 struct usb_serial_port *port =
541 container_of(work, struct usb_serial_port, work);
543 tty_port_tty_wakeup(&port->port);
546 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
550 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
551 usb_poison_urb(port->read_urbs[i]);
552 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
553 usb_poison_urb(port->write_urbs[i]);
555 usb_poison_urb(port->interrupt_in_urb);
556 usb_poison_urb(port->interrupt_out_urb);
559 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
563 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
564 usb_unpoison_urb(port->read_urbs[i]);
565 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
566 usb_unpoison_urb(port->write_urbs[i]);
568 usb_unpoison_urb(port->interrupt_in_urb);
569 usb_unpoison_urb(port->interrupt_out_urb);
572 static void usb_serial_port_release(struct device *dev)
574 struct usb_serial_port *port = to_usb_serial_port(dev);
577 dev_dbg(dev, "%s\n", __func__);
579 usb_free_urb(port->interrupt_in_urb);
580 usb_free_urb(port->interrupt_out_urb);
581 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
582 usb_free_urb(port->read_urbs[i]);
583 kfree(port->bulk_in_buffers[i]);
585 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
586 usb_free_urb(port->write_urbs[i]);
587 kfree(port->bulk_out_buffers[i]);
589 kfifo_free(&port->write_fifo);
590 kfree(port->interrupt_in_buffer);
591 kfree(port->interrupt_out_buffer);
592 tty_port_destroy(&port->port);
596 static struct usb_serial *create_serial(struct usb_device *dev,
597 struct usb_interface *interface,
598 struct usb_serial_driver *driver)
600 struct usb_serial *serial;
602 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
605 serial->dev = usb_get_dev(dev);
606 serial->type = driver;
607 serial->interface = usb_get_intf(interface);
608 kref_init(&serial->kref);
609 mutex_init(&serial->disc_mutex);
610 serial->minors_reserved = 0;
615 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
616 struct usb_serial_driver *drv)
618 struct usb_dynid *dynid;
620 spin_lock(&drv->dynids.lock);
621 list_for_each_entry(dynid, &drv->dynids.list, node) {
622 if (usb_match_one_id(intf, &dynid->id)) {
623 spin_unlock(&drv->dynids.lock);
627 spin_unlock(&drv->dynids.lock);
631 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
632 struct usb_interface *intf)
634 const struct usb_device_id *id;
636 id = usb_match_id(intf, drv->id_table);
638 dev_dbg(&intf->dev, "static descriptor matches\n");
641 id = match_dynamic_id(intf, drv);
643 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
648 /* Caller must hold table_lock */
649 static struct usb_serial_driver *search_serial_device(
650 struct usb_interface *iface)
652 const struct usb_device_id *id = NULL;
653 struct usb_serial_driver *drv;
654 struct usb_driver *driver = to_usb_driver(iface->dev.driver);
656 /* Check if the usb id matches a known device */
657 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
658 if (drv->usb_driver == driver)
659 id = get_iface_id(drv, iface);
667 static int serial_port_carrier_raised(struct tty_port *port)
669 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
670 struct usb_serial_driver *drv = p->serial->type;
672 if (drv->carrier_raised)
673 return drv->carrier_raised(p);
674 /* No carrier control - don't block */
678 static void serial_port_dtr_rts(struct tty_port *port, int on)
680 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
681 struct usb_serial_driver *drv = p->serial->type;
687 static ssize_t port_number_show(struct device *dev,
688 struct device_attribute *attr, char *buf)
690 struct usb_serial_port *port = to_usb_serial_port(dev);
692 return sprintf(buf, "%u\n", port->port_number);
694 static DEVICE_ATTR_RO(port_number);
696 static struct attribute *usb_serial_port_attrs[] = {
697 &dev_attr_port_number.attr,
700 ATTRIBUTE_GROUPS(usb_serial_port);
702 static const struct tty_port_operations serial_port_ops = {
703 .carrier_raised = serial_port_carrier_raised,
704 .dtr_rts = serial_port_dtr_rts,
705 .activate = serial_port_activate,
706 .shutdown = serial_port_shutdown,
709 static int usb_serial_probe(struct usb_interface *interface,
710 const struct usb_device_id *id)
712 struct device *ddev = &interface->dev;
713 struct usb_device *dev = interface_to_usbdev(interface);
714 struct usb_serial *serial = NULL;
715 struct usb_serial_port *port;
716 struct usb_host_interface *iface_desc;
717 struct usb_endpoint_descriptor *endpoint;
718 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
719 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
720 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
721 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
722 struct usb_serial_driver *type = NULL;
727 int num_interrupt_in = 0;
728 int num_interrupt_out = 0;
730 int num_bulk_out = 0;
734 mutex_lock(&table_lock);
735 type = search_serial_device(interface);
737 mutex_unlock(&table_lock);
738 dev_dbg(ddev, "none matched\n");
742 if (!try_module_get(type->driver.owner)) {
743 mutex_unlock(&table_lock);
744 dev_err(ddev, "module get failed, exiting\n");
747 mutex_unlock(&table_lock);
749 serial = create_serial(dev, interface, type);
751 module_put(type->driver.owner);
755 /* if this device type has a probe function, call it */
757 const struct usb_device_id *id;
759 id = get_iface_id(type, interface);
760 retval = type->probe(serial, id);
763 dev_dbg(ddev, "sub driver rejected device\n");
764 usb_serial_put(serial);
765 module_put(type->driver.owner);
770 /* descriptor matches, let's find the endpoints needed */
771 /* check out the endpoints */
772 iface_desc = interface->cur_altsetting;
773 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
774 endpoint = &iface_desc->endpoint[i].desc;
776 if (usb_endpoint_is_bulk_in(endpoint)) {
777 /* we found a bulk in endpoint */
778 dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
779 if (num_bulk_in < MAX_NUM_PORTS) {
780 bulk_in_endpoint[num_bulk_in] = endpoint;
785 if (usb_endpoint_is_bulk_out(endpoint)) {
786 /* we found a bulk out endpoint */
787 dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
788 if (num_bulk_out < MAX_NUM_PORTS) {
789 bulk_out_endpoint[num_bulk_out] = endpoint;
794 if (usb_endpoint_is_int_in(endpoint)) {
795 /* we found a interrupt in endpoint */
796 dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
797 if (num_interrupt_in < MAX_NUM_PORTS) {
798 interrupt_in_endpoint[num_interrupt_in] =
804 if (usb_endpoint_is_int_out(endpoint)) {
805 /* we found an interrupt out endpoint */
806 dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
807 if (num_interrupt_out < MAX_NUM_PORTS) {
808 interrupt_out_endpoint[num_interrupt_out] =
815 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
816 /* BEGIN HORRIBLE HACK FOR PL2303 */
817 /* this is needed due to the looney way its endpoints are set up */
818 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
819 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
820 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
821 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
822 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
823 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
824 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
825 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
826 if (interface != dev->actconfig->interface[0]) {
827 /* check out the endpoints of the other interface*/
828 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
829 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
830 endpoint = &iface_desc->endpoint[i].desc;
831 if (usb_endpoint_is_int_in(endpoint)) {
832 /* we found a interrupt in endpoint */
833 dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
834 if (num_interrupt_in < MAX_NUM_PORTS) {
835 interrupt_in_endpoint[num_interrupt_in] = endpoint;
842 /* Now make sure the PL-2303 is configured correctly.
843 * If not, give up now and hope this hack will work
844 * properly during a later invocation of usb_serial_probe
846 if (num_bulk_in == 0 || num_bulk_out == 0) {
847 dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
848 usb_serial_put(serial);
849 module_put(type->driver.owner);
853 /* END HORRIBLE HACK FOR PL2303 */
856 #ifdef CONFIG_USB_SERIAL_GENERIC
857 if (type == &usb_serial_generic_device) {
858 num_ports = num_bulk_out;
859 if (num_ports == 0) {
860 dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
861 usb_serial_put(serial);
862 module_put(type->driver.owner);
865 dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
866 dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
870 /* if this device type has a calc_num_ports function, call it */
871 if (type->calc_num_ports)
872 num_ports = type->calc_num_ports(serial);
874 num_ports = type->num_ports;
877 if (num_ports > MAX_NUM_PORTS) {
878 dev_warn(ddev, "too many ports requested: %d\n", num_ports);
879 num_ports = MAX_NUM_PORTS;
882 serial->num_ports = num_ports;
883 serial->num_bulk_in = num_bulk_in;
884 serial->num_bulk_out = num_bulk_out;
885 serial->num_interrupt_in = num_interrupt_in;
886 serial->num_interrupt_out = num_interrupt_out;
888 /* found all that we need */
889 dev_info(ddev, "%s converter detected\n", type->description);
891 /* create our ports, we need as many as the max endpoints */
892 /* we don't use num_ports here because some devices have more
893 endpoint pairs than ports */
894 max_endpoints = max(num_bulk_in, num_bulk_out);
895 max_endpoints = max(max_endpoints, num_interrupt_in);
896 max_endpoints = max(max_endpoints, num_interrupt_out);
897 max_endpoints = max(max_endpoints, (int)serial->num_ports);
898 serial->num_port_pointers = max_endpoints;
900 dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
901 for (i = 0; i < max_endpoints; ++i) {
902 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
905 tty_port_init(&port->port);
906 port->port.ops = &serial_port_ops;
907 port->serial = serial;
908 spin_lock_init(&port->lock);
909 /* Keep this for private driver use for the moment but
910 should probably go away */
911 INIT_WORK(&port->work, usb_serial_port_work);
912 serial->port[i] = port;
913 port->dev.parent = &interface->dev;
914 port->dev.driver = NULL;
915 port->dev.bus = &usb_serial_bus_type;
916 port->dev.release = &usb_serial_port_release;
917 port->dev.groups = usb_serial_port_groups;
918 device_initialize(&port->dev);
921 /* set up the endpoint information */
922 for (i = 0; i < num_bulk_in; ++i) {
923 endpoint = bulk_in_endpoint[i];
924 port = serial->port[i];
925 buffer_size = max_t(int, serial->type->bulk_in_size,
926 usb_endpoint_maxp(endpoint));
927 port->bulk_in_size = buffer_size;
928 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
930 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
931 set_bit(j, &port->read_urbs_free);
932 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
933 if (!port->read_urbs[j])
935 port->bulk_in_buffers[j] = kmalloc(buffer_size,
937 if (!port->bulk_in_buffers[j])
939 usb_fill_bulk_urb(port->read_urbs[j], dev,
941 endpoint->bEndpointAddress),
942 port->bulk_in_buffers[j], buffer_size,
943 serial->type->read_bulk_callback,
947 port->read_urb = port->read_urbs[0];
948 port->bulk_in_buffer = port->bulk_in_buffers[0];
951 for (i = 0; i < num_bulk_out; ++i) {
952 endpoint = bulk_out_endpoint[i];
953 port = serial->port[i];
954 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
956 buffer_size = serial->type->bulk_out_size;
958 buffer_size = usb_endpoint_maxp(endpoint);
959 port->bulk_out_size = buffer_size;
960 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
962 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
963 set_bit(j, &port->write_urbs_free);
964 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
965 if (!port->write_urbs[j])
967 port->bulk_out_buffers[j] = kmalloc(buffer_size,
969 if (!port->bulk_out_buffers[j])
971 usb_fill_bulk_urb(port->write_urbs[j], dev,
973 endpoint->bEndpointAddress),
974 port->bulk_out_buffers[j], buffer_size,
975 serial->type->write_bulk_callback,
979 port->write_urb = port->write_urbs[0];
980 port->bulk_out_buffer = port->bulk_out_buffers[0];
983 if (serial->type->read_int_callback) {
984 for (i = 0; i < num_interrupt_in; ++i) {
985 endpoint = interrupt_in_endpoint[i];
986 port = serial->port[i];
987 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
988 if (!port->interrupt_in_urb)
990 buffer_size = usb_endpoint_maxp(endpoint);
991 port->interrupt_in_endpointAddress =
992 endpoint->bEndpointAddress;
993 port->interrupt_in_buffer = kmalloc(buffer_size,
995 if (!port->interrupt_in_buffer)
997 usb_fill_int_urb(port->interrupt_in_urb, dev,
999 endpoint->bEndpointAddress),
1000 port->interrupt_in_buffer, buffer_size,
1001 serial->type->read_int_callback, port,
1002 endpoint->bInterval);
1004 } else if (num_interrupt_in) {
1005 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1008 if (serial->type->write_int_callback) {
1009 for (i = 0; i < num_interrupt_out; ++i) {
1010 endpoint = interrupt_out_endpoint[i];
1011 port = serial->port[i];
1012 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1013 if (!port->interrupt_out_urb)
1015 buffer_size = usb_endpoint_maxp(endpoint);
1016 port->interrupt_out_size = buffer_size;
1017 port->interrupt_out_endpointAddress =
1018 endpoint->bEndpointAddress;
1019 port->interrupt_out_buffer = kmalloc(buffer_size,
1021 if (!port->interrupt_out_buffer)
1023 usb_fill_int_urb(port->interrupt_out_urb, dev,
1025 endpoint->bEndpointAddress),
1026 port->interrupt_out_buffer, buffer_size,
1027 serial->type->write_int_callback, port,
1028 endpoint->bInterval);
1030 } else if (num_interrupt_out) {
1031 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1034 usb_set_intfdata(interface, serial);
1036 /* if this device type has an attach function, call it */
1038 retval = type->attach(serial);
1041 serial->attached = 1;
1043 /* quietly accept this device, but don't bind to a
1044 serial port as it's about to disappear */
1045 serial->num_ports = 0;
1049 serial->attached = 1;
1052 /* Avoid race with tty_open and serial_install by setting the
1053 * disconnected flag and not clearing it until all ports have been
1056 serial->disconnected = 1;
1058 if (allocate_minors(serial, num_ports)) {
1059 dev_err(ddev, "No more free serial minor numbers\n");
1063 /* register all of the individual ports with the driver core */
1064 for (i = 0; i < num_ports; ++i) {
1065 port = serial->port[i];
1066 dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1067 dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1068 device_enable_async_suspend(&port->dev);
1070 retval = device_add(&port->dev);
1072 dev_err(ddev, "Error registering port device, continuing\n");
1075 serial->disconnected = 0;
1078 usb_serial_console_init(serial->port[0]->minor);
1080 module_put(type->driver.owner);
1084 usb_serial_put(serial);
1085 module_put(type->driver.owner);
1089 static void usb_serial_disconnect(struct usb_interface *interface)
1092 struct usb_serial *serial = usb_get_intfdata(interface);
1093 struct device *dev = &interface->dev;
1094 struct usb_serial_port *port;
1095 struct tty_struct *tty;
1097 usb_serial_console_disconnect(serial);
1099 mutex_lock(&serial->disc_mutex);
1100 /* must set a flag, to signal subdrivers */
1101 serial->disconnected = 1;
1102 mutex_unlock(&serial->disc_mutex);
1104 for (i = 0; i < serial->num_ports; ++i) {
1105 port = serial->port[i];
1106 tty = tty_port_tty_get(&port->port);
1111 usb_serial_port_poison_urbs(port);
1112 wake_up_interruptible(&port->port.delta_msr_wait);
1113 cancel_work_sync(&port->work);
1114 if (device_is_registered(&port->dev))
1115 device_del(&port->dev);
1117 if (serial->type->disconnect)
1118 serial->type->disconnect(serial);
1120 /* let the last holder of this object cause it to be cleaned up */
1121 usb_serial_put(serial);
1122 dev_info(dev, "device disconnected\n");
1125 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1127 struct usb_serial *serial = usb_get_intfdata(intf);
1130 serial->suspending = 1;
1133 * serial->type->suspend() MUST return 0 in system sleep context,
1134 * otherwise, the resume callback has to recover device from
1135 * previous suspend failure.
1137 if (serial->type->suspend) {
1138 r = serial->type->suspend(serial, message);
1140 serial->suspending = 0;
1145 for (i = 0; i < serial->num_ports; ++i)
1146 usb_serial_port_poison_urbs(serial->port[i]);
1150 EXPORT_SYMBOL(usb_serial_suspend);
1152 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1156 for (i = 0; i < serial->num_ports; ++i)
1157 usb_serial_port_unpoison_urbs(serial->port[i]);
1160 int usb_serial_resume(struct usb_interface *intf)
1162 struct usb_serial *serial = usb_get_intfdata(intf);
1165 usb_serial_unpoison_port_urbs(serial);
1167 serial->suspending = 0;
1168 if (serial->type->resume)
1169 rv = serial->type->resume(serial);
1171 rv = usb_serial_generic_resume(serial);
1175 EXPORT_SYMBOL(usb_serial_resume);
1177 static int usb_serial_reset_resume(struct usb_interface *intf)
1179 struct usb_serial *serial = usb_get_intfdata(intf);
1182 usb_serial_unpoison_port_urbs(serial);
1184 serial->suspending = 0;
1185 if (serial->type->reset_resume) {
1186 rv = serial->type->reset_resume(serial);
1189 intf->needs_binding = 1;
1195 static const struct tty_operations serial_ops = {
1196 .open = serial_open,
1197 .close = serial_close,
1198 .write = serial_write,
1199 .hangup = serial_hangup,
1200 .write_room = serial_write_room,
1201 .ioctl = serial_ioctl,
1202 .set_termios = serial_set_termios,
1203 .throttle = serial_throttle,
1204 .unthrottle = serial_unthrottle,
1205 .break_ctl = serial_break,
1206 .chars_in_buffer = serial_chars_in_buffer,
1207 .wait_until_sent = serial_wait_until_sent,
1208 .tiocmget = serial_tiocmget,
1209 .tiocmset = serial_tiocmset,
1210 .get_icount = serial_get_icount,
1211 .cleanup = serial_cleanup,
1212 .install = serial_install,
1213 .proc_fops = &serial_proc_fops,
1217 struct tty_driver *usb_serial_tty_driver;
1219 /* Driver structure we register with the USB core */
1220 static struct usb_driver usb_serial_driver = {
1221 .name = "usbserial",
1222 .probe = usb_serial_probe,
1223 .disconnect = usb_serial_disconnect,
1224 .suspend = usb_serial_suspend,
1225 .resume = usb_serial_resume,
1227 .supports_autosuspend = 1,
1230 static int __init usb_serial_init(void)
1234 usb_serial_tty_driver = alloc_tty_driver(USB_SERIAL_TTY_MINORS);
1235 if (!usb_serial_tty_driver)
1238 /* Initialize our global data */
1239 result = bus_register(&usb_serial_bus_type);
1241 pr_err("%s - registering bus driver failed\n", __func__);
1245 usb_serial_tty_driver->driver_name = "usbserial";
1246 usb_serial_tty_driver->name = "ttyUSB";
1247 usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1248 usb_serial_tty_driver->minor_start = 0;
1249 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1250 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1251 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1252 TTY_DRIVER_DYNAMIC_DEV;
1253 usb_serial_tty_driver->init_termios = tty_std_termios;
1254 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1256 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1257 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1258 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1259 result = tty_register_driver(usb_serial_tty_driver);
1261 pr_err("%s - tty_register_driver failed\n", __func__);
1262 goto exit_reg_driver;
1265 /* register the USB driver */
1266 result = usb_register(&usb_serial_driver);
1268 pr_err("%s - usb_register failed\n", __func__);
1272 /* register the generic driver, if we should */
1273 result = usb_serial_generic_register();
1275 pr_err("%s - registering generic driver failed\n", __func__);
1282 usb_deregister(&usb_serial_driver);
1285 tty_unregister_driver(usb_serial_tty_driver);
1288 bus_unregister(&usb_serial_bus_type);
1291 pr_err("%s - returning with error %d\n", __func__, result);
1292 put_tty_driver(usb_serial_tty_driver);
1297 static void __exit usb_serial_exit(void)
1299 usb_serial_console_exit();
1301 usb_serial_generic_deregister();
1303 usb_deregister(&usb_serial_driver);
1304 tty_unregister_driver(usb_serial_tty_driver);
1305 put_tty_driver(usb_serial_tty_driver);
1306 bus_unregister(&usb_serial_bus_type);
1307 idr_destroy(&serial_minors);
1311 module_init(usb_serial_init);
1312 module_exit(usb_serial_exit);
1314 #define set_to_generic_if_null(type, function) \
1316 if (!type->function) { \
1317 type->function = usb_serial_generic_##function; \
1318 pr_debug("%s: using generic " #function "\n", \
1319 type->driver.name); \
1323 static void usb_serial_operations_init(struct usb_serial_driver *device)
1325 set_to_generic_if_null(device, open);
1326 set_to_generic_if_null(device, write);
1327 set_to_generic_if_null(device, close);
1328 set_to_generic_if_null(device, write_room);
1329 set_to_generic_if_null(device, chars_in_buffer);
1330 if (device->tx_empty)
1331 set_to_generic_if_null(device, wait_until_sent);
1332 set_to_generic_if_null(device, read_bulk_callback);
1333 set_to_generic_if_null(device, write_bulk_callback);
1334 set_to_generic_if_null(device, process_read_urb);
1335 set_to_generic_if_null(device, prepare_write_buffer);
1338 static int usb_serial_register(struct usb_serial_driver *driver)
1345 if (!driver->description)
1346 driver->description = driver->driver.name;
1347 if (!driver->usb_driver) {
1348 WARN(1, "Serial driver %s has no usb_driver\n",
1349 driver->description);
1353 /* Prevent individual ports from being unbound. */
1354 driver->driver.suppress_bind_attrs = true;
1356 usb_serial_operations_init(driver);
1358 /* Add this device to our list of devices */
1359 mutex_lock(&table_lock);
1360 list_add(&driver->driver_list, &usb_serial_driver_list);
1362 retval = usb_serial_bus_register(driver);
1364 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1365 list_del(&driver->driver_list);
1367 pr_info("USB Serial support registered for %s\n", driver->description);
1369 mutex_unlock(&table_lock);
1373 static void usb_serial_deregister(struct usb_serial_driver *device)
1375 pr_info("USB Serial deregistering driver %s\n", device->description);
1377 mutex_lock(&table_lock);
1378 list_del(&device->driver_list);
1379 mutex_unlock(&table_lock);
1381 usb_serial_bus_deregister(device);
1385 * usb_serial_register_drivers - register drivers for a usb-serial module
1386 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1387 * @name: name of the usb_driver for this set of @serial_drivers
1388 * @id_table: list of all devices this @serial_drivers set binds to
1390 * Registers all the drivers in the @serial_drivers array, and dynamically
1391 * creates a struct usb_driver with the name @name and id_table of @id_table.
1393 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1395 const struct usb_device_id *id_table)
1398 struct usb_driver *udriver;
1399 struct usb_serial_driver * const *sd;
1402 * udriver must be registered before any of the serial drivers,
1403 * because the store_new_id() routine for the serial drivers (in
1404 * bus.c) probes udriver.
1406 * Performance hack: We don't want udriver to be probed until
1407 * the serial drivers are registered, because the probe would
1408 * simply fail for lack of a matching serial driver.
1409 * So we leave udriver's id_table set to NULL until we are all set.
1411 * Suspend/resume support is implemented in the usb-serial core,
1412 * so fill in the PM-related fields in udriver.
1414 udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1418 udriver->name = name;
1419 udriver->no_dynamic_id = 1;
1420 udriver->supports_autosuspend = 1;
1421 udriver->suspend = usb_serial_suspend;
1422 udriver->resume = usb_serial_resume;
1423 udriver->probe = usb_serial_probe;
1424 udriver->disconnect = usb_serial_disconnect;
1426 /* we only set the reset_resume field if the serial_driver has one */
1427 for (sd = serial_drivers; *sd; ++sd) {
1428 if ((*sd)->reset_resume) {
1429 udriver->reset_resume = usb_serial_reset_resume;
1434 rc = usb_register(udriver);
1436 goto failed_usb_register;
1438 for (sd = serial_drivers; *sd; ++sd) {
1439 (*sd)->usb_driver = udriver;
1440 rc = usb_serial_register(*sd);
1445 /* Now set udriver's id_table and look for matches */
1446 udriver->id_table = id_table;
1447 rc = driver_attach(&udriver->drvwrap.driver);
1451 while (sd-- > serial_drivers)
1452 usb_serial_deregister(*sd);
1453 usb_deregister(udriver);
1454 failed_usb_register:
1458 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1461 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1462 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1464 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1465 * frees the struct usb_driver that was created by the call to
1466 * usb_serial_register_drivers().
1468 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1470 struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1472 for (; *serial_drivers; ++serial_drivers)
1473 usb_serial_deregister(*serial_drivers);
1474 usb_deregister(udriver);
1477 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1479 MODULE_AUTHOR(DRIVER_AUTHOR);
1480 MODULE_DESCRIPTION(DRIVER_DESC);
1481 MODULE_LICENSE("GPL");