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;
407 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
409 if (!port->open_count) {
410 dbg ("%s - port not open", __FUNCTION__);
414 /* pass on to the driver specific version of this function if it is available */
415 if (port->serial->type->ioctl)
416 retval = port->serial->type->ioctl(port, file, cmd, arg);
418 retval = -ENOIOCTLCMD;
424 static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
426 struct usb_serial_port *port = tty->driver_data;
431 dbg("%s - port %d", __FUNCTION__, port->number);
433 if (!port->open_count) {
434 dbg("%s - port not open", __FUNCTION__);
438 /* pass on to the driver specific version of this function if it is available */
439 if (port->serial->type->set_termios)
440 port->serial->type->set_termios(port, old);
442 tty_termios_copy_hw(tty->termios, old);
445 static void serial_break (struct tty_struct *tty, int break_state)
447 struct usb_serial_port *port = tty->driver_data;
452 dbg("%s - port %d", __FUNCTION__, port->number);
454 if (!port->open_count) {
455 dbg("%s - port not open", __FUNCTION__);
459 /* pass on to the driver specific version of this function if it is available */
460 if (port->serial->type->break_ctl)
461 port->serial->type->break_ctl(port, break_state);
464 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
466 struct usb_serial *serial;
472 dbg("%s", __FUNCTION__);
473 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
474 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
475 serial = usb_serial_get_by_index(i);
479 length += sprintf (page+length, "%d:", i);
480 if (serial->type->driver.owner)
481 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
482 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
483 length += sprintf (page+length, " vendor:%04x product:%04x",
484 le16_to_cpu(serial->dev->descriptor.idVendor),
485 le16_to_cpu(serial->dev->descriptor.idProduct));
486 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
487 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
489 usb_make_path(serial->dev, tmp, sizeof(tmp));
490 length += sprintf (page+length, " path:%s", tmp);
492 length += sprintf (page+length, "\n");
493 if ((length + begin) > (off + count)) {
494 usb_serial_put(serial);
497 if ((length + begin) < off) {
501 usb_serial_put(serial);
505 if (off >= (length + begin))
507 *start = page + (off-begin);
508 return ((count < begin+length-off) ? count : begin+length-off);
511 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
513 struct usb_serial_port *port = tty->driver_data;
518 dbg("%s - port %d", __FUNCTION__, port->number);
520 if (!port->open_count) {
521 dbg("%s - port not open", __FUNCTION__);
525 if (port->serial->type->tiocmget)
526 return port->serial->type->tiocmget(port, file);
531 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
532 unsigned int set, unsigned int clear)
534 struct usb_serial_port *port = tty->driver_data;
539 dbg("%s - port %d", __FUNCTION__, port->number);
541 if (!port->open_count) {
542 dbg("%s - port not open", __FUNCTION__);
546 if (port->serial->type->tiocmset)
547 return port->serial->type->tiocmset(port, file, set, clear);
553 * We would be calling tty_wakeup here, but unfortunately some line
554 * disciplines have an annoying habit of calling tty->write from
555 * the write wakeup callback (e.g. n_hdlc.c).
557 void usb_serial_port_softint(struct usb_serial_port *port)
559 schedule_work(&port->work);
562 static void usb_serial_port_work(struct work_struct *work)
564 struct usb_serial_port *port =
565 container_of(work, struct usb_serial_port, work);
566 struct tty_struct *tty;
568 dbg("%s - port %d", __FUNCTION__, port->number);
580 static void port_release(struct device *dev)
582 struct usb_serial_port *port = to_usb_serial_port(dev);
584 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
588 static void kill_traffic(struct usb_serial_port *port)
590 usb_kill_urb(port->read_urb);
591 usb_kill_urb(port->write_urb);
594 * Some drivers submit the read_urb in the
595 * handler for the write_urb or vice versa
596 * this order determines the order in which
597 * usb_kill_urb() must be used to reliably
598 * kill the URBs. As it is unknown here,
599 * both orders must be used in turn.
600 * The call below is not redundant.
602 usb_kill_urb(port->read_urb);
603 usb_kill_urb(port->interrupt_in_urb);
604 usb_kill_urb(port->interrupt_out_urb);
607 static void port_free(struct usb_serial_port *port)
610 usb_free_urb(port->read_urb);
611 usb_free_urb(port->write_urb);
612 usb_free_urb(port->interrupt_in_urb);
613 usb_free_urb(port->interrupt_out_urb);
614 kfree(port->bulk_in_buffer);
615 kfree(port->bulk_out_buffer);
616 kfree(port->interrupt_in_buffer);
617 kfree(port->interrupt_out_buffer);
618 flush_scheduled_work(); /* port->work */
622 static struct usb_serial * create_serial (struct usb_device *dev,
623 struct usb_interface *interface,
624 struct usb_serial_driver *driver)
626 struct usb_serial *serial;
628 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
630 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
633 serial->dev = usb_get_dev(dev);
634 serial->type = driver;
635 serial->interface = interface;
636 kref_init(&serial->kref);
641 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
642 struct usb_serial_driver *drv)
644 struct usb_dynid *dynid;
646 spin_lock(&drv->dynids.lock);
647 list_for_each_entry(dynid, &drv->dynids.list, node) {
648 if (usb_match_one_id(intf, &dynid->id)) {
649 spin_unlock(&drv->dynids.lock);
653 spin_unlock(&drv->dynids.lock);
657 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
658 struct usb_interface *intf)
660 const struct usb_device_id *id;
662 id = usb_match_id(intf, drv->id_table);
664 dbg("static descriptor matches");
667 id = match_dynamic_id(intf, drv);
669 dbg("dynamic descriptor matches");
674 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
676 const struct usb_device_id *id;
677 struct usb_serial_driver *drv;
679 /* Check if the usb id matches a known device */
680 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
681 id = get_iface_id(drv, iface);
689 int usb_serial_probe(struct usb_interface *interface,
690 const struct usb_device_id *id)
692 struct usb_device *dev = interface_to_usbdev (interface);
693 struct usb_serial *serial = NULL;
694 struct usb_serial_port *port;
695 struct usb_host_interface *iface_desc;
696 struct usb_endpoint_descriptor *endpoint;
697 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
698 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
699 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
700 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
701 struct usb_serial_driver *type = NULL;
706 int num_interrupt_in = 0;
707 int num_interrupt_out = 0;
709 int num_bulk_out = 0;
713 lock_kernel(); /* guard against unloading a serial driver module */
714 type = search_serial_device(interface);
721 serial = create_serial (dev, interface, type);
724 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
728 /* if this device type has a probe function, call it */
730 const struct usb_device_id *id;
732 if (!try_module_get(type->driver.owner)) {
734 dev_err(&interface->dev, "module get failed, exiting\n");
739 id = get_iface_id(type, interface);
740 retval = type->probe(serial, id);
741 module_put(type->driver.owner);
745 dbg ("sub driver rejected device");
751 /* descriptor matches, let's find the endpoints needed */
752 /* check out the endpoints */
753 iface_desc = interface->cur_altsetting;
754 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
755 endpoint = &iface_desc->endpoint[i].desc;
757 if (usb_endpoint_is_bulk_in(endpoint)) {
758 /* we found a bulk in endpoint */
759 dbg("found bulk in on endpoint %d", i);
760 bulk_in_endpoint[num_bulk_in] = endpoint;
764 if (usb_endpoint_is_bulk_out(endpoint)) {
765 /* we found a bulk out endpoint */
766 dbg("found bulk out on endpoint %d", i);
767 bulk_out_endpoint[num_bulk_out] = endpoint;
771 if (usb_endpoint_is_int_in(endpoint)) {
772 /* we found a interrupt in endpoint */
773 dbg("found interrupt in on endpoint %d", i);
774 interrupt_in_endpoint[num_interrupt_in] = endpoint;
778 if (usb_endpoint_is_int_out(endpoint)) {
779 /* we found an interrupt out endpoint */
780 dbg("found interrupt out on endpoint %d", i);
781 interrupt_out_endpoint[num_interrupt_out] = endpoint;
786 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
787 /* BEGIN HORRIBLE HACK FOR PL2303 */
788 /* this is needed due to the looney way its endpoints are set up */
789 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
790 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
791 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
792 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
793 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
794 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
795 if (interface != dev->actconfig->interface[0]) {
796 /* check out the endpoints of the other interface*/
797 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
798 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
799 endpoint = &iface_desc->endpoint[i].desc;
800 if (usb_endpoint_is_int_in(endpoint)) {
801 /* we found a interrupt in endpoint */
802 dbg("found interrupt in for Prolific device on separate interface");
803 interrupt_in_endpoint[num_interrupt_in] = endpoint;
809 /* Now make sure the PL-2303 is configured correctly.
810 * If not, give up now and hope this hack will work
811 * properly during a later invocation of usb_serial_probe
813 if (num_bulk_in == 0 || num_bulk_out == 0) {
815 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
820 /* END HORRIBLE HACK FOR PL2303 */
823 #ifdef CONFIG_USB_SERIAL_GENERIC
824 if (type == &usb_serial_generic_device) {
825 num_ports = num_bulk_out;
826 if (num_ports == 0) {
828 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
835 /* if this device type has a calc_num_ports function, call it */
836 if (type->calc_num_ports) {
837 if (!try_module_get(type->driver.owner)) {
839 dev_err(&interface->dev, "module get failed, exiting\n");
843 num_ports = type->calc_num_ports (serial);
844 module_put(type->driver.owner);
847 num_ports = type->num_ports;
850 serial->num_ports = num_ports;
851 serial->num_bulk_in = num_bulk_in;
852 serial->num_bulk_out = num_bulk_out;
853 serial->num_interrupt_in = num_interrupt_in;
854 serial->num_interrupt_out = num_interrupt_out;
856 /* check that the device meets the driver's requirements */
857 if ((type->num_interrupt_in != NUM_DONT_CARE &&
858 type->num_interrupt_in != num_interrupt_in)
859 || (type->num_interrupt_out != NUM_DONT_CARE &&
860 type->num_interrupt_out != num_interrupt_out)
861 || (type->num_bulk_in != NUM_DONT_CARE &&
862 type->num_bulk_in != num_bulk_in)
863 || (type->num_bulk_out != NUM_DONT_CARE &&
864 type->num_bulk_out != num_bulk_out)) {
865 dbg("wrong number of endpoints");
870 /* found all that we need */
871 dev_info(&interface->dev, "%s converter detected\n",
874 /* create our ports, we need as many as the max endpoints */
875 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
876 max_endpoints = max(num_bulk_in, num_bulk_out);
877 max_endpoints = max(max_endpoints, num_interrupt_in);
878 max_endpoints = max(max_endpoints, num_interrupt_out);
879 max_endpoints = max(max_endpoints, (int)serial->num_ports);
880 serial->num_port_pointers = max_endpoints;
883 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
884 for (i = 0; i < max_endpoints; ++i) {
885 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
888 port->serial = serial;
889 spin_lock_init(&port->lock);
890 mutex_init(&port->mutex);
891 INIT_WORK(&port->work, usb_serial_port_work);
892 serial->port[i] = port;
895 /* set up the endpoint information */
896 for (i = 0; i < num_bulk_in; ++i) {
897 endpoint = bulk_in_endpoint[i];
898 port = serial->port[i];
899 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
900 if (!port->read_urb) {
901 dev_err(&interface->dev, "No free urbs available\n");
904 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
905 port->bulk_in_size = buffer_size;
906 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
907 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
908 if (!port->bulk_in_buffer) {
909 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
912 usb_fill_bulk_urb (port->read_urb, dev,
913 usb_rcvbulkpipe (dev,
914 endpoint->bEndpointAddress),
915 port->bulk_in_buffer, buffer_size,
916 serial->type->read_bulk_callback,
920 for (i = 0; i < num_bulk_out; ++i) {
921 endpoint = bulk_out_endpoint[i];
922 port = serial->port[i];
923 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
924 if (!port->write_urb) {
925 dev_err(&interface->dev, "No free urbs available\n");
928 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
929 port->bulk_out_size = buffer_size;
930 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
931 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
932 if (!port->bulk_out_buffer) {
933 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
936 usb_fill_bulk_urb (port->write_urb, dev,
937 usb_sndbulkpipe (dev,
938 endpoint->bEndpointAddress),
939 port->bulk_out_buffer, buffer_size,
940 serial->type->write_bulk_callback,
944 if (serial->type->read_int_callback) {
945 for (i = 0; i < num_interrupt_in; ++i) {
946 endpoint = interrupt_in_endpoint[i];
947 port = serial->port[i];
948 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
949 if (!port->interrupt_in_urb) {
950 dev_err(&interface->dev, "No free urbs available\n");
953 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
954 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
955 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
956 if (!port->interrupt_in_buffer) {
957 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
960 usb_fill_int_urb (port->interrupt_in_urb, dev,
962 endpoint->bEndpointAddress),
963 port->interrupt_in_buffer, buffer_size,
964 serial->type->read_int_callback, port,
965 endpoint->bInterval);
967 } else if (num_interrupt_in) {
968 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
971 if (serial->type->write_int_callback) {
972 for (i = 0; i < num_interrupt_out; ++i) {
973 endpoint = interrupt_out_endpoint[i];
974 port = serial->port[i];
975 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
976 if (!port->interrupt_out_urb) {
977 dev_err(&interface->dev, "No free urbs available\n");
980 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
981 port->interrupt_out_size = buffer_size;
982 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
983 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
984 if (!port->interrupt_out_buffer) {
985 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
988 usb_fill_int_urb (port->interrupt_out_urb, dev,
990 endpoint->bEndpointAddress),
991 port->interrupt_out_buffer, buffer_size,
992 serial->type->write_int_callback, port,
993 endpoint->bInterval);
995 } else if (num_interrupt_out) {
996 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
999 /* if this device type has an attach function, call it */
1001 if (!try_module_get(type->driver.owner)) {
1002 dev_err(&interface->dev, "module get failed, exiting\n");
1005 retval = type->attach (serial);
1006 module_put(type->driver.owner);
1010 /* quietly accept this device, but don't bind to a serial port
1011 * as it's about to disappear */
1016 if (get_free_serial (serial, num_ports, &minor) == NULL) {
1017 dev_err(&interface->dev, "No more free serial devices\n");
1020 serial->minor = minor;
1022 /* register all of the individual ports with the driver core */
1023 for (i = 0; i < num_ports; ++i) {
1024 port = serial->port[i];
1025 port->dev.parent = &interface->dev;
1026 port->dev.driver = NULL;
1027 port->dev.bus = &usb_serial_bus_type;
1028 port->dev.release = &port_release;
1030 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1031 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1032 retval = device_register(&port->dev);
1034 dev_err(&port->dev, "Error registering port device, "
1038 usb_serial_console_init (debug, minor);
1042 usb_set_intfdata (interface, serial);
1046 for (i = 0; i < num_bulk_in; ++i) {
1047 port = serial->port[i];
1050 usb_free_urb(port->read_urb);
1051 kfree(port->bulk_in_buffer);
1053 for (i = 0; i < num_bulk_out; ++i) {
1054 port = serial->port[i];
1057 usb_free_urb(port->write_urb);
1058 kfree(port->bulk_out_buffer);
1060 for (i = 0; i < num_interrupt_in; ++i) {
1061 port = serial->port[i];
1064 usb_free_urb(port->interrupt_in_urb);
1065 kfree(port->interrupt_in_buffer);
1067 for (i = 0; i < num_interrupt_out; ++i) {
1068 port = serial->port[i];
1071 usb_free_urb(port->interrupt_out_urb);
1072 kfree(port->interrupt_out_buffer);
1075 /* free up any memory that we allocated */
1076 for (i = 0; i < serial->num_port_pointers; ++i)
1077 kfree(serial->port[i]);
1082 void usb_serial_disconnect(struct usb_interface *interface)
1085 struct usb_serial *serial = usb_get_intfdata (interface);
1086 struct device *dev = &interface->dev;
1087 struct usb_serial_port *port;
1089 usb_serial_console_disconnect(serial);
1090 dbg ("%s", __FUNCTION__);
1092 usb_set_intfdata (interface, NULL);
1094 for (i = 0; i < serial->num_ports; ++i) {
1095 port = serial->port[i];
1098 tty_hangup(port->tty);
1102 /* let the last holder of this object
1103 * cause it to be cleaned up */
1104 usb_serial_put(serial);
1106 dev_info(dev, "device disconnected\n");
1109 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1111 struct usb_serial *serial = usb_get_intfdata(intf);
1112 struct usb_serial_port *port;
1115 if (!serial) /* device has been disconnected */
1118 for (i = 0; i < serial->num_ports; ++i) {
1119 port = serial->port[i];
1124 if (serial->type->suspend)
1125 r = serial->type->suspend(serial, message);
1129 EXPORT_SYMBOL(usb_serial_suspend);
1131 int usb_serial_resume(struct usb_interface *intf)
1133 struct usb_serial *serial = usb_get_intfdata(intf);
1135 if (serial->type->resume)
1136 return serial->type->resume(serial);
1139 EXPORT_SYMBOL(usb_serial_resume);
1141 static const struct tty_operations serial_ops = {
1142 .open = serial_open,
1143 .close = serial_close,
1144 .write = serial_write,
1145 .write_room = serial_write_room,
1146 .ioctl = serial_ioctl,
1147 .set_termios = serial_set_termios,
1148 .throttle = serial_throttle,
1149 .unthrottle = serial_unthrottle,
1150 .break_ctl = serial_break,
1151 .chars_in_buffer = serial_chars_in_buffer,
1152 .read_proc = serial_read_proc,
1153 .tiocmget = serial_tiocmget,
1154 .tiocmset = serial_tiocmset,
1157 struct tty_driver *usb_serial_tty_driver;
1159 static int __init usb_serial_init(void)
1164 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1165 if (!usb_serial_tty_driver)
1168 /* Initialize our global data */
1169 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1170 serial_table[i] = NULL;
1173 result = bus_register(&usb_serial_bus_type);
1175 err("%s - registering bus driver failed", __FUNCTION__);
1179 usb_serial_tty_driver->owner = THIS_MODULE;
1180 usb_serial_tty_driver->driver_name = "usbserial";
1181 usb_serial_tty_driver->name = "ttyUSB";
1182 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1183 usb_serial_tty_driver->minor_start = 0;
1184 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1185 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1186 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1187 usb_serial_tty_driver->init_termios = tty_std_termios;
1188 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1189 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1190 result = tty_register_driver(usb_serial_tty_driver);
1192 err("%s - tty_register_driver failed", __FUNCTION__);
1193 goto exit_reg_driver;
1196 /* register the USB driver */
1197 result = usb_register(&usb_serial_driver);
1199 err("%s - usb_register failed", __FUNCTION__);
1203 /* register the generic driver, if we should */
1204 result = usb_serial_generic_register(debug);
1206 err("%s - registering generic driver failed", __FUNCTION__);
1215 usb_deregister(&usb_serial_driver);
1218 tty_unregister_driver(usb_serial_tty_driver);
1221 bus_unregister(&usb_serial_bus_type);
1224 err ("%s - returning with error %d", __FUNCTION__, result);
1225 put_tty_driver(usb_serial_tty_driver);
1230 static void __exit usb_serial_exit(void)
1232 usb_serial_console_exit();
1234 usb_serial_generic_deregister();
1236 usb_deregister(&usb_serial_driver);
1237 tty_unregister_driver(usb_serial_tty_driver);
1238 put_tty_driver(usb_serial_tty_driver);
1239 bus_unregister(&usb_serial_bus_type);
1243 module_init(usb_serial_init);
1244 module_exit(usb_serial_exit);
1246 #define set_to_generic_if_null(type, function) \
1248 if (!type->function) { \
1249 type->function = usb_serial_generic_##function; \
1250 dbg("Had to override the " #function \
1251 " usb serial operation with the generic one.");\
1255 static void fixup_generic(struct usb_serial_driver *device)
1257 set_to_generic_if_null(device, open);
1258 set_to_generic_if_null(device, write);
1259 set_to_generic_if_null(device, close);
1260 set_to_generic_if_null(device, write_room);
1261 set_to_generic_if_null(device, chars_in_buffer);
1262 set_to_generic_if_null(device, read_bulk_callback);
1263 set_to_generic_if_null(device, write_bulk_callback);
1264 set_to_generic_if_null(device, shutdown);
1265 set_to_generic_if_null(device, resume);
1268 int usb_serial_register(struct usb_serial_driver *driver) /* must be called with BKL held */
1272 fixup_generic(driver);
1274 if (!driver->description)
1275 driver->description = driver->driver.name;
1277 /* Add this device to our list of devices */
1278 list_add(&driver->driver_list, &usb_serial_driver_list);
1280 retval = usb_serial_bus_register(driver);
1282 err("problem %d when registering driver %s", retval, driver->description);
1283 list_del(&driver->driver_list);
1286 info("USB Serial support registered for %s", driver->description);
1292 void usb_serial_deregister(struct usb_serial_driver *device) /* must be called with BKL held */
1294 info("USB Serial deregistering driver %s", device->description);
1295 list_del(&device->driver_list);
1296 usb_serial_bus_deregister(device);
1301 /* If the usb-serial core is built into the core, the usb-serial drivers
1302 need these symbols to load properly as modules. */
1303 EXPORT_SYMBOL_GPL(usb_serial_register);
1304 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1305 EXPORT_SYMBOL_GPL(usb_serial_probe);
1306 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1307 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1310 /* Module information */
1311 MODULE_AUTHOR( DRIVER_AUTHOR );
1312 MODULE_DESCRIPTION( DRIVER_DESC );
1313 MODULE_LICENSE("GPL");
1315 module_param(debug, bool, S_IRUGO | S_IWUSR);
1316 MODULE_PARM_DESC(debug, "Debug enabled or not");