?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] rt2x00: Fix rfkill handling
[firewire-audio.git] / drivers / usb / serial / option.c
bloba18659e0700c2da2f4d567500fbf2d6fe5b9df97
1 /*
2 USB Driver for GSM modems
3
4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de>
5
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.
9
10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
11
12 History: see the git log.
13
14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
15
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
21
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.
25
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.
29 */
30
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"
34
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>
44
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);
53
54 static void option_instat_callback(struct urb *urb);
55
56 static int option_write(struct usb_serial_port *port,
57 const unsigned char *buf, int count);
58
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);
69
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
107
108 #define HUAWEI_VENDOR_ID 0x12D1
109 #define HUAWEI_PRODUCT_E600 0x1001
110 #define HUAWEI_PRODUCT_E220 0x1003
111 #define HUAWEI_PRODUCT_E220BIS 0x1004
112
113 #define NOVATELWIRELESS_VENDOR_ID 0x1410
114 #define DELL_VENDOR_ID 0x413C
115
116 #define ANYDATA_VENDOR_ID 0x16d5
117 #define ANYDATA_PRODUCT_ADU_E100A 0x6501
118 #define ANYDATA_PRODUCT_ADU_500A 0x6502
119
120 #define BANDRICH_VENDOR_ID 0x1A8D
121 #define BANDRICH_PRODUCT_C100_1 0x1002
122 #define BANDRICH_PRODUCT_C100_2 0x1003
123
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 */
187 };
188 MODULE_DEVICE_TABLE(usb, option_ids);
189
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,
196 };
197
198 /* The card has three separate interfaces, which the serial driver
199 * recognizes separately, thus num_port=1.
200 */
201
202 static struct usb_serial_driver option_1port_device = {
203 .driver = {
204 .owner = THIS_MODULE,
205 .name = "option1",
206 },
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,
229 };
230
231 #ifdef CONFIG_USB_DEBUG
232 static int debug;
233 #else
234 #define debug 0
235 #endif
236
237 /* per port private data */
238
239 #define N_IN_URB 4
240 #define N_OUT_URB 1
241 #define IN_BUFLEN 4096
242 #define OUT_BUFLEN 128
243
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 */
252
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;
260
261 unsigned long tx_start_time[N_OUT_URB];
262 };
263
264 /* Functions used by new usb-serial code. */
265 static int __init option_init(void)
266 {
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;
274
275 info(DRIVER_DESC ": " DRIVER_VERSION);
276
277 return 0;
278
279 failed_driver_register:
280 usb_serial_deregister (&option_1port_device);
281 failed_1port_device_register:
282 return retval;
283 }
284
285 static void __exit option_exit(void)
286 {
287 usb_deregister (&option_driver);
288 usb_serial_deregister (&option_1port_device);
289 }
290
291 module_init(option_init);
292 module_exit(option_exit);
293
294 static void option_rx_throttle(struct usb_serial_port *port)
295 {
296 dbg("%s", __FUNCTION__);
297 }
298
299 static void option_rx_unthrottle(struct usb_serial_port *port)
300 {
301 dbg("%s", __FUNCTION__);
302 }
303
304 static void option_break_ctl(struct usb_serial_port *port, int break_state)
305 {
306 /* Unfortunately, I don't know how to send a break */
307 dbg("%s", __FUNCTION__);
308 }
309
310 static void option_set_termios(struct usb_serial_port *port,
311 struct ktermios *old_termios)
312 {
313 dbg("%s", __FUNCTION__);
314
315 option_send_setup(port);
316 }
317
318 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
319 {
320 unsigned int value;
321 struct option_port_private *portdata;
322
323 portdata = usb_get_serial_port_data(port);
324
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);
331
332 return value;
333 }
334
335 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
336 unsigned int set, unsigned int clear)
337 {
338 struct option_port_private *portdata;
339
340 portdata = usb_get_serial_port_data(port);
341
342 if (set & TIOCM_RTS)
343 portdata->rts_state = 1;
344 if (set & TIOCM_DTR)
345 portdata->dtr_state = 1;
346
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);
352 }
353
354 static int option_ioctl(struct usb_serial_port *port, struct file *file,
355 unsigned int cmd, unsigned long arg)
356 {
357 return -ENOIOCTLCMD;
358 }
359
360 /* Write */
361 static int option_write(struct usb_serial_port *port,
362 const unsigned char *buf, int count)
363 {
364 struct option_port_private *portdata;
365 int i;
366 int left, todo;
367 struct urb *this_urb = NULL; /* spurious */
368 int err;
369
370 portdata = usb_get_serial_port_data(port);
371
372 dbg("%s: write (%d chars)", __FUNCTION__, count);
373
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;
380
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;
388 }
389 if (this_urb->status != 0)
390 dbg("usb_write %p failed (err=%d)",
391 this_urb, this_urb->status);
392
393 dbg("%s: endpoint %d buf %d", __FUNCTION__,
394 usb_pipeendpoint(this_urb->pipe), i);
395
396 /* send the data */
397 memcpy (this_urb->transfer_buffer, buf, todo);
398 this_urb->transfer_buffer_length = todo;
399
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;
408 }
409 portdata->tx_start_time[i] = jiffies;
410 buf += todo;
411 left -= todo;
412 }
413
414 count -= left;
415 dbg("%s: wrote (did %d)", __FUNCTION__, count);
416 return count;
417 }
418
419 static void option_indat_callback(struct urb *urb)
420 {
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;
427
428 dbg("%s: %p", __FUNCTION__, urb);
429
430 endpoint = usb_pipeendpoint(urb->pipe);
431 port = (struct usb_serial_port *) urb->context;
432
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__);
444 }
445
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);
452 }
453 }
454 return;
455 }
456
457 static void option_outdat_callback(struct urb *urb)
458 {
459 struct usb_serial_port *port;
460 struct option_port_private *portdata;
461 int i;
462
463 dbg("%s", __FUNCTION__);
464
465 port = (struct usb_serial_port *) urb->context;
466
467 usb_serial_port_softint(port);
468
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;
475 }
476 }
477 }
478
479 static void option_instat_callback(struct urb *urb)
480 {
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;
486
487 dbg("%s", __FUNCTION__);
488 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
489
490 if (status == 0) {
491 struct usb_ctrlrequest *req_pkt =
492 (struct usb_ctrlrequest *)urb->transfer_buffer;
493
494 if (!req_pkt) {
495 dbg("%s: NULL req_pkt\n", __FUNCTION__);
496 return;
497 }
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));
504
505 dbg("%s: signal x%x", __FUNCTION__, signals);
506
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);
512
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);
519 }
520 } else
521 dbg("%s: error %d", __FUNCTION__, status);
522
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);
530 }
531 }
532
533 static int option_write_room(struct usb_serial_port *port)
534 {
535 struct option_port_private *portdata;
536 int i;
537 int data_len = 0;
538 struct urb *this_urb;
539
540 portdata = usb_get_serial_port_data(port);
541
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;
546 }
547
548 dbg("%s: %d", __FUNCTION__, data_len);
549 return data_len;
550 }
551
552 static int option_chars_in_buffer(struct usb_serial_port *port)
553 {
554 struct option_port_private *portdata;
555 int i;
556 int data_len = 0;
557 struct urb *this_urb;
558
559 portdata = usb_get_serial_port_data(port);
560
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;
565 }
566 dbg("%s: %d", __FUNCTION__, data_len);
567 return data_len;
568 }
569
570 static int option_open(struct usb_serial_port *port, struct file *filp)
571 {
572 struct option_port_private *portdata;
573 struct usb_serial *serial = port->serial;
574 int i, err;
575 struct urb *urb;
576
577 portdata = usb_get_serial_port_data(port);
578
579 dbg("%s", __FUNCTION__);
580
581 /* Set some sane defaults */
582 portdata->rts_state = 1;
583 portdata->dtr_state = 1;
584
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;
594 }
595
596 /*
597 * make sure endpoint data toggle is synchronized with the
598 * device
599 */
600 usb_clear_halt(urb->dev, urb->pipe);
601
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);
607 }
608 }
609
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); */
618 }
619
620 port->tty->low_latency = 1;
621
622 option_send_setup(port);
623
624 return (0);
625 }
626
627 static void option_close(struct usb_serial_port *port, struct file *filp)
628 {
629 int i;
630 struct usb_serial *serial = port->serial;
631 struct option_port_private *portdata;
632
633 dbg("%s", __FUNCTION__);
634 portdata = usb_get_serial_port_data(port);
635
636 portdata->rts_state = 0;
637 portdata->dtr_state = 0;
638
639 if (serial->dev) {
640 option_send_setup(port);
641
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]);
647 }
648 port->tty = NULL;
649 }
650
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 *))
655 {
656 struct urb *urb;
657
658 if (endpoint == -1)
659 return NULL; /* endpoint not needed */
660
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;
665 }
666
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);
671
672 return urb;
673 }
674
675 /* Setup urbs */
676 static void option_setup_urbs(struct usb_serial *serial)
677 {
678 int i,j;
679 struct usb_serial_port *port;
680 struct option_port_private *portdata;
681
682 dbg("%s", __FUNCTION__);
683
684 for (i = 0; i < serial->num_ports; i++) {
685 port = serial->port[i];
686 portdata = usb_get_serial_port_data(port);
687
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);
693 }
694
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);
700 }
701 }
702 }
703
704 static int option_send_setup(struct usb_serial_port *port)
705 {
706 struct usb_serial *serial = port->serial;
707 struct option_port_private *portdata;
708
709 dbg("%s", __FUNCTION__);
710
711 if (port->number != 0)
712 return 0;
713
714 portdata = usb_get_serial_port_data(port);
715
716 if (port->tty) {
717 int val = 0;
718 if (portdata->dtr_state)
719 val |= 0x01;
720 if (portdata->rts_state)
721 val |= 0x02;
722
723 return usb_control_msg(serial->dev,
724 usb_rcvctrlpipe(serial->dev, 0),
725 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
726 }
727
728 return 0;
729 }
730
731 static int option_startup(struct usb_serial *serial)
732 {
733 int i, err;
734 struct usb_serial_port *port;
735 struct option_port_private *portdata;
736
737 dbg("%s", __FUNCTION__);
738
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);
747 }
748
749 usb_set_serial_port_data(port, portdata);
750
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);
757 }
758
759 option_setup_urbs(serial);
760
761 return (0);
762 }
763
764 static void option_shutdown(struct usb_serial *serial)
765 {
766 int i, j;
767 struct usb_serial_port *port;
768 struct option_port_private *portdata;
769
770 dbg("%s", __FUNCTION__);
771
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]);
780 }
781
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);
786
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;
791 }
792 }
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;
797 }
798 }
799 }
800
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));
805 }
806 }
807
808 MODULE_AUTHOR(DRIVER_AUTHOR);
809 MODULE_DESCRIPTION(DRIVER_DESC);
810 MODULE_VERSION(DRIVER_VERSION);
811 MODULE_LICENSE("GPL");
812
813 #ifdef CONFIG_USB_DEBUG
814 module_param(debug, bool, S_IRUGO | S_IWUSR);
815 MODULE_PARM_DESC(debug, "Debug messages");
816 #endif
817
AMDTP streaming driver for the Linux FireWire stack (Juju)