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