2 * USB Serial Converter driver
4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
12 * This driver was originally based on the ACM driver by Armin Fuerst (which was
13 * based on a driver by Brad Keryan)
15 * See Documentation/usb/usb-serial.txt for more information on using this driver
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/tty.h>
24 #include <linux/tty_driver.h>
25 #include <linux/tty_flip.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/spinlock.h>
29 #include <linux/mutex.h>
30 #include <linux/list.h>
31 #include <asm/uaccess.h>
32 #include <linux/usb.h>
33 #include <linux/usb/serial.h>
39 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
40 #define DRIVER_DESC "USB Serial Driver core"
42 static void port_free(struct usb_serial_port *port);
44 /* Driver structure we register with the USB core */
45 static struct usb_driver usb_serial_driver = {
47 .probe = usb_serial_probe,
48 .disconnect = usb_serial_disconnect,
49 .suspend = usb_serial_suspend,
50 .resume = usb_serial_resume,
54 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
55 the MODULE_DEVICE_TABLE declarations in each serial driver
56 cause the "hotplug" program to pull in whatever module is necessary
57 via modprobe, and modprobe will load usbserial because the serial
62 static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
63 static DEFINE_MUTEX(table_lock);
64 static LIST_HEAD(usb_serial_driver_list);
66 struct usb_serial *usb_serial_get_by_index(unsigned index)
68 struct usb_serial *serial;
70 mutex_lock(&table_lock);
71 serial = serial_table[index];
74 kref_get(&serial->kref);
75 mutex_unlock(&table_lock);
79 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
84 dbg("%s %d", __FUNCTION__, num_ports);
87 mutex_lock(&table_lock);
88 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
93 for (j = 1; j <= num_ports-1; ++j)
94 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
104 dbg("%s - minor base = %d", __FUNCTION__, *minor);
105 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
106 serial_table[i] = serial;
107 serial->port[j++]->number = i;
109 mutex_unlock(&table_lock);
112 mutex_unlock(&table_lock);
116 static void return_serial(struct usb_serial *serial)
120 dbg("%s", __FUNCTION__);
125 for (i = 0; i < serial->num_ports; ++i) {
126 serial_table[serial->minor + i] = NULL;
130 static void destroy_serial(struct kref *kref)
132 struct usb_serial *serial;
133 struct usb_serial_port *port;
136 serial = to_usb_serial(kref);
138 dbg("%s - %s", __FUNCTION__, serial->type->description);
140 serial->type->shutdown(serial);
142 /* return the minor range that this device had */
143 return_serial(serial);
145 for (i = 0; i < serial->num_ports; ++i)
146 serial->port[i]->open_count = 0;
148 /* the ports are cleaned up and released in port_release() */
149 for (i = 0; i < serial->num_ports; ++i)
150 if (serial->port[i]->dev.parent != NULL) {
151 device_unregister(&serial->port[i]->dev);
152 serial->port[i] = NULL;
155 /* If this is a "fake" port, we have to clean it up here, as it will
156 * not get cleaned up in port_release() as it was never registered with
158 if (serial->num_ports < serial->num_port_pointers) {
159 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
160 port = serial->port[i];
167 usb_put_dev(serial->dev);
169 /* free up any memory that we allocated */
173 void usb_serial_put(struct usb_serial *serial)
175 mutex_lock(&table_lock);
176 kref_put(&serial->kref, destroy_serial);
177 mutex_unlock(&table_lock);
180 /*****************************************************************************
181 * Driver tty interface functions
182 *****************************************************************************/
183 static int serial_open (struct tty_struct *tty, struct file * filp)
185 struct usb_serial *serial;
186 struct usb_serial_port *port;
187 unsigned int portNumber;
190 dbg("%s", __FUNCTION__);
192 /* get the serial object associated with this tty pointer */
193 serial = usb_serial_get_by_index(tty->index);
195 tty->driver_data = NULL;
199 portNumber = tty->index - serial->minor;
200 port = serial->port[portNumber];
203 goto bailout_kref_put;
206 if (mutex_lock_interruptible(&port->mutex)) {
207 retval = -ERESTARTSYS;
208 goto bailout_kref_put;
213 /* set up our port structure making the tty driver
214 * remember our port object, and us it */
215 tty->driver_data = port;
218 if (port->open_count == 1) {
220 /* lock this module before we call it
221 * this may fail, which means we must bail out,
222 * safe because we are called with BKL held */
223 if (!try_module_get(serial->type->driver.owner)) {
225 goto bailout_mutex_unlock;
228 retval = usb_autopm_get_interface(serial->interface);
230 goto bailout_module_put;
231 /* only call the device specific open if this
232 * is the first time the port is opened */
233 retval = serial->type->open(port, filp);
235 goto bailout_interface_put;
238 mutex_unlock(&port->mutex);
241 bailout_interface_put:
242 usb_autopm_put_interface(serial->interface);
244 module_put(serial->type->driver.owner);
245 bailout_mutex_unlock:
246 port->open_count = 0;
247 tty->driver_data = NULL;
249 mutex_unlock(&port->mutex);
251 usb_serial_put(serial);
255 static void serial_close(struct tty_struct *tty, struct file * filp)
257 struct usb_serial_port *port = tty->driver_data;
262 dbg("%s - port %d", __FUNCTION__, port->number);
264 mutex_lock(&port->mutex);
266 if (port->open_count == 0) {
267 mutex_unlock(&port->mutex);
272 if (port->open_count == 0)
273 /* only call the device specific close if this
274 * port is being closed by the last owner */
275 port->serial->type->close(port, filp);
277 if (port->open_count == (port->console? 1 : 0)) {
279 if (port->tty->driver_data)
280 port->tty->driver_data = NULL;
285 if (port->open_count == 0) {
286 usb_autopm_put_interface(port->serial->interface);
287 module_put(port->serial->type->driver.owner);
290 mutex_unlock(&port->mutex);
291 usb_serial_put(port->serial);
294 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
296 struct usb_serial_port *port = tty->driver_data;
297 int retval = -ENODEV;
299 if (!port || port->serial->dev->state == USB_STATE_NOTATTACHED)
302 dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
304 if (!port->open_count) {
306 dbg("%s - port not opened", __FUNCTION__);
310 /* pass on to the driver specific version of this function */
311 retval = port->serial->type->write(port, buf, count);
317 static int serial_write_room (struct tty_struct *tty)
319 struct usb_serial_port *port = tty->driver_data;
320 int retval = -ENODEV;
325 dbg("%s - port %d", __FUNCTION__, port->number);
327 if (!port->open_count) {
328 dbg("%s - port not open", __FUNCTION__);
332 /* pass on to the driver specific version of this function */
333 retval = port->serial->type->write_room(port);
339 static int serial_chars_in_buffer (struct tty_struct *tty)
341 struct usb_serial_port *port = tty->driver_data;
342 int retval = -ENODEV;
347 dbg("%s = port %d", __FUNCTION__, port->number);
349 if (!port->open_count) {
350 dbg("%s - port not open", __FUNCTION__);
354 /* pass on to the driver specific version of this function */
355 retval = port->serial->type->chars_in_buffer(port);
361 static void serial_throttle (struct tty_struct * tty)
363 struct usb_serial_port *port = tty->driver_data;
368 dbg("%s - port %d", __FUNCTION__, port->number);
370 if (!port->open_count) {
371 dbg ("%s - port not open", __FUNCTION__);
375 /* pass on to the driver specific version of this function */
376 if (port->serial->type->throttle)
377 port->serial->type->throttle(port);
380 static void serial_unthrottle (struct tty_struct * tty)
382 struct usb_serial_port *port = tty->driver_data;
387 dbg("%s - port %d", __FUNCTION__, port->number);
389 if (!port->open_count) {
390 dbg("%s - port not open", __FUNCTION__);
394 /* pass on to the driver specific version of this function */
395 if (port->serial->type->unthrottle)
396 port->serial->type->unthrottle(port);
399 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
401 struct usb_serial_port *port = tty->driver_data;
402 int retval = -ENODEV;
408 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
410 /* Caution - port->open_count is BKL protected */
411 if (!port->open_count) {
412 dbg ("%s - port not open", __FUNCTION__);
416 /* pass on to the driver specific version of this function if it is available */
417 if (port->serial->type->ioctl)
418 retval = port->serial->type->ioctl(port, file, cmd, arg);
420 retval = -ENOIOCTLCMD;
426 static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
428 struct usb_serial_port *port = tty->driver_data;
433 dbg("%s - port %d", __FUNCTION__, port->number);
435 if (!port->open_count) {
436 dbg("%s - port not open", __FUNCTION__);
440 /* pass on to the driver specific version of this function if it is available */
441 if (port->serial->type->set_termios)
442 port->serial->type->set_termios(port, old);
444 tty_termios_copy_hw(tty->termios, old);
447 static void serial_break (struct tty_struct *tty, int break_state)
449 struct usb_serial_port *port = tty->driver_data;
457 dbg("%s - port %d", __FUNCTION__, port->number);
459 if (!port->open_count) {
460 dbg("%s - port not open", __FUNCTION__);
465 /* pass on to the driver specific version of this function if it is available */
466 if (port->serial->type->break_ctl)
467 port->serial->type->break_ctl(port, break_state);
471 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
473 struct usb_serial *serial;
479 dbg("%s", __FUNCTION__);
480 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
481 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
482 serial = usb_serial_get_by_index(i);
486 length += sprintf (page+length, "%d:", i);
487 if (serial->type->driver.owner)
488 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
489 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
490 length += sprintf (page+length, " vendor:%04x product:%04x",
491 le16_to_cpu(serial->dev->descriptor.idVendor),
492 le16_to_cpu(serial->dev->descriptor.idProduct));
493 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
494 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
496 usb_make_path(serial->dev, tmp, sizeof(tmp));
497 length += sprintf (page+length, " path:%s", tmp);
499 length += sprintf (page+length, "\n");
500 if ((length + begin) > (off + count)) {
501 usb_serial_put(serial);
504 if ((length + begin) < off) {
508 usb_serial_put(serial);
512 if (off >= (length + begin))
514 *start = page + (off-begin);
515 return ((count < begin+length-off) ? count : begin+length-off);
518 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
520 struct usb_serial_port *port = tty->driver_data;
525 dbg("%s - port %d", __FUNCTION__, port->number);
527 if (!port->open_count) {
528 dbg("%s - port not open", __FUNCTION__);
532 if (port->serial->type->tiocmget)
533 return port->serial->type->tiocmget(port, file);
538 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
539 unsigned int set, unsigned int clear)
541 struct usb_serial_port *port = tty->driver_data;
546 dbg("%s - port %d", __FUNCTION__, port->number);
548 if (!port->open_count) {
549 dbg("%s - port not open", __FUNCTION__);
553 if (port->serial->type->tiocmset)
554 return port->serial->type->tiocmset(port, file, set, clear);
560 * We would be calling tty_wakeup here, but unfortunately some line
561 * disciplines have an annoying habit of calling tty->write from
562 * the write wakeup callback (e.g. n_hdlc.c).
564 void usb_serial_port_softint(struct usb_serial_port *port)
566 schedule_work(&port->work);
569 static void usb_serial_port_work(struct work_struct *work)
571 struct usb_serial_port *port =
572 container_of(work, struct usb_serial_port, work);
573 struct tty_struct *tty;
575 dbg("%s - port %d", __FUNCTION__, port->number);
587 static void port_release(struct device *dev)
589 struct usb_serial_port *port = to_usb_serial_port(dev);
591 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
595 static void kill_traffic(struct usb_serial_port *port)
597 usb_kill_urb(port->read_urb);
598 usb_kill_urb(port->write_urb);
601 * Some drivers submit the read_urb in the
602 * handler for the write_urb or vice versa
603 * this order determines the order in which
604 * usb_kill_urb() must be used to reliably
605 * kill the URBs. As it is unknown here,
606 * both orders must be used in turn.
607 * The call below is not redundant.
609 usb_kill_urb(port->read_urb);
610 usb_kill_urb(port->interrupt_in_urb);
611 usb_kill_urb(port->interrupt_out_urb);
614 static void port_free(struct usb_serial_port *port)
617 usb_free_urb(port->read_urb);
618 usb_free_urb(port->write_urb);
619 usb_free_urb(port->interrupt_in_urb);
620 usb_free_urb(port->interrupt_out_urb);
621 kfree(port->bulk_in_buffer);
622 kfree(port->bulk_out_buffer);
623 kfree(port->interrupt_in_buffer);
624 kfree(port->interrupt_out_buffer);
625 flush_scheduled_work(); /* port->work */
629 static struct usb_serial * create_serial (struct usb_device *dev,
630 struct usb_interface *interface,
631 struct usb_serial_driver *driver)
633 struct usb_serial *serial;
635 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
637 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
640 serial->dev = usb_get_dev(dev);
641 serial->type = driver;
642 serial->interface = interface;
643 kref_init(&serial->kref);
644 mutex_init(&serial->disc_mutex);
649 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
650 struct usb_serial_driver *drv)
652 struct usb_dynid *dynid;
654 spin_lock(&drv->dynids.lock);
655 list_for_each_entry(dynid, &drv->dynids.list, node) {
656 if (usb_match_one_id(intf, &dynid->id)) {
657 spin_unlock(&drv->dynids.lock);
661 spin_unlock(&drv->dynids.lock);
665 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
666 struct usb_interface *intf)
668 const struct usb_device_id *id;
670 id = usb_match_id(intf, drv->id_table);
672 dbg("static descriptor matches");
675 id = match_dynamic_id(intf, drv);
677 dbg("dynamic descriptor matches");
682 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
684 const struct usb_device_id *id;
685 struct usb_serial_driver *drv;
687 /* Check if the usb id matches a known device */
688 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
689 id = get_iface_id(drv, iface);
697 int usb_serial_probe(struct usb_interface *interface,
698 const struct usb_device_id *id)
700 struct usb_device *dev = interface_to_usbdev (interface);
701 struct usb_serial *serial = NULL;
702 struct usb_serial_port *port;
703 struct usb_host_interface *iface_desc;
704 struct usb_endpoint_descriptor *endpoint;
705 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
706 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
707 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
708 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
709 struct usb_serial_driver *type = NULL;
714 int num_interrupt_in = 0;
715 int num_interrupt_out = 0;
717 int num_bulk_out = 0;
721 lock_kernel(); /* guard against unloading a serial driver module */
722 type = search_serial_device(interface);
729 serial = create_serial (dev, interface, type);
732 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
736 /* if this device type has a probe function, call it */
738 const struct usb_device_id *id;
740 if (!try_module_get(type->driver.owner)) {
742 dev_err(&interface->dev, "module get failed, exiting\n");
747 id = get_iface_id(type, interface);
748 retval = type->probe(serial, id);
749 module_put(type->driver.owner);
753 dbg ("sub driver rejected device");
759 /* descriptor matches, let's find the endpoints needed */
760 /* check out the endpoints */
761 iface_desc = interface->cur_altsetting;
762 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
763 endpoint = &iface_desc->endpoint[i].desc;
765 if (usb_endpoint_is_bulk_in(endpoint)) {
766 /* we found a bulk in endpoint */
767 dbg("found bulk in on endpoint %d", i);
768 bulk_in_endpoint[num_bulk_in] = endpoint;
772 if (usb_endpoint_is_bulk_out(endpoint)) {
773 /* we found a bulk out endpoint */
774 dbg("found bulk out on endpoint %d", i);
775 bulk_out_endpoint[num_bulk_out] = endpoint;
779 if (usb_endpoint_is_int_in(endpoint)) {
780 /* we found a interrupt in endpoint */
781 dbg("found interrupt in on endpoint %d", i);
782 interrupt_in_endpoint[num_interrupt_in] = endpoint;
786 if (usb_endpoint_is_int_out(endpoint)) {
787 /* we found an interrupt out endpoint */
788 dbg("found interrupt out on endpoint %d", i);
789 interrupt_out_endpoint[num_interrupt_out] = endpoint;
794 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
795 /* BEGIN HORRIBLE HACK FOR PL2303 */
796 /* this is needed due to the looney way its endpoints are set up */
797 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
798 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
799 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
800 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
801 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
802 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
803 if (interface != dev->actconfig->interface[0]) {
804 /* check out the endpoints of the other interface*/
805 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
806 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
807 endpoint = &iface_desc->endpoint[i].desc;
808 if (usb_endpoint_is_int_in(endpoint)) {
809 /* we found a interrupt in endpoint */
810 dbg("found interrupt in for Prolific device on separate interface");
811 interrupt_in_endpoint[num_interrupt_in] = endpoint;
817 /* Now make sure the PL-2303 is configured correctly.
818 * If not, give up now and hope this hack will work
819 * properly during a later invocation of usb_serial_probe
821 if (num_bulk_in == 0 || num_bulk_out == 0) {
823 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
828 /* END HORRIBLE HACK FOR PL2303 */
831 #ifdef CONFIG_USB_SERIAL_GENERIC
832 if (type == &usb_serial_generic_device) {
833 num_ports = num_bulk_out;
834 if (num_ports == 0) {
836 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
843 /* if this device type has a calc_num_ports function, call it */
844 if (type->calc_num_ports) {
845 if (!try_module_get(type->driver.owner)) {
847 dev_err(&interface->dev, "module get failed, exiting\n");
851 num_ports = type->calc_num_ports (serial);
852 module_put(type->driver.owner);
855 num_ports = type->num_ports;
858 serial->num_ports = num_ports;
859 serial->num_bulk_in = num_bulk_in;
860 serial->num_bulk_out = num_bulk_out;
861 serial->num_interrupt_in = num_interrupt_in;
862 serial->num_interrupt_out = num_interrupt_out;
865 /* check that the device meets the driver's requirements */
866 if ((type->num_interrupt_in != NUM_DONT_CARE &&
867 type->num_interrupt_in != num_interrupt_in)
868 || (type->num_interrupt_out != NUM_DONT_CARE &&
869 type->num_interrupt_out != num_interrupt_out)
870 || (type->num_bulk_in != NUM_DONT_CARE &&
871 type->num_bulk_in != num_bulk_in)
872 || (type->num_bulk_out != NUM_DONT_CARE &&
873 type->num_bulk_out != num_bulk_out)) {
874 dbg("wrong number of endpoints");
880 /* found all that we need */
881 dev_info(&interface->dev, "%s converter detected\n",
884 /* create our ports, we need as many as the max endpoints */
885 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
886 max_endpoints = max(num_bulk_in, num_bulk_out);
887 max_endpoints = max(max_endpoints, num_interrupt_in);
888 max_endpoints = max(max_endpoints, num_interrupt_out);
889 max_endpoints = max(max_endpoints, (int)serial->num_ports);
890 serial->num_port_pointers = max_endpoints;
893 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
894 for (i = 0; i < max_endpoints; ++i) {
895 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
898 port->serial = serial;
899 spin_lock_init(&port->lock);
900 mutex_init(&port->mutex);
901 INIT_WORK(&port->work, usb_serial_port_work);
902 serial->port[i] = port;
905 /* set up the endpoint information */
906 for (i = 0; i < num_bulk_in; ++i) {
907 endpoint = bulk_in_endpoint[i];
908 port = serial->port[i];
909 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
910 if (!port->read_urb) {
911 dev_err(&interface->dev, "No free urbs available\n");
914 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
915 port->bulk_in_size = buffer_size;
916 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
917 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
918 if (!port->bulk_in_buffer) {
919 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
922 usb_fill_bulk_urb (port->read_urb, dev,
923 usb_rcvbulkpipe (dev,
924 endpoint->bEndpointAddress),
925 port->bulk_in_buffer, buffer_size,
926 serial->type->read_bulk_callback,
930 for (i = 0; i < num_bulk_out; ++i) {
931 endpoint = bulk_out_endpoint[i];
932 port = serial->port[i];
933 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
934 if (!port->write_urb) {
935 dev_err(&interface->dev, "No free urbs available\n");
938 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
939 port->bulk_out_size = buffer_size;
940 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
941 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
942 if (!port->bulk_out_buffer) {
943 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
946 usb_fill_bulk_urb (port->write_urb, dev,
947 usb_sndbulkpipe (dev,
948 endpoint->bEndpointAddress),
949 port->bulk_out_buffer, buffer_size,
950 serial->type->write_bulk_callback,
954 if (serial->type->read_int_callback) {
955 for (i = 0; i < num_interrupt_in; ++i) {
956 endpoint = interrupt_in_endpoint[i];
957 port = serial->port[i];
958 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
959 if (!port->interrupt_in_urb) {
960 dev_err(&interface->dev, "No free urbs available\n");
963 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
964 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
965 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
966 if (!port->interrupt_in_buffer) {
967 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
970 usb_fill_int_urb (port->interrupt_in_urb, dev,
972 endpoint->bEndpointAddress),
973 port->interrupt_in_buffer, buffer_size,
974 serial->type->read_int_callback, port,
975 endpoint->bInterval);
977 } else if (num_interrupt_in) {
978 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
981 if (serial->type->write_int_callback) {
982 for (i = 0; i < num_interrupt_out; ++i) {
983 endpoint = interrupt_out_endpoint[i];
984 port = serial->port[i];
985 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
986 if (!port->interrupt_out_urb) {
987 dev_err(&interface->dev, "No free urbs available\n");
990 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
991 port->interrupt_out_size = buffer_size;
992 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
993 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
994 if (!port->interrupt_out_buffer) {
995 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
998 usb_fill_int_urb (port->interrupt_out_urb, dev,
1000 endpoint->bEndpointAddress),
1001 port->interrupt_out_buffer, buffer_size,
1002 serial->type->write_int_callback, port,
1003 endpoint->bInterval);
1005 } else if (num_interrupt_out) {
1006 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1009 /* if this device type has an attach function, call it */
1011 if (!try_module_get(type->driver.owner)) {
1012 dev_err(&interface->dev, "module get failed, exiting\n");
1015 retval = type->attach (serial);
1016 module_put(type->driver.owner);
1020 /* quietly accept this device, but don't bind to a serial port
1021 * as it's about to disappear */
1026 if (get_free_serial (serial, num_ports, &minor) == NULL) {
1027 dev_err(&interface->dev, "No more free serial devices\n");
1030 serial->minor = minor;
1032 /* register all of the individual ports with the driver core */
1033 for (i = 0; i < num_ports; ++i) {
1034 port = serial->port[i];
1035 port->dev.parent = &interface->dev;
1036 port->dev.driver = NULL;
1037 port->dev.bus = &usb_serial_bus_type;
1038 port->dev.release = &port_release;
1040 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1041 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1042 retval = device_register(&port->dev);
1044 dev_err(&port->dev, "Error registering port device, "
1048 usb_serial_console_init (debug, minor);
1052 usb_set_intfdata (interface, serial);
1056 for (i = 0; i < num_bulk_in; ++i) {
1057 port = serial->port[i];
1060 usb_free_urb(port->read_urb);
1061 kfree(port->bulk_in_buffer);
1063 for (i = 0; i < num_bulk_out; ++i) {
1064 port = serial->port[i];
1067 usb_free_urb(port->write_urb);
1068 kfree(port->bulk_out_buffer);
1070 for (i = 0; i < num_interrupt_in; ++i) {
1071 port = serial->port[i];
1074 usb_free_urb(port->interrupt_in_urb);
1075 kfree(port->interrupt_in_buffer);
1077 for (i = 0; i < num_interrupt_out; ++i) {
1078 port = serial->port[i];
1081 usb_free_urb(port->interrupt_out_urb);
1082 kfree(port->interrupt_out_buffer);
1085 /* free up any memory that we allocated */
1086 for (i = 0; i < serial->num_port_pointers; ++i)
1087 kfree(serial->port[i]);
1092 void usb_serial_disconnect(struct usb_interface *interface)
1095 struct usb_serial *serial = usb_get_intfdata (interface);
1096 struct device *dev = &interface->dev;
1097 struct usb_serial_port *port;
1099 usb_serial_console_disconnect(serial);
1100 dbg ("%s", __FUNCTION__);
1102 mutex_lock(&serial->disc_mutex);
1103 usb_set_intfdata (interface, NULL);
1104 /* must set a flag, to signal subdrivers */
1105 serial->disconnected = 1;
1106 for (i = 0; i < serial->num_ports; ++i) {
1107 port = serial->port[i];
1110 tty_hangup(port->tty);
1114 /* let the last holder of this object
1115 * cause it to be cleaned up */
1116 mutex_unlock(&serial->disc_mutex);
1117 usb_serial_put(serial);
1118 dev_info(dev, "device disconnected\n");
1121 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1123 struct usb_serial *serial = usb_get_intfdata(intf);
1124 struct usb_serial_port *port;
1127 for (i = 0; i < serial->num_ports; ++i) {
1128 port = serial->port[i];
1133 if (serial->type->suspend)
1134 r = serial->type->suspend(serial, message);
1138 EXPORT_SYMBOL(usb_serial_suspend);
1140 int usb_serial_resume(struct usb_interface *intf)
1142 struct usb_serial *serial = usb_get_intfdata(intf);
1144 if (serial->type->resume)
1145 return serial->type->resume(serial);
1148 EXPORT_SYMBOL(usb_serial_resume);
1150 static const struct tty_operations serial_ops = {
1151 .open = serial_open,
1152 .close = serial_close,
1153 .write = serial_write,
1154 .write_room = serial_write_room,
1155 .ioctl = serial_ioctl,
1156 .set_termios = serial_set_termios,
1157 .throttle = serial_throttle,
1158 .unthrottle = serial_unthrottle,
1159 .break_ctl = serial_break,
1160 .chars_in_buffer = serial_chars_in_buffer,
1161 .read_proc = serial_read_proc,
1162 .tiocmget = serial_tiocmget,
1163 .tiocmset = serial_tiocmset,
1166 struct tty_driver *usb_serial_tty_driver;
1168 static int __init usb_serial_init(void)
1173 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1174 if (!usb_serial_tty_driver)
1177 /* Initialize our global data */
1178 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1179 serial_table[i] = NULL;
1182 result = bus_register(&usb_serial_bus_type);
1184 err("%s - registering bus driver failed", __FUNCTION__);
1188 usb_serial_tty_driver->owner = THIS_MODULE;
1189 usb_serial_tty_driver->driver_name = "usbserial";
1190 usb_serial_tty_driver->name = "ttyUSB";
1191 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1192 usb_serial_tty_driver->minor_start = 0;
1193 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1194 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1195 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1196 usb_serial_tty_driver->init_termios = tty_std_termios;
1197 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1198 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1199 result = tty_register_driver(usb_serial_tty_driver);
1201 err("%s - tty_register_driver failed", __FUNCTION__);
1202 goto exit_reg_driver;
1205 /* register the USB driver */
1206 result = usb_register(&usb_serial_driver);
1208 err("%s - usb_register failed", __FUNCTION__);
1212 /* register the generic driver, if we should */
1213 result = usb_serial_generic_register(debug);
1215 err("%s - registering generic driver failed", __FUNCTION__);
1224 usb_deregister(&usb_serial_driver);
1227 tty_unregister_driver(usb_serial_tty_driver);
1230 bus_unregister(&usb_serial_bus_type);
1233 err ("%s - returning with error %d", __FUNCTION__, result);
1234 put_tty_driver(usb_serial_tty_driver);
1239 static void __exit usb_serial_exit(void)
1241 usb_serial_console_exit();
1243 usb_serial_generic_deregister();
1245 usb_deregister(&usb_serial_driver);
1246 tty_unregister_driver(usb_serial_tty_driver);
1247 put_tty_driver(usb_serial_tty_driver);
1248 bus_unregister(&usb_serial_bus_type);
1252 module_init(usb_serial_init);
1253 module_exit(usb_serial_exit);
1255 #define set_to_generic_if_null(type, function) \
1257 if (!type->function) { \
1258 type->function = usb_serial_generic_##function; \
1259 dbg("Had to override the " #function \
1260 " usb serial operation with the generic one.");\
1264 static void fixup_generic(struct usb_serial_driver *device)
1266 set_to_generic_if_null(device, open);
1267 set_to_generic_if_null(device, write);
1268 set_to_generic_if_null(device, close);
1269 set_to_generic_if_null(device, write_room);
1270 set_to_generic_if_null(device, chars_in_buffer);
1271 set_to_generic_if_null(device, read_bulk_callback);
1272 set_to_generic_if_null(device, write_bulk_callback);
1273 set_to_generic_if_null(device, shutdown);
1274 set_to_generic_if_null(device, resume);
1277 int usb_serial_register(struct usb_serial_driver *driver) /* must be called with BKL held */
1281 fixup_generic(driver);
1283 if (!driver->description)
1284 driver->description = driver->driver.name;
1286 /* Add this device to our list of devices */
1287 list_add(&driver->driver_list, &usb_serial_driver_list);
1289 retval = usb_serial_bus_register(driver);
1291 err("problem %d when registering driver %s", retval, driver->description);
1292 list_del(&driver->driver_list);
1295 info("USB Serial support registered for %s", driver->description);
1301 void usb_serial_deregister(struct usb_serial_driver *device) /* must be called with BKL held */
1303 info("USB Serial deregistering driver %s", device->description);
1304 list_del(&device->driver_list);
1305 usb_serial_bus_deregister(device);
1310 /* If the usb-serial core is built into the core, the usb-serial drivers
1311 need these symbols to load properly as modules. */
1312 EXPORT_SYMBOL_GPL(usb_serial_register);
1313 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1314 EXPORT_SYMBOL_GPL(usb_serial_probe);
1315 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1316 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1319 /* Module information */
1320 MODULE_AUTHOR( DRIVER_AUTHOR );
1321 MODULE_DESCRIPTION( DRIVER_DESC );
1322 MODULE_LICENSE("GPL");
1324 module_param(debug, bool, S_IRUGO | S_IWUSR);
1325 MODULE_PARM_DESC(debug, "Debug enabled or not");