pcmcia: CompactFlash driver for PA Semi Electra boards
[pv_ops_mirror.git] / drivers / usb / serial / option.c
bloba18659e0700c2da2f4d567500fbf2d6fe5b9df97
1 /*
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
28 device features.
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/bitops.h>
42 #include <linux/usb.h>
43 #include <linux/usb/serial.h>
45 /* Function prototypes */
46 static int option_open(struct usb_serial_port *port, struct file *filp);
47 static void option_close(struct usb_serial_port *port, struct file *filp);
48 static int option_startup(struct usb_serial *serial);
49 static void option_shutdown(struct usb_serial *serial);
50 static void option_rx_throttle(struct usb_serial_port *port);
51 static void option_rx_unthrottle(struct usb_serial_port *port);
52 static int option_write_room(struct usb_serial_port *port);
54 static void option_instat_callback(struct urb *urb);
56 static int option_write(struct usb_serial_port *port,
57 const unsigned char *buf, int count);
59 static int option_chars_in_buffer(struct usb_serial_port *port);
60 static int option_ioctl(struct usb_serial_port *port, struct file *file,
61 unsigned int cmd, unsigned long arg);
62 static void option_set_termios(struct usb_serial_port *port,
63 struct ktermios *old);
64 static void option_break_ctl(struct usb_serial_port *port, int break_state);
65 static int option_tiocmget(struct usb_serial_port *port, struct file *file);
66 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
67 unsigned int set, unsigned int clear);
68 static int option_send_setup(struct usb_serial_port *port);
70 /* Vendor and product IDs */
71 #define OPTION_VENDOR_ID 0x0AF0
72 #define OPTION_PRODUCT_COLT 0x5000
73 #define OPTION_PRODUCT_RICOLA 0x6000
74 #define OPTION_PRODUCT_RICOLA_LIGHT 0x6100
75 #define OPTION_PRODUCT_RICOLA_QUAD 0x6200
76 #define OPTION_PRODUCT_RICOLA_QUAD_LIGHT 0x6300
77 #define OPTION_PRODUCT_RICOLA_NDIS 0x6050
78 #define OPTION_PRODUCT_RICOLA_NDIS_LIGHT 0x6150
79 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD 0x6250
80 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT 0x6350
81 #define OPTION_PRODUCT_COBRA 0x6500
82 #define OPTION_PRODUCT_COBRA_BUS 0x6501
83 #define OPTION_PRODUCT_VIPER 0x6600
84 #define OPTION_PRODUCT_VIPER_BUS 0x6601
85 #define OPTION_PRODUCT_GT_MAX_READY 0x6701
86 #define OPTION_PRODUCT_GT_MAX 0x6711
87 #define OPTION_PRODUCT_FUJI_MODEM_LIGHT 0x6721
88 #define OPTION_PRODUCT_FUJI_MODEM_GT 0x6741
89 #define OPTION_PRODUCT_FUJI_MODEM_EX 0x6761
90 #define OPTION_PRODUCT_FUJI_NETWORK_LIGHT 0x6731
91 #define OPTION_PRODUCT_FUJI_NETWORK_GT 0x6751
92 #define OPTION_PRODUCT_FUJI_NETWORK_EX 0x6771
93 #define OPTION_PRODUCT_KOI_MODEM 0x6800
94 #define OPTION_PRODUCT_KOI_NETWORK 0x6811
95 #define OPTION_PRODUCT_SCORPION_MODEM 0x6901
96 #define OPTION_PRODUCT_SCORPION_NETWORK 0x6911
97 #define OPTION_PRODUCT_ETNA_MODEM 0x7001
98 #define OPTION_PRODUCT_ETNA_NETWORK 0x7011
99 #define OPTION_PRODUCT_ETNA_MODEM_LITE 0x7021
100 #define OPTION_PRODUCT_ETNA_MODEM_GT 0x7041
101 #define OPTION_PRODUCT_ETNA_MODEM_EX 0x7061
102 #define OPTION_PRODUCT_ETNA_NETWORK_LITE 0x7031
103 #define OPTION_PRODUCT_ETNA_NETWORK_GT 0x7051
104 #define OPTION_PRODUCT_ETNA_NETWORK_EX 0x7071
105 #define OPTION_PRODUCT_ETNA_KOI_MODEM 0x7100
106 #define OPTION_PRODUCT_ETNA_KOI_NETWORK 0x7111
108 #define HUAWEI_VENDOR_ID 0x12D1
109 #define HUAWEI_PRODUCT_E600 0x1001
110 #define HUAWEI_PRODUCT_E220 0x1003
111 #define HUAWEI_PRODUCT_E220BIS 0x1004
113 #define NOVATELWIRELESS_VENDOR_ID 0x1410
114 #define DELL_VENDOR_ID 0x413C
116 #define ANYDATA_VENDOR_ID 0x16d5
117 #define ANYDATA_PRODUCT_ADU_E100A 0x6501
118 #define ANYDATA_PRODUCT_ADU_500A 0x6502
120 #define BANDRICH_VENDOR_ID 0x1A8D
121 #define BANDRICH_PRODUCT_C100_1 0x1002
122 #define BANDRICH_PRODUCT_C100_2 0x1003
124 static struct usb_device_id option_ids[] = {
125 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
126 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
127 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
128 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
129 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
130 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
131 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
132 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
133 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
134 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
135 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
136 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
137 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
138 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
139 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX) },
140 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
141 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
142 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
143 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_LIGHT) },
144 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_GT) },
145 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_EX) },
146 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
147 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_NETWORK) },
148 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
149 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_NETWORK) },
150 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
151 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK) },
152 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
153 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
154 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
155 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_LITE) },
156 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_GT) },
157 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
158 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
159 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
160 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
161 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
162 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220BIS) },
163 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1100) }, /* Novatel Merlin XS620/S640 */
164 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1110) }, /* Novatel Merlin S620 */
165 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1120) }, /* Novatel Merlin EX720 */
166 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1130) }, /* Novatel Merlin S720 */
167 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1400) }, /* Novatel U730 */
168 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1410) }, /* Novatel U740 */
169 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1420) }, /* Novatel EU870 */
170 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1430) }, /* Novatel Merlin XU870 HSDPA/3G */
171 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2100) }, /* Novatel EV620 CDMA/EV-DO */
172 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2110) }, /* Novatel Merlin ES620 / Merlin ES720 / Ovation U720 */
173 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
174 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2410) }, /* Novatel EU740 */
175 { USB_DEVICE(DELL_VENDOR_ID, 0x8114) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite EV620 CDMA/EV-DO */
176 { USB_DEVICE(DELL_VENDOR_ID, 0x8115) }, /* Dell Wireless 5500 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
177 { USB_DEVICE(DELL_VENDOR_ID, 0x8116) }, /* Dell Wireless 5505 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
178 { USB_DEVICE(DELL_VENDOR_ID, 0x8117) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO ExpressCard == Novatel Merlin XV620 CDMA/EV-DO */
179 { USB_DEVICE(DELL_VENDOR_ID, 0x8118) }, /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard == Novatel Merlin XU870 HSDPA/3G */
180 { USB_DEVICE(DELL_VENDOR_ID, 0x8128) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite E720 CDMA/EV-DO */
181 { USB_DEVICE(DELL_VENDOR_ID, 0x8137) }, /* Dell Wireless HSDPA 5520 */
182 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
183 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
184 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
185 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
186 { } /* Terminating entry */
188 MODULE_DEVICE_TABLE(usb, option_ids);
190 static struct usb_driver option_driver = {
191 .name = "option",
192 .probe = usb_serial_probe,
193 .disconnect = usb_serial_disconnect,
194 .id_table = option_ids,
195 .no_dynamic_id = 1,
198 /* The card has three separate interfaces, which the serial driver
199 * recognizes separately, thus num_port=1.
202 static struct usb_serial_driver option_1port_device = {
203 .driver = {
204 .owner = THIS_MODULE,
205 .name = "option1",
207 .description = "GSM modem (1-port)",
208 .usb_driver = &option_driver,
209 .id_table = option_ids,
210 .num_interrupt_in = NUM_DONT_CARE,
211 .num_bulk_in = NUM_DONT_CARE,
212 .num_bulk_out = NUM_DONT_CARE,
213 .num_ports = 1,
214 .open = option_open,
215 .close = option_close,
216 .write = option_write,
217 .write_room = option_write_room,
218 .chars_in_buffer = option_chars_in_buffer,
219 .throttle = option_rx_throttle,
220 .unthrottle = option_rx_unthrottle,
221 .ioctl = option_ioctl,
222 .set_termios = option_set_termios,
223 .break_ctl = option_break_ctl,
224 .tiocmget = option_tiocmget,
225 .tiocmset = option_tiocmset,
226 .attach = option_startup,
227 .shutdown = option_shutdown,
228 .read_int_callback = option_instat_callback,
231 #ifdef CONFIG_USB_DEBUG
232 static int debug;
233 #else
234 #define debug 0
235 #endif
237 /* per port private data */
239 #define N_IN_URB 4
240 #define N_OUT_URB 1
241 #define IN_BUFLEN 4096
242 #define OUT_BUFLEN 128
244 struct option_port_private {
245 /* Input endpoints and buffer for this port */
246 struct urb *in_urbs[N_IN_URB];
247 char in_buffer[N_IN_URB][IN_BUFLEN];
248 /* Output endpoints and buffer for this port */
249 struct urb *out_urbs[N_OUT_URB];
250 char out_buffer[N_OUT_URB][OUT_BUFLEN];
251 unsigned long out_busy; /* Bit vector of URBs in use */
253 /* Settings for the port */
254 int rts_state; /* Handshaking pins (outputs) */
255 int dtr_state;
256 int cts_state; /* Handshaking pins (inputs) */
257 int dsr_state;
258 int dcd_state;
259 int ri_state;
261 unsigned long tx_start_time[N_OUT_URB];
264 /* Functions used by new usb-serial code. */
265 static int __init option_init(void)
267 int retval;
268 retval = usb_serial_register(&option_1port_device);
269 if (retval)
270 goto failed_1port_device_register;
271 retval = usb_register(&option_driver);
272 if (retval)
273 goto failed_driver_register;
275 info(DRIVER_DESC ": " DRIVER_VERSION);
277 return 0;
279 failed_driver_register:
280 usb_serial_deregister (&option_1port_device);
281 failed_1port_device_register:
282 return retval;
285 static void __exit option_exit(void)
287 usb_deregister (&option_driver);
288 usb_serial_deregister (&option_1port_device);
291 module_init(option_init);
292 module_exit(option_exit);
294 static void option_rx_throttle(struct usb_serial_port *port)
296 dbg("%s", __FUNCTION__);
299 static void option_rx_unthrottle(struct usb_serial_port *port)
301 dbg("%s", __FUNCTION__);
304 static void option_break_ctl(struct usb_serial_port *port, int break_state)
306 /* Unfortunately, I don't know how to send a break */
307 dbg("%s", __FUNCTION__);
310 static void option_set_termios(struct usb_serial_port *port,
311 struct ktermios *old_termios)
313 dbg("%s", __FUNCTION__);
315 option_send_setup(port);
318 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
320 unsigned int value;
321 struct option_port_private *portdata;
323 portdata = usb_get_serial_port_data(port);
325 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
326 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
327 ((portdata->cts_state) ? TIOCM_CTS : 0) |
328 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
329 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
330 ((portdata->ri_state) ? TIOCM_RNG : 0);
332 return value;
335 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
336 unsigned int set, unsigned int clear)
338 struct option_port_private *portdata;
340 portdata = usb_get_serial_port_data(port);
342 if (set & TIOCM_RTS)
343 portdata->rts_state = 1;
344 if (set & TIOCM_DTR)
345 portdata->dtr_state = 1;
347 if (clear & TIOCM_RTS)
348 portdata->rts_state = 0;
349 if (clear & TIOCM_DTR)
350 portdata->dtr_state = 0;
351 return option_send_setup(port);
354 static int option_ioctl(struct usb_serial_port *port, struct file *file,
355 unsigned int cmd, unsigned long arg)
357 return -ENOIOCTLCMD;
360 /* Write */
361 static int option_write(struct usb_serial_port *port,
362 const unsigned char *buf, int count)
364 struct option_port_private *portdata;
365 int i;
366 int left, todo;
367 struct urb *this_urb = NULL; /* spurious */
368 int err;
370 portdata = usb_get_serial_port_data(port);
372 dbg("%s: write (%d chars)", __FUNCTION__, count);
374 i = 0;
375 left = count;
376 for (i=0; left > 0 && i < N_OUT_URB; i++) {
377 todo = left;
378 if (todo > OUT_BUFLEN)
379 todo = OUT_BUFLEN;
381 this_urb = portdata->out_urbs[i];
382 if (test_and_set_bit(i, &portdata->out_busy)) {
383 if (time_before(jiffies,
384 portdata->tx_start_time[i] + 10 * HZ))
385 continue;
386 usb_unlink_urb(this_urb);
387 continue;
389 if (this_urb->status != 0)
390 dbg("usb_write %p failed (err=%d)",
391 this_urb, this_urb->status);
393 dbg("%s: endpoint %d buf %d", __FUNCTION__,
394 usb_pipeendpoint(this_urb->pipe), i);
396 /* send the data */
397 memcpy (this_urb->transfer_buffer, buf, todo);
398 this_urb->transfer_buffer_length = todo;
400 this_urb->dev = port->serial->dev;
401 err = usb_submit_urb(this_urb, GFP_ATOMIC);
402 if (err) {
403 dbg("usb_submit_urb %p (write bulk) failed "
404 "(%d, has %d)", this_urb,
405 err, this_urb->status);
406 clear_bit(i, &portdata->out_busy);
407 continue;
409 portdata->tx_start_time[i] = jiffies;
410 buf += todo;
411 left -= todo;
414 count -= left;
415 dbg("%s: wrote (did %d)", __FUNCTION__, count);
416 return count;
419 static void option_indat_callback(struct urb *urb)
421 int err;
422 int endpoint;
423 struct usb_serial_port *port;
424 struct tty_struct *tty;
425 unsigned char *data = urb->transfer_buffer;
426 int status = urb->status;
428 dbg("%s: %p", __FUNCTION__, urb);
430 endpoint = usb_pipeendpoint(urb->pipe);
431 port = (struct usb_serial_port *) urb->context;
433 if (status) {
434 dbg("%s: nonzero status: %d on endpoint %02x.",
435 __FUNCTION__, status, endpoint);
436 } else {
437 tty = port->tty;
438 if (urb->actual_length) {
439 tty_buffer_request_room(tty, urb->actual_length);
440 tty_insert_flip_string(tty, data, urb->actual_length);
441 tty_flip_buffer_push(tty);
442 } else {
443 dbg("%s: empty read urb received", __FUNCTION__);
446 /* Resubmit urb so we continue receiving */
447 if (port->open_count && status != -ESHUTDOWN) {
448 err = usb_submit_urb(urb, GFP_ATOMIC);
449 if (err)
450 printk(KERN_ERR "%s: resubmit read urb failed. "
451 "(%d)", __FUNCTION__, err);
454 return;
457 static void option_outdat_callback(struct urb *urb)
459 struct usb_serial_port *port;
460 struct option_port_private *portdata;
461 int i;
463 dbg("%s", __FUNCTION__);
465 port = (struct usb_serial_port *) urb->context;
467 usb_serial_port_softint(port);
469 portdata = usb_get_serial_port_data(port);
470 for (i = 0; i < N_OUT_URB; ++i) {
471 if (portdata->out_urbs[i] == urb) {
472 smp_mb__before_clear_bit();
473 clear_bit(i, &portdata->out_busy);
474 break;
479 static void option_instat_callback(struct urb *urb)
481 int err;
482 int status = urb->status;
483 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
484 struct option_port_private *portdata = usb_get_serial_port_data(port);
485 struct usb_serial *serial = port->serial;
487 dbg("%s", __FUNCTION__);
488 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
490 if (status == 0) {
491 struct usb_ctrlrequest *req_pkt =
492 (struct usb_ctrlrequest *)urb->transfer_buffer;
494 if (!req_pkt) {
495 dbg("%s: NULL req_pkt\n", __FUNCTION__);
496 return;
498 if ((req_pkt->bRequestType == 0xA1) &&
499 (req_pkt->bRequest == 0x20)) {
500 int old_dcd_state;
501 unsigned char signals = *((unsigned char *)
502 urb->transfer_buffer +
503 sizeof(struct usb_ctrlrequest));
505 dbg("%s: signal x%x", __FUNCTION__, signals);
507 old_dcd_state = portdata->dcd_state;
508 portdata->cts_state = 1;
509 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
510 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
511 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
513 if (port->tty && !C_CLOCAL(port->tty) &&
514 old_dcd_state && !portdata->dcd_state)
515 tty_hangup(port->tty);
516 } else {
517 dbg("%s: type %x req %x", __FUNCTION__,
518 req_pkt->bRequestType,req_pkt->bRequest);
520 } else
521 dbg("%s: error %d", __FUNCTION__, status);
523 /* Resubmit urb so we continue receiving IRQ data */
524 if (status != -ESHUTDOWN) {
525 urb->dev = serial->dev;
526 err = usb_submit_urb(urb, GFP_ATOMIC);
527 if (err)
528 dbg("%s: resubmit intr urb failed. (%d)",
529 __FUNCTION__, err);
533 static int option_write_room(struct usb_serial_port *port)
535 struct option_port_private *portdata;
536 int i;
537 int data_len = 0;
538 struct urb *this_urb;
540 portdata = usb_get_serial_port_data(port);
542 for (i=0; i < N_OUT_URB; i++) {
543 this_urb = portdata->out_urbs[i];
544 if (this_urb && !test_bit(i, &portdata->out_busy))
545 data_len += OUT_BUFLEN;
548 dbg("%s: %d", __FUNCTION__, data_len);
549 return data_len;
552 static int option_chars_in_buffer(struct usb_serial_port *port)
554 struct option_port_private *portdata;
555 int i;
556 int data_len = 0;
557 struct urb *this_urb;
559 portdata = usb_get_serial_port_data(port);
561 for (i=0; i < N_OUT_URB; i++) {
562 this_urb = portdata->out_urbs[i];
563 if (this_urb && test_bit(i, &portdata->out_busy))
564 data_len += this_urb->transfer_buffer_length;
566 dbg("%s: %d", __FUNCTION__, data_len);
567 return data_len;
570 static int option_open(struct usb_serial_port *port, struct file *filp)
572 struct option_port_private *portdata;
573 struct usb_serial *serial = port->serial;
574 int i, err;
575 struct urb *urb;
577 portdata = usb_get_serial_port_data(port);
579 dbg("%s", __FUNCTION__);
581 /* Set some sane defaults */
582 portdata->rts_state = 1;
583 portdata->dtr_state = 1;
585 /* Reset low level data toggle and start reading from endpoints */
586 for (i = 0; i < N_IN_URB; i++) {
587 urb = portdata->in_urbs[i];
588 if (! urb)
589 continue;
590 if (urb->dev != serial->dev) {
591 dbg("%s: dev %p != %p", __FUNCTION__,
592 urb->dev, serial->dev);
593 continue;
597 * make sure endpoint data toggle is synchronized with the
598 * device
600 usb_clear_halt(urb->dev, urb->pipe);
602 err = usb_submit_urb(urb, GFP_KERNEL);
603 if (err) {
604 dbg("%s: submit urb %d failed (%d) %d",
605 __FUNCTION__, i, err,
606 urb->transfer_buffer_length);
610 /* Reset low level data toggle on out endpoints */
611 for (i = 0; i < N_OUT_URB; i++) {
612 urb = portdata->out_urbs[i];
613 if (! urb)
614 continue;
615 urb->dev = serial->dev;
616 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
617 usb_pipeout(urb->pipe), 0); */
620 port->tty->low_latency = 1;
622 option_send_setup(port);
624 return (0);
627 static void option_close(struct usb_serial_port *port, struct file *filp)
629 int i;
630 struct usb_serial *serial = port->serial;
631 struct option_port_private *portdata;
633 dbg("%s", __FUNCTION__);
634 portdata = usb_get_serial_port_data(port);
636 portdata->rts_state = 0;
637 portdata->dtr_state = 0;
639 if (serial->dev) {
640 option_send_setup(port);
642 /* Stop reading/writing urbs */
643 for (i = 0; i < N_IN_URB; i++)
644 usb_kill_urb(portdata->in_urbs[i]);
645 for (i = 0; i < N_OUT_URB; i++)
646 usb_kill_urb(portdata->out_urbs[i]);
648 port->tty = NULL;
651 /* Helper functions used by option_setup_urbs */
652 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
653 int dir, void *ctx, char *buf, int len,
654 void (*callback)(struct urb *))
656 struct urb *urb;
658 if (endpoint == -1)
659 return NULL; /* endpoint not needed */
661 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
662 if (urb == NULL) {
663 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
664 return NULL;
667 /* Fill URB using supplied data. */
668 usb_fill_bulk_urb(urb, serial->dev,
669 usb_sndbulkpipe(serial->dev, endpoint) | dir,
670 buf, len, callback, ctx);
672 return urb;
675 /* Setup urbs */
676 static void option_setup_urbs(struct usb_serial *serial)
678 int i,j;
679 struct usb_serial_port *port;
680 struct option_port_private *portdata;
682 dbg("%s", __FUNCTION__);
684 for (i = 0; i < serial->num_ports; i++) {
685 port = serial->port[i];
686 portdata = usb_get_serial_port_data(port);
688 /* Do indat endpoints first */
689 for (j = 0; j < N_IN_URB; ++j) {
690 portdata->in_urbs[j] = option_setup_urb (serial,
691 port->bulk_in_endpointAddress, USB_DIR_IN, port,
692 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
695 /* outdat endpoints */
696 for (j = 0; j < N_OUT_URB; ++j) {
697 portdata->out_urbs[j] = option_setup_urb (serial,
698 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
699 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
704 static int option_send_setup(struct usb_serial_port *port)
706 struct usb_serial *serial = port->serial;
707 struct option_port_private *portdata;
709 dbg("%s", __FUNCTION__);
711 if (port->number != 0)
712 return 0;
714 portdata = usb_get_serial_port_data(port);
716 if (port->tty) {
717 int val = 0;
718 if (portdata->dtr_state)
719 val |= 0x01;
720 if (portdata->rts_state)
721 val |= 0x02;
723 return usb_control_msg(serial->dev,
724 usb_rcvctrlpipe(serial->dev, 0),
725 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
728 return 0;
731 static int option_startup(struct usb_serial *serial)
733 int i, err;
734 struct usb_serial_port *port;
735 struct option_port_private *portdata;
737 dbg("%s", __FUNCTION__);
739 /* Now setup per port private data */
740 for (i = 0; i < serial->num_ports; i++) {
741 port = serial->port[i];
742 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
743 if (!portdata) {
744 dbg("%s: kmalloc for option_port_private (%d) failed!.",
745 __FUNCTION__, i);
746 return (1);
749 usb_set_serial_port_data(port, portdata);
751 if (! port->interrupt_in_urb)
752 continue;
753 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
754 if (err)
755 dbg("%s: submit irq_in urb failed %d",
756 __FUNCTION__, err);
759 option_setup_urbs(serial);
761 return (0);
764 static void option_shutdown(struct usb_serial *serial)
766 int i, j;
767 struct usb_serial_port *port;
768 struct option_port_private *portdata;
770 dbg("%s", __FUNCTION__);
772 /* Stop reading/writing urbs */
773 for (i = 0; i < serial->num_ports; ++i) {
774 port = serial->port[i];
775 portdata = usb_get_serial_port_data(port);
776 for (j = 0; j < N_IN_URB; j++)
777 usb_kill_urb(portdata->in_urbs[j]);
778 for (j = 0; j < N_OUT_URB; j++)
779 usb_kill_urb(portdata->out_urbs[j]);
782 /* Now free them */
783 for (i = 0; i < serial->num_ports; ++i) {
784 port = serial->port[i];
785 portdata = usb_get_serial_port_data(port);
787 for (j = 0; j < N_IN_URB; j++) {
788 if (portdata->in_urbs[j]) {
789 usb_free_urb(portdata->in_urbs[j]);
790 portdata->in_urbs[j] = NULL;
793 for (j = 0; j < N_OUT_URB; j++) {
794 if (portdata->out_urbs[j]) {
795 usb_free_urb(portdata->out_urbs[j]);
796 portdata->out_urbs[j] = NULL;
801 /* Now free per port private data */
802 for (i = 0; i < serial->num_ports; i++) {
803 port = serial->port[i];
804 kfree(usb_get_serial_port_data(port));
808 MODULE_AUTHOR(DRIVER_AUTHOR);
809 MODULE_DESCRIPTION(DRIVER_DESC);
810 MODULE_VERSION(DRIVER_VERSION);
811 MODULE_LICENSE("GPL");
813 #ifdef CONFIG_USB_DEBUG
814 module_param(debug, bool, S_IRUGO | S_IWUSR);
815 MODULE_PARM_DESC(debug, "Debug messages");
816 #endif