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 <linux/smp_lock.h>
32 #include <asm/uaccess.h>
33 #include <linux/usb.h>
34 #include <linux/usb/serial.h>
40 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
41 #define DRIVER_DESC "USB Serial Driver core"
43 static void port_free(struct usb_serial_port
*port
);
45 /* Driver structure we register with the USB core */
46 static struct usb_driver usb_serial_driver
= {
48 .probe
= usb_serial_probe
,
49 .disconnect
= usb_serial_disconnect
,
53 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
54 the MODULE_DEVICE_TABLE declarations in each serial driver
55 cause the "hotplug" program to pull in whatever module is necessary
56 via modprobe, and modprobe will load usbserial because the serial
61 static struct usb_serial
*serial_table
[SERIAL_TTY_MINORS
]; /* initially all NULL */
62 static LIST_HEAD(usb_serial_driver_list
);
64 struct usb_serial
*usb_serial_get_by_index(unsigned index
)
66 struct usb_serial
*serial
= serial_table
[index
];
69 kref_get(&serial
->kref
);
73 static struct usb_serial
*get_free_serial (struct usb_serial
*serial
, int num_ports
, unsigned int *minor
)
78 dbg("%s %d", __FUNCTION__
, num_ports
);
81 for (i
= 0; i
< SERIAL_TTY_MINORS
; ++i
) {
86 for (j
= 1; j
<= num_ports
-1; ++j
)
87 if ((i
+j
>= SERIAL_TTY_MINORS
) || (serial_table
[i
+j
])) {
96 dbg("%s - minor base = %d", __FUNCTION__
, *minor
);
97 for (i
= *minor
; (i
< (*minor
+ num_ports
)) && (i
< SERIAL_TTY_MINORS
); ++i
)
98 serial_table
[i
] = serial
;
104 static void return_serial(struct usb_serial
*serial
)
108 dbg("%s", __FUNCTION__
);
113 for (i
= 0; i
< serial
->num_ports
; ++i
) {
114 serial_table
[serial
->minor
+ i
] = NULL
;
118 static void destroy_serial(struct kref
*kref
)
120 struct usb_serial
*serial
;
121 struct usb_serial_port
*port
;
124 serial
= to_usb_serial(kref
);
126 dbg("%s - %s", __FUNCTION__
, serial
->type
->description
);
128 serial
->type
->shutdown(serial
);
130 /* return the minor range that this device had */
131 return_serial(serial
);
133 for (i
= 0; i
< serial
->num_ports
; ++i
)
134 serial
->port
[i
]->open_count
= 0;
136 /* the ports are cleaned up and released in port_release() */
137 for (i
= 0; i
< serial
->num_ports
; ++i
)
138 if (serial
->port
[i
]->dev
.parent
!= NULL
) {
139 device_unregister(&serial
->port
[i
]->dev
);
140 serial
->port
[i
] = NULL
;
143 /* If this is a "fake" port, we have to clean it up here, as it will
144 * not get cleaned up in port_release() as it was never registered with
146 if (serial
->num_ports
< serial
->num_port_pointers
) {
147 for (i
= serial
->num_ports
; i
< serial
->num_port_pointers
; ++i
) {
148 port
= serial
->port
[i
];
155 usb_put_dev(serial
->dev
);
157 /* free up any memory that we allocated */
161 void usb_serial_put(struct usb_serial
*serial
)
163 kref_put(&serial
->kref
, destroy_serial
);
166 /*****************************************************************************
167 * Driver tty interface functions
168 *****************************************************************************/
169 static int serial_open (struct tty_struct
*tty
, struct file
* filp
)
171 struct usb_serial
*serial
;
172 struct usb_serial_port
*port
;
173 unsigned int portNumber
;
176 dbg("%s", __FUNCTION__
);
178 /* get the serial object associated with this tty pointer */
179 serial
= usb_serial_get_by_index(tty
->index
);
181 tty
->driver_data
= NULL
;
185 portNumber
= tty
->index
- serial
->minor
;
186 port
= serial
->port
[portNumber
];
189 goto bailout_kref_put
;
192 if (mutex_lock_interruptible(&port
->mutex
)) {
193 retval
= -ERESTARTSYS
;
194 goto bailout_kref_put
;
199 /* set up our port structure making the tty driver
200 * remember our port object, and us it */
201 tty
->driver_data
= port
;
204 if (port
->open_count
== 1) {
206 /* lock this module before we call it
207 * this may fail, which means we must bail out,
208 * safe because we are called with BKL held */
209 if (!try_module_get(serial
->type
->driver
.owner
)) {
211 goto bailout_mutex_unlock
;
214 /* only call the device specific open if this
215 * is the first time the port is opened */
216 retval
= serial
->type
->open(port
, filp
);
218 goto bailout_module_put
;
221 mutex_unlock(&port
->mutex
);
225 module_put(serial
->type
->driver
.owner
);
226 bailout_mutex_unlock
:
227 port
->open_count
= 0;
228 tty
->driver_data
= NULL
;
230 mutex_unlock(&port
->mutex
);
232 usb_serial_put(serial
);
236 static void serial_close(struct tty_struct
*tty
, struct file
* filp
)
238 struct usb_serial_port
*port
= tty
->driver_data
;
243 dbg("%s - port %d", __FUNCTION__
, port
->number
);
245 mutex_lock(&port
->mutex
);
247 if (port
->open_count
== 0) {
248 mutex_unlock(&port
->mutex
);
253 if (port
->open_count
== 0) {
254 /* only call the device specific close if this
255 * port is being closed by the last owner */
256 port
->serial
->type
->close(port
, filp
);
259 if (port
->tty
->driver_data
)
260 port
->tty
->driver_data
= NULL
;
264 module_put(port
->serial
->type
->driver
.owner
);
267 mutex_unlock(&port
->mutex
);
268 usb_serial_put(port
->serial
);
271 static int serial_write (struct tty_struct
* tty
, const unsigned char *buf
, int count
)
273 struct usb_serial_port
*port
= tty
->driver_data
;
274 int retval
= -EINVAL
;
276 if (!port
|| port
->serial
->dev
->state
== USB_STATE_NOTATTACHED
)
279 dbg("%s - port %d, %d byte(s)", __FUNCTION__
, port
->number
, count
);
281 if (!port
->open_count
) {
282 dbg("%s - port not opened", __FUNCTION__
);
286 /* pass on to the driver specific version of this function */
287 retval
= port
->serial
->type
->write(port
, buf
, count
);
293 static int serial_write_room (struct tty_struct
*tty
)
295 struct usb_serial_port
*port
= tty
->driver_data
;
296 int retval
= -ENODEV
;
301 dbg("%s - port %d", __FUNCTION__
, port
->number
);
303 if (!port
->open_count
) {
304 dbg("%s - port not open", __FUNCTION__
);
308 /* pass on to the driver specific version of this function */
309 retval
= port
->serial
->type
->write_room(port
);
315 static int serial_chars_in_buffer (struct tty_struct
*tty
)
317 struct usb_serial_port
*port
= tty
->driver_data
;
318 int retval
= -ENODEV
;
323 dbg("%s = port %d", __FUNCTION__
, port
->number
);
325 if (!port
->open_count
) {
326 dbg("%s - port not open", __FUNCTION__
);
330 /* pass on to the driver specific version of this function */
331 retval
= port
->serial
->type
->chars_in_buffer(port
);
337 static void serial_throttle (struct tty_struct
* tty
)
339 struct usb_serial_port
*port
= tty
->driver_data
;
344 dbg("%s - port %d", __FUNCTION__
, port
->number
);
346 if (!port
->open_count
) {
347 dbg ("%s - port not open", __FUNCTION__
);
351 /* pass on to the driver specific version of this function */
352 if (port
->serial
->type
->throttle
)
353 port
->serial
->type
->throttle(port
);
356 static void serial_unthrottle (struct tty_struct
* tty
)
358 struct usb_serial_port
*port
= tty
->driver_data
;
363 dbg("%s - port %d", __FUNCTION__
, port
->number
);
365 if (!port
->open_count
) {
366 dbg("%s - port not open", __FUNCTION__
);
370 /* pass on to the driver specific version of this function */
371 if (port
->serial
->type
->unthrottle
)
372 port
->serial
->type
->unthrottle(port
);
375 static int serial_ioctl (struct tty_struct
*tty
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
377 struct usb_serial_port
*port
= tty
->driver_data
;
378 int retval
= -ENODEV
;
383 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
385 if (!port
->open_count
) {
386 dbg ("%s - port not open", __FUNCTION__
);
390 /* pass on to the driver specific version of this function if it is available */
391 if (port
->serial
->type
->ioctl
)
392 retval
= port
->serial
->type
->ioctl(port
, file
, cmd
, arg
);
394 retval
= -ENOIOCTLCMD
;
400 static void serial_set_termios (struct tty_struct
*tty
, struct termios
* old
)
402 struct usb_serial_port
*port
= tty
->driver_data
;
407 dbg("%s - port %d", __FUNCTION__
, port
->number
);
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
->set_termios
)
416 port
->serial
->type
->set_termios(port
, old
);
419 static void serial_break (struct tty_struct
*tty
, int break_state
)
421 struct usb_serial_port
*port
= tty
->driver_data
;
426 dbg("%s - port %d", __FUNCTION__
, port
->number
);
428 if (!port
->open_count
) {
429 dbg("%s - port not open", __FUNCTION__
);
433 /* pass on to the driver specific version of this function if it is available */
434 if (port
->serial
->type
->break_ctl
)
435 port
->serial
->type
->break_ctl(port
, break_state
);
438 static int serial_read_proc (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
440 struct usb_serial
*serial
;
446 dbg("%s", __FUNCTION__
);
447 length
+= sprintf (page
, "usbserinfo:1.0 driver:2.0\n");
448 for (i
= 0; i
< SERIAL_TTY_MINORS
&& length
< PAGE_SIZE
; ++i
) {
449 serial
= usb_serial_get_by_index(i
);
453 length
+= sprintf (page
+length
, "%d:", i
);
454 if (serial
->type
->driver
.owner
)
455 length
+= sprintf (page
+length
, " module:%s", module_name(serial
->type
->driver
.owner
));
456 length
+= sprintf (page
+length
, " name:\"%s\"", serial
->type
->description
);
457 length
+= sprintf (page
+length
, " vendor:%04x product:%04x",
458 le16_to_cpu(serial
->dev
->descriptor
.idVendor
),
459 le16_to_cpu(serial
->dev
->descriptor
.idProduct
));
460 length
+= sprintf (page
+length
, " num_ports:%d", serial
->num_ports
);
461 length
+= sprintf (page
+length
, " port:%d", i
- serial
->minor
+ 1);
463 usb_make_path(serial
->dev
, tmp
, sizeof(tmp
));
464 length
+= sprintf (page
+length
, " path:%s", tmp
);
466 length
+= sprintf (page
+length
, "\n");
467 if ((length
+ begin
) > (off
+ count
))
469 if ((length
+ begin
) < off
) {
473 usb_serial_put(serial
);
477 if (off
>= (length
+ begin
))
479 *start
= page
+ (off
-begin
);
480 return ((count
< begin
+length
-off
) ? count
: begin
+length
-off
);
483 static int serial_tiocmget (struct tty_struct
*tty
, struct file
*file
)
485 struct usb_serial_port
*port
= tty
->driver_data
;
490 dbg("%s - port %d", __FUNCTION__
, port
->number
);
492 if (!port
->open_count
) {
493 dbg("%s - port not open", __FUNCTION__
);
497 if (port
->serial
->type
->tiocmget
)
498 return port
->serial
->type
->tiocmget(port
, file
);
503 static int serial_tiocmset (struct tty_struct
*tty
, struct file
*file
,
504 unsigned int set
, unsigned int clear
)
506 struct usb_serial_port
*port
= tty
->driver_data
;
511 dbg("%s - port %d", __FUNCTION__
, port
->number
);
513 if (!port
->open_count
) {
514 dbg("%s - port not open", __FUNCTION__
);
518 if (port
->serial
->type
->tiocmset
)
519 return port
->serial
->type
->tiocmset(port
, file
, set
, clear
);
525 * We would be calling tty_wakeup here, but unfortunately some line
526 * disciplines have an annoying habit of calling tty->write from
527 * the write wakeup callback (e.g. n_hdlc.c).
529 void usb_serial_port_softint(struct usb_serial_port
*port
)
531 schedule_work(&port
->work
);
534 static void usb_serial_port_work(void *private)
536 struct usb_serial_port
*port
= private;
537 struct tty_struct
*tty
;
539 dbg("%s - port %d", __FUNCTION__
, port
->number
);
551 static void port_release(struct device
*dev
)
553 struct usb_serial_port
*port
= to_usb_serial_port(dev
);
555 dbg ("%s - %s", __FUNCTION__
, dev
->bus_id
);
559 static void port_free(struct usb_serial_port
*port
)
561 usb_kill_urb(port
->read_urb
);
562 usb_free_urb(port
->read_urb
);
563 usb_kill_urb(port
->write_urb
);
564 usb_free_urb(port
->write_urb
);
565 usb_kill_urb(port
->interrupt_in_urb
);
566 usb_free_urb(port
->interrupt_in_urb
);
567 usb_kill_urb(port
->interrupt_out_urb
);
568 usb_free_urb(port
->interrupt_out_urb
);
569 kfree(port
->bulk_in_buffer
);
570 kfree(port
->bulk_out_buffer
);
571 kfree(port
->interrupt_in_buffer
);
572 kfree(port
->interrupt_out_buffer
);
573 flush_scheduled_work(); /* port->work */
577 static struct usb_serial
* create_serial (struct usb_device
*dev
,
578 struct usb_interface
*interface
,
579 struct usb_serial_driver
*driver
)
581 struct usb_serial
*serial
;
583 serial
= kzalloc(sizeof(*serial
), GFP_KERNEL
);
585 dev_err(&dev
->dev
, "%s - out of memory\n", __FUNCTION__
);
588 serial
->dev
= usb_get_dev(dev
);
589 serial
->type
= driver
;
590 serial
->interface
= interface
;
591 kref_init(&serial
->kref
);
596 static struct usb_serial_driver
*search_serial_device(struct usb_interface
*iface
)
599 const struct usb_device_id
*id
;
600 struct usb_serial_driver
*t
;
602 /* Check if the usb id matches a known device */
603 list_for_each(p
, &usb_serial_driver_list
) {
604 t
= list_entry(p
, struct usb_serial_driver
, driver_list
);
605 id
= usb_match_id(iface
, t
->id_table
);
607 dbg("descriptor matches");
615 int usb_serial_probe(struct usb_interface
*interface
,
616 const struct usb_device_id
*id
)
618 struct usb_device
*dev
= interface_to_usbdev (interface
);
619 struct usb_serial
*serial
= NULL
;
620 struct usb_serial_port
*port
;
621 struct usb_host_interface
*iface_desc
;
622 struct usb_endpoint_descriptor
*endpoint
;
623 struct usb_endpoint_descriptor
*interrupt_in_endpoint
[MAX_NUM_PORTS
];
624 struct usb_endpoint_descriptor
*interrupt_out_endpoint
[MAX_NUM_PORTS
];
625 struct usb_endpoint_descriptor
*bulk_in_endpoint
[MAX_NUM_PORTS
];
626 struct usb_endpoint_descriptor
*bulk_out_endpoint
[MAX_NUM_PORTS
];
627 struct usb_serial_driver
*type
= NULL
;
632 int num_interrupt_in
= 0;
633 int num_interrupt_out
= 0;
635 int num_bulk_out
= 0;
639 type
= search_serial_device(interface
);
645 serial
= create_serial (dev
, interface
, type
);
647 dev_err(&interface
->dev
, "%s - out of memory\n", __FUNCTION__
);
651 /* if this device type has a probe function, call it */
653 const struct usb_device_id
*id
;
655 if (!try_module_get(type
->driver
.owner
)) {
656 dev_err(&interface
->dev
, "module get failed, exiting\n");
661 id
= usb_match_id(interface
, type
->id_table
);
662 retval
= type
->probe(serial
, id
);
663 module_put(type
->driver
.owner
);
666 dbg ("sub driver rejected device");
672 /* descriptor matches, let's find the endpoints needed */
673 /* check out the endpoints */
674 iface_desc
= interface
->cur_altsetting
;
675 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
676 endpoint
= &iface_desc
->endpoint
[i
].desc
;
678 if ((endpoint
->bEndpointAddress
& 0x80) &&
679 ((endpoint
->bmAttributes
& 3) == 0x02)) {
680 /* we found a bulk in endpoint */
681 dbg("found bulk in on endpoint %d", i
);
682 bulk_in_endpoint
[num_bulk_in
] = endpoint
;
686 if (((endpoint
->bEndpointAddress
& 0x80) == 0x00) &&
687 ((endpoint
->bmAttributes
& 3) == 0x02)) {
688 /* we found a bulk out endpoint */
689 dbg("found bulk out on endpoint %d", i
);
690 bulk_out_endpoint
[num_bulk_out
] = endpoint
;
694 if ((endpoint
->bEndpointAddress
& 0x80) &&
695 ((endpoint
->bmAttributes
& 3) == 0x03)) {
696 /* we found a interrupt in endpoint */
697 dbg("found interrupt in on endpoint %d", i
);
698 interrupt_in_endpoint
[num_interrupt_in
] = endpoint
;
702 if (((endpoint
->bEndpointAddress
& 0x80) == 0x00) &&
703 ((endpoint
->bmAttributes
& 3) == 0x03)) {
704 /* we found an interrupt out endpoint */
705 dbg("found interrupt out on endpoint %d", i
);
706 interrupt_out_endpoint
[num_interrupt_out
] = endpoint
;
711 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
712 /* BEGIN HORRIBLE HACK FOR PL2303 */
713 /* this is needed due to the looney way its endpoints are set up */
714 if (((le16_to_cpu(dev
->descriptor
.idVendor
) == PL2303_VENDOR_ID
) &&
715 (le16_to_cpu(dev
->descriptor
.idProduct
) == PL2303_PRODUCT_ID
)) ||
716 ((le16_to_cpu(dev
->descriptor
.idVendor
) == ATEN_VENDOR_ID
) &&
717 (le16_to_cpu(dev
->descriptor
.idProduct
) == ATEN_PRODUCT_ID
))) {
718 if (interface
!= dev
->actconfig
->interface
[0]) {
719 /* check out the endpoints of the other interface*/
720 iface_desc
= dev
->actconfig
->interface
[0]->cur_altsetting
;
721 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
722 endpoint
= &iface_desc
->endpoint
[i
].desc
;
723 if ((endpoint
->bEndpointAddress
& 0x80) &&
724 ((endpoint
->bmAttributes
& 3) == 0x03)) {
725 /* we found a interrupt in endpoint */
726 dbg("found interrupt in for Prolific device on separate interface");
727 interrupt_in_endpoint
[num_interrupt_in
] = endpoint
;
733 /* Now make sure the PL-2303 is configured correctly.
734 * If not, give up now and hope this hack will work
735 * properly during a later invocation of usb_serial_probe
737 if (num_bulk_in
== 0 || num_bulk_out
== 0) {
738 dev_info(&interface
->dev
, "PL-2303 hack: descriptors matched but endpoints did not\n");
743 /* END HORRIBLE HACK FOR PL2303 */
746 /* found all that we need */
747 dev_info(&interface
->dev
, "%s converter detected\n", type
->description
);
749 #ifdef CONFIG_USB_SERIAL_GENERIC
750 if (type
== &usb_serial_generic_device
) {
751 num_ports
= num_bulk_out
;
752 if (num_ports
== 0) {
753 dev_err(&interface
->dev
, "Generic device with no bulk out, not allowed.\n");
760 /* if this device type has a calc_num_ports function, call it */
761 if (type
->calc_num_ports
) {
762 if (!try_module_get(type
->driver
.owner
)) {
763 dev_err(&interface
->dev
, "module get failed, exiting\n");
767 num_ports
= type
->calc_num_ports (serial
);
768 module_put(type
->driver
.owner
);
771 num_ports
= type
->num_ports
;
774 if (get_free_serial (serial
, num_ports
, &minor
) == NULL
) {
775 dev_err(&interface
->dev
, "No more free serial devices\n");
780 serial
->minor
= minor
;
781 serial
->num_ports
= num_ports
;
782 serial
->num_bulk_in
= num_bulk_in
;
783 serial
->num_bulk_out
= num_bulk_out
;
784 serial
->num_interrupt_in
= num_interrupt_in
;
785 serial
->num_interrupt_out
= num_interrupt_out
;
787 /* create our ports, we need as many as the max endpoints */
788 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
789 max_endpoints
= max(num_bulk_in
, num_bulk_out
);
790 max_endpoints
= max(max_endpoints
, num_interrupt_in
);
791 max_endpoints
= max(max_endpoints
, num_interrupt_out
);
792 max_endpoints
= max(max_endpoints
, (int)serial
->num_ports
);
793 serial
->num_port_pointers
= max_endpoints
;
794 dbg("%s - setting up %d port structures for this device", __FUNCTION__
, max_endpoints
);
795 for (i
= 0; i
< max_endpoints
; ++i
) {
796 port
= kzalloc(sizeof(struct usb_serial_port
), GFP_KERNEL
);
799 port
->number
= i
+ serial
->minor
;
800 port
->serial
= serial
;
801 spin_lock_init(&port
->lock
);
802 mutex_init(&port
->mutex
);
803 INIT_WORK(&port
->work
, usb_serial_port_work
, port
);
804 serial
->port
[i
] = port
;
807 /* set up the endpoint information */
808 for (i
= 0; i
< num_bulk_in
; ++i
) {
809 endpoint
= bulk_in_endpoint
[i
];
810 port
= serial
->port
[i
];
811 port
->read_urb
= usb_alloc_urb (0, GFP_KERNEL
);
812 if (!port
->read_urb
) {
813 dev_err(&interface
->dev
, "No free urbs available\n");
816 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
817 port
->bulk_in_size
= buffer_size
;
818 port
->bulk_in_endpointAddress
= endpoint
->bEndpointAddress
;
819 port
->bulk_in_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
820 if (!port
->bulk_in_buffer
) {
821 dev_err(&interface
->dev
, "Couldn't allocate bulk_in_buffer\n");
824 usb_fill_bulk_urb (port
->read_urb
, dev
,
825 usb_rcvbulkpipe (dev
,
826 endpoint
->bEndpointAddress
),
827 port
->bulk_in_buffer
, buffer_size
,
828 serial
->type
->read_bulk_callback
,
832 for (i
= 0; i
< num_bulk_out
; ++i
) {
833 endpoint
= bulk_out_endpoint
[i
];
834 port
= serial
->port
[i
];
835 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
836 if (!port
->write_urb
) {
837 dev_err(&interface
->dev
, "No free urbs available\n");
840 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
841 port
->bulk_out_size
= buffer_size
;
842 port
->bulk_out_endpointAddress
= endpoint
->bEndpointAddress
;
843 port
->bulk_out_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
844 if (!port
->bulk_out_buffer
) {
845 dev_err(&interface
->dev
, "Couldn't allocate bulk_out_buffer\n");
848 usb_fill_bulk_urb (port
->write_urb
, dev
,
849 usb_sndbulkpipe (dev
,
850 endpoint
->bEndpointAddress
),
851 port
->bulk_out_buffer
, buffer_size
,
852 serial
->type
->write_bulk_callback
,
856 if (serial
->type
->read_int_callback
) {
857 for (i
= 0; i
< num_interrupt_in
; ++i
) {
858 endpoint
= interrupt_in_endpoint
[i
];
859 port
= serial
->port
[i
];
860 port
->interrupt_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
861 if (!port
->interrupt_in_urb
) {
862 dev_err(&interface
->dev
, "No free urbs available\n");
865 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
866 port
->interrupt_in_endpointAddress
= endpoint
->bEndpointAddress
;
867 port
->interrupt_in_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
868 if (!port
->interrupt_in_buffer
) {
869 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_buffer\n");
872 usb_fill_int_urb (port
->interrupt_in_urb
, dev
,
874 endpoint
->bEndpointAddress
),
875 port
->interrupt_in_buffer
, buffer_size
,
876 serial
->type
->read_int_callback
, port
,
877 endpoint
->bInterval
);
879 } else if (num_interrupt_in
) {
880 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
883 if (serial
->type
->write_int_callback
) {
884 for (i
= 0; i
< num_interrupt_out
; ++i
) {
885 endpoint
= interrupt_out_endpoint
[i
];
886 port
= serial
->port
[i
];
887 port
->interrupt_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
888 if (!port
->interrupt_out_urb
) {
889 dev_err(&interface
->dev
, "No free urbs available\n");
892 buffer_size
= le16_to_cpu(endpoint
->wMaxPacketSize
);
893 port
->interrupt_out_size
= buffer_size
;
894 port
->interrupt_out_endpointAddress
= endpoint
->bEndpointAddress
;
895 port
->interrupt_out_buffer
= kmalloc (buffer_size
, GFP_KERNEL
);
896 if (!port
->interrupt_out_buffer
) {
897 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_buffer\n");
900 usb_fill_int_urb (port
->interrupt_out_urb
, dev
,
902 endpoint
->bEndpointAddress
),
903 port
->interrupt_out_buffer
, buffer_size
,
904 serial
->type
->write_int_callback
, port
,
905 endpoint
->bInterval
);
907 } else if (num_interrupt_out
) {
908 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
911 /* if this device type has an attach function, call it */
913 if (!try_module_get(type
->driver
.owner
)) {
914 dev_err(&interface
->dev
, "module get failed, exiting\n");
917 retval
= type
->attach (serial
);
918 module_put(type
->driver
.owner
);
922 /* quietly accept this device, but don't bind to a serial port
923 * as it's about to disappear */
928 /* register all of the individual ports with the driver core */
929 for (i
= 0; i
< num_ports
; ++i
) {
930 port
= serial
->port
[i
];
931 port
->dev
.parent
= &interface
->dev
;
932 port
->dev
.driver
= NULL
;
933 port
->dev
.bus
= &usb_serial_bus_type
;
934 port
->dev
.release
= &port_release
;
936 snprintf (&port
->dev
.bus_id
[0], sizeof(port
->dev
.bus_id
), "ttyUSB%d", port
->number
);
937 dbg ("%s - registering %s", __FUNCTION__
, port
->dev
.bus_id
);
938 device_register (&port
->dev
);
941 usb_serial_console_init (debug
, minor
);
945 usb_set_intfdata (interface
, serial
);
949 for (i
= 0; i
< num_bulk_in
; ++i
) {
950 port
= serial
->port
[i
];
954 usb_free_urb (port
->read_urb
);
955 kfree(port
->bulk_in_buffer
);
957 for (i
= 0; i
< num_bulk_out
; ++i
) {
958 port
= serial
->port
[i
];
962 usb_free_urb (port
->write_urb
);
963 kfree(port
->bulk_out_buffer
);
965 for (i
= 0; i
< num_interrupt_in
; ++i
) {
966 port
= serial
->port
[i
];
969 if (port
->interrupt_in_urb
)
970 usb_free_urb (port
->interrupt_in_urb
);
971 kfree(port
->interrupt_in_buffer
);
973 for (i
= 0; i
< num_interrupt_out
; ++i
) {
974 port
= serial
->port
[i
];
977 if (port
->interrupt_out_urb
)
978 usb_free_urb (port
->interrupt_out_urb
);
979 kfree(port
->interrupt_out_buffer
);
982 /* return the minor range that this device had */
983 return_serial (serial
);
985 /* free up any memory that we allocated */
986 for (i
= 0; i
< serial
->num_port_pointers
; ++i
)
987 kfree(serial
->port
[i
]);
992 void usb_serial_disconnect(struct usb_interface
*interface
)
995 struct usb_serial
*serial
= usb_get_intfdata (interface
);
996 struct device
*dev
= &interface
->dev
;
997 struct usb_serial_port
*port
;
999 usb_serial_console_disconnect(serial
);
1000 dbg ("%s", __FUNCTION__
);
1002 usb_set_intfdata (interface
, NULL
);
1004 for (i
= 0; i
< serial
->num_ports
; ++i
) {
1005 port
= serial
->port
[i
];
1006 if (port
&& port
->tty
)
1007 tty_hangup(port
->tty
);
1009 /* let the last holder of this object
1010 * cause it to be cleaned up */
1011 usb_serial_put(serial
);
1013 dev_info(dev
, "device disconnected\n");
1016 static struct tty_operations serial_ops
= {
1017 .open
= serial_open
,
1018 .close
= serial_close
,
1019 .write
= serial_write
,
1020 .write_room
= serial_write_room
,
1021 .ioctl
= serial_ioctl
,
1022 .set_termios
= serial_set_termios
,
1023 .throttle
= serial_throttle
,
1024 .unthrottle
= serial_unthrottle
,
1025 .break_ctl
= serial_break
,
1026 .chars_in_buffer
= serial_chars_in_buffer
,
1027 .read_proc
= serial_read_proc
,
1028 .tiocmget
= serial_tiocmget
,
1029 .tiocmset
= serial_tiocmset
,
1032 struct tty_driver
*usb_serial_tty_driver
;
1034 static int __init
usb_serial_init(void)
1039 usb_serial_tty_driver
= alloc_tty_driver(SERIAL_TTY_MINORS
);
1040 if (!usb_serial_tty_driver
)
1043 /* Initialize our global data */
1044 for (i
= 0; i
< SERIAL_TTY_MINORS
; ++i
) {
1045 serial_table
[i
] = NULL
;
1048 result
= bus_register(&usb_serial_bus_type
);
1050 err("%s - registering bus driver failed", __FUNCTION__
);
1054 usb_serial_tty_driver
->owner
= THIS_MODULE
;
1055 usb_serial_tty_driver
->driver_name
= "usbserial";
1056 usb_serial_tty_driver
->name
= "ttyUSB";
1057 usb_serial_tty_driver
->major
= SERIAL_TTY_MAJOR
;
1058 usb_serial_tty_driver
->minor_start
= 0;
1059 usb_serial_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1060 usb_serial_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1061 usb_serial_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1062 usb_serial_tty_driver
->init_termios
= tty_std_termios
;
1063 usb_serial_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1064 tty_set_operations(usb_serial_tty_driver
, &serial_ops
);
1065 result
= tty_register_driver(usb_serial_tty_driver
);
1067 err("%s - tty_register_driver failed", __FUNCTION__
);
1068 goto exit_reg_driver
;
1071 /* register the USB driver */
1072 result
= usb_register(&usb_serial_driver
);
1074 err("%s - usb_register failed", __FUNCTION__
);
1078 /* register the generic driver, if we should */
1079 result
= usb_serial_generic_register(debug
);
1081 err("%s - registering generic driver failed", __FUNCTION__
);
1090 usb_deregister(&usb_serial_driver
);
1093 tty_unregister_driver(usb_serial_tty_driver
);
1096 bus_unregister(&usb_serial_bus_type
);
1099 err ("%s - returning with error %d", __FUNCTION__
, result
);
1100 put_tty_driver(usb_serial_tty_driver
);
1105 static void __exit
usb_serial_exit(void)
1107 usb_serial_console_exit();
1109 usb_serial_generic_deregister();
1111 usb_deregister(&usb_serial_driver
);
1112 tty_unregister_driver(usb_serial_tty_driver
);
1113 put_tty_driver(usb_serial_tty_driver
);
1114 bus_unregister(&usb_serial_bus_type
);
1118 module_init(usb_serial_init
);
1119 module_exit(usb_serial_exit
);
1121 #define set_to_generic_if_null(type, function) \
1123 if (!type->function) { \
1124 type->function = usb_serial_generic_##function; \
1125 dbg("Had to override the " #function \
1126 " usb serial operation with the generic one.");\
1130 static void fixup_generic(struct usb_serial_driver
*device
)
1132 set_to_generic_if_null(device
, open
);
1133 set_to_generic_if_null(device
, write
);
1134 set_to_generic_if_null(device
, close
);
1135 set_to_generic_if_null(device
, write_room
);
1136 set_to_generic_if_null(device
, chars_in_buffer
);
1137 set_to_generic_if_null(device
, read_bulk_callback
);
1138 set_to_generic_if_null(device
, write_bulk_callback
);
1139 set_to_generic_if_null(device
, shutdown
);
1142 int usb_serial_register(struct usb_serial_driver
*driver
)
1146 fixup_generic(driver
);
1148 if (!driver
->description
)
1149 driver
->description
= driver
->driver
.name
;
1151 /* Add this device to our list of devices */
1152 list_add(&driver
->driver_list
, &usb_serial_driver_list
);
1154 retval
= usb_serial_bus_register(driver
);
1156 err("problem %d when registering driver %s", retval
, driver
->description
);
1157 list_del(&driver
->driver_list
);
1160 info("USB Serial support registered for %s", driver
->description
);
1166 void usb_serial_deregister(struct usb_serial_driver
*device
)
1168 info("USB Serial deregistering driver %s", device
->description
);
1169 list_del(&device
->driver_list
);
1170 usb_serial_bus_deregister(device
);
1175 /* If the usb-serial core is built into the core, the usb-serial drivers
1176 need these symbols to load properly as modules. */
1177 EXPORT_SYMBOL_GPL(usb_serial_register
);
1178 EXPORT_SYMBOL_GPL(usb_serial_deregister
);
1179 EXPORT_SYMBOL_GPL(usb_serial_probe
);
1180 EXPORT_SYMBOL_GPL(usb_serial_disconnect
);
1181 EXPORT_SYMBOL_GPL(usb_serial_port_softint
);
1184 /* Module information */
1185 MODULE_AUTHOR( DRIVER_AUTHOR
);
1186 MODULE_DESCRIPTION( DRIVER_DESC
);
1187 MODULE_LICENSE("GPL");
1189 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1190 MODULE_PARM_DESC(debug
, "Debug enabled or not");