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);
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,
62 struct ktermios *old);
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 NOVATELWIRELESS_VENDOR_ID 0x1410
73 #define ANYDATA_VENDOR_ID 0x16d5
75 #define OPTION_PRODUCT_OLD 0x5000
76 #define OPTION_PRODUCT_FUSION 0x6000
77 #define OPTION_PRODUCT_FUSION2 0x6300
78 #define OPTION_PRODUCT_COBRA 0x6500
79 #define OPTION_PRODUCT_COBRA2 0x6600
80 #define OPTION_PRODUCT_GTMAX36 0x6701
81 #define HUAWEI_PRODUCT_E600 0x1001
82 #define HUAWEI_PRODUCT_E220 0x1003
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(OPTION_VENDOR_ID, OPTION_PRODUCT_GTMAX36) },
93 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
94 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
95 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
96 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
97 { } /* Terminating entry */
99 MODULE_DEVICE_TABLE(usb, option_ids);
101 static struct usb_driver option_driver = {
103 .probe = usb_serial_probe,
104 .disconnect = usb_serial_disconnect,
105 .id_table = option_ids,
109 /* The card has three separate interfaces, which the serial driver
110 * recognizes separately, thus num_port=1.
113 static struct usb_serial_driver option_1port_device = {
115 .owner = THIS_MODULE,
118 .description = "GSM modem (1-port)",
119 .usb_driver = &option_driver,
120 .id_table = option_ids,
121 .num_interrupt_in = NUM_DONT_CARE,
122 .num_bulk_in = NUM_DONT_CARE,
123 .num_bulk_out = NUM_DONT_CARE,
126 .close = option_close,
127 .write = option_write,
128 .write_room = option_write_room,
129 .chars_in_buffer = option_chars_in_buffer,
130 .throttle = option_rx_throttle,
131 .unthrottle = option_rx_unthrottle,
132 .ioctl = option_ioctl,
133 .set_termios = option_set_termios,
134 .break_ctl = option_break_ctl,
135 .tiocmget = option_tiocmget,
136 .tiocmset = option_tiocmset,
137 .attach = option_startup,
138 .shutdown = option_shutdown,
139 .read_int_callback = option_instat_callback,
142 #ifdef CONFIG_USB_DEBUG
148 /* per port private data */
152 #define IN_BUFLEN 4096
153 #define OUT_BUFLEN 128
155 struct option_port_private {
156 /* Input endpoints and buffer for this port */
157 struct urb *in_urbs[N_IN_URB];
158 char in_buffer[N_IN_URB][IN_BUFLEN];
159 /* Output endpoints and buffer for this port */
160 struct urb *out_urbs[N_OUT_URB];
161 char out_buffer[N_OUT_URB][OUT_BUFLEN];
163 /* Settings for the port */
164 int rts_state; /* Handshaking pins (outputs) */
166 int cts_state; /* Handshaking pins (inputs) */
171 unsigned long tx_start_time[N_OUT_URB];
174 /* Functions used by new usb-serial code. */
175 static int __init option_init(void)
178 retval = usb_serial_register(&option_1port_device);
180 goto failed_1port_device_register;
181 retval = usb_register(&option_driver);
183 goto failed_driver_register;
185 info(DRIVER_DESC ": " DRIVER_VERSION);
189 failed_driver_register:
190 usb_serial_deregister (&option_1port_device);
191 failed_1port_device_register:
195 static void __exit option_exit(void)
197 usb_deregister (&option_driver);
198 usb_serial_deregister (&option_1port_device);
201 module_init(option_init);
202 module_exit(option_exit);
204 static void option_rx_throttle(struct usb_serial_port *port)
206 dbg("%s", __FUNCTION__);
209 static void option_rx_unthrottle(struct usb_serial_port *port)
211 dbg("%s", __FUNCTION__);
214 static void option_break_ctl(struct usb_serial_port *port, int break_state)
216 /* Unfortunately, I don't know how to send a break */
217 dbg("%s", __FUNCTION__);
220 static void option_set_termios(struct usb_serial_port *port,
221 struct ktermios *old_termios)
223 dbg("%s", __FUNCTION__);
225 option_send_setup(port);
228 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
231 struct option_port_private *portdata;
233 portdata = usb_get_serial_port_data(port);
235 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
236 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
237 ((portdata->cts_state) ? TIOCM_CTS : 0) |
238 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
239 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
240 ((portdata->ri_state) ? TIOCM_RNG : 0);
245 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
246 unsigned int set, unsigned int clear)
248 struct option_port_private *portdata;
250 portdata = usb_get_serial_port_data(port);
253 portdata->rts_state = 1;
255 portdata->dtr_state = 1;
257 if (clear & TIOCM_RTS)
258 portdata->rts_state = 0;
259 if (clear & TIOCM_DTR)
260 portdata->dtr_state = 0;
261 return option_send_setup(port);
264 static int option_ioctl(struct usb_serial_port *port, struct file *file,
265 unsigned int cmd, unsigned long arg)
271 static int option_write(struct usb_serial_port *port,
272 const unsigned char *buf, int count)
274 struct option_port_private *portdata;
277 struct urb *this_urb = NULL; /* spurious */
280 portdata = usb_get_serial_port_data(port);
282 dbg("%s: write (%d chars)", __FUNCTION__, count);
286 for (i=0; left > 0 && i < N_OUT_URB; i++) {
288 if (todo > OUT_BUFLEN)
291 this_urb = portdata->out_urbs[i];
292 if (this_urb->status == -EINPROGRESS) {
293 if (time_before(jiffies,
294 portdata->tx_start_time[i] + 10 * HZ))
296 usb_unlink_urb(this_urb);
299 if (this_urb->status != 0)
300 dbg("usb_write %p failed (err=%d)",
301 this_urb, this_urb->status);
303 dbg("%s: endpoint %d buf %d", __FUNCTION__,
304 usb_pipeendpoint(this_urb->pipe), i);
307 memcpy (this_urb->transfer_buffer, buf, todo);
308 this_urb->transfer_buffer_length = todo;
310 this_urb->dev = port->serial->dev;
311 err = usb_submit_urb(this_urb, GFP_ATOMIC);
313 dbg("usb_submit_urb %p (write bulk) failed "
314 "(%d, has %d)", this_urb,
315 err, this_urb->status);
318 portdata->tx_start_time[i] = jiffies;
324 dbg("%s: wrote (did %d)", __FUNCTION__, count);
328 static void option_indat_callback(struct urb *urb)
332 struct usb_serial_port *port;
333 struct tty_struct *tty;
334 unsigned char *data = urb->transfer_buffer;
336 dbg("%s: %p", __FUNCTION__, urb);
338 endpoint = usb_pipeendpoint(urb->pipe);
339 port = (struct usb_serial_port *) urb->context;
342 dbg("%s: nonzero status: %d on endpoint %02x.",
343 __FUNCTION__, urb->status, endpoint);
346 if (urb->actual_length) {
347 tty_buffer_request_room(tty, urb->actual_length);
348 tty_insert_flip_string(tty, data, urb->actual_length);
349 tty_flip_buffer_push(tty);
351 dbg("%s: empty read urb received", __FUNCTION__);
354 /* Resubmit urb so we continue receiving */
355 if (port->open_count && urb->status != -ESHUTDOWN) {
356 err = usb_submit_urb(urb, GFP_ATOMIC);
358 printk(KERN_ERR "%s: resubmit read urb failed. "
359 "(%d)", __FUNCTION__, err);
365 static void option_outdat_callback(struct urb *urb)
367 struct usb_serial_port *port;
369 dbg("%s", __FUNCTION__);
371 port = (struct usb_serial_port *) urb->context;
373 usb_serial_port_softint(port);
376 static void option_instat_callback(struct urb *urb)
379 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
380 struct option_port_private *portdata = usb_get_serial_port_data(port);
381 struct usb_serial *serial = port->serial;
383 dbg("%s", __FUNCTION__);
384 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
386 if (urb->status == 0) {
387 struct usb_ctrlrequest *req_pkt =
388 (struct usb_ctrlrequest *)urb->transfer_buffer;
391 dbg("%s: NULL req_pkt\n", __FUNCTION__);
394 if ((req_pkt->bRequestType == 0xA1) &&
395 (req_pkt->bRequest == 0x20)) {
397 unsigned char signals = *((unsigned char *)
398 urb->transfer_buffer +
399 sizeof(struct usb_ctrlrequest));
401 dbg("%s: signal x%x", __FUNCTION__, signals);
403 old_dcd_state = portdata->dcd_state;
404 portdata->cts_state = 1;
405 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
406 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
407 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
409 if (port->tty && !C_CLOCAL(port->tty) &&
410 old_dcd_state && !portdata->dcd_state)
411 tty_hangup(port->tty);
413 dbg("%s: type %x req %x", __FUNCTION__,
414 req_pkt->bRequestType,req_pkt->bRequest);
417 dbg("%s: error %d", __FUNCTION__, urb->status);
419 /* Resubmit urb so we continue receiving IRQ data */
420 if (urb->status != -ESHUTDOWN) {
421 urb->dev = serial->dev;
422 err = usb_submit_urb(urb, GFP_ATOMIC);
424 dbg("%s: resubmit intr urb failed. (%d)",
429 static int option_write_room(struct usb_serial_port *port)
431 struct option_port_private *portdata;
434 struct urb *this_urb;
436 portdata = usb_get_serial_port_data(port);
438 for (i=0; i < N_OUT_URB; i++) {
439 this_urb = portdata->out_urbs[i];
440 if (this_urb && this_urb->status != -EINPROGRESS)
441 data_len += OUT_BUFLEN;
444 dbg("%s: %d", __FUNCTION__, data_len);
448 static int option_chars_in_buffer(struct usb_serial_port *port)
450 struct option_port_private *portdata;
453 struct urb *this_urb;
455 portdata = usb_get_serial_port_data(port);
457 for (i=0; i < N_OUT_URB; i++) {
458 this_urb = portdata->out_urbs[i];
459 if (this_urb && this_urb->status == -EINPROGRESS)
460 data_len += this_urb->transfer_buffer_length;
462 dbg("%s: %d", __FUNCTION__, data_len);
466 static int option_open(struct usb_serial_port *port, struct file *filp)
468 struct option_port_private *portdata;
469 struct usb_serial *serial = port->serial;
473 portdata = usb_get_serial_port_data(port);
475 dbg("%s", __FUNCTION__);
477 /* Set some sane defaults */
478 portdata->rts_state = 1;
479 portdata->dtr_state = 1;
481 /* Reset low level data toggle and start reading from endpoints */
482 for (i = 0; i < N_IN_URB; i++) {
483 urb = portdata->in_urbs[i];
486 if (urb->dev != serial->dev) {
487 dbg("%s: dev %p != %p", __FUNCTION__,
488 urb->dev, serial->dev);
493 * make sure endpoint data toggle is synchronized with the
496 usb_clear_halt(urb->dev, urb->pipe);
498 err = usb_submit_urb(urb, GFP_KERNEL);
500 dbg("%s: submit urb %d failed (%d) %d",
501 __FUNCTION__, i, err,
502 urb->transfer_buffer_length);
506 /* Reset low level data toggle on out endpoints */
507 for (i = 0; i < N_OUT_URB; i++) {
508 urb = portdata->out_urbs[i];
511 urb->dev = serial->dev;
512 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
513 usb_pipeout(urb->pipe), 0); */
516 port->tty->low_latency = 1;
518 option_send_setup(port);
523 static inline void stop_urb(struct urb *urb)
525 if (urb && urb->status == -EINPROGRESS)
529 static void option_close(struct usb_serial_port *port, struct file *filp)
532 struct usb_serial *serial = port->serial;
533 struct option_port_private *portdata;
535 dbg("%s", __FUNCTION__);
536 portdata = usb_get_serial_port_data(port);
538 portdata->rts_state = 0;
539 portdata->dtr_state = 0;
542 option_send_setup(port);
544 /* Stop reading/writing urbs */
545 for (i = 0; i < N_IN_URB; i++)
546 stop_urb(portdata->in_urbs[i]);
547 for (i = 0; i < N_OUT_URB; i++)
548 stop_urb(portdata->out_urbs[i]);
553 /* Helper functions used by option_setup_urbs */
554 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
555 int dir, void *ctx, char *buf, int len,
556 void (*callback)(struct urb *))
561 return NULL; /* endpoint not needed */
563 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
565 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
569 /* Fill URB using supplied data. */
570 usb_fill_bulk_urb(urb, serial->dev,
571 usb_sndbulkpipe(serial->dev, endpoint) | dir,
572 buf, len, callback, ctx);
578 static void option_setup_urbs(struct usb_serial *serial)
581 struct usb_serial_port *port;
582 struct option_port_private *portdata;
584 dbg("%s", __FUNCTION__);
586 for (i = 0; i < serial->num_ports; i++) {
587 port = serial->port[i];
588 portdata = usb_get_serial_port_data(port);
590 /* Do indat endpoints first */
591 for (j = 0; j < N_IN_URB; ++j) {
592 portdata->in_urbs[j] = option_setup_urb (serial,
593 port->bulk_in_endpointAddress, USB_DIR_IN, port,
594 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
597 /* outdat endpoints */
598 for (j = 0; j < N_OUT_URB; ++j) {
599 portdata->out_urbs[j] = option_setup_urb (serial,
600 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
601 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
606 static int option_send_setup(struct usb_serial_port *port)
608 struct usb_serial *serial = port->serial;
609 struct option_port_private *portdata;
611 dbg("%s", __FUNCTION__);
613 if (port->number != 0)
616 portdata = usb_get_serial_port_data(port);
620 if (portdata->dtr_state)
622 if (portdata->rts_state)
625 return usb_control_msg(serial->dev,
626 usb_rcvctrlpipe(serial->dev, 0),
627 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
633 static int option_startup(struct usb_serial *serial)
636 struct usb_serial_port *port;
637 struct option_port_private *portdata;
639 dbg("%s", __FUNCTION__);
641 /* Now setup per port private data */
642 for (i = 0; i < serial->num_ports; i++) {
643 port = serial->port[i];
644 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
646 dbg("%s: kmalloc for option_port_private (%d) failed!.",
651 usb_set_serial_port_data(port, portdata);
653 if (! port->interrupt_in_urb)
655 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
657 dbg("%s: submit irq_in urb failed %d",
661 option_setup_urbs(serial);
666 static void option_shutdown(struct usb_serial *serial)
669 struct usb_serial_port *port;
670 struct option_port_private *portdata;
672 dbg("%s", __FUNCTION__);
674 /* Stop reading/writing urbs */
675 for (i = 0; i < serial->num_ports; ++i) {
676 port = serial->port[i];
677 portdata = usb_get_serial_port_data(port);
678 for (j = 0; j < N_IN_URB; j++)
679 stop_urb(portdata->in_urbs[j]);
680 for (j = 0; j < N_OUT_URB; j++)
681 stop_urb(portdata->out_urbs[j]);
685 for (i = 0; i < serial->num_ports; ++i) {
686 port = serial->port[i];
687 portdata = usb_get_serial_port_data(port);
689 for (j = 0; j < N_IN_URB; j++) {
690 if (portdata->in_urbs[j]) {
691 usb_free_urb(portdata->in_urbs[j]);
692 portdata->in_urbs[j] = NULL;
695 for (j = 0; j < N_OUT_URB; j++) {
696 if (portdata->out_urbs[j]) {
697 usb_free_urb(portdata->out_urbs[j]);
698 portdata->out_urbs[j] = NULL;
703 /* Now free per port private data */
704 for (i = 0; i < serial->num_ports; i++) {
705 port = serial->port[i];
706 kfree(usb_get_serial_port_data(port));
710 MODULE_AUTHOR(DRIVER_AUTHOR);
711 MODULE_DESCRIPTION(DRIVER_DESC);
712 MODULE_VERSION(DRIVER_VERSION);
713 MODULE_LICENSE("GPL");
715 #ifdef CONFIG_USB_DEBUG
716 module_param(debug, bool, S_IRUGO | S_IWUSR);
717 MODULE_PARM_DESC(debug, "Debug messages");