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 OPTION_PRODUCT_COLT 0x5000
72 #define OPTION_PRODUCT_RICOLA 0x6000
73 #define OPTION_PRODUCT_RICOLA_LIGHT 0x6100
74 #define OPTION_PRODUCT_RICOLA_QUAD 0x6200
75 #define OPTION_PRODUCT_RICOLA_QUAD_LIGHT 0x6300
76 #define OPTION_PRODUCT_RICOLA_NDIS 0x6050
77 #define OPTION_PRODUCT_RICOLA_NDIS_LIGHT 0x6150
78 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD 0x6250
79 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT 0x6350
80 #define OPTION_PRODUCT_COBRA 0x6500
81 #define OPTION_PRODUCT_COBRA_BUS 0x6501
82 #define OPTION_PRODUCT_VIPER 0x6600
83 #define OPTION_PRODUCT_VIPER_BUS 0x6601
84 #define OPTION_PRODUCT_GT_MAX_READY 0x6701
85 #define OPTION_PRODUCT_GT_MAX 0x6711
86 #define OPTION_PRODUCT_FUJI_MODEM_LIGHT 0x6721
87 #define OPTION_PRODUCT_FUJI_MODEM_GT 0x6741
88 #define OPTION_PRODUCT_FUJI_MODEM_EX 0x6761
89 #define OPTION_PRODUCT_FUJI_NETWORK_LIGHT 0x6731
90 #define OPTION_PRODUCT_FUJI_NETWORK_GT 0x6751
91 #define OPTION_PRODUCT_FUJI_NETWORK_EX 0x6771
92 #define OPTION_PRODUCT_KOI_MODEM 0x6800
93 #define OPTION_PRODUCT_KOI_NETWORK 0x6811
94 #define OPTION_PRODUCT_SCORPION_MODEM 0x6901
95 #define OPTION_PRODUCT_SCORPION_NETWORK 0x6911
96 #define OPTION_PRODUCT_ETNA_MODEM 0x7001
97 #define OPTION_PRODUCT_ETNA_NETWORK 0x7011
98 #define OPTION_PRODUCT_ETNA_MODEM_LITE 0x7021
99 #define OPTION_PRODUCT_ETNA_MODEM_GT 0x7041
100 #define OPTION_PRODUCT_ETNA_MODEM_EX 0x7061
101 #define OPTION_PRODUCT_ETNA_NETWORK_LITE 0x7031
102 #define OPTION_PRODUCT_ETNA_NETWORK_GT 0x7051
103 #define OPTION_PRODUCT_ETNA_NETWORK_EX 0x7071
104 #define OPTION_PRODUCT_ETNA_KOI_MODEM 0x7100
105 #define OPTION_PRODUCT_ETNA_KOI_NETWORK 0x7111
107 #define HUAWEI_VENDOR_ID 0x12D1
108 #define HUAWEI_PRODUCT_E600 0x1001
109 #define HUAWEI_PRODUCT_E220 0x1003
111 #define NOVATELWIRELESS_VENDOR_ID 0x1410
113 #define ANYDATA_VENDOR_ID 0x16d5
114 #define ANYDATA_PRODUCT_ADU_E100A 0x6501
115 #define ANYDATA_PRODUCT_ADU_500A 0x6502
117 #define BANDRICH_VENDOR_ID 0x1A8D
118 #define BANDRICH_PRODUCT_C100_1 0x1002
119 #define BANDRICH_PRODUCT_C100_2 0x1003
121 #define DELL_VENDOR_ID 0x413C
123 static struct usb_device_id option_ids[] = {
124 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
125 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
126 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
127 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
128 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
129 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
130 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
131 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
132 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
133 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
134 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
135 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
136 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
137 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
138 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX) },
139 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
140 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
141 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
142 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_LIGHT) },
143 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_GT) },
144 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_EX) },
145 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
146 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_NETWORK) },
147 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
148 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_NETWORK) },
149 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
150 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK) },
151 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
152 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
153 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
154 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_LITE) },
155 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_GT) },
156 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
157 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
158 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
159 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
160 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
161 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1100) }, /* Novatel Merlin XS620/S640 */
162 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1110) }, /* Novatel Merlin S620 */
163 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1120) }, /* Novatel Merlin EX720 */
164 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1130) }, /* Novatel Merlin S720 */
165 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1400) }, /* Novatel U730 */
166 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1410) }, /* Novatel U740 */
167 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1420) }, /* Novatel EU870 */
168 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1430) }, /* Novatel Merlin XU870 HSDPA/3G */
169 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2100) }, /* Novatel EV620 CDMA/EV-DO */
170 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2110) }, /* Novatel Merlin ES620 / Merlin ES720 / Ovation U720 */
171 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
172 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2410) }, /* Novatel EU740 */
173 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
174 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
175 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
176 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
177 { USB_DEVICE(DELL_VENDOR_ID, 0x8118) }, /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard */
178 { } /* Terminating entry */
180 MODULE_DEVICE_TABLE(usb, option_ids);
182 static struct usb_driver option_driver = {
184 .probe = usb_serial_probe,
185 .disconnect = usb_serial_disconnect,
186 .id_table = option_ids,
190 /* The card has three separate interfaces, which the serial driver
191 * recognizes separately, thus num_port=1.
194 static struct usb_serial_driver option_1port_device = {
196 .owner = THIS_MODULE,
199 .description = "GSM modem (1-port)",
200 .usb_driver = &option_driver,
201 .id_table = option_ids,
202 .num_interrupt_in = NUM_DONT_CARE,
203 .num_bulk_in = NUM_DONT_CARE,
204 .num_bulk_out = NUM_DONT_CARE,
207 .close = option_close,
208 .write = option_write,
209 .write_room = option_write_room,
210 .chars_in_buffer = option_chars_in_buffer,
211 .throttle = option_rx_throttle,
212 .unthrottle = option_rx_unthrottle,
213 .ioctl = option_ioctl,
214 .set_termios = option_set_termios,
215 .break_ctl = option_break_ctl,
216 .tiocmget = option_tiocmget,
217 .tiocmset = option_tiocmset,
218 .attach = option_startup,
219 .shutdown = option_shutdown,
220 .read_int_callback = option_instat_callback,
223 #ifdef CONFIG_USB_DEBUG
229 /* per port private data */
233 #define IN_BUFLEN 4096
234 #define OUT_BUFLEN 128
236 struct option_port_private {
237 /* Input endpoints and buffer for this port */
238 struct urb *in_urbs[N_IN_URB];
239 char in_buffer[N_IN_URB][IN_BUFLEN];
240 /* Output endpoints and buffer for this port */
241 struct urb *out_urbs[N_OUT_URB];
242 char out_buffer[N_OUT_URB][OUT_BUFLEN];
244 /* Settings for the port */
245 int rts_state; /* Handshaking pins (outputs) */
247 int cts_state; /* Handshaking pins (inputs) */
252 unsigned long tx_start_time[N_OUT_URB];
255 /* Functions used by new usb-serial code. */
256 static int __init option_init(void)
259 retval = usb_serial_register(&option_1port_device);
261 goto failed_1port_device_register;
262 retval = usb_register(&option_driver);
264 goto failed_driver_register;
266 info(DRIVER_DESC ": " DRIVER_VERSION);
270 failed_driver_register:
271 usb_serial_deregister (&option_1port_device);
272 failed_1port_device_register:
276 static void __exit option_exit(void)
278 usb_deregister (&option_driver);
279 usb_serial_deregister (&option_1port_device);
282 module_init(option_init);
283 module_exit(option_exit);
285 static void option_rx_throttle(struct usb_serial_port *port)
287 dbg("%s", __FUNCTION__);
290 static void option_rx_unthrottle(struct usb_serial_port *port)
292 dbg("%s", __FUNCTION__);
295 static void option_break_ctl(struct usb_serial_port *port, int break_state)
297 /* Unfortunately, I don't know how to send a break */
298 dbg("%s", __FUNCTION__);
301 static void option_set_termios(struct usb_serial_port *port,
302 struct ktermios *old_termios)
304 dbg("%s", __FUNCTION__);
306 option_send_setup(port);
309 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
312 struct option_port_private *portdata;
314 portdata = usb_get_serial_port_data(port);
316 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
317 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
318 ((portdata->cts_state) ? TIOCM_CTS : 0) |
319 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
320 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
321 ((portdata->ri_state) ? TIOCM_RNG : 0);
326 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
327 unsigned int set, unsigned int clear)
329 struct option_port_private *portdata;
331 portdata = usb_get_serial_port_data(port);
334 portdata->rts_state = 1;
336 portdata->dtr_state = 1;
338 if (clear & TIOCM_RTS)
339 portdata->rts_state = 0;
340 if (clear & TIOCM_DTR)
341 portdata->dtr_state = 0;
342 return option_send_setup(port);
345 static int option_ioctl(struct usb_serial_port *port, struct file *file,
346 unsigned int cmd, unsigned long arg)
352 static int option_write(struct usb_serial_port *port,
353 const unsigned char *buf, int count)
355 struct option_port_private *portdata;
358 struct urb *this_urb = NULL; /* spurious */
361 portdata = usb_get_serial_port_data(port);
363 dbg("%s: write (%d chars)", __FUNCTION__, count);
367 for (i=0; left > 0 && i < N_OUT_URB; i++) {
369 if (todo > OUT_BUFLEN)
372 this_urb = portdata->out_urbs[i];
373 if (this_urb->status == -EINPROGRESS) {
374 if (time_before(jiffies,
375 portdata->tx_start_time[i] + 10 * HZ))
377 usb_unlink_urb(this_urb);
380 if (this_urb->status != 0)
381 dbg("usb_write %p failed (err=%d)",
382 this_urb, this_urb->status);
384 dbg("%s: endpoint %d buf %d", __FUNCTION__,
385 usb_pipeendpoint(this_urb->pipe), i);
388 memcpy (this_urb->transfer_buffer, buf, todo);
389 this_urb->transfer_buffer_length = todo;
391 this_urb->dev = port->serial->dev;
392 err = usb_submit_urb(this_urb, GFP_ATOMIC);
394 dbg("usb_submit_urb %p (write bulk) failed "
395 "(%d, has %d)", this_urb,
396 err, this_urb->status);
399 portdata->tx_start_time[i] = jiffies;
405 dbg("%s: wrote (did %d)", __FUNCTION__, count);
409 static void option_indat_callback(struct urb *urb)
413 struct usb_serial_port *port;
414 struct tty_struct *tty;
415 unsigned char *data = urb->transfer_buffer;
417 dbg("%s: %p", __FUNCTION__, urb);
419 endpoint = usb_pipeendpoint(urb->pipe);
420 port = (struct usb_serial_port *) urb->context;
423 dbg("%s: nonzero status: %d on endpoint %02x.",
424 __FUNCTION__, urb->status, endpoint);
427 if (urb->actual_length) {
428 tty_buffer_request_room(tty, urb->actual_length);
429 tty_insert_flip_string(tty, data, urb->actual_length);
430 tty_flip_buffer_push(tty);
432 dbg("%s: empty read urb received", __FUNCTION__);
435 /* Resubmit urb so we continue receiving */
436 if (port->open_count && urb->status != -ESHUTDOWN) {
437 err = usb_submit_urb(urb, GFP_ATOMIC);
439 printk(KERN_ERR "%s: resubmit read urb failed. "
440 "(%d)", __FUNCTION__, err);
446 static void option_outdat_callback(struct urb *urb)
448 struct usb_serial_port *port;
450 dbg("%s", __FUNCTION__);
452 port = (struct usb_serial_port *) urb->context;
454 usb_serial_port_softint(port);
457 static void option_instat_callback(struct urb *urb)
460 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
461 struct option_port_private *portdata = usb_get_serial_port_data(port);
462 struct usb_serial *serial = port->serial;
464 dbg("%s", __FUNCTION__);
465 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
467 if (urb->status == 0) {
468 struct usb_ctrlrequest *req_pkt =
469 (struct usb_ctrlrequest *)urb->transfer_buffer;
472 dbg("%s: NULL req_pkt\n", __FUNCTION__);
475 if ((req_pkt->bRequestType == 0xA1) &&
476 (req_pkt->bRequest == 0x20)) {
478 unsigned char signals = *((unsigned char *)
479 urb->transfer_buffer +
480 sizeof(struct usb_ctrlrequest));
482 dbg("%s: signal x%x", __FUNCTION__, signals);
484 old_dcd_state = portdata->dcd_state;
485 portdata->cts_state = 1;
486 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
487 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
488 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
490 if (port->tty && !C_CLOCAL(port->tty) &&
491 old_dcd_state && !portdata->dcd_state)
492 tty_hangup(port->tty);
494 dbg("%s: type %x req %x", __FUNCTION__,
495 req_pkt->bRequestType,req_pkt->bRequest);
498 dbg("%s: error %d", __FUNCTION__, urb->status);
500 /* Resubmit urb so we continue receiving IRQ data */
501 if (urb->status != -ESHUTDOWN) {
502 urb->dev = serial->dev;
503 err = usb_submit_urb(urb, GFP_ATOMIC);
505 dbg("%s: resubmit intr urb failed. (%d)",
510 static int option_write_room(struct usb_serial_port *port)
512 struct option_port_private *portdata;
515 struct urb *this_urb;
517 portdata = usb_get_serial_port_data(port);
519 for (i=0; i < N_OUT_URB; i++) {
520 this_urb = portdata->out_urbs[i];
521 if (this_urb && this_urb->status != -EINPROGRESS)
522 data_len += OUT_BUFLEN;
525 dbg("%s: %d", __FUNCTION__, data_len);
529 static int option_chars_in_buffer(struct usb_serial_port *port)
531 struct option_port_private *portdata;
534 struct urb *this_urb;
536 portdata = usb_get_serial_port_data(port);
538 for (i=0; i < N_OUT_URB; i++) {
539 this_urb = portdata->out_urbs[i];
540 if (this_urb && this_urb->status == -EINPROGRESS)
541 data_len += this_urb->transfer_buffer_length;
543 dbg("%s: %d", __FUNCTION__, data_len);
547 static int option_open(struct usb_serial_port *port, struct file *filp)
549 struct option_port_private *portdata;
550 struct usb_serial *serial = port->serial;
554 portdata = usb_get_serial_port_data(port);
556 dbg("%s", __FUNCTION__);
558 /* Set some sane defaults */
559 portdata->rts_state = 1;
560 portdata->dtr_state = 1;
562 /* Reset low level data toggle and start reading from endpoints */
563 for (i = 0; i < N_IN_URB; i++) {
564 urb = portdata->in_urbs[i];
567 if (urb->dev != serial->dev) {
568 dbg("%s: dev %p != %p", __FUNCTION__,
569 urb->dev, serial->dev);
574 * make sure endpoint data toggle is synchronized with the
577 usb_clear_halt(urb->dev, urb->pipe);
579 err = usb_submit_urb(urb, GFP_KERNEL);
581 dbg("%s: submit urb %d failed (%d) %d",
582 __FUNCTION__, i, err,
583 urb->transfer_buffer_length);
587 /* Reset low level data toggle on out endpoints */
588 for (i = 0; i < N_OUT_URB; i++) {
589 urb = portdata->out_urbs[i];
592 urb->dev = serial->dev;
593 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
594 usb_pipeout(urb->pipe), 0); */
597 port->tty->low_latency = 1;
599 option_send_setup(port);
604 static void option_close(struct usb_serial_port *port, struct file *filp)
607 struct usb_serial *serial = port->serial;
608 struct option_port_private *portdata;
610 dbg("%s", __FUNCTION__);
611 portdata = usb_get_serial_port_data(port);
613 portdata->rts_state = 0;
614 portdata->dtr_state = 0;
617 option_send_setup(port);
619 /* Stop reading/writing urbs */
620 for (i = 0; i < N_IN_URB; i++)
621 usb_kill_urb(portdata->in_urbs[i]);
622 for (i = 0; i < N_OUT_URB; i++)
623 usb_kill_urb(portdata->out_urbs[i]);
628 /* Helper functions used by option_setup_urbs */
629 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
630 int dir, void *ctx, char *buf, int len,
631 void (*callback)(struct urb *))
636 return NULL; /* endpoint not needed */
638 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
640 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
644 /* Fill URB using supplied data. */
645 usb_fill_bulk_urb(urb, serial->dev,
646 usb_sndbulkpipe(serial->dev, endpoint) | dir,
647 buf, len, callback, ctx);
653 static void option_setup_urbs(struct usb_serial *serial)
656 struct usb_serial_port *port;
657 struct option_port_private *portdata;
659 dbg("%s", __FUNCTION__);
661 for (i = 0; i < serial->num_ports; i++) {
662 port = serial->port[i];
663 portdata = usb_get_serial_port_data(port);
665 /* Do indat endpoints first */
666 for (j = 0; j < N_IN_URB; ++j) {
667 portdata->in_urbs[j] = option_setup_urb (serial,
668 port->bulk_in_endpointAddress, USB_DIR_IN, port,
669 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
672 /* outdat endpoints */
673 for (j = 0; j < N_OUT_URB; ++j) {
674 portdata->out_urbs[j] = option_setup_urb (serial,
675 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
676 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
681 static int option_send_setup(struct usb_serial_port *port)
683 struct usb_serial *serial = port->serial;
684 struct option_port_private *portdata;
686 dbg("%s", __FUNCTION__);
688 if (port->number != 0)
691 portdata = usb_get_serial_port_data(port);
695 if (portdata->dtr_state)
697 if (portdata->rts_state)
700 return usb_control_msg(serial->dev,
701 usb_rcvctrlpipe(serial->dev, 0),
702 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
708 static int option_startup(struct usb_serial *serial)
711 struct usb_serial_port *port;
712 struct option_port_private *portdata;
714 dbg("%s", __FUNCTION__);
716 /* Now setup per port private data */
717 for (i = 0; i < serial->num_ports; i++) {
718 port = serial->port[i];
719 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
721 dbg("%s: kmalloc for option_port_private (%d) failed!.",
726 usb_set_serial_port_data(port, portdata);
728 if (! port->interrupt_in_urb)
730 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
732 dbg("%s: submit irq_in urb failed %d",
736 option_setup_urbs(serial);
741 static void option_shutdown(struct usb_serial *serial)
744 struct usb_serial_port *port;
745 struct option_port_private *portdata;
747 dbg("%s", __FUNCTION__);
749 /* Stop reading/writing urbs */
750 for (i = 0; i < serial->num_ports; ++i) {
751 port = serial->port[i];
752 portdata = usb_get_serial_port_data(port);
753 for (j = 0; j < N_IN_URB; j++)
754 usb_kill_urb(portdata->in_urbs[j]);
755 for (j = 0; j < N_OUT_URB; j++)
756 usb_kill_urb(portdata->out_urbs[j]);
760 for (i = 0; i < serial->num_ports; ++i) {
761 port = serial->port[i];
762 portdata = usb_get_serial_port_data(port);
764 for (j = 0; j < N_IN_URB; j++) {
765 if (portdata->in_urbs[j]) {
766 usb_free_urb(portdata->in_urbs[j]);
767 portdata->in_urbs[j] = NULL;
770 for (j = 0; j < N_OUT_URB; j++) {
771 if (portdata->out_urbs[j]) {
772 usb_free_urb(portdata->out_urbs[j]);
773 portdata->out_urbs[j] = NULL;
778 /* Now free per port private data */
779 for (i = 0; i < serial->num_ports; i++) {
780 port = serial->port[i];
781 kfree(usb_get_serial_port_data(port));
785 MODULE_AUTHOR(DRIVER_AUTHOR);
786 MODULE_DESCRIPTION(DRIVER_DESC);
787 MODULE_VERSION(DRIVER_VERSION);
788 MODULE_LICENSE("GPL");
790 #ifdef CONFIG_USB_DEBUG
791 module_param(debug, bool, S_IRUGO | S_IWUSR);
792 MODULE_PARM_DESC(debug, "Debug messages");