2 * USB Serial Converter Generic functions
4 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
12 #include <linux/config.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/tty.h>
17 #include <linux/tty_flip.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/usb.h>
21 #include <asm/uaccess.h>
22 #include "usb-serial.h"
26 #ifdef CONFIG_USB_SERIAL_GENERIC
27 static __u16 vendor
= 0x05f9;
28 static __u16 product
= 0xffff;
30 module_param(vendor
, ushort
, 0);
31 MODULE_PARM_DESC(vendor
, "User specified USB idVendor");
33 module_param(product
, ushort
, 0);
34 MODULE_PARM_DESC(product
, "User specified USB idProduct");
36 #if 0 // Modified by Jared 10-02-2006
37 static struct usb_device_id generic_device_ids
[2]; /* Initially all zeroes. */
39 static struct usb_device_id generic_device_ids
[]= {
40 {.idVendor
=0xaf0, // Vodafone 3G datacard
42 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
44 {.idVendor
=0xaf0, // GlobalTrotter 3G
46 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
48 {.idVendor
=0xaf0, //GlobalTrotter Fusion
50 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
52 //{.idVendor=0xaf0, //GlobalTrotter Fusion
54 // .match_flags=USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT
56 {.idVendor
=0x12d1, // Huawei E612
58 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
60 {.idVendor
=0x12d1, // Huawei E220, HSDPA USB Modem
62 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
64 {.idVendor
=0x12d1, // Huawei E220, HSDPA USB Modem
66 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
68 {.idVendor
=0x1400, // NVW-U740
70 .match_flags
=USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
76 /* All of the device info needed for the Generic Serial Converter */
77 struct usb_serial_device_type usb_serial_generic_device
= {
80 .short_name
= "generic",
81 .id_table
= generic_device_ids
,
82 .num_interrupt_in
= NUM_DONT_CARE
,
83 .num_bulk_in
= NUM_DONT_CARE
,
84 .num_bulk_out
= NUM_DONT_CARE
,
86 .shutdown
= usb_serial_generic_shutdown
,
89 /* we want to look at all devices, as the vendor/product id can change
90 * depending on the command line argument */
91 static struct usb_device_id generic_serial_ids
[] = {
96 static int generic_probe(struct usb_interface
*interface
,
97 const struct usb_device_id
*id
)
99 const struct usb_device_id
*id_pattern
;
100 //__usb_reset_device(interface_to_usbdev(interface));
101 id_pattern
= usb_match_id(interface
, generic_device_ids
);
102 if (id_pattern
!= NULL
)
103 return usb_serial_probe(interface
, id
);
107 static struct usb_driver generic_driver
= {
108 .owner
= THIS_MODULE
,
109 .name
= "usbserial_generic",
110 .probe
= generic_probe
,
111 .disconnect
= usb_serial_disconnect
,
112 .id_table
= generic_serial_ids
,
116 int usb_serial_generic_register (int _debug
)
121 #ifdef CONFIG_USB_SERIAL_GENERIC
122 #if 0 // Masked by Jared 10-02-2006
123 generic_device_ids
[0].idVendor
= vendor
;
124 generic_device_ids
[0].idProduct
= product
;
125 generic_device_ids
[0].match_flags
= USB_DEVICE_ID_MATCH_VENDOR
| USB_DEVICE_ID_MATCH_PRODUCT
;
127 /* register our generic driver with ourselves */
128 retval
= usb_serial_register (&usb_serial_generic_device
);
131 retval
= usb_register(&generic_driver
);
133 usb_serial_deregister(&usb_serial_generic_device
);
139 void usb_serial_generic_deregister (void)
141 #ifdef CONFIG_USB_SERIAL_GENERIC
142 /* remove our generic driver */
143 usb_deregister(&generic_driver
);
144 usb_serial_deregister (&usb_serial_generic_device
);
148 int usb_serial_generic_open (struct usb_serial_port
*port
, struct file
*filp
)
150 struct usb_serial
*serial
= port
->serial
;
153 dbg("%s - port %d", __FUNCTION__
, port
->number
);
155 /* force low_latency on so that our tty_push actually forces the data through,
156 otherwise it is scheduled, and with high data rates (like with OHCI) data
159 port
->tty
->low_latency
= 1;
161 /* if we have a bulk interrupt, start reading from it */
162 if (serial
->num_bulk_in
) {
163 /* Start reading from the device */
164 usb_fill_bulk_urb (port
->read_urb
, serial
->dev
,
165 usb_rcvbulkpipe(serial
->dev
, port
->bulk_in_endpointAddress
),
166 port
->read_urb
->transfer_buffer
,
167 port
->read_urb
->transfer_buffer_length
,
168 ((serial
->type
->read_bulk_callback
) ?
169 serial
->type
->read_bulk_callback
:
170 usb_serial_generic_read_bulk_callback
),
172 result
= usb_submit_urb(port
->read_urb
, GFP_KERNEL
);
174 dev_err(&port
->dev
, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__
, result
);
180 static void generic_cleanup (struct usb_serial_port
*port
)
182 struct usb_serial
*serial
= port
->serial
;
184 dbg("%s - port %d", __FUNCTION__
, port
->number
);
187 /* shutdown any bulk reads that might be going on */
188 if (serial
->num_bulk_out
)
189 usb_unlink_urb (port
->write_urb
);
190 if (serial
->num_bulk_in
)
191 usb_unlink_urb (port
->read_urb
);
195 void usb_serial_generic_close (struct usb_serial_port
*port
, struct file
* filp
)
197 dbg("%s - port %d", __FUNCTION__
, port
->number
);
198 generic_cleanup (port
);
201 int usb_serial_generic_write (struct usb_serial_port
*port
, int from_user
, const unsigned char *buf
, int count
)
203 struct usb_serial
*serial
= port
->serial
;
207 dbg("%s - port %d", __FUNCTION__
, port
->number
);
210 dbg("%s - write request of 0 bytes", __FUNCTION__
);
214 /* only do something if we have a bulk out endpoint */
215 if (serial
->num_bulk_out
) {
216 if (port
->write_urb
->status
== -EINPROGRESS
) {
217 dbg("%s - already writing", __FUNCTION__
);
221 count
= (count
> port
->bulk_out_size
) ? port
->bulk_out_size
: count
;
224 if (copy_from_user(port
->write_urb
->transfer_buffer
, buf
, count
))
228 memcpy (port
->write_urb
->transfer_buffer
, buf
, count
);
230 data
= port
->write_urb
->transfer_buffer
;
231 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, count
, data
);
234 usb_fill_bulk_urb (port
->write_urb
, serial
->dev
,
235 usb_sndbulkpipe (serial
->dev
,
236 port
->bulk_out_endpointAddress
),
237 port
->write_urb
->transfer_buffer
, count
,
238 ((serial
->type
->write_bulk_callback
) ?
239 serial
->type
->write_bulk_callback
:
240 usb_serial_generic_write_bulk_callback
), port
);
242 /* send the data out the bulk port */
243 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
245 dev_err(&port
->dev
, "%s - failed submitting write urb, error %d\n", __FUNCTION__
, result
);
252 /* no bulk out, so return 0 bytes written */
256 int usb_serial_generic_write_room (struct usb_serial_port
*port
)
258 struct usb_serial
*serial
= port
->serial
;
261 dbg("%s - port %d", __FUNCTION__
, port
->number
);
263 if (serial
->num_bulk_out
) {
264 if (port
->write_urb
->status
!= -EINPROGRESS
)
265 room
= port
->bulk_out_size
;
268 dbg("%s - returns %d", __FUNCTION__
, room
);
272 int usb_serial_generic_chars_in_buffer (struct usb_serial_port
*port
)
274 struct usb_serial
*serial
= port
->serial
;
277 dbg("%s - port %d", __FUNCTION__
, port
->number
);
279 if (serial
->num_bulk_out
) {
280 if (port
->write_urb
->status
== -EINPROGRESS
)
281 chars
= port
->write_urb
->transfer_buffer_length
;
284 dbg("%s - returns %d", __FUNCTION__
, chars
);
288 void usb_serial_generic_read_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
)
290 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
291 struct usb_serial
*serial
= port
->serial
;
292 struct tty_struct
*tty
;
293 unsigned char *data
= urb
->transfer_buffer
;
297 dbg("%s - port %d", __FUNCTION__
, port
->number
);
300 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__
, urb
->status
);
304 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
307 if (tty
&& urb
->actual_length
) {
308 for (i
= 0; i
< urb
->actual_length
; ++i
) {
309 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
310 if(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
) {
311 tty_flip_buffer_push(tty
);
313 /* this doesn't actually push the data through unless tty->low_latency is set */
314 tty_insert_flip_char(tty
, data
[i
], 0);
316 tty_flip_buffer_push(tty
);
319 /* Continue trying to always read */
320 usb_fill_bulk_urb (port
->read_urb
, serial
->dev
,
321 usb_rcvbulkpipe (serial
->dev
,
322 port
->bulk_in_endpointAddress
),
323 port
->read_urb
->transfer_buffer
,
324 port
->read_urb
->transfer_buffer_length
,
325 ((serial
->type
->read_bulk_callback
) ?
326 serial
->type
->read_bulk_callback
:
327 usb_serial_generic_read_bulk_callback
), port
);
328 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
330 dev_err(&port
->dev
, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__
, result
);
333 void usb_serial_generic_write_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
)
335 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
337 dbg("%s - port %d", __FUNCTION__
, port
->number
);
340 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
344 usb_serial_port_softint((void *)port
);
346 schedule_work(&port
->work
);
349 void usb_serial_generic_shutdown (struct usb_serial
*serial
)
353 dbg("%s", __FUNCTION__
);
355 /* stop reads and writes on all ports */
356 for (i
=0; i
< serial
->num_ports
; ++i
) {
357 generic_cleanup(serial
->port
[i
]);