tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 */
46static int option_open(struct usb_serial_port *port, struct file *filp);
47static void option_close(struct usb_serial_port *port, struct file *filp);
48static int option_startup(struct usb_serial *serial);
49static void option_shutdown(struct usb_serial *serial);
50static void option_rx_throttle(struct usb_serial_port *port);
51static void option_rx_unthrottle(struct usb_serial_port *port);
52static int option_write_room(struct usb_serial_port *port);
53
54static void option_instat_callback(struct urb *urb);
55
56static int option_write(struct usb_serial_port *port,
57 const unsigned char *buf, int count);
58
59static int option_chars_in_buffer(struct usb_serial_port *port);
60static int option_ioctl(struct usb_serial_port *port, struct file *file,
61 unsigned int cmd, unsigned long arg);
62static void option_set_termios(struct usb_serial_port *port,
63 struct ktermios *old);
64static void option_break_ctl(struct usb_serial_port *port, int break_state);
65static int option_tiocmget(struct usb_serial_port *port, struct file *file);
66static int option_tiocmset(struct usb_serial_port *port, struct file *file,
67 unsigned int set, unsigned int clear);
68static 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 KYOCERA_VENDOR_ID 0x0c88
117#define KYOCERA_PRODUCT_KPC680 0x180a
118
119#define ANYDATA_VENDOR_ID 0x16d5
120#define ANYDATA_PRODUCT_ADU_E100A 0x6501
121#define ANYDATA_PRODUCT_ADU_500A 0x6502
122
123#define AXESSTEL_VENDOR_ID 0x1726
124#define AXESSTEL_PRODUCT_MV110H 0x1000
125
126#define BANDRICH_VENDOR_ID 0x1A8D
127#define BANDRICH_PRODUCT_C100_1 0x1002
128#define BANDRICH_PRODUCT_C100_2 0x1003
129
130#define QUALCOMM_VENDOR_ID 0x05C6
131
132static struct usb_device_id option_ids[] = {
133 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
134 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
135 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
136 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
137 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
138 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
139 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
140 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
141 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
142 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
143 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
144 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
145 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
146 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
147 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX) },
148 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
149 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
150 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
151 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_LIGHT) },
152 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_GT) },
153 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_EX) },
154 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
155 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_NETWORK) },
156 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
157 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_NETWORK) },
158 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
159 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK) },
160 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
161 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
162 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
163 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_LITE) },
164 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_GT) },
165 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
166 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
167 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
168 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
169 { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220, 0xff, 0xff, 0xff) },
170 { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220BIS, 0xff, 0xff, 0xff) },
171 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1100) }, /* Novatel Merlin XS620/S640 */
172 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1110) }, /* Novatel Merlin S620 */
173 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1120) }, /* Novatel Merlin EX720 */
174 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1130) }, /* Novatel Merlin S720 */
175 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1400) }, /* Novatel U730 */
176 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1410) }, /* Novatel U740 */
177 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1420) }, /* Novatel EU870 */
178 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x1430) }, /* Novatel Merlin XU870 HSDPA/3G */
179 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2100) }, /* Novatel EV620 CDMA/EV-DO */
180 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2110) }, /* Novatel Merlin ES620 / Merlin ES720 / Ovation U720 */
181 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
182 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2410) }, /* Novatel EU740 */
183 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x4100) }, /* Novatel U727 */
184 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x4400) }, /* Novatel MC950 */
185 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x5010) }, /* Novatel U727 */
186 { USB_DEVICE(DELL_VENDOR_ID, 0x8114) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite EV620 CDMA/EV-DO */
187 { USB_DEVICE(DELL_VENDOR_ID, 0x8115) }, /* Dell Wireless 5500 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
188 { USB_DEVICE(DELL_VENDOR_ID, 0x8116) }, /* Dell Wireless 5505 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
189 { USB_DEVICE(DELL_VENDOR_ID, 0x8117) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO ExpressCard == Novatel Merlin XV620 CDMA/EV-DO */
190 { USB_DEVICE(DELL_VENDOR_ID, 0x8118) }, /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard == Novatel Merlin XU870 HSDPA/3G */
191 { USB_DEVICE(DELL_VENDOR_ID, 0x8128) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite E720 CDMA/EV-DO */
192 { USB_DEVICE(DELL_VENDOR_ID, 0x8129) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite ET620 CDMA/EV-DO */
193 { USB_DEVICE(DELL_VENDOR_ID, 0x8133) }, /* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
194 { USB_DEVICE(DELL_VENDOR_ID, 0x8136) }, /* Dell Wireless HSDPA 5520 == Novatel Expedite EU860D */
195 { USB_DEVICE(DELL_VENDOR_ID, 0x8137) }, /* Dell Wireless HSDPA 5520 */
196 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
197 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
198 { USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
199 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
200 { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
201 { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
202 { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
203 { } /* Terminating entry */
204};
205MODULE_DEVICE_TABLE(usb, option_ids);
206
207static struct usb_driver option_driver = {
208 .name = "option",
209 .probe = usb_serial_probe,
210 .disconnect = usb_serial_disconnect,
211 .id_table = option_ids,
212 .no_dynamic_id = 1,
213};
214
215/* The card has three separate interfaces, which the serial driver
216 * recognizes separately, thus num_port=1.
217 */
218
219static struct usb_serial_driver option_1port_device = {
220 .driver = {
221 .owner = THIS_MODULE,
222 .name = "option1",
223 },
224 .description = "GSM modem (1-port)",
225 .usb_driver = &option_driver,
226 .id_table = option_ids,
227 .num_interrupt_in = NUM_DONT_CARE,
228 .num_bulk_in = NUM_DONT_CARE,
229 .num_bulk_out = NUM_DONT_CARE,
230 .num_ports = 1,
231 .open = option_open,
232 .close = option_close,
233 .write = option_write,
234 .write_room = option_write_room,
235 .chars_in_buffer = option_chars_in_buffer,
236 .throttle = option_rx_throttle,
237 .unthrottle = option_rx_unthrottle,
238 .ioctl = option_ioctl,
239 .set_termios = option_set_termios,
240 .break_ctl = option_break_ctl,
241 .tiocmget = option_tiocmget,
242 .tiocmset = option_tiocmset,
243 .attach = option_startup,
244 .shutdown = option_shutdown,
245 .read_int_callback = option_instat_callback,
246};
247
248#ifdef CONFIG_USB_DEBUG
249static int debug;
250#else
251#define debug 0
252#endif
253
254/* per port private data */
255
256#define N_IN_URB 4
257#define N_OUT_URB 1
258#define IN_BUFLEN 4096
259#define OUT_BUFLEN 128
260
261struct option_port_private {
262 /* Input endpoints and buffer for this port */
263 struct urb *in_urbs[N_IN_URB];
264 u8 *in_buffer[N_IN_URB];
265 /* Output endpoints and buffer for this port */
266 struct urb *out_urbs[N_OUT_URB];
267 u8 *out_buffer[N_OUT_URB];
268 unsigned long out_busy; /* Bit vector of URBs in use */
269
270 /* Settings for the port */
271 int rts_state; /* Handshaking pins (outputs) */
272 int dtr_state;
273 int cts_state; /* Handshaking pins (inputs) */
274 int dsr_state;
275 int dcd_state;
276 int ri_state;
277
278 unsigned long tx_start_time[N_OUT_URB];
279};
280
281/* Functions used by new usb-serial code. */
282static int __init option_init(void)
283{
284 int retval;
285 retval = usb_serial_register(&option_1port_device);
286 if (retval)
287 goto failed_1port_device_register;
288 retval = usb_register(&option_driver);
289 if (retval)
290 goto failed_driver_register;
291
292 info(DRIVER_DESC ": " DRIVER_VERSION);
293
294 return 0;
295
296failed_driver_register:
297 usb_serial_deregister (&option_1port_device);
298failed_1port_device_register:
299 return retval;
300}
301
302static void __exit option_exit(void)
303{
304 usb_deregister (&option_driver);
305 usb_serial_deregister (&option_1port_device);
306}
307
308module_init(option_init);
309module_exit(option_exit);
310
311static void option_rx_throttle(struct usb_serial_port *port)
312{
313 dbg("%s", __FUNCTION__);
314}
315
316static void option_rx_unthrottle(struct usb_serial_port *port)
317{
318 dbg("%s", __FUNCTION__);
319}
320
321static void option_break_ctl(struct usb_serial_port *port, int break_state)
322{
323 /* Unfortunately, I don't know how to send a break */
324 dbg("%s", __FUNCTION__);
325}
326
327static void option_set_termios(struct usb_serial_port *port,
328 struct ktermios *old_termios)
329{
330 dbg("%s", __FUNCTION__);
331 /* Doesn't support option setting */
332 tty_termios_copy_hw(port->tty->termios, old_termios);
333 option_send_setup(port);
334}
335
336static int option_tiocmget(struct usb_serial_port *port, struct file *file)
337{
338 unsigned int value;
339 struct option_port_private *portdata;
340
341 portdata = usb_get_serial_port_data(port);
342
343 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
344 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
345 ((portdata->cts_state) ? TIOCM_CTS : 0) |
346 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
347 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
348 ((portdata->ri_state) ? TIOCM_RNG : 0);
349
350 return value;
351}
352
353static int option_tiocmset(struct usb_serial_port *port, struct file *file,
354 unsigned int set, unsigned int clear)
355{
356 struct option_port_private *portdata;
357
358 portdata = usb_get_serial_port_data(port);
359
360 if (set & TIOCM_RTS)
361 portdata->rts_state = 1;
362 if (set & TIOCM_DTR)
363 portdata->dtr_state = 1;
364
365 if (clear & TIOCM_RTS)
366 portdata->rts_state = 0;
367 if (clear & TIOCM_DTR)
368 portdata->dtr_state = 0;
369 return option_send_setup(port);
370}
371
372static int option_ioctl(struct usb_serial_port *port, struct file *file,
373 unsigned int cmd, unsigned long arg)
374{
375 return -ENOIOCTLCMD;
376}
377
378/* Write */
379static int option_write(struct usb_serial_port *port,
380 const unsigned char *buf, int count)
381{
382 struct option_port_private *portdata;
383 int i;
384 int left, todo;
385 struct urb *this_urb = NULL; /* spurious */
386 int err;
387
388 portdata = usb_get_serial_port_data(port);
389
390 dbg("%s: write (%d chars)", __FUNCTION__, count);
391
392 i = 0;
393 left = count;
394 for (i=0; left > 0 && i < N_OUT_URB; i++) {
395 todo = left;
396 if (todo > OUT_BUFLEN)
397 todo = OUT_BUFLEN;
398
399 this_urb = portdata->out_urbs[i];
400 if (test_and_set_bit(i, &portdata->out_busy)) {
401 if (time_before(jiffies,
402 portdata->tx_start_time[i] + 10 * HZ))
403 continue;
404 usb_unlink_urb(this_urb);
405 continue;
406 }
407 if (this_urb->status != 0)
408 dbg("usb_write %p failed (err=%d)",
409 this_urb, this_urb->status);
410
411 dbg("%s: endpoint %d buf %d", __FUNCTION__,
412 usb_pipeendpoint(this_urb->pipe), i);
413
414 /* send the data */
415 memcpy (this_urb->transfer_buffer, buf, todo);
416 this_urb->transfer_buffer_length = todo;
417
418 this_urb->dev = port->serial->dev;
419 err = usb_submit_urb(this_urb, GFP_ATOMIC);
420 if (err) {
421 dbg("usb_submit_urb %p (write bulk) failed "
422 "(%d, has %d)", this_urb,
423 err, this_urb->status);
424 clear_bit(i, &portdata->out_busy);
425 continue;
426 }
427 portdata->tx_start_time[i] = jiffies;
428 buf += todo;
429 left -= todo;
430 }
431
432 count -= left;
433 dbg("%s: wrote (did %d)", __FUNCTION__, count);
434 return count;
435}
436
437static void option_indat_callback(struct urb *urb)
438{
439 int err;
440 int endpoint;
441 struct usb_serial_port *port;
442 struct tty_struct *tty;
443 unsigned char *data = urb->transfer_buffer;
444 int status = urb->status;
445
446 dbg("%s: %p", __FUNCTION__, urb);
447
448 endpoint = usb_pipeendpoint(urb->pipe);
449 port = (struct usb_serial_port *) urb->context;
450
451 if (status) {
452 dbg("%s: nonzero status: %d on endpoint %02x.",
453 __FUNCTION__, status, endpoint);
454 } else {
455 tty = port->tty;
456 if (urb->actual_length) {
457 tty_buffer_request_room(tty, urb->actual_length);
458 tty_insert_flip_string(tty, data, urb->actual_length);
459 tty_flip_buffer_push(tty);
460 } else {
461 dbg("%s: empty read urb received", __FUNCTION__);
462 }
463
464 /* Resubmit urb so we continue receiving */
465 if (port->open_count && status != -ESHUTDOWN) {
466 err = usb_submit_urb(urb, GFP_ATOMIC);
467 if (err)
468 printk(KERN_ERR "%s: resubmit read urb failed. "
469 "(%d)", __FUNCTION__, err);
470 }
471 }
472 return;
473}
474
475static void option_outdat_callback(struct urb *urb)
476{
477 struct usb_serial_port *port;
478 struct option_port_private *portdata;
479 int i;
480
481 dbg("%s", __FUNCTION__);
482
483 port = (struct usb_serial_port *) urb->context;
484
485 usb_serial_port_softint(port);
486
487 portdata = usb_get_serial_port_data(port);
488 for (i = 0; i < N_OUT_URB; ++i) {
489 if (portdata->out_urbs[i] == urb) {
490 smp_mb__before_clear_bit();
491 clear_bit(i, &portdata->out_busy);
492 break;
493 }
494 }
495}
496
497static void option_instat_callback(struct urb *urb)
498{
499 int err;
500 int status = urb->status;
501 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
502 struct option_port_private *portdata = usb_get_serial_port_data(port);
503 struct usb_serial *serial = port->serial;
504
505 dbg("%s", __FUNCTION__);
506 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
507
508 if (status == 0) {
509 struct usb_ctrlrequest *req_pkt =
510 (struct usb_ctrlrequest *)urb->transfer_buffer;
511
512 if (!req_pkt) {
513 dbg("%s: NULL req_pkt\n", __FUNCTION__);
514 return;
515 }
516 if ((req_pkt->bRequestType == 0xA1) &&
517 (req_pkt->bRequest == 0x20)) {
518 int old_dcd_state;
519 unsigned char signals = *((unsigned char *)
520 urb->transfer_buffer +
521 sizeof(struct usb_ctrlrequest));
522
523 dbg("%s: signal x%x", __FUNCTION__, signals);
524
525 old_dcd_state = portdata->dcd_state;
526 portdata->cts_state = 1;
527 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
528 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
529 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
530
531 if (port->tty && !C_CLOCAL(port->tty) &&
532 old_dcd_state && !portdata->dcd_state)
533 tty_hangup(port->tty);
534 } else {
535 dbg("%s: type %x req %x", __FUNCTION__,
536 req_pkt->bRequestType,req_pkt->bRequest);
537 }
538 } else
539 dbg("%s: error %d", __FUNCTION__, status);
540
541 /* Resubmit urb so we continue receiving IRQ data */
542 if (status != -ESHUTDOWN) {
543 urb->dev = serial->dev;
544 err = usb_submit_urb(urb, GFP_ATOMIC);
545 if (err)
546 dbg("%s: resubmit intr urb failed. (%d)",
547 __FUNCTION__, err);
548 }
549}
550
551static int option_write_room(struct usb_serial_port *port)
552{
553 struct option_port_private *portdata;
554 int i;
555 int data_len = 0;
556 struct urb *this_urb;
557
558 portdata = usb_get_serial_port_data(port);
559
560 for (i=0; i < N_OUT_URB; i++) {
561 this_urb = portdata->out_urbs[i];
562 if (this_urb && !test_bit(i, &portdata->out_busy))
563 data_len += OUT_BUFLEN;
564 }
565
566 dbg("%s: %d", __FUNCTION__, data_len);
567 return data_len;
568}
569
570static int option_chars_in_buffer(struct usb_serial_port *port)
571{
572 struct option_port_private *portdata;
573 int i;
574 int data_len = 0;
575 struct urb *this_urb;
576
577 portdata = usb_get_serial_port_data(port);
578
579 for (i=0; i < N_OUT_URB; i++) {
580 this_urb = portdata->out_urbs[i];
581 if (this_urb && test_bit(i, &portdata->out_busy))
582 data_len += this_urb->transfer_buffer_length;
583 }
584 dbg("%s: %d", __FUNCTION__, data_len);
585 return data_len;
586}
587
588static int option_open(struct usb_serial_port *port, struct file *filp)
589{
590 struct option_port_private *portdata;
591 struct usb_serial *serial = port->serial;
592 int i, err;
593 struct urb *urb;
594
595 portdata = usb_get_serial_port_data(port);
596
597 dbg("%s", __FUNCTION__);
598
599 /* Set some sane defaults */
600 portdata->rts_state = 1;
601 portdata->dtr_state = 1;
602
603 /* Reset low level data toggle and start reading from endpoints */
604 for (i = 0; i < N_IN_URB; i++) {
605 urb = portdata->in_urbs[i];
606 if (! urb)
607 continue;
608 if (urb->dev != serial->dev) {
609 dbg("%s: dev %p != %p", __FUNCTION__,
610 urb->dev, serial->dev);
611 continue;
612 }
613
614 /*
615 * make sure endpoint data toggle is synchronized with the
616 * device
617 */
618 usb_clear_halt(urb->dev, urb->pipe);
619
620 err = usb_submit_urb(urb, GFP_KERNEL);
621 if (err) {
622 dbg("%s: submit urb %d failed (%d) %d",
623 __FUNCTION__, i, err,
624 urb->transfer_buffer_length);
625 }
626 }
627
628 /* Reset low level data toggle on out endpoints */
629 for (i = 0; i < N_OUT_URB; i++) {
630 urb = portdata->out_urbs[i];
631 if (! urb)
632 continue;
633 urb->dev = serial->dev;
634 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
635 usb_pipeout(urb->pipe), 0); */
636 }
637
638 port->tty->low_latency = 1;
639
640 option_send_setup(port);
641
642 return (0);
643}
644
645static void option_close(struct usb_serial_port *port, struct file *filp)
646{
647 int i;
648 struct usb_serial *serial = port->serial;
649 struct option_port_private *portdata;
650
651 dbg("%s", __FUNCTION__);
652 portdata = usb_get_serial_port_data(port);
653
654 portdata->rts_state = 0;
655 portdata->dtr_state = 0;
656
657 if (serial->dev) {
658 mutex_lock(&serial->disc_mutex);
659 if (!serial->disconnected)
660 option_send_setup(port);
661 mutex_unlock(&serial->disc_mutex);
662
663 /* Stop reading/writing urbs */
664 for (i = 0; i < N_IN_URB; i++)
665 usb_kill_urb(portdata->in_urbs[i]);
666 for (i = 0; i < N_OUT_URB; i++)
667 usb_kill_urb(portdata->out_urbs[i]);
668 }
669 port->tty = NULL;
670}
671
672/* Helper functions used by option_setup_urbs */
673static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
674 int dir, void *ctx, char *buf, int len,
675 void (*callback)(struct urb *))
676{
677 struct urb *urb;
678
679 if (endpoint == -1)
680 return NULL; /* endpoint not needed */
681
682 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
683 if (urb == NULL) {
684 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
685 return NULL;
686 }
687
688 /* Fill URB using supplied data. */
689 usb_fill_bulk_urb(urb, serial->dev,
690 usb_sndbulkpipe(serial->dev, endpoint) | dir,
691 buf, len, callback, ctx);
692
693 return urb;
694}
695
696/* Setup urbs */
697static void option_setup_urbs(struct usb_serial *serial)
698{
699 int i,j;
700 struct usb_serial_port *port;
701 struct option_port_private *portdata;
702
703 dbg("%s", __FUNCTION__);
704
705 for (i = 0; i < serial->num_ports; i++) {
706 port = serial->port[i];
707 portdata = usb_get_serial_port_data(port);
708
709 /* Do indat endpoints first */
710 for (j = 0; j < N_IN_URB; ++j) {
711 portdata->in_urbs[j] = option_setup_urb (serial,
712 port->bulk_in_endpointAddress, USB_DIR_IN, port,
713 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
714 }
715
716 /* outdat endpoints */
717 for (j = 0; j < N_OUT_URB; ++j) {
718 portdata->out_urbs[j] = option_setup_urb (serial,
719 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
720 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
721 }
722 }
723}
724
725static int option_send_setup(struct usb_serial_port *port)
726{
727 struct usb_serial *serial = port->serial;
728 struct option_port_private *portdata;
729
730 dbg("%s", __FUNCTION__);
731
732 if (port->number != 0)
733 return 0;
734
735 portdata = usb_get_serial_port_data(port);
736
737 if (port->tty) {
738 int val = 0;
739 if (portdata->dtr_state)
740 val |= 0x01;
741 if (portdata->rts_state)
742 val |= 0x02;
743
744 return usb_control_msg(serial->dev,
745 usb_rcvctrlpipe(serial->dev, 0),
746 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
747 }
748
749 return 0;
750}
751
752static int option_startup(struct usb_serial *serial)
753{
754 int i, j, err;
755 struct usb_serial_port *port;
756 struct option_port_private *portdata;
757 u8 *buffer;
758
759 dbg("%s", __FUNCTION__);
760
761 /* Now setup per port private data */
762 for (i = 0; i < serial->num_ports; i++) {
763 port = serial->port[i];
764 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
765 if (!portdata) {
766 dbg("%s: kmalloc for option_port_private (%d) failed!.",
767 __FUNCTION__, i);
768 return (1);
769 }
770
771 for (j = 0; j < N_IN_URB; j++) {
772 buffer = (u8 *)__get_free_page(GFP_KERNEL);
773 if (!buffer)
774 goto bail_out_error;
775 portdata->in_buffer[j] = buffer;
776 }
777
778 for (j = 0; j < N_OUT_URB; j++) {
779 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
780 if (!buffer)
781 goto bail_out_error2;
782 portdata->out_buffer[j] = buffer;
783 }
784
785 usb_set_serial_port_data(port, portdata);
786
787 if (! port->interrupt_in_urb)
788 continue;
789 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
790 if (err)
791 dbg("%s: submit irq_in urb failed %d",
792 __FUNCTION__, err);
793 }
794
795 option_setup_urbs(serial);
796
797 return (0);
798
799bail_out_error2:
800 for (j = 0; j < N_OUT_URB; j++)
801 kfree(portdata->out_buffer[j]);
802bail_out_error:
803 for (j = 0; j < N_IN_URB; j++)
804 if (portdata->in_buffer[j])
805 free_page((unsigned long)portdata->in_buffer[j]);
806 kfree(portdata);
807 return 1;
808}
809
810static void option_shutdown(struct usb_serial *serial)
811{
812 int i, j;
813 struct usb_serial_port *port;
814 struct option_port_private *portdata;
815
816 dbg("%s", __FUNCTION__);
817
818 /* Stop reading/writing urbs */
819 for (i = 0; i < serial->num_ports; ++i) {
820 port = serial->port[i];
821 portdata = usb_get_serial_port_data(port);
822 for (j = 0; j < N_IN_URB; j++)
823 usb_kill_urb(portdata->in_urbs[j]);
824 for (j = 0; j < N_OUT_URB; j++)
825 usb_kill_urb(portdata->out_urbs[j]);
826 }
827
828 /* Now free them */
829 for (i = 0; i < serial->num_ports; ++i) {
830 port = serial->port[i];
831 portdata = usb_get_serial_port_data(port);
832
833 for (j = 0; j < N_IN_URB; j++) {
834 if (portdata->in_urbs[j]) {
835 usb_free_urb(portdata->in_urbs[j]);
836 free_page((unsigned long)portdata->in_buffer[j]);
837 portdata->in_urbs[j] = NULL;
838 }
839 }
840 for (j = 0; j < N_OUT_URB; j++) {
841 if (portdata->out_urbs[j]) {
842 usb_free_urb(portdata->out_urbs[j]);
843 kfree(portdata->out_buffer[j]);
844 portdata->out_urbs[j] = NULL;
845 }
846 }
847 }
848
849 /* Now free per port private data */
850 for (i = 0; i < serial->num_ports; i++) {
851 port = serial->port[i];
852 kfree(usb_get_serial_port_data(port));
853 }
854}
855
856MODULE_AUTHOR(DRIVER_AUTHOR);
857MODULE_DESCRIPTION(DRIVER_DESC);
858MODULE_VERSION(DRIVER_VERSION);
859MODULE_LICENSE("GPL");
860
861#ifdef CONFIG_USB_DEBUG
862module_param(debug, bool, S_IRUGO | S_IWUSR);
863MODULE_PARM_DESC(debug, "Debug messages");
864#endif
865