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_ID 0x6501
116 #define BANDRICH_VENDOR_ID 0x1A8D
117 #define BANDRICH_PRODUCT_C100_1 0x1002
118 #define BANDRICH_PRODUCT_C100_2 0x1003
120 #define DELL_VENDOR_ID 0x413C
122 static struct usb_device_id option_ids[] = {
123 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
124 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
125 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
126 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
127 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
128 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
129 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
130 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
131 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
132 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
133 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
134 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
135 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
136 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
137 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX) },
138 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
139 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
140 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
141 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_LIGHT) },
142 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_GT) },
143 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_EX) },
144 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
145 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_NETWORK) },
146 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
147 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_NETWORK) },
148 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
149 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK) },
150 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
151 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
152 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
153 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_LITE) },
154 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_GT) },
155 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
156 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
157 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
158 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
159 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
160 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1100) }, /* Novatel Merlin XS620/S640 */
161 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1110) }, /* Novatel Merlin S620 */
162 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1120) }, /* Novatel Merlin EX720 */
163 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1130) }, /* Novatel Merlin S720 */
164 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1400) }, /* Novatel U730 */
165 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1410) }, /* Novatel U740 */
166 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1420) }, /* Novatel EU870 */
167 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1430) }, /* Novatel Merlin XU870 HSDPA/3G */
168 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2100) }, /* Novatel EV620 CDMA/EV-DO */
169 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2110) }, /* Novatel Merlin ES620 / Merlin ES720 / Ovation U720 */
170 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
171 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2410) }, /* Novatel EU740 */
172 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
173 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
174 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
175 { USB_DEVICE(DELL_VENDOR_ID, 0x8118) }, /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard */
176 { } /* Terminating entry */
178 MODULE_DEVICE_TABLE(usb, option_ids);
180 static struct usb_driver option_driver = {
182 .probe = usb_serial_probe,
183 .disconnect = usb_serial_disconnect,
184 .id_table = option_ids,
188 /* The card has three separate interfaces, which the serial driver
189 * recognizes separately, thus num_port=1.
192 static struct usb_serial_driver option_1port_device = {
194 .owner = THIS_MODULE,
197 .description = "GSM modem (1-port)",
198 .usb_driver = &option_driver,
199 .id_table = option_ids,
200 .num_interrupt_in = NUM_DONT_CARE,
201 .num_bulk_in = NUM_DONT_CARE,
202 .num_bulk_out = NUM_DONT_CARE,
205 .close = option_close,
206 .write = option_write,
207 .write_room = option_write_room,
208 .chars_in_buffer = option_chars_in_buffer,
209 .throttle = option_rx_throttle,
210 .unthrottle = option_rx_unthrottle,
211 .ioctl = option_ioctl,
212 .set_termios = option_set_termios,
213 .break_ctl = option_break_ctl,
214 .tiocmget = option_tiocmget,
215 .tiocmset = option_tiocmset,
216 .attach = option_startup,
217 .shutdown = option_shutdown,
218 .read_int_callback = option_instat_callback,
221 #ifdef CONFIG_USB_DEBUG
227 /* per port private data */
231 #define IN_BUFLEN 4096
232 #define OUT_BUFLEN 128
234 struct option_port_private {
235 /* Input endpoints and buffer for this port */
236 struct urb *in_urbs[N_IN_URB];
237 char in_buffer[N_IN_URB][IN_BUFLEN];
238 /* Output endpoints and buffer for this port */
239 struct urb *out_urbs[N_OUT_URB];
240 char out_buffer[N_OUT_URB][OUT_BUFLEN];
242 /* Settings for the port */
243 int rts_state; /* Handshaking pins (outputs) */
245 int cts_state; /* Handshaking pins (inputs) */
250 unsigned long tx_start_time[N_OUT_URB];
253 /* Functions used by new usb-serial code. */
254 static int __init option_init(void)
257 retval = usb_serial_register(&option_1port_device);
259 goto failed_1port_device_register;
260 retval = usb_register(&option_driver);
262 goto failed_driver_register;
264 info(DRIVER_DESC ": " DRIVER_VERSION);
268 failed_driver_register:
269 usb_serial_deregister (&option_1port_device);
270 failed_1port_device_register:
274 static void __exit option_exit(void)
276 usb_deregister (&option_driver);
277 usb_serial_deregister (&option_1port_device);
280 module_init(option_init);
281 module_exit(option_exit);
283 static void option_rx_throttle(struct usb_serial_port *port)
285 dbg("%s", __FUNCTION__);
288 static void option_rx_unthrottle(struct usb_serial_port *port)
290 dbg("%s", __FUNCTION__);
293 static void option_break_ctl(struct usb_serial_port *port, int break_state)
295 /* Unfortunately, I don't know how to send a break */
296 dbg("%s", __FUNCTION__);
299 static void option_set_termios(struct usb_serial_port *port,
300 struct ktermios *old_termios)
302 dbg("%s", __FUNCTION__);
304 option_send_setup(port);
307 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
310 struct option_port_private *portdata;
312 portdata = usb_get_serial_port_data(port);
314 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
315 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
316 ((portdata->cts_state) ? TIOCM_CTS : 0) |
317 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
318 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
319 ((portdata->ri_state) ? TIOCM_RNG : 0);
324 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
325 unsigned int set, unsigned int clear)
327 struct option_port_private *portdata;
329 portdata = usb_get_serial_port_data(port);
332 portdata->rts_state = 1;
334 portdata->dtr_state = 1;
336 if (clear & TIOCM_RTS)
337 portdata->rts_state = 0;
338 if (clear & TIOCM_DTR)
339 portdata->dtr_state = 0;
340 return option_send_setup(port);
343 static int option_ioctl(struct usb_serial_port *port, struct file *file,
344 unsigned int cmd, unsigned long arg)
350 static int option_write(struct usb_serial_port *port,
351 const unsigned char *buf, int count)
353 struct option_port_private *portdata;
356 struct urb *this_urb = NULL; /* spurious */
359 portdata = usb_get_serial_port_data(port);
361 dbg("%s: write (%d chars)", __FUNCTION__, count);
365 for (i=0; left > 0 && i < N_OUT_URB; i++) {
367 if (todo > OUT_BUFLEN)
370 this_urb = portdata->out_urbs[i];
371 if (this_urb->status == -EINPROGRESS) {
372 if (time_before(jiffies,
373 portdata->tx_start_time[i] + 10 * HZ))
375 usb_unlink_urb(this_urb);
378 if (this_urb->status != 0)
379 dbg("usb_write %p failed (err=%d)",
380 this_urb, this_urb->status);
382 dbg("%s: endpoint %d buf %d", __FUNCTION__,
383 usb_pipeendpoint(this_urb->pipe), i);
386 memcpy (this_urb->transfer_buffer, buf, todo);
387 this_urb->transfer_buffer_length = todo;
389 this_urb->dev = port->serial->dev;
390 err = usb_submit_urb(this_urb, GFP_ATOMIC);
392 dbg("usb_submit_urb %p (write bulk) failed "
393 "(%d, has %d)", this_urb,
394 err, this_urb->status);
397 portdata->tx_start_time[i] = jiffies;
403 dbg("%s: wrote (did %d)", __FUNCTION__, count);
407 static void option_indat_callback(struct urb *urb)
411 struct usb_serial_port *port;
412 struct tty_struct *tty;
413 unsigned char *data = urb->transfer_buffer;
415 dbg("%s: %p", __FUNCTION__, urb);
417 endpoint = usb_pipeendpoint(urb->pipe);
418 port = (struct usb_serial_port *) urb->context;
421 dbg("%s: nonzero status: %d on endpoint %02x.",
422 __FUNCTION__, urb->status, endpoint);
425 if (urb->actual_length) {
426 tty_buffer_request_room(tty, urb->actual_length);
427 tty_insert_flip_string(tty, data, urb->actual_length);
428 tty_flip_buffer_push(tty);
430 dbg("%s: empty read urb received", __FUNCTION__);
433 /* Resubmit urb so we continue receiving */
434 if (port->open_count && urb->status != -ESHUTDOWN) {
435 err = usb_submit_urb(urb, GFP_ATOMIC);
437 printk(KERN_ERR "%s: resubmit read urb failed. "
438 "(%d)", __FUNCTION__, err);
444 static void option_outdat_callback(struct urb *urb)
446 struct usb_serial_port *port;
448 dbg("%s", __FUNCTION__);
450 port = (struct usb_serial_port *) urb->context;
452 usb_serial_port_softint(port);
455 static void option_instat_callback(struct urb *urb)
458 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
459 struct option_port_private *portdata = usb_get_serial_port_data(port);
460 struct usb_serial *serial = port->serial;
462 dbg("%s", __FUNCTION__);
463 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
465 if (urb->status == 0) {
466 struct usb_ctrlrequest *req_pkt =
467 (struct usb_ctrlrequest *)urb->transfer_buffer;
470 dbg("%s: NULL req_pkt\n", __FUNCTION__);
473 if ((req_pkt->bRequestType == 0xA1) &&
474 (req_pkt->bRequest == 0x20)) {
476 unsigned char signals = *((unsigned char *)
477 urb->transfer_buffer +
478 sizeof(struct usb_ctrlrequest));
480 dbg("%s: signal x%x", __FUNCTION__, signals);
482 old_dcd_state = portdata->dcd_state;
483 portdata->cts_state = 1;
484 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
485 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
486 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
488 if (port->tty && !C_CLOCAL(port->tty) &&
489 old_dcd_state && !portdata->dcd_state)
490 tty_hangup(port->tty);
492 dbg("%s: type %x req %x", __FUNCTION__,
493 req_pkt->bRequestType,req_pkt->bRequest);
496 dbg("%s: error %d", __FUNCTION__, urb->status);
498 /* Resubmit urb so we continue receiving IRQ data */
499 if (urb->status != -ESHUTDOWN) {
500 urb->dev = serial->dev;
501 err = usb_submit_urb(urb, GFP_ATOMIC);
503 dbg("%s: resubmit intr urb failed. (%d)",
508 static int option_write_room(struct usb_serial_port *port)
510 struct option_port_private *portdata;
513 struct urb *this_urb;
515 portdata = usb_get_serial_port_data(port);
517 for (i=0; i < N_OUT_URB; i++) {
518 this_urb = portdata->out_urbs[i];
519 if (this_urb && this_urb->status != -EINPROGRESS)
520 data_len += OUT_BUFLEN;
523 dbg("%s: %d", __FUNCTION__, data_len);
527 static int option_chars_in_buffer(struct usb_serial_port *port)
529 struct option_port_private *portdata;
532 struct urb *this_urb;
534 portdata = usb_get_serial_port_data(port);
536 for (i=0; i < N_OUT_URB; i++) {
537 this_urb = portdata->out_urbs[i];
538 if (this_urb && this_urb->status == -EINPROGRESS)
539 data_len += this_urb->transfer_buffer_length;
541 dbg("%s: %d", __FUNCTION__, data_len);
545 static int option_open(struct usb_serial_port *port, struct file *filp)
547 struct option_port_private *portdata;
548 struct usb_serial *serial = port->serial;
552 portdata = usb_get_serial_port_data(port);
554 dbg("%s", __FUNCTION__);
556 /* Set some sane defaults */
557 portdata->rts_state = 1;
558 portdata->dtr_state = 1;
560 /* Reset low level data toggle and start reading from endpoints */
561 for (i = 0; i < N_IN_URB; i++) {
562 urb = portdata->in_urbs[i];
565 if (urb->dev != serial->dev) {
566 dbg("%s: dev %p != %p", __FUNCTION__,
567 urb->dev, serial->dev);
572 * make sure endpoint data toggle is synchronized with the
575 usb_clear_halt(urb->dev, urb->pipe);
577 err = usb_submit_urb(urb, GFP_KERNEL);
579 dbg("%s: submit urb %d failed (%d) %d",
580 __FUNCTION__, i, err,
581 urb->transfer_buffer_length);
585 /* Reset low level data toggle on out endpoints */
586 for (i = 0; i < N_OUT_URB; i++) {
587 urb = portdata->out_urbs[i];
590 urb->dev = serial->dev;
591 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
592 usb_pipeout(urb->pipe), 0); */
595 port->tty->low_latency = 1;
597 option_send_setup(port);
602 static void option_close(struct usb_serial_port *port, struct file *filp)
605 struct usb_serial *serial = port->serial;
606 struct option_port_private *portdata;
608 dbg("%s", __FUNCTION__);
609 portdata = usb_get_serial_port_data(port);
611 portdata->rts_state = 0;
612 portdata->dtr_state = 0;
615 option_send_setup(port);
617 /* Stop reading/writing urbs */
618 for (i = 0; i < N_IN_URB; i++)
619 usb_kill_urb(portdata->in_urbs[i]);
620 for (i = 0; i < N_OUT_URB; i++)
621 usb_kill_urb(portdata->out_urbs[i]);
626 /* Helper functions used by option_setup_urbs */
627 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
628 int dir, void *ctx, char *buf, int len,
629 void (*callback)(struct urb *))
634 return NULL; /* endpoint not needed */
636 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
638 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
642 /* Fill URB using supplied data. */
643 usb_fill_bulk_urb(urb, serial->dev,
644 usb_sndbulkpipe(serial->dev, endpoint) | dir,
645 buf, len, callback, ctx);
651 static void option_setup_urbs(struct usb_serial *serial)
654 struct usb_serial_port *port;
655 struct option_port_private *portdata;
657 dbg("%s", __FUNCTION__);
659 for (i = 0; i < serial->num_ports; i++) {
660 port = serial->port[i];
661 portdata = usb_get_serial_port_data(port);
663 /* Do indat endpoints first */
664 for (j = 0; j < N_IN_URB; ++j) {
665 portdata->in_urbs[j] = option_setup_urb (serial,
666 port->bulk_in_endpointAddress, USB_DIR_IN, port,
667 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
670 /* outdat endpoints */
671 for (j = 0; j < N_OUT_URB; ++j) {
672 portdata->out_urbs[j] = option_setup_urb (serial,
673 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
674 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
679 static int option_send_setup(struct usb_serial_port *port)
681 struct usb_serial *serial = port->serial;
682 struct option_port_private *portdata;
684 dbg("%s", __FUNCTION__);
686 if (port->number != 0)
689 portdata = usb_get_serial_port_data(port);
693 if (portdata->dtr_state)
695 if (portdata->rts_state)
698 return usb_control_msg(serial->dev,
699 usb_rcvctrlpipe(serial->dev, 0),
700 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
706 static int option_startup(struct usb_serial *serial)
709 struct usb_serial_port *port;
710 struct option_port_private *portdata;
712 dbg("%s", __FUNCTION__);
714 /* Now setup per port private data */
715 for (i = 0; i < serial->num_ports; i++) {
716 port = serial->port[i];
717 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
719 dbg("%s: kmalloc for option_port_private (%d) failed!.",
724 usb_set_serial_port_data(port, portdata);
726 if (! port->interrupt_in_urb)
728 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
730 dbg("%s: submit irq_in urb failed %d",
734 option_setup_urbs(serial);
739 static void option_shutdown(struct usb_serial *serial)
742 struct usb_serial_port *port;
743 struct option_port_private *portdata;
745 dbg("%s", __FUNCTION__);
747 /* Stop reading/writing urbs */
748 for (i = 0; i < serial->num_ports; ++i) {
749 port = serial->port[i];
750 portdata = usb_get_serial_port_data(port);
751 for (j = 0; j < N_IN_URB; j++)
752 usb_kill_urb(portdata->in_urbs[j]);
753 for (j = 0; j < N_OUT_URB; j++)
754 usb_kill_urb(portdata->out_urbs[j]);
758 for (i = 0; i < serial->num_ports; ++i) {
759 port = serial->port[i];
760 portdata = usb_get_serial_port_data(port);
762 for (j = 0; j < N_IN_URB; j++) {
763 if (portdata->in_urbs[j]) {
764 usb_free_urb(portdata->in_urbs[j]);
765 portdata->in_urbs[j] = NULL;
768 for (j = 0; j < N_OUT_URB; j++) {
769 if (portdata->out_urbs[j]) {
770 usb_free_urb(portdata->out_urbs[j]);
771 portdata->out_urbs[j] = NULL;
776 /* Now free per port private data */
777 for (i = 0; i < serial->num_ports; i++) {
778 port = serial->port[i];
779 kfree(usb_get_serial_port_data(port));
783 MODULE_AUTHOR(DRIVER_AUTHOR);
784 MODULE_DESCRIPTION(DRIVER_DESC);
785 MODULE_VERSION(DRIVER_VERSION);
786 MODULE_LICENSE("GPL");
788 #ifdef CONFIG_USB_DEBUG
789 module_param(debug, bool, S_IRUGO | S_IWUSR);
790 MODULE_PARM_DESC(debug, "Debug messages");