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>
42 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
43 #define DRIVER_DESC "USB Serial Driver core"
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 struct usb_serial *serial_table[SERIAL_TTY_MINORS];
53 static DEFINE_MUTEX(table_lock);
54 static LIST_HEAD(usb_serial_driver_list);
57 * Look up the serial structure. If it is found and it hasn't been
58 * disconnected, return with its disc_mutex held and its refcount
59 * incremented. Otherwise return NULL.
61 struct usb_serial *usb_serial_get_by_index(unsigned index)
63 struct usb_serial *serial;
65 mutex_lock(&table_lock);
66 serial = serial_table[index];
69 mutex_lock(&serial->disc_mutex);
70 if (serial->disconnected) {
71 mutex_unlock(&serial->disc_mutex);
74 kref_get(&serial->kref);
77 mutex_unlock(&table_lock);
81 static struct usb_serial *get_free_serial(struct usb_serial *serial,
82 int num_ports, unsigned int *minor)
87 dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
90 mutex_lock(&table_lock);
91 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
96 for (j = 1; j <= num_ports-1; ++j)
97 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
107 dev_dbg(&serial->interface->dev, "%s - minor base = %d\n", __func__, *minor);
108 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
109 serial_table[i] = serial;
110 serial->port[j++]->number = i;
112 mutex_unlock(&table_lock);
115 mutex_unlock(&table_lock);
119 static void return_serial(struct usb_serial *serial)
123 mutex_lock(&table_lock);
124 for (i = 0; i < serial->num_ports; ++i)
125 serial_table[serial->minor + i] = NULL;
126 mutex_unlock(&table_lock);
129 static void destroy_serial(struct kref *kref)
131 struct usb_serial *serial;
132 struct usb_serial_port *port;
135 serial = to_usb_serial(kref);
137 /* return the minor range that this device had */
138 if (serial->minor != SERIAL_TTY_NO_MINOR)
139 return_serial(serial);
141 if (serial->attached && serial->type->release)
142 serial->type->release(serial);
144 /* Now that nothing is using the ports, they can be freed */
145 for (i = 0; i < serial->num_port_pointers; ++i) {
146 port = serial->port[i];
149 put_device(&port->dev);
153 usb_put_intf(serial->interface);
154 usb_put_dev(serial->dev);
158 void usb_serial_put(struct usb_serial *serial)
160 kref_put(&serial->kref, destroy_serial);
163 /*****************************************************************************
164 * Driver tty interface functions
165 *****************************************************************************/
168 * serial_install - install tty
169 * @driver: the driver (USB in our case)
170 * @tty: the tty being created
172 * Create the termios objects for this tty. We use the default
173 * USB serial settings but permit them to be overridden by
174 * serial->type->init_termios.
176 * This is the first place a new tty gets used. Hence this is where we
177 * acquire references to the usb_serial structure and the driver module,
178 * where we store a pointer to the port, and where we do an autoresume.
179 * All these actions are reversed in serial_cleanup().
181 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
183 int idx = tty->index;
184 struct usb_serial *serial;
185 struct usb_serial_port *port;
186 int retval = -ENODEV;
188 serial = usb_serial_get_by_index(idx);
192 port = serial->port[idx - serial->minor];
195 if (!try_module_get(serial->type->driver.owner))
196 goto error_module_get;
198 retval = usb_autopm_get_interface(serial->interface);
200 goto error_get_interface;
202 retval = tty_port_install(&port->port, driver, tty);
204 goto error_init_termios;
206 mutex_unlock(&serial->disc_mutex);
208 /* allow the driver to update the settings */
209 if (serial->type->init_termios)
210 serial->type->init_termios(tty);
212 tty->driver_data = port;
217 usb_autopm_put_interface(serial->interface);
219 module_put(serial->type->driver.owner);
222 usb_serial_put(serial);
223 mutex_unlock(&serial->disc_mutex);
227 static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
229 struct usb_serial_port *port =
230 container_of(tport, struct usb_serial_port, port);
231 struct usb_serial *serial = port->serial;
234 mutex_lock(&serial->disc_mutex);
235 if (serial->disconnected)
238 retval = port->serial->type->open(tty, port);
239 mutex_unlock(&serial->disc_mutex);
242 retval = usb_translate_errors(retval);
247 static int serial_open(struct tty_struct *tty, struct file *filp)
249 struct usb_serial_port *port = tty->driver_data;
251 dev_dbg(tty->dev, "%s\n", __func__);
253 return tty_port_open(&port->port, tty, filp);
257 * serial_port_shutdown - shut down hardware
258 * @tport: tty port to shut down
260 * Shut down a USB serial port. Serialized against activate by the
261 * tport mutex and kept to matching open/close pairs
262 * of calls by the ASYNCB_INITIALIZED flag.
264 * Not called if tty is console.
266 static void serial_port_shutdown(struct tty_port *tport)
268 struct usb_serial_port *port =
269 container_of(tport, struct usb_serial_port, port);
270 struct usb_serial_driver *drv = port->serial->type;
276 static void serial_hangup(struct tty_struct *tty)
278 struct usb_serial_port *port = tty->driver_data;
280 dev_dbg(tty->dev, "%s\n", __func__);
282 tty_port_hangup(&port->port);
285 static void serial_close(struct tty_struct *tty, struct file *filp)
287 struct usb_serial_port *port = tty->driver_data;
289 dev_dbg(tty->dev, "%s\n", __func__);
291 tty_port_close(&port->port, tty, filp);
295 * serial_cleanup - free resources post close/hangup
296 * @port: port to free up
298 * Do the resource freeing and refcount dropping for the port.
299 * Avoid freeing the console.
301 * Called asynchronously after the last tty kref is dropped.
303 static void serial_cleanup(struct tty_struct *tty)
305 struct usb_serial_port *port = tty->driver_data;
306 struct usb_serial *serial;
307 struct module *owner;
309 dev_dbg(tty->dev, "%s\n", __func__);
311 /* The console is magical. Do not hang up the console hardware
312 * or there will be tears.
314 if (port->port.console)
317 tty->driver_data = NULL;
319 serial = port->serial;
320 owner = serial->type->driver.owner;
322 mutex_lock(&serial->disc_mutex);
323 if (!serial->disconnected)
324 usb_autopm_put_interface(serial->interface);
325 mutex_unlock(&serial->disc_mutex);
327 usb_serial_put(serial);
331 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
334 struct usb_serial_port *port = tty->driver_data;
335 int retval = -ENODEV;
337 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
340 dev_dbg(tty->dev, "%s - %d byte(s)\n", __func__, count);
342 retval = port->serial->type->write(tty, port, buf, count);
344 retval = usb_translate_errors(retval);
349 static int serial_write_room(struct tty_struct *tty)
351 struct usb_serial_port *port = tty->driver_data;
353 dev_dbg(tty->dev, "%s\n", __func__);
355 return port->serial->type->write_room(tty);
358 static int serial_chars_in_buffer(struct tty_struct *tty)
360 struct usb_serial_port *port = tty->driver_data;
361 struct usb_serial *serial = port->serial;
364 dev_dbg(tty->dev, "%s\n", __func__);
366 mutex_lock(&serial->disc_mutex);
367 /* if the device was unplugged then any remaining characters
368 fell out of the connector ;) */
369 if (serial->disconnected)
372 count = serial->type->chars_in_buffer(tty);
373 mutex_unlock(&serial->disc_mutex);
378 static void serial_throttle(struct tty_struct *tty)
380 struct usb_serial_port *port = tty->driver_data;
382 dev_dbg(tty->dev, "%s\n", __func__);
384 if (port->serial->type->throttle)
385 port->serial->type->throttle(tty);
388 static void serial_unthrottle(struct tty_struct *tty)
390 struct usb_serial_port *port = tty->driver_data;
392 dev_dbg(tty->dev, "%s\n", __func__);
394 if (port->serial->type->unthrottle)
395 port->serial->type->unthrottle(tty);
398 static int serial_ioctl(struct tty_struct *tty,
399 unsigned int cmd, unsigned long arg)
401 struct usb_serial_port *port = tty->driver_data;
402 int retval = -ENODEV;
404 dev_dbg(tty->dev, "%s - cmd 0x%.4x\n", __func__, cmd);
408 if (port->serial->type->tiocmiwait)
409 retval = port->serial->type->tiocmiwait(tty, arg);
412 if (port->serial->type->ioctl)
413 retval = port->serial->type->ioctl(tty, cmd, arg);
415 retval = -ENOIOCTLCMD;
421 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
423 struct usb_serial_port *port = tty->driver_data;
425 dev_dbg(tty->dev, "%s\n", __func__);
427 if (port->serial->type->set_termios)
428 port->serial->type->set_termios(tty, port, old);
430 tty_termios_copy_hw(&tty->termios, old);
433 static int serial_break(struct tty_struct *tty, int break_state)
435 struct usb_serial_port *port = tty->driver_data;
437 dev_dbg(tty->dev, "%s\n", __func__);
439 if (port->serial->type->break_ctl)
440 port->serial->type->break_ctl(tty, break_state);
445 static int serial_proc_show(struct seq_file *m, void *v)
447 struct usb_serial *serial;
451 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
452 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
453 serial = usb_serial_get_by_index(i);
457 seq_printf(m, "%d:", i);
458 if (serial->type->driver.owner)
459 seq_printf(m, " module:%s",
460 module_name(serial->type->driver.owner));
461 seq_printf(m, " name:\"%s\"",
462 serial->type->description);
463 seq_printf(m, " vendor:%04x product:%04x",
464 le16_to_cpu(serial->dev->descriptor.idVendor),
465 le16_to_cpu(serial->dev->descriptor.idProduct));
466 seq_printf(m, " num_ports:%d", serial->num_ports);
467 seq_printf(m, " port:%d", i - serial->minor + 1);
468 usb_make_path(serial->dev, tmp, sizeof(tmp));
469 seq_printf(m, " path:%s", tmp);
472 usb_serial_put(serial);
473 mutex_unlock(&serial->disc_mutex);
478 static int serial_proc_open(struct inode *inode, struct file *file)
480 return single_open(file, serial_proc_show, NULL);
483 static const struct file_operations serial_proc_fops = {
484 .owner = THIS_MODULE,
485 .open = serial_proc_open,
488 .release = single_release,
491 static int serial_tiocmget(struct tty_struct *tty)
493 struct usb_serial_port *port = tty->driver_data;
495 dev_dbg(tty->dev, "%s\n", __func__);
497 if (port->serial->type->tiocmget)
498 return port->serial->type->tiocmget(tty);
502 static int serial_tiocmset(struct tty_struct *tty,
503 unsigned int set, unsigned int clear)
505 struct usb_serial_port *port = tty->driver_data;
507 dev_dbg(tty->dev, "%s\n", __func__);
509 if (port->serial->type->tiocmset)
510 return port->serial->type->tiocmset(tty, set, clear);
514 static int serial_get_icount(struct tty_struct *tty,
515 struct serial_icounter_struct *icount)
517 struct usb_serial_port *port = tty->driver_data;
519 dev_dbg(tty->dev, "%s\n", __func__);
521 if (port->serial->type->get_icount)
522 return port->serial->type->get_icount(tty, icount);
527 * We would be calling tty_wakeup here, but unfortunately some line
528 * disciplines have an annoying habit of calling tty->write from
529 * the write wakeup callback (e.g. n_hdlc.c).
531 void usb_serial_port_softint(struct usb_serial_port *port)
533 schedule_work(&port->work);
535 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
537 static void usb_serial_port_work(struct work_struct *work)
539 struct usb_serial_port *port =
540 container_of(work, struct usb_serial_port, work);
541 struct tty_struct *tty;
543 tty = tty_port_tty_get(&port->port);
547 dev_dbg(tty->dev, "%s\n", __func__);
553 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
557 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
558 usb_poison_urb(port->read_urbs[i]);
559 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
560 usb_poison_urb(port->write_urbs[i]);
562 usb_poison_urb(port->interrupt_in_urb);
563 usb_poison_urb(port->interrupt_out_urb);
566 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
570 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
571 usb_unpoison_urb(port->read_urbs[i]);
572 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
573 usb_unpoison_urb(port->write_urbs[i]);
575 usb_unpoison_urb(port->interrupt_in_urb);
576 usb_unpoison_urb(port->interrupt_out_urb);
579 static void usb_serial_port_release(struct device *dev)
581 struct usb_serial_port *port = to_usb_serial_port(dev);
584 dev_dbg(dev, "%s\n", __func__);
586 usb_free_urb(port->interrupt_in_urb);
587 usb_free_urb(port->interrupt_out_urb);
588 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
589 usb_free_urb(port->read_urbs[i]);
590 kfree(port->bulk_in_buffers[i]);
592 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
593 usb_free_urb(port->write_urbs[i]);
594 kfree(port->bulk_out_buffers[i]);
596 kfifo_free(&port->write_fifo);
597 kfree(port->interrupt_in_buffer);
598 kfree(port->interrupt_out_buffer);
599 tty_port_destroy(&port->port);
603 static struct usb_serial *create_serial(struct usb_device *dev,
604 struct usb_interface *interface,
605 struct usb_serial_driver *driver)
607 struct usb_serial *serial;
609 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
612 serial->dev = usb_get_dev(dev);
613 serial->type = driver;
614 serial->interface = usb_get_intf(interface);
615 kref_init(&serial->kref);
616 mutex_init(&serial->disc_mutex);
617 serial->minor = SERIAL_TTY_NO_MINOR;
622 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
623 struct usb_serial_driver *drv)
625 struct usb_dynid *dynid;
627 spin_lock(&drv->dynids.lock);
628 list_for_each_entry(dynid, &drv->dynids.list, node) {
629 if (usb_match_one_id(intf, &dynid->id)) {
630 spin_unlock(&drv->dynids.lock);
634 spin_unlock(&drv->dynids.lock);
638 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
639 struct usb_interface *intf)
641 const struct usb_device_id *id;
643 id = usb_match_id(intf, drv->id_table);
645 dev_dbg(&intf->dev, "static descriptor matches\n");
648 id = match_dynamic_id(intf, drv);
650 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
655 /* Caller must hold table_lock */
656 static struct usb_serial_driver *search_serial_device(
657 struct usb_interface *iface)
659 const struct usb_device_id *id = NULL;
660 struct usb_serial_driver *drv;
661 struct usb_driver *driver = to_usb_driver(iface->dev.driver);
663 /* Check if the usb id matches a known device */
664 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
665 if (drv->usb_driver == driver)
666 id = get_iface_id(drv, iface);
674 static int serial_port_carrier_raised(struct tty_port *port)
676 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
677 struct usb_serial_driver *drv = p->serial->type;
679 if (drv->carrier_raised)
680 return drv->carrier_raised(p);
681 /* No carrier control - don't block */
685 static void serial_port_dtr_rts(struct tty_port *port, int on)
687 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
688 struct usb_serial *serial = p->serial;
689 struct usb_serial_driver *drv = serial->type;
694 * Work-around bug in the tty-layer which can result in dtr_rts
695 * being called after a disconnect (and tty_unregister_device
696 * has returned). Remove once bug has been squashed.
698 mutex_lock(&serial->disc_mutex);
699 if (!serial->disconnected)
701 mutex_unlock(&serial->disc_mutex);
704 static const struct tty_port_operations serial_port_ops = {
705 .carrier_raised = serial_port_carrier_raised,
706 .dtr_rts = serial_port_dtr_rts,
707 .activate = serial_port_activate,
708 .shutdown = serial_port_shutdown,
711 static int usb_serial_probe(struct usb_interface *interface,
712 const struct usb_device_id *id)
714 struct device *ddev = &interface->dev;
715 struct usb_device *dev = interface_to_usbdev(interface);
716 struct usb_serial *serial = NULL;
717 struct usb_serial_port *port;
718 struct usb_host_interface *iface_desc;
719 struct usb_endpoint_descriptor *endpoint;
720 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
721 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
722 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
723 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
724 struct usb_serial_driver *type = NULL;
730 int num_interrupt_in = 0;
731 int num_interrupt_out = 0;
733 int num_bulk_out = 0;
737 mutex_lock(&table_lock);
738 type = search_serial_device(interface);
740 mutex_unlock(&table_lock);
741 dev_dbg(ddev, "none matched\n");
745 if (!try_module_get(type->driver.owner)) {
746 mutex_unlock(&table_lock);
747 dev_err(ddev, "module get failed, exiting\n");
750 mutex_unlock(&table_lock);
752 serial = create_serial(dev, interface, type);
754 module_put(type->driver.owner);
758 /* if this device type has a probe function, call it */
760 const struct usb_device_id *id;
762 id = get_iface_id(type, interface);
763 retval = type->probe(serial, id);
766 dev_dbg(ddev, "sub driver rejected device\n");
767 usb_serial_put(serial);
768 module_put(type->driver.owner);
773 /* descriptor matches, let's find the endpoints needed */
774 /* check out the endpoints */
775 iface_desc = interface->cur_altsetting;
776 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
777 endpoint = &iface_desc->endpoint[i].desc;
779 if (usb_endpoint_is_bulk_in(endpoint)) {
780 /* we found a bulk in endpoint */
781 dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
782 bulk_in_endpoint[num_bulk_in] = endpoint;
786 if (usb_endpoint_is_bulk_out(endpoint)) {
787 /* we found a bulk out endpoint */
788 dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
789 bulk_out_endpoint[num_bulk_out] = endpoint;
793 if (usb_endpoint_is_int_in(endpoint)) {
794 /* we found a interrupt in endpoint */
795 dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
796 interrupt_in_endpoint[num_interrupt_in] = endpoint;
800 if (usb_endpoint_is_int_out(endpoint)) {
801 /* we found an interrupt out endpoint */
802 dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
803 interrupt_out_endpoint[num_interrupt_out] = endpoint;
808 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
809 /* BEGIN HORRIBLE HACK FOR PL2303 */
810 /* this is needed due to the looney way its endpoints are set up */
811 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
812 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
813 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
814 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
815 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
816 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
817 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
818 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
819 if (interface != dev->actconfig->interface[0]) {
820 /* check out the endpoints of the other interface*/
821 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
822 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
823 endpoint = &iface_desc->endpoint[i].desc;
824 if (usb_endpoint_is_int_in(endpoint)) {
825 /* we found a interrupt in endpoint */
826 dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
827 interrupt_in_endpoint[num_interrupt_in] = endpoint;
833 /* Now make sure the PL-2303 is configured correctly.
834 * If not, give up now and hope this hack will work
835 * properly during a later invocation of usb_serial_probe
837 if (num_bulk_in == 0 || num_bulk_out == 0) {
838 dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
839 usb_serial_put(serial);
840 module_put(type->driver.owner);
844 /* END HORRIBLE HACK FOR PL2303 */
847 #ifdef CONFIG_USB_SERIAL_GENERIC
848 if (type == &usb_serial_generic_device) {
849 num_ports = num_bulk_out;
850 if (num_ports == 0) {
851 dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
852 usb_serial_put(serial);
853 module_put(type->driver.owner);
856 dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
857 dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
861 /* if this device type has a calc_num_ports function, call it */
862 if (type->calc_num_ports)
863 num_ports = type->calc_num_ports(serial);
865 num_ports = type->num_ports;
868 serial->num_ports = num_ports;
869 serial->num_bulk_in = num_bulk_in;
870 serial->num_bulk_out = num_bulk_out;
871 serial->num_interrupt_in = num_interrupt_in;
872 serial->num_interrupt_out = num_interrupt_out;
874 /* found all that we need */
875 dev_info(ddev, "%s converter detected\n", type->description);
877 /* create our ports, we need as many as the max endpoints */
878 /* we don't use num_ports here because some devices have more
879 endpoint pairs than ports */
880 max_endpoints = max(num_bulk_in, num_bulk_out);
881 max_endpoints = max(max_endpoints, num_interrupt_in);
882 max_endpoints = max(max_endpoints, num_interrupt_out);
883 max_endpoints = max(max_endpoints, (int)serial->num_ports);
884 serial->num_port_pointers = max_endpoints;
886 dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
887 for (i = 0; i < max_endpoints; ++i) {
888 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
891 tty_port_init(&port->port);
892 port->port.ops = &serial_port_ops;
893 port->serial = serial;
894 spin_lock_init(&port->lock);
895 /* Keep this for private driver use for the moment but
896 should probably go away */
897 INIT_WORK(&port->work, usb_serial_port_work);
898 serial->port[i] = port;
899 port->dev.parent = &interface->dev;
900 port->dev.driver = NULL;
901 port->dev.bus = &usb_serial_bus_type;
902 port->dev.release = &usb_serial_port_release;
903 device_initialize(&port->dev);
906 /* set up the endpoint information */
907 for (i = 0; i < num_bulk_in; ++i) {
908 endpoint = bulk_in_endpoint[i];
909 port = serial->port[i];
910 buffer_size = max_t(int, serial->type->bulk_in_size,
911 usb_endpoint_maxp(endpoint));
912 port->bulk_in_size = buffer_size;
913 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
915 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
916 set_bit(j, &port->read_urbs_free);
917 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
918 if (!port->read_urbs[j])
920 port->bulk_in_buffers[j] = kmalloc(buffer_size,
922 if (!port->bulk_in_buffers[j])
924 usb_fill_bulk_urb(port->read_urbs[j], dev,
926 endpoint->bEndpointAddress),
927 port->bulk_in_buffers[j], buffer_size,
928 serial->type->read_bulk_callback,
932 port->read_urb = port->read_urbs[0];
933 port->bulk_in_buffer = port->bulk_in_buffers[0];
936 for (i = 0; i < num_bulk_out; ++i) {
937 endpoint = bulk_out_endpoint[i];
938 port = serial->port[i];
939 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
941 buffer_size = serial->type->bulk_out_size;
943 buffer_size = usb_endpoint_maxp(endpoint);
944 port->bulk_out_size = buffer_size;
945 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
947 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
948 set_bit(j, &port->write_urbs_free);
949 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
950 if (!port->write_urbs[j])
952 port->bulk_out_buffers[j] = kmalloc(buffer_size,
954 if (!port->bulk_out_buffers[j])
956 usb_fill_bulk_urb(port->write_urbs[j], dev,
958 endpoint->bEndpointAddress),
959 port->bulk_out_buffers[j], buffer_size,
960 serial->type->write_bulk_callback,
964 port->write_urb = port->write_urbs[0];
965 port->bulk_out_buffer = port->bulk_out_buffers[0];
968 if (serial->type->read_int_callback) {
969 for (i = 0; i < num_interrupt_in; ++i) {
970 endpoint = interrupt_in_endpoint[i];
971 port = serial->port[i];
972 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
973 if (!port->interrupt_in_urb)
975 buffer_size = usb_endpoint_maxp(endpoint);
976 port->interrupt_in_endpointAddress =
977 endpoint->bEndpointAddress;
978 port->interrupt_in_buffer = kmalloc(buffer_size,
980 if (!port->interrupt_in_buffer)
982 usb_fill_int_urb(port->interrupt_in_urb, dev,
984 endpoint->bEndpointAddress),
985 port->interrupt_in_buffer, buffer_size,
986 serial->type->read_int_callback, port,
987 endpoint->bInterval);
989 } else if (num_interrupt_in) {
990 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
993 if (serial->type->write_int_callback) {
994 for (i = 0; i < num_interrupt_out; ++i) {
995 endpoint = interrupt_out_endpoint[i];
996 port = serial->port[i];
997 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
998 if (!port->interrupt_out_urb)
1000 buffer_size = usb_endpoint_maxp(endpoint);
1001 port->interrupt_out_size = buffer_size;
1002 port->interrupt_out_endpointAddress =
1003 endpoint->bEndpointAddress;
1004 port->interrupt_out_buffer = kmalloc(buffer_size,
1006 if (!port->interrupt_out_buffer)
1008 usb_fill_int_urb(port->interrupt_out_urb, dev,
1010 endpoint->bEndpointAddress),
1011 port->interrupt_out_buffer, buffer_size,
1012 serial->type->write_int_callback, port,
1013 endpoint->bInterval);
1015 } else if (num_interrupt_out) {
1016 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1019 usb_set_intfdata(interface, serial);
1021 /* if this device type has an attach function, call it */
1023 retval = type->attach(serial);
1026 serial->attached = 1;
1028 /* quietly accept this device, but don't bind to a
1029 serial port as it's about to disappear */
1030 serial->num_ports = 0;
1034 serial->attached = 1;
1037 /* Avoid race with tty_open and serial_install by setting the
1038 * disconnected flag and not clearing it until all ports have been
1041 serial->disconnected = 1;
1043 if (get_free_serial(serial, num_ports, &minor) == NULL) {
1044 dev_err(ddev, "No more free serial devices\n");
1047 serial->minor = minor;
1049 /* register all of the individual ports with the driver core */
1050 for (i = 0; i < num_ports; ++i) {
1051 port = serial->port[i];
1052 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1053 dev_dbg(ddev, "registering %s", dev_name(&port->dev));
1054 device_enable_async_suspend(&port->dev);
1056 retval = device_add(&port->dev);
1058 dev_err(ddev, "Error registering port device, continuing\n");
1061 serial->disconnected = 0;
1063 usb_serial_console_init(minor);
1065 module_put(type->driver.owner);
1069 usb_serial_put(serial);
1070 module_put(type->driver.owner);
1074 static void usb_serial_disconnect(struct usb_interface *interface)
1077 struct usb_serial *serial = usb_get_intfdata(interface);
1078 struct device *dev = &interface->dev;
1079 struct usb_serial_port *port;
1081 usb_serial_console_disconnect(serial);
1083 mutex_lock(&serial->disc_mutex);
1084 /* must set a flag, to signal subdrivers */
1085 serial->disconnected = 1;
1086 mutex_unlock(&serial->disc_mutex);
1088 for (i = 0; i < serial->num_ports; ++i) {
1089 port = serial->port[i];
1091 struct tty_struct *tty = tty_port_tty_get(&port->port);
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);
1103 if (serial->type->disconnect)
1104 serial->type->disconnect(serial);
1106 /* let the last holder of this object cause it to be cleaned up */
1107 usb_serial_put(serial);
1108 dev_info(dev, "device disconnected\n");
1111 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1113 struct usb_serial *serial = usb_get_intfdata(intf);
1114 struct usb_serial_port *port;
1117 serial->suspending = 1;
1120 * serial->type->suspend() MUST return 0 in system sleep context,
1121 * otherwise, the resume callback has to recover device from
1122 * previous suspend failure.
1124 if (serial->type->suspend) {
1125 r = serial->type->suspend(serial, message);
1127 serial->suspending = 0;
1132 for (i = 0; i < serial->num_ports; ++i) {
1133 port = serial->port[i];
1135 usb_serial_port_poison_urbs(port);
1141 EXPORT_SYMBOL(usb_serial_suspend);
1143 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1145 struct usb_serial_port *port;
1148 for (i = 0; i < serial->num_ports; ++i) {
1149 port = serial->port[i];
1151 usb_serial_port_unpoison_urbs(port);
1155 int usb_serial_resume(struct usb_interface *intf)
1157 struct usb_serial *serial = usb_get_intfdata(intf);
1160 usb_serial_unpoison_port_urbs(serial);
1162 serial->suspending = 0;
1163 if (serial->type->resume)
1164 rv = serial->type->resume(serial);
1166 rv = usb_serial_generic_resume(serial);
1170 EXPORT_SYMBOL(usb_serial_resume);
1172 static int usb_serial_reset_resume(struct usb_interface *intf)
1174 struct usb_serial *serial = usb_get_intfdata(intf);
1177 usb_serial_unpoison_port_urbs(serial);
1179 serial->suspending = 0;
1180 if (serial->type->reset_resume)
1181 rv = serial->type->reset_resume(serial);
1184 intf->needs_binding = 1;
1190 static const struct tty_operations serial_ops = {
1191 .open = serial_open,
1192 .close = serial_close,
1193 .write = serial_write,
1194 .hangup = serial_hangup,
1195 .write_room = serial_write_room,
1196 .ioctl = serial_ioctl,
1197 .set_termios = serial_set_termios,
1198 .throttle = serial_throttle,
1199 .unthrottle = serial_unthrottle,
1200 .break_ctl = serial_break,
1201 .chars_in_buffer = serial_chars_in_buffer,
1202 .tiocmget = serial_tiocmget,
1203 .tiocmset = serial_tiocmset,
1204 .get_icount = serial_get_icount,
1205 .cleanup = serial_cleanup,
1206 .install = serial_install,
1207 .proc_fops = &serial_proc_fops,
1211 struct tty_driver *usb_serial_tty_driver;
1213 /* Driver structure we register with the USB core */
1214 static struct usb_driver usb_serial_driver = {
1215 .name = "usbserial",
1216 .probe = usb_serial_probe,
1217 .disconnect = usb_serial_disconnect,
1218 .suspend = usb_serial_suspend,
1219 .resume = usb_serial_resume,
1221 .supports_autosuspend = 1,
1224 static int __init usb_serial_init(void)
1229 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1230 if (!usb_serial_tty_driver)
1233 /* Initialize our global data */
1234 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1235 serial_table[i] = NULL;
1237 result = bus_register(&usb_serial_bus_type);
1239 pr_err("%s - registering bus driver failed\n", __func__);
1243 usb_serial_tty_driver->driver_name = "usbserial";
1244 usb_serial_tty_driver->name = "ttyUSB";
1245 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1246 usb_serial_tty_driver->minor_start = 0;
1247 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1248 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1249 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1250 TTY_DRIVER_DYNAMIC_DEV;
1251 usb_serial_tty_driver->init_termios = tty_std_termios;
1252 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1254 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1255 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1256 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1257 result = tty_register_driver(usb_serial_tty_driver);
1259 pr_err("%s - tty_register_driver failed\n", __func__);
1260 goto exit_reg_driver;
1263 /* register the USB driver */
1264 result = usb_register(&usb_serial_driver);
1266 pr_err("%s - usb_register failed\n", __func__);
1270 /* register the generic driver, if we should */
1271 result = usb_serial_generic_register();
1273 pr_err("%s - registering generic driver failed\n", __func__);
1280 usb_deregister(&usb_serial_driver);
1283 tty_unregister_driver(usb_serial_tty_driver);
1286 bus_unregister(&usb_serial_bus_type);
1289 pr_err("%s - returning with error %d\n", __func__, result);
1290 put_tty_driver(usb_serial_tty_driver);
1295 static void __exit usb_serial_exit(void)
1297 usb_serial_console_exit();
1299 usb_serial_generic_deregister();
1301 usb_deregister(&usb_serial_driver);
1302 tty_unregister_driver(usb_serial_tty_driver);
1303 put_tty_driver(usb_serial_tty_driver);
1304 bus_unregister(&usb_serial_bus_type);
1308 module_init(usb_serial_init);
1309 module_exit(usb_serial_exit);
1311 #define set_to_generic_if_null(type, function) \
1313 if (!type->function) { \
1314 type->function = usb_serial_generic_##function; \
1315 pr_debug("%s: using generic " #function "\n", \
1316 type->driver.name); \
1320 static void usb_serial_operations_init(struct usb_serial_driver *device)
1322 set_to_generic_if_null(device, open);
1323 set_to_generic_if_null(device, write);
1324 set_to_generic_if_null(device, close);
1325 set_to_generic_if_null(device, write_room);
1326 set_to_generic_if_null(device, chars_in_buffer);
1327 set_to_generic_if_null(device, read_bulk_callback);
1328 set_to_generic_if_null(device, write_bulk_callback);
1329 set_to_generic_if_null(device, process_read_urb);
1330 set_to_generic_if_null(device, prepare_write_buffer);
1333 static int usb_serial_register(struct usb_serial_driver *driver)
1340 if (!driver->description)
1341 driver->description = driver->driver.name;
1342 if (!driver->usb_driver) {
1343 WARN(1, "Serial driver %s has no usb_driver\n",
1344 driver->description);
1348 usb_serial_operations_init(driver);
1350 /* Add this device to our list of devices */
1351 mutex_lock(&table_lock);
1352 list_add(&driver->driver_list, &usb_serial_driver_list);
1354 retval = usb_serial_bus_register(driver);
1356 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1357 list_del(&driver->driver_list);
1359 pr_info("USB Serial support registered for %s\n", driver->description);
1361 mutex_unlock(&table_lock);
1365 static void usb_serial_deregister(struct usb_serial_driver *device)
1367 pr_info("USB Serial deregistering driver %s\n", device->description);
1368 mutex_lock(&table_lock);
1369 list_del(&device->driver_list);
1370 usb_serial_bus_deregister(device);
1371 mutex_unlock(&table_lock);
1375 * usb_serial_register_drivers - register drivers for a usb-serial module
1376 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1377 * @name: name of the usb_driver for this set of @serial_drivers
1378 * @id_table: list of all devices this @serial_drivers set binds to
1380 * Registers all the drivers in the @serial_drivers array, and dynamically
1381 * creates a struct usb_driver with the name @name and id_table of @id_table.
1383 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1385 const struct usb_device_id *id_table)
1388 struct usb_driver *udriver;
1389 struct usb_serial_driver * const *sd;
1392 * udriver must be registered before any of the serial drivers,
1393 * because the store_new_id() routine for the serial drivers (in
1394 * bus.c) probes udriver.
1396 * Performance hack: We don't want udriver to be probed until
1397 * the serial drivers are registered, because the probe would
1398 * simply fail for lack of a matching serial driver.
1399 * So we leave udriver's id_table set to NULL until we are all set.
1401 * Suspend/resume support is implemented in the usb-serial core,
1402 * so fill in the PM-related fields in udriver.
1404 udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1408 udriver->name = name;
1409 udriver->no_dynamic_id = 1;
1410 udriver->supports_autosuspend = 1;
1411 udriver->suspend = usb_serial_suspend;
1412 udriver->resume = usb_serial_resume;
1413 udriver->probe = usb_serial_probe;
1414 udriver->disconnect = usb_serial_disconnect;
1416 /* we only set the reset_resume field if the serial_driver has one */
1417 for (sd = serial_drivers; *sd; ++sd) {
1418 if ((*sd)->reset_resume) {
1419 udriver->reset_resume = usb_serial_reset_resume;
1424 rc = usb_register(udriver);
1428 for (sd = serial_drivers; *sd; ++sd) {
1429 (*sd)->usb_driver = udriver;
1430 rc = usb_serial_register(*sd);
1435 /* Now set udriver's id_table and look for matches */
1436 udriver->id_table = id_table;
1437 rc = driver_attach(&udriver->drvwrap.driver);
1441 while (sd-- > serial_drivers)
1442 usb_serial_deregister(*sd);
1443 usb_deregister(udriver);
1446 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1449 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1450 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1452 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1453 * frees the struct usb_driver that was created by the call to
1454 * usb_serial_register_drivers().
1456 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1458 struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1460 for (; *serial_drivers; ++serial_drivers)
1461 usb_serial_deregister(*serial_drivers);
1462 usb_deregister(udriver);
1465 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1467 MODULE_AUTHOR(DRIVER_AUTHOR);
1468 MODULE_DESCRIPTION(DRIVER_DESC);
1469 MODULE_LICENSE("GPL");