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", __func__
, 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", __func__
, *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
)
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", __func__
, 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
;
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", __func__
, 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)", __func__
, port
->number
, count
);
304 if (!port
->open_count
) {
306 dbg("%s - port not opened", __func__
);
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", __func__
, port
->number
);
327 if (!port
->open_count
) {
328 dbg("%s - port not open", __func__
);
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", __func__
, port
->number
);
349 if (!port
->open_count
) {
350 dbg("%s - port not open", __func__
);
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", __func__
, port
->number
);
370 if (!port
->open_count
) {
371 dbg ("%s - port not open", __func__
);
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", __func__
, port
->number
);
389 if (!port
->open_count
) {
390 dbg("%s - port not open", __func__
);
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", __func__
, port
->number
, cmd
);
410 /* Caution - port->open_count is BKL protected */
411 if (!port
->open_count
) {
412 dbg ("%s - port not open", __func__
);
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", __func__
, port
->number
);
435 if (!port
->open_count
) {
436 dbg("%s - port not open", __func__
);
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", __func__
, port
->number
);
459 if (!port
->open_count
) {
460 dbg("%s - port not open", __func__
);
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
;
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", __func__
, port
->number
);
527 if (!port
->open_count
) {
528 dbg("%s - port not open", __func__
);
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", __func__
, port
->number
);
548 if (!port
->open_count
) {
549 dbg("%s - port not open", __func__
);
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", __func__
, 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", __func__
, 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", __func__
);
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", __func__
);
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
;
864 /* found all that we need */
865 dev_info(&interface
->dev
, "%s converter detected\n",
868 /* create our ports, we need as many as the max endpoints */
869 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
870 max_endpoints
= max(num_bulk_in
, num_bulk_out
);
871 max_endpoints
= max(max_endpoints
, num_interrupt_in
);
872 max_endpoints
= max(max_endpoints
, num_interrupt_out
);
873 max_endpoints
= max(max_endpoints
, (int)serial
->num_ports
);
874 serial
->num_port_pointers
= max_endpoints
;
877 dbg("%s - setting up %d port structures for this device", __func__
, max_endpoints
);
878 for (i
= 0; i
< max_endpoints
; ++i
) {
879 port
= kzalloc(sizeof(struct usb_serial_port
), GFP_KERNEL
);
882 port
->serial
= serial
;
883 spin_lock_init(&port
->lock
);
884 mutex_init(&port
->mutex
);
885 INIT_WORK(&port
->work
, usb_serial_port_work
);
886 serial
->port
[i
] = port
;
889 /* set up the endpoint information */
890 for (i
= 0; i
< num_bulk_in
; ++i
) {
891 endpoint
= bulk_in_endpoint
[i
];
892 port
= serial
->port
[i
];
893 port
->read_urb
= usb_alloc_urb (0, GFP_KERNEL
);
894 if (!port
->read_urb
) {
895 dev_err(&interface
->dev
, "No free urbs available\n");
898 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
899 port
->bulk_in_size
= buffer_size
;
900 port
->bulk_in_endpointAddress
= endpoint
->bEndpointAddress
;
901 port
->bulk_in_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
902 if (!port
->bulk_in_buffer
) {
903 dev_err(&interface
->dev
, "Couldn't allocate bulk_in_buffer\n");
906 usb_fill_bulk_urb (port
->read_urb
, dev
,
907 usb_rcvbulkpipe (dev
,
908 endpoint
->bEndpointAddress
),
909 port
->bulk_in_buffer
, buffer_size
,
910 serial
->type
->read_bulk_callback
,
914 for (i
= 0; i
< num_bulk_out
; ++i
) {
915 endpoint
= bulk_out_endpoint
[i
];
916 port
= serial
->port
[i
];
917 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
918 if (!port
->write_urb
) {
919 dev_err(&interface
->dev
, "No free urbs available\n");
922 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
923 port
->bulk_out_size
= buffer_size
;
924 port
->bulk_out_endpointAddress
= endpoint
->bEndpointAddress
;
925 port
->bulk_out_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
926 if (!port
->bulk_out_buffer
) {
927 dev_err(&interface
->dev
, "Couldn't allocate bulk_out_buffer\n");
930 usb_fill_bulk_urb (port
->write_urb
, dev
,
931 usb_sndbulkpipe (dev
,
932 endpoint
->bEndpointAddress
),
933 port
->bulk_out_buffer
, buffer_size
,
934 serial
->type
->write_bulk_callback
,
938 if (serial
->type
->read_int_callback
) {
939 for (i
= 0; i
< num_interrupt_in
; ++i
) {
940 endpoint
= interrupt_in_endpoint
[i
];
941 port
= serial
->port
[i
];
942 port
->interrupt_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
943 if (!port
->interrupt_in_urb
) {
944 dev_err(&interface
->dev
, "No free urbs available\n");
947 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
948 port
->interrupt_in_endpointAddress
= endpoint
->bEndpointAddress
;
949 port
->interrupt_in_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
950 if (!port
->interrupt_in_buffer
) {
951 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_buffer\n");
954 usb_fill_int_urb (port
->interrupt_in_urb
, dev
,
956 endpoint
->bEndpointAddress
),
957 port
->interrupt_in_buffer
, buffer_size
,
958 serial
->type
->read_int_callback
, port
,
959 endpoint
->bInterval
);
961 } else if (num_interrupt_in
) {
962 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
965 if (serial
->type
->write_int_callback
) {
966 for (i
= 0; i
< num_interrupt_out
; ++i
) {
967 endpoint
= interrupt_out_endpoint
[i
];
968 port
= serial
->port
[i
];
969 port
->interrupt_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
970 if (!port
->interrupt_out_urb
) {
971 dev_err(&interface
->dev
, "No free urbs available\n");
974 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
975 port
->interrupt_out_size
= buffer_size
;
976 port
->interrupt_out_endpointAddress
= endpoint
->bEndpointAddress
;
977 port
->interrupt_out_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
978 if (!port
->interrupt_out_buffer
) {
979 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_buffer\n");
982 usb_fill_int_urb (port
->interrupt_out_urb
, dev
,
984 endpoint
->bEndpointAddress
),
985 port
->interrupt_out_buffer
, buffer_size
,
986 serial
->type
->write_int_callback
, port
,
987 endpoint
->bInterval
);
989 } else if (num_interrupt_out
) {
990 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
993 /* if this device type has an attach function, call it */
995 if (!try_module_get(type
->driver
.owner
)) {
996 dev_err(&interface
->dev
, "module get failed, exiting\n");
999 retval
= type
->attach (serial
);
1000 module_put(type
->driver
.owner
);
1004 /* quietly accept this device, but don't bind to a serial port
1005 * as it's about to disappear */
1010 if (get_free_serial (serial
, num_ports
, &minor
) == NULL
) {
1011 dev_err(&interface
->dev
, "No more free serial devices\n");
1014 serial
->minor
= minor
;
1016 /* register all of the individual ports with the driver core */
1017 for (i
= 0; i
< num_ports
; ++i
) {
1018 port
= serial
->port
[i
];
1019 port
->dev
.parent
= &interface
->dev
;
1020 port
->dev
.driver
= NULL
;
1021 port
->dev
.bus
= &usb_serial_bus_type
;
1022 port
->dev
.release
= &port_release
;
1024 snprintf (&port
->dev
.bus_id
[0], sizeof(port
->dev
.bus_id
), "ttyUSB%d", port
->number
);
1025 dbg ("%s - registering %s", __func__
, port
->dev
.bus_id
);
1026 retval
= device_register(&port
->dev
);
1028 dev_err(&port
->dev
, "Error registering port device, "
1032 usb_serial_console_init (debug
, minor
);
1036 usb_set_intfdata (interface
, serial
);
1040 for (i
= 0; i
< num_bulk_in
; ++i
) {
1041 port
= serial
->port
[i
];
1044 usb_free_urb(port
->read_urb
);
1045 kfree(port
->bulk_in_buffer
);
1047 for (i
= 0; i
< num_bulk_out
; ++i
) {
1048 port
= serial
->port
[i
];
1051 usb_free_urb(port
->write_urb
);
1052 kfree(port
->bulk_out_buffer
);
1054 for (i
= 0; i
< num_interrupt_in
; ++i
) {
1055 port
= serial
->port
[i
];
1058 usb_free_urb(port
->interrupt_in_urb
);
1059 kfree(port
->interrupt_in_buffer
);
1061 for (i
= 0; i
< num_interrupt_out
; ++i
) {
1062 port
= serial
->port
[i
];
1065 usb_free_urb(port
->interrupt_out_urb
);
1066 kfree(port
->interrupt_out_buffer
);
1069 /* free up any memory that we allocated */
1070 for (i
= 0; i
< serial
->num_port_pointers
; ++i
)
1071 kfree(serial
->port
[i
]);
1076 void usb_serial_disconnect(struct usb_interface
*interface
)
1079 struct usb_serial
*serial
= usb_get_intfdata (interface
);
1080 struct device
*dev
= &interface
->dev
;
1081 struct usb_serial_port
*port
;
1083 usb_serial_console_disconnect(serial
);
1084 dbg ("%s", __func__
);
1086 mutex_lock(&serial
->disc_mutex
);
1087 usb_set_intfdata (interface
, NULL
);
1088 /* must set a flag, to signal subdrivers */
1089 serial
->disconnected
= 1;
1090 for (i
= 0; i
< serial
->num_ports
; ++i
) {
1091 port
= serial
->port
[i
];
1094 tty_hangup(port
->tty
);
1098 /* let the last holder of this object
1099 * cause it to be cleaned up */
1100 mutex_unlock(&serial
->disc_mutex
);
1101 usb_serial_put(serial
);
1102 dev_info(dev
, "device disconnected\n");
1105 int usb_serial_suspend(struct usb_interface
*intf
, pm_message_t message
)
1107 struct usb_serial
*serial
= usb_get_intfdata(intf
);
1108 struct usb_serial_port
*port
;
1111 for (i
= 0; i
< serial
->num_ports
; ++i
) {
1112 port
= serial
->port
[i
];
1117 if (serial
->type
->suspend
)
1118 r
= serial
->type
->suspend(serial
, message
);
1122 EXPORT_SYMBOL(usb_serial_suspend
);
1124 int usb_serial_resume(struct usb_interface
*intf
)
1126 struct usb_serial
*serial
= usb_get_intfdata(intf
);
1128 if (serial
->type
->resume
)
1129 return serial
->type
->resume(serial
);
1132 EXPORT_SYMBOL(usb_serial_resume
);
1134 static const struct tty_operations serial_ops
= {
1135 .open
= serial_open
,
1136 .close
= serial_close
,
1137 .write
= serial_write
,
1138 .write_room
= serial_write_room
,
1139 .ioctl
= serial_ioctl
,
1140 .set_termios
= serial_set_termios
,
1141 .throttle
= serial_throttle
,
1142 .unthrottle
= serial_unthrottle
,
1143 .break_ctl
= serial_break
,
1144 .chars_in_buffer
= serial_chars_in_buffer
,
1145 .read_proc
= serial_read_proc
,
1146 .tiocmget
= serial_tiocmget
,
1147 .tiocmset
= serial_tiocmset
,
1150 struct tty_driver
*usb_serial_tty_driver
;
1152 static int __init
usb_serial_init(void)
1157 usb_serial_tty_driver
= alloc_tty_driver(SERIAL_TTY_MINORS
);
1158 if (!usb_serial_tty_driver
)
1161 /* Initialize our global data */
1162 for (i
= 0; i
< SERIAL_TTY_MINORS
; ++i
) {
1163 serial_table
[i
] = NULL
;
1166 result
= bus_register(&usb_serial_bus_type
);
1168 err("%s - registering bus driver failed", __func__
);
1172 usb_serial_tty_driver
->owner
= THIS_MODULE
;
1173 usb_serial_tty_driver
->driver_name
= "usbserial";
1174 usb_serial_tty_driver
->name
= "ttyUSB";
1175 usb_serial_tty_driver
->major
= SERIAL_TTY_MAJOR
;
1176 usb_serial_tty_driver
->minor_start
= 0;
1177 usb_serial_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1178 usb_serial_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1179 usb_serial_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1180 usb_serial_tty_driver
->init_termios
= tty_std_termios
;
1181 usb_serial_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1182 tty_set_operations(usb_serial_tty_driver
, &serial_ops
);
1183 result
= tty_register_driver(usb_serial_tty_driver
);
1185 err("%s - tty_register_driver failed", __func__
);
1186 goto exit_reg_driver
;
1189 /* register the USB driver */
1190 result
= usb_register(&usb_serial_driver
);
1192 err("%s - usb_register failed", __func__
);
1196 /* register the generic driver, if we should */
1197 result
= usb_serial_generic_register(debug
);
1199 err("%s - registering generic driver failed", __func__
);
1208 usb_deregister(&usb_serial_driver
);
1211 tty_unregister_driver(usb_serial_tty_driver
);
1214 bus_unregister(&usb_serial_bus_type
);
1217 err ("%s - returning with error %d", __func__
, result
);
1218 put_tty_driver(usb_serial_tty_driver
);
1223 static void __exit
usb_serial_exit(void)
1225 usb_serial_console_exit();
1227 usb_serial_generic_deregister();
1229 usb_deregister(&usb_serial_driver
);
1230 tty_unregister_driver(usb_serial_tty_driver
);
1231 put_tty_driver(usb_serial_tty_driver
);
1232 bus_unregister(&usb_serial_bus_type
);
1236 module_init(usb_serial_init
);
1237 module_exit(usb_serial_exit
);
1239 #define set_to_generic_if_null(type, function) \
1241 if (!type->function) { \
1242 type->function = usb_serial_generic_##function; \
1243 dbg("Had to override the " #function \
1244 " usb serial operation with the generic one.");\
1248 static void fixup_generic(struct usb_serial_driver
*device
)
1250 set_to_generic_if_null(device
, open
);
1251 set_to_generic_if_null(device
, write
);
1252 set_to_generic_if_null(device
, close
);
1253 set_to_generic_if_null(device
, write_room
);
1254 set_to_generic_if_null(device
, chars_in_buffer
);
1255 set_to_generic_if_null(device
, read_bulk_callback
);
1256 set_to_generic_if_null(device
, write_bulk_callback
);
1257 set_to_generic_if_null(device
, shutdown
);
1258 set_to_generic_if_null(device
, resume
);
1261 int usb_serial_register(struct usb_serial_driver
*driver
) /* must be called with BKL held */
1265 fixup_generic(driver
);
1267 if (!driver
->description
)
1268 driver
->description
= driver
->driver
.name
;
1270 /* Add this device to our list of devices */
1271 list_add(&driver
->driver_list
, &usb_serial_driver_list
);
1273 retval
= usb_serial_bus_register(driver
);
1275 err("problem %d when registering driver %s", retval
, driver
->description
);
1276 list_del(&driver
->driver_list
);
1279 info("USB Serial support registered for %s", driver
->description
);
1285 void usb_serial_deregister(struct usb_serial_driver
*device
) /* must be called with BKL held */
1287 info("USB Serial deregistering driver %s", device
->description
);
1288 list_del(&device
->driver_list
);
1289 usb_serial_bus_deregister(device
);
1294 /* If the usb-serial core is built into the core, the usb-serial drivers
1295 need these symbols to load properly as modules. */
1296 EXPORT_SYMBOL_GPL(usb_serial_register
);
1297 EXPORT_SYMBOL_GPL(usb_serial_deregister
);
1298 EXPORT_SYMBOL_GPL(usb_serial_probe
);
1299 EXPORT_SYMBOL_GPL(usb_serial_disconnect
);
1300 EXPORT_SYMBOL_GPL(usb_serial_port_softint
);
1303 /* Module information */
1304 MODULE_AUTHOR( DRIVER_AUTHOR
);
1305 MODULE_DESCRIPTION( DRIVER_DESC
);
1306 MODULE_LICENSE("GPL");
1308 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1309 MODULE_PARM_DESC(debug
, "Debug enabled or not");