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