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;
363 dev_dbg(tty->dev, "%s\n", __func__);
365 if (serial->disconnected)
368 return serial->type->chars_in_buffer(tty);
371 static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
373 struct usb_serial_port *port = tty->driver_data;
374 struct usb_serial *serial = port->serial;
376 dev_dbg(tty->dev, "%s\n", __func__);
378 if (!port->serial->type->wait_until_sent)
381 mutex_lock(&serial->disc_mutex);
382 if (!serial->disconnected)
383 port->serial->type->wait_until_sent(tty, timeout);
384 mutex_unlock(&serial->disc_mutex);
387 static void serial_throttle(struct tty_struct *tty)
389 struct usb_serial_port *port = tty->driver_data;
391 dev_dbg(tty->dev, "%s\n", __func__);
393 if (port->serial->type->throttle)
394 port->serial->type->throttle(tty);
397 static void serial_unthrottle(struct tty_struct *tty)
399 struct usb_serial_port *port = tty->driver_data;
401 dev_dbg(tty->dev, "%s\n", __func__);
403 if (port->serial->type->unthrottle)
404 port->serial->type->unthrottle(tty);
407 static int serial_ioctl(struct tty_struct *tty,
408 unsigned int cmd, unsigned long arg)
410 struct usb_serial_port *port = tty->driver_data;
411 int retval = -ENOIOCTLCMD;
413 dev_dbg(tty->dev, "%s - cmd 0x%.4x\n", __func__, cmd);
417 if (port->serial->type->tiocmiwait)
418 retval = port->serial->type->tiocmiwait(tty, arg);
421 if (port->serial->type->ioctl)
422 retval = port->serial->type->ioctl(tty, cmd, arg);
428 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
430 struct usb_serial_port *port = tty->driver_data;
432 dev_dbg(tty->dev, "%s\n", __func__);
434 if (port->serial->type->set_termios)
435 port->serial->type->set_termios(tty, port, old);
437 tty_termios_copy_hw(&tty->termios, old);
440 static int serial_break(struct tty_struct *tty, int break_state)
442 struct usb_serial_port *port = tty->driver_data;
444 dev_dbg(tty->dev, "%s\n", __func__);
446 if (port->serial->type->break_ctl)
447 port->serial->type->break_ctl(tty, break_state);
452 static int serial_proc_show(struct seq_file *m, void *v)
454 struct usb_serial *serial;
458 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
459 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
460 serial = usb_serial_get_by_index(i);
464 seq_printf(m, "%d:", i);
465 if (serial->type->driver.owner)
466 seq_printf(m, " module:%s",
467 module_name(serial->type->driver.owner));
468 seq_printf(m, " name:\"%s\"",
469 serial->type->description);
470 seq_printf(m, " vendor:%04x product:%04x",
471 le16_to_cpu(serial->dev->descriptor.idVendor),
472 le16_to_cpu(serial->dev->descriptor.idProduct));
473 seq_printf(m, " num_ports:%d", serial->num_ports);
474 seq_printf(m, " port:%d", i - serial->minor + 1);
475 usb_make_path(serial->dev, tmp, sizeof(tmp));
476 seq_printf(m, " path:%s", tmp);
479 usb_serial_put(serial);
480 mutex_unlock(&serial->disc_mutex);
485 static int serial_proc_open(struct inode *inode, struct file *file)
487 return single_open(file, serial_proc_show, NULL);
490 static const struct file_operations serial_proc_fops = {
491 .owner = THIS_MODULE,
492 .open = serial_proc_open,
495 .release = single_release,
498 static int serial_tiocmget(struct tty_struct *tty)
500 struct usb_serial_port *port = tty->driver_data;
502 dev_dbg(tty->dev, "%s\n", __func__);
504 if (port->serial->type->tiocmget)
505 return port->serial->type->tiocmget(tty);
509 static int serial_tiocmset(struct tty_struct *tty,
510 unsigned int set, unsigned int clear)
512 struct usb_serial_port *port = tty->driver_data;
514 dev_dbg(tty->dev, "%s\n", __func__);
516 if (port->serial->type->tiocmset)
517 return port->serial->type->tiocmset(tty, set, clear);
521 static int serial_get_icount(struct tty_struct *tty,
522 struct serial_icounter_struct *icount)
524 struct usb_serial_port *port = tty->driver_data;
526 dev_dbg(tty->dev, "%s\n", __func__);
528 if (port->serial->type->get_icount)
529 return port->serial->type->get_icount(tty, icount);
534 * We would be calling tty_wakeup here, but unfortunately some line
535 * disciplines have an annoying habit of calling tty->write from
536 * the write wakeup callback (e.g. n_hdlc.c).
538 void usb_serial_port_softint(struct usb_serial_port *port)
540 schedule_work(&port->work);
542 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
544 static void usb_serial_port_work(struct work_struct *work)
546 struct usb_serial_port *port =
547 container_of(work, struct usb_serial_port, work);
549 tty_port_tty_wakeup(&port->port);
552 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
556 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
557 usb_poison_urb(port->read_urbs[i]);
558 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
559 usb_poison_urb(port->write_urbs[i]);
561 usb_poison_urb(port->interrupt_in_urb);
562 usb_poison_urb(port->interrupt_out_urb);
565 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
569 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
570 usb_unpoison_urb(port->read_urbs[i]);
571 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
572 usb_unpoison_urb(port->write_urbs[i]);
574 usb_unpoison_urb(port->interrupt_in_urb);
575 usb_unpoison_urb(port->interrupt_out_urb);
578 static void usb_serial_port_release(struct device *dev)
580 struct usb_serial_port *port = to_usb_serial_port(dev);
583 dev_dbg(dev, "%s\n", __func__);
585 usb_free_urb(port->interrupt_in_urb);
586 usb_free_urb(port->interrupt_out_urb);
587 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
588 usb_free_urb(port->read_urbs[i]);
589 kfree(port->bulk_in_buffers[i]);
591 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
592 usb_free_urb(port->write_urbs[i]);
593 kfree(port->bulk_out_buffers[i]);
595 kfifo_free(&port->write_fifo);
596 kfree(port->interrupt_in_buffer);
597 kfree(port->interrupt_out_buffer);
598 tty_port_destroy(&port->port);
602 static struct usb_serial *create_serial(struct usb_device *dev,
603 struct usb_interface *interface,
604 struct usb_serial_driver *driver)
606 struct usb_serial *serial;
608 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
611 serial->dev = usb_get_dev(dev);
612 serial->type = driver;
613 serial->interface = usb_get_intf(interface);
614 kref_init(&serial->kref);
615 mutex_init(&serial->disc_mutex);
616 serial->minor = SERIAL_TTY_NO_MINOR;
621 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
622 struct usb_serial_driver *drv)
624 struct usb_dynid *dynid;
626 spin_lock(&drv->dynids.lock);
627 list_for_each_entry(dynid, &drv->dynids.list, node) {
628 if (usb_match_one_id(intf, &dynid->id)) {
629 spin_unlock(&drv->dynids.lock);
633 spin_unlock(&drv->dynids.lock);
637 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
638 struct usb_interface *intf)
640 const struct usb_device_id *id;
642 id = usb_match_id(intf, drv->id_table);
644 dev_dbg(&intf->dev, "static descriptor matches\n");
647 id = match_dynamic_id(intf, drv);
649 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
654 /* Caller must hold table_lock */
655 static struct usb_serial_driver *search_serial_device(
656 struct usb_interface *iface)
658 const struct usb_device_id *id = NULL;
659 struct usb_serial_driver *drv;
660 struct usb_driver *driver = to_usb_driver(iface->dev.driver);
662 /* Check if the usb id matches a known device */
663 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
664 if (drv->usb_driver == driver)
665 id = get_iface_id(drv, iface);
673 static int serial_port_carrier_raised(struct tty_port *port)
675 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
676 struct usb_serial_driver *drv = p->serial->type;
678 if (drv->carrier_raised)
679 return drv->carrier_raised(p);
680 /* No carrier control - don't block */
684 static void serial_port_dtr_rts(struct tty_port *port, int on)
686 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
687 struct usb_serial *serial = p->serial;
688 struct usb_serial_driver *drv = serial->type;
693 * Work-around bug in the tty-layer which can result in dtr_rts
694 * being called after a disconnect (and tty_unregister_device
695 * has returned). Remove once bug has been squashed.
697 mutex_lock(&serial->disc_mutex);
698 if (!serial->disconnected)
700 mutex_unlock(&serial->disc_mutex);
703 static const struct tty_port_operations serial_port_ops = {
704 .carrier_raised = serial_port_carrier_raised,
705 .dtr_rts = serial_port_dtr_rts,
706 .activate = serial_port_activate,
707 .shutdown = serial_port_shutdown,
710 static int usb_serial_probe(struct usb_interface *interface,
711 const struct usb_device_id *id)
713 struct device *ddev = &interface->dev;
714 struct usb_device *dev = interface_to_usbdev(interface);
715 struct usb_serial *serial = NULL;
716 struct usb_serial_port *port;
717 struct usb_host_interface *iface_desc;
718 struct usb_endpoint_descriptor *endpoint;
719 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
720 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
721 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
722 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
723 struct usb_serial_driver *type = NULL;
729 int num_interrupt_in = 0;
730 int num_interrupt_out = 0;
732 int num_bulk_out = 0;
736 mutex_lock(&table_lock);
737 type = search_serial_device(interface);
739 mutex_unlock(&table_lock);
740 dev_dbg(ddev, "none matched\n");
744 if (!try_module_get(type->driver.owner)) {
745 mutex_unlock(&table_lock);
746 dev_err(ddev, "module get failed, exiting\n");
749 mutex_unlock(&table_lock);
751 serial = create_serial(dev, interface, type);
753 module_put(type->driver.owner);
757 /* if this device type has a probe function, call it */
759 const struct usb_device_id *id;
761 id = get_iface_id(type, interface);
762 retval = type->probe(serial, id);
765 dev_dbg(ddev, "sub driver rejected device\n");
766 usb_serial_put(serial);
767 module_put(type->driver.owner);
772 /* descriptor matches, let's find the endpoints needed */
773 /* check out the endpoints */
774 iface_desc = interface->cur_altsetting;
775 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
776 endpoint = &iface_desc->endpoint[i].desc;
778 if (usb_endpoint_is_bulk_in(endpoint)) {
779 /* we found a bulk in endpoint */
780 dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
781 if (num_bulk_in < MAX_NUM_PORTS) {
782 bulk_in_endpoint[num_bulk_in] = endpoint;
787 if (usb_endpoint_is_bulk_out(endpoint)) {
788 /* we found a bulk out endpoint */
789 dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
790 if (num_bulk_out < MAX_NUM_PORTS) {
791 bulk_out_endpoint[num_bulk_out] = endpoint;
796 if (usb_endpoint_is_int_in(endpoint)) {
797 /* we found a interrupt in endpoint */
798 dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
799 if (num_interrupt_in < MAX_NUM_PORTS) {
800 interrupt_in_endpoint[num_interrupt_in] =
806 if (usb_endpoint_is_int_out(endpoint)) {
807 /* we found an interrupt out endpoint */
808 dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
809 if (num_interrupt_out < MAX_NUM_PORTS) {
810 interrupt_out_endpoint[num_interrupt_out] =
817 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
818 /* BEGIN HORRIBLE HACK FOR PL2303 */
819 /* this is needed due to the looney way its endpoints are set up */
820 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
821 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
822 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
823 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
824 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
825 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
826 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
827 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
828 if (interface != dev->actconfig->interface[0]) {
829 /* check out the endpoints of the other interface*/
830 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
831 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
832 endpoint = &iface_desc->endpoint[i].desc;
833 if (usb_endpoint_is_int_in(endpoint)) {
834 /* we found a interrupt in endpoint */
835 dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
836 if (num_interrupt_in < MAX_NUM_PORTS) {
837 interrupt_in_endpoint[num_interrupt_in] = endpoint;
844 /* Now make sure the PL-2303 is configured correctly.
845 * If not, give up now and hope this hack will work
846 * properly during a later invocation of usb_serial_probe
848 if (num_bulk_in == 0 || num_bulk_out == 0) {
849 dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
850 usb_serial_put(serial);
851 module_put(type->driver.owner);
855 /* END HORRIBLE HACK FOR PL2303 */
858 #ifdef CONFIG_USB_SERIAL_GENERIC
859 if (type == &usb_serial_generic_device) {
860 num_ports = num_bulk_out;
861 if (num_ports == 0) {
862 dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
863 usb_serial_put(serial);
864 module_put(type->driver.owner);
867 dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
868 dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
872 /* if this device type has a calc_num_ports function, call it */
873 if (type->calc_num_ports)
874 num_ports = type->calc_num_ports(serial);
876 num_ports = type->num_ports;
879 serial->num_ports = num_ports;
880 serial->num_bulk_in = num_bulk_in;
881 serial->num_bulk_out = num_bulk_out;
882 serial->num_interrupt_in = num_interrupt_in;
883 serial->num_interrupt_out = num_interrupt_out;
885 /* found all that we need */
886 dev_info(ddev, "%s converter detected\n", type->description);
888 /* create our ports, we need as many as the max endpoints */
889 /* we don't use num_ports here because some devices have more
890 endpoint pairs than ports */
891 max_endpoints = max(num_bulk_in, num_bulk_out);
892 max_endpoints = max(max_endpoints, num_interrupt_in);
893 max_endpoints = max(max_endpoints, num_interrupt_out);
894 max_endpoints = max(max_endpoints, (int)serial->num_ports);
895 serial->num_port_pointers = max_endpoints;
897 dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
898 for (i = 0; i < max_endpoints; ++i) {
899 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
902 tty_port_init(&port->port);
903 port->port.ops = &serial_port_ops;
904 port->serial = serial;
905 spin_lock_init(&port->lock);
906 /* Keep this for private driver use for the moment but
907 should probably go away */
908 INIT_WORK(&port->work, usb_serial_port_work);
909 serial->port[i] = port;
910 port->dev.parent = &interface->dev;
911 port->dev.driver = NULL;
912 port->dev.bus = &usb_serial_bus_type;
913 port->dev.release = &usb_serial_port_release;
914 device_initialize(&port->dev);
917 /* set up the endpoint information */
918 for (i = 0; i < num_bulk_in; ++i) {
919 endpoint = bulk_in_endpoint[i];
920 port = serial->port[i];
921 buffer_size = max_t(int, serial->type->bulk_in_size,
922 usb_endpoint_maxp(endpoint));
923 port->bulk_in_size = buffer_size;
924 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
926 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
927 set_bit(j, &port->read_urbs_free);
928 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
929 if (!port->read_urbs[j])
931 port->bulk_in_buffers[j] = kmalloc(buffer_size,
933 if (!port->bulk_in_buffers[j])
935 usb_fill_bulk_urb(port->read_urbs[j], dev,
937 endpoint->bEndpointAddress),
938 port->bulk_in_buffers[j], buffer_size,
939 serial->type->read_bulk_callback,
943 port->read_urb = port->read_urbs[0];
944 port->bulk_in_buffer = port->bulk_in_buffers[0];
947 for (i = 0; i < num_bulk_out; ++i) {
948 endpoint = bulk_out_endpoint[i];
949 port = serial->port[i];
950 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
952 buffer_size = serial->type->bulk_out_size;
954 buffer_size = usb_endpoint_maxp(endpoint);
955 port->bulk_out_size = buffer_size;
956 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
958 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
959 set_bit(j, &port->write_urbs_free);
960 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
961 if (!port->write_urbs[j])
963 port->bulk_out_buffers[j] = kmalloc(buffer_size,
965 if (!port->bulk_out_buffers[j])
967 usb_fill_bulk_urb(port->write_urbs[j], dev,
969 endpoint->bEndpointAddress),
970 port->bulk_out_buffers[j], buffer_size,
971 serial->type->write_bulk_callback,
975 port->write_urb = port->write_urbs[0];
976 port->bulk_out_buffer = port->bulk_out_buffers[0];
979 if (serial->type->read_int_callback) {
980 for (i = 0; i < num_interrupt_in; ++i) {
981 endpoint = interrupt_in_endpoint[i];
982 port = serial->port[i];
983 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
984 if (!port->interrupt_in_urb)
986 buffer_size = usb_endpoint_maxp(endpoint);
987 port->interrupt_in_endpointAddress =
988 endpoint->bEndpointAddress;
989 port->interrupt_in_buffer = kmalloc(buffer_size,
991 if (!port->interrupt_in_buffer)
993 usb_fill_int_urb(port->interrupt_in_urb, dev,
995 endpoint->bEndpointAddress),
996 port->interrupt_in_buffer, buffer_size,
997 serial->type->read_int_callback, port,
998 endpoint->bInterval);
1000 } else if (num_interrupt_in) {
1001 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1004 if (serial->type->write_int_callback) {
1005 for (i = 0; i < num_interrupt_out; ++i) {
1006 endpoint = interrupt_out_endpoint[i];
1007 port = serial->port[i];
1008 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1009 if (!port->interrupt_out_urb)
1011 buffer_size = usb_endpoint_maxp(endpoint);
1012 port->interrupt_out_size = buffer_size;
1013 port->interrupt_out_endpointAddress =
1014 endpoint->bEndpointAddress;
1015 port->interrupt_out_buffer = kmalloc(buffer_size,
1017 if (!port->interrupt_out_buffer)
1019 usb_fill_int_urb(port->interrupt_out_urb, dev,
1021 endpoint->bEndpointAddress),
1022 port->interrupt_out_buffer, buffer_size,
1023 serial->type->write_int_callback, port,
1024 endpoint->bInterval);
1026 } else if (num_interrupt_out) {
1027 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1030 usb_set_intfdata(interface, serial);
1032 /* if this device type has an attach function, call it */
1034 retval = type->attach(serial);
1037 serial->attached = 1;
1039 /* quietly accept this device, but don't bind to a
1040 serial port as it's about to disappear */
1041 serial->num_ports = 0;
1045 serial->attached = 1;
1048 /* Avoid race with tty_open and serial_install by setting the
1049 * disconnected flag and not clearing it until all ports have been
1052 serial->disconnected = 1;
1054 if (get_free_serial(serial, num_ports, &minor) == NULL) {
1055 dev_err(ddev, "No more free serial devices\n");
1058 serial->minor = minor;
1060 /* register all of the individual ports with the driver core */
1061 for (i = 0; i < num_ports; ++i) {
1062 port = serial->port[i];
1063 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1064 dev_dbg(ddev, "registering %s", dev_name(&port->dev));
1065 device_enable_async_suspend(&port->dev);
1067 retval = device_add(&port->dev);
1069 dev_err(ddev, "Error registering port device, continuing\n");
1072 serial->disconnected = 0;
1074 usb_serial_console_init(minor);
1076 module_put(type->driver.owner);
1080 usb_serial_put(serial);
1081 module_put(type->driver.owner);
1085 static void usb_serial_disconnect(struct usb_interface *interface)
1088 struct usb_serial *serial = usb_get_intfdata(interface);
1089 struct device *dev = &interface->dev;
1090 struct usb_serial_port *port;
1092 usb_serial_console_disconnect(serial);
1094 mutex_lock(&serial->disc_mutex);
1095 /* must set a flag, to signal subdrivers */
1096 serial->disconnected = 1;
1097 mutex_unlock(&serial->disc_mutex);
1099 for (i = 0; i < serial->num_ports; ++i) {
1100 port = serial->port[i];
1102 struct tty_struct *tty = tty_port_tty_get(&port->port);
1107 usb_serial_port_poison_urbs(port);
1108 wake_up_interruptible(&port->port.delta_msr_wait);
1109 cancel_work_sync(&port->work);
1110 if (device_is_registered(&port->dev))
1111 device_del(&port->dev);
1114 if (serial->type->disconnect)
1115 serial->type->disconnect(serial);
1117 /* let the last holder of this object cause it to be cleaned up */
1118 usb_serial_put(serial);
1119 dev_info(dev, "device disconnected\n");
1122 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1124 struct usb_serial *serial = usb_get_intfdata(intf);
1125 struct usb_serial_port *port;
1128 serial->suspending = 1;
1131 * serial->type->suspend() MUST return 0 in system sleep context,
1132 * otherwise, the resume callback has to recover device from
1133 * previous suspend failure.
1135 if (serial->type->suspend) {
1136 r = serial->type->suspend(serial, message);
1138 serial->suspending = 0;
1143 for (i = 0; i < serial->num_ports; ++i) {
1144 port = serial->port[i];
1146 usb_serial_port_poison_urbs(port);
1152 EXPORT_SYMBOL(usb_serial_suspend);
1154 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1156 struct usb_serial_port *port;
1159 for (i = 0; i < serial->num_ports; ++i) {
1160 port = serial->port[i];
1162 usb_serial_port_unpoison_urbs(port);
1166 int usb_serial_resume(struct usb_interface *intf)
1168 struct usb_serial *serial = usb_get_intfdata(intf);
1171 usb_serial_unpoison_port_urbs(serial);
1173 serial->suspending = 0;
1174 if (serial->type->resume)
1175 rv = serial->type->resume(serial);
1177 rv = usb_serial_generic_resume(serial);
1181 EXPORT_SYMBOL(usb_serial_resume);
1183 static int usb_serial_reset_resume(struct usb_interface *intf)
1185 struct usb_serial *serial = usb_get_intfdata(intf);
1188 usb_serial_unpoison_port_urbs(serial);
1190 serial->suspending = 0;
1191 if (serial->type->reset_resume)
1192 rv = serial->type->reset_resume(serial);
1195 intf->needs_binding = 1;
1201 static const struct tty_operations serial_ops = {
1202 .open = serial_open,
1203 .close = serial_close,
1204 .write = serial_write,
1205 .hangup = serial_hangup,
1206 .write_room = serial_write_room,
1207 .ioctl = serial_ioctl,
1208 .set_termios = serial_set_termios,
1209 .throttle = serial_throttle,
1210 .unthrottle = serial_unthrottle,
1211 .break_ctl = serial_break,
1212 .chars_in_buffer = serial_chars_in_buffer,
1213 .wait_until_sent = serial_wait_until_sent,
1214 .tiocmget = serial_tiocmget,
1215 .tiocmset = serial_tiocmset,
1216 .get_icount = serial_get_icount,
1217 .cleanup = serial_cleanup,
1218 .install = serial_install,
1219 .proc_fops = &serial_proc_fops,
1223 struct tty_driver *usb_serial_tty_driver;
1225 /* Driver structure we register with the USB core */
1226 static struct usb_driver usb_serial_driver = {
1227 .name = "usbserial",
1228 .probe = usb_serial_probe,
1229 .disconnect = usb_serial_disconnect,
1230 .suspend = usb_serial_suspend,
1231 .resume = usb_serial_resume,
1233 .supports_autosuspend = 1,
1236 static int __init usb_serial_init(void)
1241 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1242 if (!usb_serial_tty_driver)
1245 /* Initialize our global data */
1246 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1247 serial_table[i] = NULL;
1249 result = bus_register(&usb_serial_bus_type);
1251 pr_err("%s - registering bus driver failed\n", __func__);
1255 usb_serial_tty_driver->driver_name = "usbserial";
1256 usb_serial_tty_driver->name = "ttyUSB";
1257 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1258 usb_serial_tty_driver->minor_start = 0;
1259 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1260 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1261 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1262 TTY_DRIVER_DYNAMIC_DEV;
1263 usb_serial_tty_driver->init_termios = tty_std_termios;
1264 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1266 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1267 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1268 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1269 result = tty_register_driver(usb_serial_tty_driver);
1271 pr_err("%s - tty_register_driver failed\n", __func__);
1272 goto exit_reg_driver;
1275 /* register the USB driver */
1276 result = usb_register(&usb_serial_driver);
1278 pr_err("%s - usb_register failed\n", __func__);
1282 /* register the generic driver, if we should */
1283 result = usb_serial_generic_register();
1285 pr_err("%s - registering generic driver failed\n", __func__);
1292 usb_deregister(&usb_serial_driver);
1295 tty_unregister_driver(usb_serial_tty_driver);
1298 bus_unregister(&usb_serial_bus_type);
1301 pr_err("%s - returning with error %d\n", __func__, result);
1302 put_tty_driver(usb_serial_tty_driver);
1307 static void __exit usb_serial_exit(void)
1309 usb_serial_console_exit();
1311 usb_serial_generic_deregister();
1313 usb_deregister(&usb_serial_driver);
1314 tty_unregister_driver(usb_serial_tty_driver);
1315 put_tty_driver(usb_serial_tty_driver);
1316 bus_unregister(&usb_serial_bus_type);
1320 module_init(usb_serial_init);
1321 module_exit(usb_serial_exit);
1323 #define set_to_generic_if_null(type, function) \
1325 if (!type->function) { \
1326 type->function = usb_serial_generic_##function; \
1327 pr_debug("%s: using generic " #function "\n", \
1328 type->driver.name); \
1332 static void usb_serial_operations_init(struct usb_serial_driver *device)
1334 set_to_generic_if_null(device, open);
1335 set_to_generic_if_null(device, write);
1336 set_to_generic_if_null(device, close);
1337 set_to_generic_if_null(device, write_room);
1338 set_to_generic_if_null(device, chars_in_buffer);
1339 if (device->tx_empty)
1340 set_to_generic_if_null(device, wait_until_sent);
1341 set_to_generic_if_null(device, read_bulk_callback);
1342 set_to_generic_if_null(device, write_bulk_callback);
1343 set_to_generic_if_null(device, process_read_urb);
1344 set_to_generic_if_null(device, prepare_write_buffer);
1347 static int usb_serial_register(struct usb_serial_driver *driver)
1354 if (!driver->description)
1355 driver->description = driver->driver.name;
1356 if (!driver->usb_driver) {
1357 WARN(1, "Serial driver %s has no usb_driver\n",
1358 driver->description);
1362 usb_serial_operations_init(driver);
1364 /* Add this device to our list of devices */
1365 mutex_lock(&table_lock);
1366 list_add(&driver->driver_list, &usb_serial_driver_list);
1368 retval = usb_serial_bus_register(driver);
1370 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1371 list_del(&driver->driver_list);
1373 pr_info("USB Serial support registered for %s\n", driver->description);
1375 mutex_unlock(&table_lock);
1379 static void usb_serial_deregister(struct usb_serial_driver *device)
1381 pr_info("USB Serial deregistering driver %s\n", device->description);
1383 mutex_lock(&table_lock);
1384 list_del(&device->driver_list);
1385 mutex_unlock(&table_lock);
1387 usb_serial_bus_deregister(device);
1391 * usb_serial_register_drivers - register drivers for a usb-serial module
1392 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1393 * @name: name of the usb_driver for this set of @serial_drivers
1394 * @id_table: list of all devices this @serial_drivers set binds to
1396 * Registers all the drivers in the @serial_drivers array, and dynamically
1397 * creates a struct usb_driver with the name @name and id_table of @id_table.
1399 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1401 const struct usb_device_id *id_table)
1404 struct usb_driver *udriver;
1405 struct usb_serial_driver * const *sd;
1408 * udriver must be registered before any of the serial drivers,
1409 * because the store_new_id() routine for the serial drivers (in
1410 * bus.c) probes udriver.
1412 * Performance hack: We don't want udriver to be probed until
1413 * the serial drivers are registered, because the probe would
1414 * simply fail for lack of a matching serial driver.
1415 * So we leave udriver's id_table set to NULL until we are all set.
1417 * Suspend/resume support is implemented in the usb-serial core,
1418 * so fill in the PM-related fields in udriver.
1420 udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1424 udriver->name = name;
1425 udriver->no_dynamic_id = 1;
1426 udriver->supports_autosuspend = 1;
1427 udriver->suspend = usb_serial_suspend;
1428 udriver->resume = usb_serial_resume;
1429 udriver->probe = usb_serial_probe;
1430 udriver->disconnect = usb_serial_disconnect;
1432 /* we only set the reset_resume field if the serial_driver has one */
1433 for (sd = serial_drivers; *sd; ++sd) {
1434 if ((*sd)->reset_resume) {
1435 udriver->reset_resume = usb_serial_reset_resume;
1440 rc = usb_register(udriver);
1444 for (sd = serial_drivers; *sd; ++sd) {
1445 (*sd)->usb_driver = udriver;
1446 rc = usb_serial_register(*sd);
1451 /* Now set udriver's id_table and look for matches */
1452 udriver->id_table = id_table;
1453 rc = driver_attach(&udriver->drvwrap.driver);
1457 while (sd-- > serial_drivers)
1458 usb_serial_deregister(*sd);
1459 usb_deregister(udriver);
1462 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1465 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1466 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1468 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1469 * frees the struct usb_driver that was created by the call to
1470 * usb_serial_register_drivers().
1472 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1474 struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1476 for (; *serial_drivers; ++serial_drivers)
1477 usb_serial_deregister(*serial_drivers);
1478 usb_deregister(udriver);
1481 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1483 MODULE_AUTHOR(DRIVER_AUTHOR);
1484 MODULE_DESCRIPTION(DRIVER_DESC);
1485 MODULE_LICENSE("GPL");