2 USB Driver for GSM modems
4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de>
6 This driver is free software; you can redistribute it and/or modify
7 it under the terms of Version 2 of the GNU General Public License as
8 published by the Free Software Foundation.
10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
12 History: see the git log.
14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
16 This driver exists because the "normal" serial driver doesn't work too well
17 with GSM modems. Issues:
18 - data loss -- one single Receive URB is not nearly enough
19 - nonstandard flow (Option devices) control
20 - controlling the baud rate doesn't make sense
22 This driver is named "option" because the most common device it's
23 used for is a PC-Card (with an internal OHCI-USB interface, behind
24 which the GSM interface sits), made by Option Inc.
26 Some of the "one port" devices actually exhibit multiple USB instances
27 on the USB bus. This is not a bug, these ports are used for different
31 #define DRIVER_VERSION "v0.7.1"
32 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
33 #define DRIVER_DESC "USB Driver for GSM modems"
35 #include <linux/kernel.h>
36 #include <linux/jiffies.h>
37 #include <linux/errno.h>
38 #include <linux/tty.h>
39 #include <linux/tty_flip.h>
40 #include <linux/module.h>
41 #include <linux/usb.h>
42 #include <linux/usb/serial.h>
44 /* Function prototypes */
45 static int option_open(struct usb_serial_port *port, struct file *filp);
46 static void option_close(struct usb_serial_port *port, struct file *filp);
47 static int option_startup(struct usb_serial *serial);
48 static void option_shutdown(struct usb_serial *serial);
49 static void option_rx_throttle(struct usb_serial_port *port);
50 static void option_rx_unthrottle(struct usb_serial_port *port);
51 static int option_write_room(struct usb_serial_port *port);
53 static void option_instat_callback(struct urb *urb, struct pt_regs *regs);
55 static int option_write(struct usb_serial_port *port,
56 const unsigned char *buf, int count);
58 static int option_chars_in_buffer(struct usb_serial_port *port);
59 static int option_ioctl(struct usb_serial_port *port, struct file *file,
60 unsigned int cmd, unsigned long arg);
61 static void option_set_termios(struct usb_serial_port *port,
63 static void option_break_ctl(struct usb_serial_port *port, int break_state);
64 static int option_tiocmget(struct usb_serial_port *port, struct file *file);
65 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
66 unsigned int set, unsigned int clear);
67 static int option_send_setup(struct usb_serial_port *port);
69 /* Vendor and product IDs */
70 #define OPTION_VENDOR_ID 0x0AF0
71 #define HUAWEI_VENDOR_ID 0x12D1
72 #define AUDIOVOX_VENDOR_ID 0x0F3D
73 #define NOVATELWIRELESS_VENDOR_ID 0x1410
74 #define ANYDATA_VENDOR_ID 0x16d5
76 #define OPTION_PRODUCT_OLD 0x5000
77 #define OPTION_PRODUCT_FUSION 0x6000
78 #define OPTION_PRODUCT_FUSION2 0x6300
79 #define OPTION_PRODUCT_COBRA 0x6500
80 #define OPTION_PRODUCT_COBRA2 0x6600
81 #define HUAWEI_PRODUCT_E600 0x1001
82 #define AUDIOVOX_PRODUCT_AIRCARD 0x0112
83 #define NOVATELWIRELESS_PRODUCT_U740 0x1400
84 #define ANYDATA_PRODUCT_ID 0x6501
86 static struct usb_device_id option_ids[] = {
87 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
88 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
89 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
90 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
91 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
92 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
93 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
94 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
95 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
96 { } /* Terminating entry */
99 static struct usb_device_id option_ids1[] = {
100 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
101 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
102 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
103 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
104 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
105 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
106 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
107 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
108 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
109 { } /* Terminating entry */
111 static struct usb_device_id option_ids3[] = {
112 { } /* Terminating entry */
115 MODULE_DEVICE_TABLE(usb, option_ids);
117 static struct usb_driver option_driver = {
119 .probe = usb_serial_probe,
120 .disconnect = usb_serial_disconnect,
121 .id_table = option_ids,
125 /* The card has three separate interfaces, which the serial driver
126 * recognizes separately, thus num_port=1.
128 static struct usb_serial_driver option_3port_device = {
130 .owner = THIS_MODULE,
133 .description = "GSM modem (3-port)",
134 .id_table = option_ids3,
135 .num_interrupt_in = NUM_DONT_CARE,
136 .num_bulk_in = NUM_DONT_CARE,
137 .num_bulk_out = NUM_DONT_CARE,
140 .close = option_close,
141 .write = option_write,
142 .write_room = option_write_room,
143 .chars_in_buffer = option_chars_in_buffer,
144 .throttle = option_rx_throttle,
145 .unthrottle = option_rx_unthrottle,
146 .ioctl = option_ioctl,
147 .set_termios = option_set_termios,
148 .break_ctl = option_break_ctl,
149 .tiocmget = option_tiocmget,
150 .tiocmset = option_tiocmset,
151 .attach = option_startup,
152 .shutdown = option_shutdown,
153 .read_int_callback = option_instat_callback,
156 static struct usb_serial_driver option_1port_device = {
158 .owner = THIS_MODULE,
161 .description = "GSM modem (1-port)",
162 .id_table = option_ids1,
163 .num_interrupt_in = NUM_DONT_CARE,
164 .num_bulk_in = NUM_DONT_CARE,
165 .num_bulk_out = NUM_DONT_CARE,
168 .close = option_close,
169 .write = option_write,
170 .write_room = option_write_room,
171 .chars_in_buffer = option_chars_in_buffer,
172 .throttle = option_rx_throttle,
173 .unthrottle = option_rx_unthrottle,
174 .ioctl = option_ioctl,
175 .set_termios = option_set_termios,
176 .break_ctl = option_break_ctl,
177 .tiocmget = option_tiocmget,
178 .tiocmset = option_tiocmset,
179 .attach = option_startup,
180 .shutdown = option_shutdown,
181 .read_int_callback = option_instat_callback,
184 #ifdef CONFIG_USB_DEBUG
190 /* per port private data */
194 #define IN_BUFLEN 4096
195 #define OUT_BUFLEN 128
197 struct option_port_private {
198 /* Input endpoints and buffer for this port */
199 struct urb *in_urbs[N_IN_URB];
200 char in_buffer[N_IN_URB][IN_BUFLEN];
201 /* Output endpoints and buffer for this port */
202 struct urb *out_urbs[N_OUT_URB];
203 char out_buffer[N_OUT_URB][OUT_BUFLEN];
205 /* Settings for the port */
206 int rts_state; /* Handshaking pins (outputs) */
208 int cts_state; /* Handshaking pins (inputs) */
213 unsigned long tx_start_time[N_OUT_URB];
216 /* Functions used by new usb-serial code. */
217 static int __init option_init(void)
220 retval = usb_serial_register(&option_1port_device);
222 goto failed_1port_device_register;
223 retval = usb_serial_register(&option_3port_device);
225 goto failed_3port_device_register;
226 retval = usb_register(&option_driver);
228 goto failed_driver_register;
230 info(DRIVER_DESC ": " DRIVER_VERSION);
234 failed_driver_register:
235 usb_serial_deregister (&option_3port_device);
236 failed_3port_device_register:
237 usb_serial_deregister (&option_1port_device);
238 failed_1port_device_register:
242 static void __exit option_exit(void)
244 usb_deregister (&option_driver);
245 usb_serial_deregister (&option_3port_device);
246 usb_serial_deregister (&option_1port_device);
249 module_init(option_init);
250 module_exit(option_exit);
252 static void option_rx_throttle(struct usb_serial_port *port)
254 dbg("%s", __FUNCTION__);
257 static void option_rx_unthrottle(struct usb_serial_port *port)
259 dbg("%s", __FUNCTION__);
262 static void option_break_ctl(struct usb_serial_port *port, int break_state)
264 /* Unfortunately, I don't know how to send a break */
265 dbg("%s", __FUNCTION__);
268 static void option_set_termios(struct usb_serial_port *port,
269 struct termios *old_termios)
271 dbg("%s", __FUNCTION__);
273 option_send_setup(port);
276 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
279 struct option_port_private *portdata;
281 portdata = usb_get_serial_port_data(port);
283 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
284 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
285 ((portdata->cts_state) ? TIOCM_CTS : 0) |
286 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
287 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
288 ((portdata->ri_state) ? TIOCM_RNG : 0);
293 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
294 unsigned int set, unsigned int clear)
296 struct option_port_private *portdata;
298 portdata = usb_get_serial_port_data(port);
301 portdata->rts_state = 1;
303 portdata->dtr_state = 1;
305 if (clear & TIOCM_RTS)
306 portdata->rts_state = 0;
307 if (clear & TIOCM_DTR)
308 portdata->dtr_state = 0;
309 return option_send_setup(port);
312 static int option_ioctl(struct usb_serial_port *port, struct file *file,
313 unsigned int cmd, unsigned long arg)
319 static int option_write(struct usb_serial_port *port,
320 const unsigned char *buf, int count)
322 struct option_port_private *portdata;
325 struct urb *this_urb = NULL; /* spurious */
328 portdata = usb_get_serial_port_data(port);
330 dbg("%s: write (%d chars)", __FUNCTION__, count);
334 for (i=0; left > 0 && i < N_OUT_URB; i++) {
336 if (todo > OUT_BUFLEN)
339 this_urb = portdata->out_urbs[i];
340 if (this_urb->status == -EINPROGRESS) {
341 if (time_before(jiffies,
342 portdata->tx_start_time[i] + 10 * HZ))
344 usb_unlink_urb(this_urb);
347 if (this_urb->status != 0)
348 dbg("usb_write %p failed (err=%d)",
349 this_urb, this_urb->status);
351 dbg("%s: endpoint %d buf %d", __FUNCTION__,
352 usb_pipeendpoint(this_urb->pipe), i);
355 memcpy (this_urb->transfer_buffer, buf, todo);
356 this_urb->transfer_buffer_length = todo;
358 this_urb->dev = port->serial->dev;
359 err = usb_submit_urb(this_urb, GFP_ATOMIC);
361 dbg("usb_submit_urb %p (write bulk) failed "
362 "(%d, has %d)", this_urb,
363 err, this_urb->status);
366 portdata->tx_start_time[i] = jiffies;
372 dbg("%s: wrote (did %d)", __FUNCTION__, count);
376 static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
380 struct usb_serial_port *port;
381 struct tty_struct *tty;
382 unsigned char *data = urb->transfer_buffer;
384 dbg("%s: %p", __FUNCTION__, urb);
386 endpoint = usb_pipeendpoint(urb->pipe);
387 port = (struct usb_serial_port *) urb->context;
390 dbg("%s: nonzero status: %d on endpoint %02x.",
391 __FUNCTION__, urb->status, endpoint);
394 if (urb->actual_length) {
395 tty_buffer_request_room(tty, urb->actual_length);
396 tty_insert_flip_string(tty, data, urb->actual_length);
397 tty_flip_buffer_push(tty);
399 dbg("%s: empty read urb received", __FUNCTION__);
402 /* Resubmit urb so we continue receiving */
403 if (port->open_count && urb->status != -ESHUTDOWN) {
404 err = usb_submit_urb(urb, GFP_ATOMIC);
406 printk(KERN_ERR "%s: resubmit read urb failed. "
407 "(%d)", __FUNCTION__, err);
413 static void option_outdat_callback(struct urb *urb, struct pt_regs *regs)
415 struct usb_serial_port *port;
417 dbg("%s", __FUNCTION__);
419 port = (struct usb_serial_port *) urb->context;
421 usb_serial_port_softint(port);
424 static void option_instat_callback(struct urb *urb, struct pt_regs *regs)
427 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
428 struct option_port_private *portdata = usb_get_serial_port_data(port);
429 struct usb_serial *serial = port->serial;
431 dbg("%s", __FUNCTION__);
432 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
434 if (urb->status == 0) {
435 struct usb_ctrlrequest *req_pkt =
436 (struct usb_ctrlrequest *)urb->transfer_buffer;
439 dbg("%s: NULL req_pkt\n", __FUNCTION__);
442 if ((req_pkt->bRequestType == 0xA1) &&
443 (req_pkt->bRequest == 0x20)) {
445 unsigned char signals = *((unsigned char *)
446 urb->transfer_buffer +
447 sizeof(struct usb_ctrlrequest));
449 dbg("%s: signal x%x", __FUNCTION__, signals);
451 old_dcd_state = portdata->dcd_state;
452 portdata->cts_state = 1;
453 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
454 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
455 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
457 if (port->tty && !C_CLOCAL(port->tty) &&
458 old_dcd_state && !portdata->dcd_state)
459 tty_hangup(port->tty);
461 dbg("%s: type %x req %x", __FUNCTION__,
462 req_pkt->bRequestType,req_pkt->bRequest);
465 dbg("%s: error %d", __FUNCTION__, urb->status);
467 /* Resubmit urb so we continue receiving IRQ data */
468 if (urb->status != -ESHUTDOWN) {
469 urb->dev = serial->dev;
470 err = usb_submit_urb(urb, GFP_ATOMIC);
472 dbg("%s: resubmit intr urb failed. (%d)",
477 static int option_write_room(struct usb_serial_port *port)
479 struct option_port_private *portdata;
482 struct urb *this_urb;
484 portdata = usb_get_serial_port_data(port);
486 for (i=0; i < N_OUT_URB; i++) {
487 this_urb = portdata->out_urbs[i];
488 if (this_urb && this_urb->status != -EINPROGRESS)
489 data_len += OUT_BUFLEN;
492 dbg("%s: %d", __FUNCTION__, data_len);
496 static int option_chars_in_buffer(struct usb_serial_port *port)
498 struct option_port_private *portdata;
501 struct urb *this_urb;
503 portdata = usb_get_serial_port_data(port);
505 for (i=0; i < N_OUT_URB; i++) {
506 this_urb = portdata->out_urbs[i];
507 if (this_urb && this_urb->status == -EINPROGRESS)
508 data_len += this_urb->transfer_buffer_length;
510 dbg("%s: %d", __FUNCTION__, data_len);
514 static int option_open(struct usb_serial_port *port, struct file *filp)
516 struct option_port_private *portdata;
517 struct usb_serial *serial = port->serial;
521 portdata = usb_get_serial_port_data(port);
523 dbg("%s", __FUNCTION__);
525 /* Set some sane defaults */
526 portdata->rts_state = 1;
527 portdata->dtr_state = 1;
529 /* Reset low level data toggle and start reading from endpoints */
530 for (i = 0; i < N_IN_URB; i++) {
531 urb = portdata->in_urbs[i];
534 if (urb->dev != serial->dev) {
535 dbg("%s: dev %p != %p", __FUNCTION__,
536 urb->dev, serial->dev);
541 * make sure endpoint data toggle is synchronized with the
544 usb_clear_halt(urb->dev, urb->pipe);
546 err = usb_submit_urb(urb, GFP_KERNEL);
548 dbg("%s: submit urb %d failed (%d) %d",
549 __FUNCTION__, i, err,
550 urb->transfer_buffer_length);
554 /* Reset low level data toggle on out endpoints */
555 for (i = 0; i < N_OUT_URB; i++) {
556 urb = portdata->out_urbs[i];
559 urb->dev = serial->dev;
560 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
561 usb_pipeout(urb->pipe), 0); */
564 port->tty->low_latency = 1;
566 option_send_setup(port);
571 static inline void stop_urb(struct urb *urb)
573 if (urb && urb->status == -EINPROGRESS)
577 static void option_close(struct usb_serial_port *port, struct file *filp)
580 struct usb_serial *serial = port->serial;
581 struct option_port_private *portdata;
583 dbg("%s", __FUNCTION__);
584 portdata = usb_get_serial_port_data(port);
586 portdata->rts_state = 0;
587 portdata->dtr_state = 0;
590 option_send_setup(port);
592 /* Stop reading/writing urbs */
593 for (i = 0; i < N_IN_URB; i++)
594 stop_urb(portdata->in_urbs[i]);
595 for (i = 0; i < N_OUT_URB; i++)
596 stop_urb(portdata->out_urbs[i]);
601 /* Helper functions used by option_setup_urbs */
602 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
603 int dir, void *ctx, char *buf, int len,
604 void (*callback)(struct urb *, struct pt_regs *regs))
609 return NULL; /* endpoint not needed */
611 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
613 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
617 /* Fill URB using supplied data. */
618 usb_fill_bulk_urb(urb, serial->dev,
619 usb_sndbulkpipe(serial->dev, endpoint) | dir,
620 buf, len, callback, ctx);
626 static void option_setup_urbs(struct usb_serial *serial)
629 struct usb_serial_port *port;
630 struct option_port_private *portdata;
632 dbg("%s", __FUNCTION__);
634 for (i = 0; i < serial->num_ports; i++) {
635 port = serial->port[i];
636 portdata = usb_get_serial_port_data(port);
638 /* Do indat endpoints first */
639 for (j = 0; j < N_IN_URB; ++j) {
640 portdata->in_urbs[j] = option_setup_urb (serial,
641 port->bulk_in_endpointAddress, USB_DIR_IN, port,
642 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
645 /* outdat endpoints */
646 for (j = 0; j < N_OUT_URB; ++j) {
647 portdata->out_urbs[j] = option_setup_urb (serial,
648 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
649 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
654 static int option_send_setup(struct usb_serial_port *port)
656 struct usb_serial *serial = port->serial;
657 struct option_port_private *portdata;
659 dbg("%s", __FUNCTION__);
661 portdata = usb_get_serial_port_data(port);
665 if (portdata->dtr_state)
667 if (portdata->rts_state)
670 return usb_control_msg(serial->dev,
671 usb_rcvctrlpipe(serial->dev, 0),
672 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
678 static int option_startup(struct usb_serial *serial)
681 struct usb_serial_port *port;
682 struct option_port_private *portdata;
684 dbg("%s", __FUNCTION__);
686 /* Now setup per port private data */
687 for (i = 0; i < serial->num_ports; i++) {
688 port = serial->port[i];
689 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
691 dbg("%s: kmalloc for option_port_private (%d) failed!.",
696 usb_set_serial_port_data(port, portdata);
698 if (! port->interrupt_in_urb)
700 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
702 dbg("%s: submit irq_in urb failed %d",
706 option_setup_urbs(serial);
711 static void option_shutdown(struct usb_serial *serial)
714 struct usb_serial_port *port;
715 struct option_port_private *portdata;
717 dbg("%s", __FUNCTION__);
719 /* Stop reading/writing urbs */
720 for (i = 0; i < serial->num_ports; ++i) {
721 port = serial->port[i];
722 portdata = usb_get_serial_port_data(port);
723 for (j = 0; j < N_IN_URB; j++)
724 stop_urb(portdata->in_urbs[j]);
725 for (j = 0; j < N_OUT_URB; j++)
726 stop_urb(portdata->out_urbs[j]);
730 for (i = 0; i < serial->num_ports; ++i) {
731 port = serial->port[i];
732 portdata = usb_get_serial_port_data(port);
734 for (j = 0; j < N_IN_URB; j++) {
735 if (portdata->in_urbs[j]) {
736 usb_free_urb(portdata->in_urbs[j]);
737 portdata->in_urbs[j] = NULL;
740 for (j = 0; j < N_OUT_URB; j++) {
741 if (portdata->out_urbs[j]) {
742 usb_free_urb(portdata->out_urbs[j]);
743 portdata->out_urbs[j] = NULL;
748 /* Now free per port private data */
749 for (i = 0; i < serial->num_ports; i++) {
750 port = serial->port[i];
751 kfree(usb_get_serial_port_data(port));
755 MODULE_AUTHOR(DRIVER_AUTHOR);
756 MODULE_DESCRIPTION(DRIVER_DESC);
757 MODULE_VERSION(DRIVER_VERSION);
758 MODULE_LICENSE("GPL");
760 #ifdef CONFIG_USB_DEBUG
761 module_param(debug, bool, S_IRUGO | S_IWUSR);
762 MODULE_PARM_DESC(debug, "Debug messages");