?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: Let option driver handle Anydata CDMA modems. Remove anydata driver.
[usb.git] / drivers / usb / serial / option.c
blobb020f13b95bb5731583e572ff3db934ae3b8e7d3
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) and multiplex (Sierra) 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/usb.h>
42 #include <linux/usb/serial.h>
43
44 /* Function prototypes */
45 static int option_open(struct usb_serial_port *port, struct file *filp);
46 static void option_close(struct usb_serial_port *port, struct file *filp);
47 static int option_startup(struct usb_serial *serial);
48 static void option_shutdown(struct usb_serial *serial);
49 static void option_rx_throttle(struct usb_serial_port *port);
50 static void option_rx_unthrottle(struct usb_serial_port *port);
51 static int option_write_room(struct usb_serial_port *port);
52
53 static void option_instat_callback(struct urb *urb, struct pt_regs *regs);
54
55 static int option_write(struct usb_serial_port *port,
56 const unsigned char *buf, int count);
57
58 static int option_chars_in_buffer(struct usb_serial_port *port);
59 static int option_ioctl(struct usb_serial_port *port, struct file *file,
60 unsigned int cmd, unsigned long arg);
61 static void option_set_termios(struct usb_serial_port *port,
62 struct termios *old);
63 static void option_break_ctl(struct usb_serial_port *port, int break_state);
64 static int option_tiocmget(struct usb_serial_port *port, struct file *file);
65 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
66 unsigned int set, unsigned int clear);
67 static int option_send_setup(struct usb_serial_port *port);
68
69 /* Vendor and product IDs */
70 #define OPTION_VENDOR_ID 0x0AF0
71 #define HUAWEI_VENDOR_ID 0x12D1
72 #define AUDIOVOX_VENDOR_ID 0x0F3D
73 #define SIERRAWIRELESS_VENDOR_ID 0x1199
74 #define NOVATELWIRELESS_VENDOR_ID 0x1410
75 #define ANYDATA_VENDOR_ID 0x16d5
76
77 #define OPTION_PRODUCT_OLD 0x5000
78 #define OPTION_PRODUCT_FUSION 0x6000
79 #define OPTION_PRODUCT_FUSION2 0x6300
80 #define OPTION_PRODUCT_COBRA 0x6500
81 #define OPTION_PRODUCT_COBRA2 0x6600
82 #define HUAWEI_PRODUCT_E600 0x1001
83 #define AUDIOVOX_PRODUCT_AIRCARD 0x0112
84 #define SIERRAWIRELESS_PRODUCT_MC8755 0x6802
85 #define NOVATELWIRELESS_PRODUCT_U740 0x1400
86 #define ANYDATA_PRODUCT_ID 0x6501
87
88 static struct usb_device_id option_ids[] = {
89 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
90 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
91 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
92 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
93 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
94 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
95 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
96 { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) },
97 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
98 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
99 { } /* Terminating entry */
100 };
101
102 static struct usb_device_id option_ids1[] = {
103 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
104 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
105 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
106 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
107 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
108 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
109 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
110 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
111 { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
112 { } /* Terminating entry */
113 };
114 static struct usb_device_id option_ids3[] = {
115 { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) },
116 { } /* Terminating entry */
117 };
118
119 MODULE_DEVICE_TABLE(usb, option_ids);
120
121 static struct usb_driver option_driver = {
122 .name = "option",
123 .probe = usb_serial_probe,
124 .disconnect = usb_serial_disconnect,
125 .id_table = option_ids,
126 .no_dynamic_id = 1,
127 };
128
129 /* The card has three separate interfaces, which the serial driver
130 * recognizes separately, thus num_port=1.
131 */
132 static struct usb_serial_driver option_3port_device = {
133 .driver = {
134 .owner = THIS_MODULE,
135 .name = "option3",
136 },
137 .description = "GSM modem (3-port)",
138 .id_table = option_ids3,
139 .num_interrupt_in = NUM_DONT_CARE,
140 .num_bulk_in = NUM_DONT_CARE,
141 .num_bulk_out = NUM_DONT_CARE,
142 .num_ports = 3,
143 .open = option_open,
144 .close = option_close,
145 .write = option_write,
146 .write_room = option_write_room,
147 .chars_in_buffer = option_chars_in_buffer,
148 .throttle = option_rx_throttle,
149 .unthrottle = option_rx_unthrottle,
150 .ioctl = option_ioctl,
151 .set_termios = option_set_termios,
152 .break_ctl = option_break_ctl,
153 .tiocmget = option_tiocmget,
154 .tiocmset = option_tiocmset,
155 .attach = option_startup,
156 .shutdown = option_shutdown,
157 .read_int_callback = option_instat_callback,
158 };
159
160 static struct usb_serial_driver option_1port_device = {
161 .driver = {
162 .owner = THIS_MODULE,
163 .name = "option1",
164 },
165 .description = "GSM modem (1-port)",
166 .id_table = option_ids1,
167 .num_interrupt_in = NUM_DONT_CARE,
168 .num_bulk_in = NUM_DONT_CARE,
169 .num_bulk_out = NUM_DONT_CARE,
170 .num_ports = 1,
171 .open = option_open,
172 .close = option_close,
173 .write = option_write,
174 .write_room = option_write_room,
175 .chars_in_buffer = option_chars_in_buffer,
176 .throttle = option_rx_throttle,
177 .unthrottle = option_rx_unthrottle,
178 .ioctl = option_ioctl,
179 .set_termios = option_set_termios,
180 .break_ctl = option_break_ctl,
181 .tiocmget = option_tiocmget,
182 .tiocmset = option_tiocmset,
183 .attach = option_startup,
184 .shutdown = option_shutdown,
185 .read_int_callback = option_instat_callback,
186 };
187
188 #ifdef CONFIG_USB_DEBUG
189 static int debug;
190 #else
191 #define debug 0
192 #endif
193
194 /* per port private data */
195
196 #define N_IN_URB 4
197 #define N_OUT_URB 1
198 #define IN_BUFLEN 4096
199 #define OUT_BUFLEN 128
200
201 struct option_port_private {
202 /* Input endpoints and buffer for this port */
203 struct urb *in_urbs[N_IN_URB];
204 char in_buffer[N_IN_URB][IN_BUFLEN];
205 /* Output endpoints and buffer for this port */
206 struct urb *out_urbs[N_OUT_URB];
207 char out_buffer[N_OUT_URB][OUT_BUFLEN];
208
209 /* Settings for the port */
210 int rts_state; /* Handshaking pins (outputs) */
211 int dtr_state;
212 int cts_state; /* Handshaking pins (inputs) */
213 int dsr_state;
214 int dcd_state;
215 int ri_state;
216
217 unsigned long tx_start_time[N_OUT_URB];
218 };
219
220 /* Functions used by new usb-serial code. */
221 static int __init option_init(void)
222 {
223 int retval;
224 retval = usb_serial_register(&option_1port_device);
225 if (retval)
226 goto failed_1port_device_register;
227 retval = usb_serial_register(&option_3port_device);
228 if (retval)
229 goto failed_3port_device_register;
230 retval = usb_register(&option_driver);
231 if (retval)
232 goto failed_driver_register;
233
234 info(DRIVER_DESC ": " DRIVER_VERSION);
235
236 return 0;
237
238 failed_driver_register:
239 usb_serial_deregister (&option_3port_device);
240 failed_3port_device_register:
241 usb_serial_deregister (&option_1port_device);
242 failed_1port_device_register:
243 return retval;
244 }
245
246 static void __exit option_exit(void)
247 {
248 usb_deregister (&option_driver);
249 usb_serial_deregister (&option_3port_device);
250 usb_serial_deregister (&option_1port_device);
251 }
252
253 module_init(option_init);
254 module_exit(option_exit);
255
256 static void option_rx_throttle(struct usb_serial_port *port)
257 {
258 dbg("%s", __FUNCTION__);
259 }
260
261 static void option_rx_unthrottle(struct usb_serial_port *port)
262 {
263 dbg("%s", __FUNCTION__);
264 }
265
266 static void option_break_ctl(struct usb_serial_port *port, int break_state)
267 {
268 /* Unfortunately, I don't know how to send a break */
269 dbg("%s", __FUNCTION__);
270 }
271
272 static void option_set_termios(struct usb_serial_port *port,
273 struct termios *old_termios)
274 {
275 dbg("%s", __FUNCTION__);
276
277 option_send_setup(port);
278 }
279
280 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
281 {
282 unsigned int value;
283 struct option_port_private *portdata;
284
285 portdata = usb_get_serial_port_data(port);
286
287 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
288 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
289 ((portdata->cts_state) ? TIOCM_CTS : 0) |
290 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
291 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
292 ((portdata->ri_state) ? TIOCM_RNG : 0);
293
294 return value;
295 }
296
297 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
298 unsigned int set, unsigned int clear)
299 {
300 struct option_port_private *portdata;
301
302 portdata = usb_get_serial_port_data(port);
303
304 if (set & TIOCM_RTS)
305 portdata->rts_state = 1;
306 if (set & TIOCM_DTR)
307 portdata->dtr_state = 1;
308
309 if (clear & TIOCM_RTS)
310 portdata->rts_state = 0;
311 if (clear & TIOCM_DTR)
312 portdata->dtr_state = 0;
313 return option_send_setup(port);
314 }
315
316 static int option_ioctl(struct usb_serial_port *port, struct file *file,
317 unsigned int cmd, unsigned long arg)
318 {
319 return -ENOIOCTLCMD;
320 }
321
322 /* Write */
323 static int option_write(struct usb_serial_port *port,
324 const unsigned char *buf, int count)
325 {
326 struct option_port_private *portdata;
327 int i;
328 int left, todo;
329 struct urb *this_urb = NULL; /* spurious */
330 int err;
331
332 portdata = usb_get_serial_port_data(port);
333
334 dbg("%s: write (%d chars)", __FUNCTION__, count);
335
336 i = 0;
337 left = count;
338 for (i=0; left > 0 && i < N_OUT_URB; i++) {
339 todo = left;
340 if (todo > OUT_BUFLEN)
341 todo = OUT_BUFLEN;
342
343 this_urb = portdata->out_urbs[i];
344 if (this_urb->status == -EINPROGRESS) {
345 if (time_before(jiffies,
346 portdata->tx_start_time[i] + 10 * HZ))
347 continue;
348 usb_unlink_urb(this_urb);
349 continue;
350 }
351 if (this_urb->status != 0)
352 dbg("usb_write %p failed (err=%d)",
353 this_urb, this_urb->status);
354
355 dbg("%s: endpoint %d buf %d", __FUNCTION__,
356 usb_pipeendpoint(this_urb->pipe), i);
357
358 /* send the data */
359 memcpy (this_urb->transfer_buffer, buf, todo);
360 this_urb->transfer_buffer_length = todo;
361
362 this_urb->dev = port->serial->dev;
363 err = usb_submit_urb(this_urb, GFP_ATOMIC);
364 if (err) {
365 dbg("usb_submit_urb %p (write bulk) failed "
366 "(%d, has %d)", this_urb,
367 err, this_urb->status);
368 continue;
369 }
370 portdata->tx_start_time[i] = jiffies;
371 buf += todo;
372 left -= todo;
373 }
374
375 count -= left;
376 dbg("%s: wrote (did %d)", __FUNCTION__, count);
377 return count;
378 }
379
380 static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
381 {
382 int err;
383 int endpoint;
384 struct usb_serial_port *port;
385 struct tty_struct *tty;
386 unsigned char *data = urb->transfer_buffer;
387
388 dbg("%s: %p", __FUNCTION__, urb);
389
390 endpoint = usb_pipeendpoint(urb->pipe);
391 port = (struct usb_serial_port *) urb->context;
392
393 if (urb->status) {
394 dbg("%s: nonzero status: %d on endpoint %02x.",
395 __FUNCTION__, urb->status, endpoint);
396 } else {
397 tty = port->tty;
398 if (urb->actual_length) {
399 tty_buffer_request_room(tty, urb->actual_length);
400 tty_insert_flip_string(tty, data, urb->actual_length);
401 tty_flip_buffer_push(tty);
402 } else {
403 dbg("%s: empty read urb received", __FUNCTION__);
404 }
405
406 /* Resubmit urb so we continue receiving */
407 if (port->open_count && urb->status != -ESHUTDOWN) {
408 err = usb_submit_urb(urb, GFP_ATOMIC);
409 if (err)
410 printk(KERN_ERR "%s: resubmit read urb failed. "
411 "(%d)", __FUNCTION__, err);
412 }
413 }
414 return;
415 }
416
417 static void option_outdat_callback(struct urb *urb, struct pt_regs *regs)
418 {
419 struct usb_serial_port *port;
420
421 dbg("%s", __FUNCTION__);
422
423 port = (struct usb_serial_port *) urb->context;
424
425 usb_serial_port_softint(port);
426 }
427
428 static void option_instat_callback(struct urb *urb, struct pt_regs *regs)
429 {
430 int err;
431 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
432 struct option_port_private *portdata = usb_get_serial_port_data(port);
433 struct usb_serial *serial = port->serial;
434
435 dbg("%s", __FUNCTION__);
436 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
437
438 if (urb->status == 0) {
439 struct usb_ctrlrequest *req_pkt =
440 (struct usb_ctrlrequest *)urb->transfer_buffer;
441
442 if (!req_pkt) {
443 dbg("%s: NULL req_pkt\n", __FUNCTION__);
444 return;
445 }
446 if ((req_pkt->bRequestType == 0xA1) &&
447 (req_pkt->bRequest == 0x20)) {
448 int old_dcd_state;
449 unsigned char signals = *((unsigned char *)
450 urb->transfer_buffer +
451 sizeof(struct usb_ctrlrequest));
452
453 dbg("%s: signal x%x", __FUNCTION__, signals);
454
455 old_dcd_state = portdata->dcd_state;
456 portdata->cts_state = 1;
457 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
458 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
459 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
460
461 if (port->tty && !C_CLOCAL(port->tty) &&
462 old_dcd_state && !portdata->dcd_state)
463 tty_hangup(port->tty);
464 } else {
465 dbg("%s: type %x req %x", __FUNCTION__,
466 req_pkt->bRequestType,req_pkt->bRequest);
467 }
468 } else
469 dbg("%s: error %d", __FUNCTION__, urb->status);
470
471 /* Resubmit urb so we continue receiving IRQ data */
472 if (urb->status != -ESHUTDOWN) {
473 urb->dev = serial->dev;
474 err = usb_submit_urb(urb, GFP_ATOMIC);
475 if (err)
476 dbg("%s: resubmit intr urb failed. (%d)",
477 __FUNCTION__, err);
478 }
479 }
480
481 static int option_write_room(struct usb_serial_port *port)
482 {
483 struct option_port_private *portdata;
484 int i;
485 int data_len = 0;
486 struct urb *this_urb;
487
488 portdata = usb_get_serial_port_data(port);
489
490 for (i=0; i < N_OUT_URB; i++) {
491 this_urb = portdata->out_urbs[i];
492 if (this_urb && this_urb->status != -EINPROGRESS)
493 data_len += OUT_BUFLEN;
494 }
495
496 dbg("%s: %d", __FUNCTION__, data_len);
497 return data_len;
498 }
499
500 static int option_chars_in_buffer(struct usb_serial_port *port)
501 {
502 struct option_port_private *portdata;
503 int i;
504 int data_len = 0;
505 struct urb *this_urb;
506
507 portdata = usb_get_serial_port_data(port);
508
509 for (i=0; i < N_OUT_URB; i++) {
510 this_urb = portdata->out_urbs[i];
511 if (this_urb && this_urb->status == -EINPROGRESS)
512 data_len += this_urb->transfer_buffer_length;
513 }
514 dbg("%s: %d", __FUNCTION__, data_len);
515 return data_len;
516 }
517
518 static int option_open(struct usb_serial_port *port, struct file *filp)
519 {
520 struct option_port_private *portdata;
521 struct usb_serial *serial = port->serial;
522 int i, err;
523 struct urb *urb;
524
525 portdata = usb_get_serial_port_data(port);
526
527 dbg("%s", __FUNCTION__);
528
529 /* Set some sane defaults */
530 portdata->rts_state = 1;
531 portdata->dtr_state = 1;
532
533 /* Reset low level data toggle and start reading from endpoints */
534 for (i = 0; i < N_IN_URB; i++) {
535 urb = portdata->in_urbs[i];
536 if (! urb)
537 continue;
538 if (urb->dev != serial->dev) {
539 dbg("%s: dev %p != %p", __FUNCTION__,
540 urb->dev, serial->dev);
541 continue;
542 }
543
544 /*
545 * make sure endpoint data toggle is synchronized with the
546 * device
547 */
548 usb_clear_halt(urb->dev, urb->pipe);
549
550 err = usb_submit_urb(urb, GFP_KERNEL);
551 if (err) {
552 dbg("%s: submit urb %d failed (%d) %d",
553 __FUNCTION__, i, err,
554 urb->transfer_buffer_length);
555 }
556 }
557
558 /* Reset low level data toggle on out endpoints */
559 for (i = 0; i < N_OUT_URB; i++) {
560 urb = portdata->out_urbs[i];
561 if (! urb)
562 continue;
563 urb->dev = serial->dev;
564 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
565 usb_pipeout(urb->pipe), 0); */
566 }
567
568 port->tty->low_latency = 1;
569
570 option_send_setup(port);
571
572 return (0);
573 }
574
575 static inline void stop_urb(struct urb *urb)
576 {
577 if (urb && urb->status == -EINPROGRESS)
578 usb_kill_urb(urb);
579 }
580
581 static void option_close(struct usb_serial_port *port, struct file *filp)
582 {
583 int i;
584 struct usb_serial *serial = port->serial;
585 struct option_port_private *portdata;
586
587 dbg("%s", __FUNCTION__);
588 portdata = usb_get_serial_port_data(port);
589
590 portdata->rts_state = 0;
591 portdata->dtr_state = 0;
592
593 if (serial->dev) {
594 option_send_setup(port);
595
596 /* Stop reading/writing urbs */
597 for (i = 0; i < N_IN_URB; i++)
598 stop_urb(portdata->in_urbs[i]);
599 for (i = 0; i < N_OUT_URB; i++)
600 stop_urb(portdata->out_urbs[i]);
601 }
602 port->tty = NULL;
603 }
604
605 /* Helper functions used by option_setup_urbs */
606 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
607 int dir, void *ctx, char *buf, int len,
608 void (*callback)(struct urb *, struct pt_regs *regs))
609 {
610 struct urb *urb;
611
612 if (endpoint == -1)
613 return NULL; /* endpoint not needed */
614
615 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
616 if (urb == NULL) {
617 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
618 return NULL;
619 }
620
621 /* Fill URB using supplied data. */
622 usb_fill_bulk_urb(urb, serial->dev,
623 usb_sndbulkpipe(serial->dev, endpoint) | dir,
624 buf, len, callback, ctx);
625
626 return urb;
627 }
628
629 /* Setup urbs */
630 static void option_setup_urbs(struct usb_serial *serial)
631 {
632 int i,j;
633 struct usb_serial_port *port;
634 struct option_port_private *portdata;
635
636 dbg("%s", __FUNCTION__);
637
638 for (i = 0; i < serial->num_ports; i++) {
639 port = serial->port[i];
640 portdata = usb_get_serial_port_data(port);
641
642 /* Do indat endpoints first */
643 for (j = 0; j < N_IN_URB; ++j) {
644 portdata->in_urbs[j] = option_setup_urb (serial,
645 port->bulk_in_endpointAddress, USB_DIR_IN, port,
646 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
647 }
648
649 /* outdat endpoints */
650 for (j = 0; j < N_OUT_URB; ++j) {
651 portdata->out_urbs[j] = option_setup_urb (serial,
652 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
653 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
654 }
655 }
656 }
657
658 static int option_send_setup(struct usb_serial_port *port)
659 {
660 struct usb_serial *serial = port->serial;
661 struct option_port_private *portdata;
662
663 dbg("%s", __FUNCTION__);
664
665 portdata = usb_get_serial_port_data(port);
666
667 if (port->tty) {
668 int val = 0;
669 if (portdata->dtr_state)
670 val |= 0x01;
671 if (portdata->rts_state)
672 val |= 0x02;
673
674 return usb_control_msg(serial->dev,
675 usb_rcvctrlpipe(serial->dev, 0),
676 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
677 }
678
679 return 0;
680 }
681
682 static int option_startup(struct usb_serial *serial)
683 {
684 int i, err;
685 struct usb_serial_port *port;
686 struct option_port_private *portdata;
687
688 dbg("%s", __FUNCTION__);
689
690 /* Now setup per port private data */
691 for (i = 0; i < serial->num_ports; i++) {
692 port = serial->port[i];
693 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
694 if (!portdata) {
695 dbg("%s: kmalloc for option_port_private (%d) failed!.",
696 __FUNCTION__, i);
697 return (1);
698 }
699
700 usb_set_serial_port_data(port, portdata);
701
702 if (! port->interrupt_in_urb)
703 continue;
704 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
705 if (err)
706 dbg("%s: submit irq_in urb failed %d",
707 __FUNCTION__, err);
708 }
709
710 option_setup_urbs(serial);
711
712 return (0);
713 }
714
715 static void option_shutdown(struct usb_serial *serial)
716 {
717 int i, j;
718 struct usb_serial_port *port;
719 struct option_port_private *portdata;
720
721 dbg("%s", __FUNCTION__);
722
723 /* Stop reading/writing urbs */
724 for (i = 0; i < serial->num_ports; ++i) {
725 port = serial->port[i];
726 portdata = usb_get_serial_port_data(port);
727 for (j = 0; j < N_IN_URB; j++)
728 stop_urb(portdata->in_urbs[j]);
729 for (j = 0; j < N_OUT_URB; j++)
730 stop_urb(portdata->out_urbs[j]);
731 }
732
733 /* Now free them */
734 for (i = 0; i < serial->num_ports; ++i) {
735 port = serial->port[i];
736 portdata = usb_get_serial_port_data(port);
737
738 for (j = 0; j < N_IN_URB; j++) {
739 if (portdata->in_urbs[j]) {
740 usb_free_urb(portdata->in_urbs[j]);
741 portdata->in_urbs[j] = NULL;
742 }
743 }
744 for (j = 0; j < N_OUT_URB; j++) {
745 if (portdata->out_urbs[j]) {
746 usb_free_urb(portdata->out_urbs[j]);
747 portdata->out_urbs[j] = NULL;
748 }
749 }
750 }
751
752 /* Now free per port private data */
753 for (i = 0; i < serial->num_ports; i++) {
754 port = serial->port[i];
755 kfree(usb_get_serial_port_data(port));
756 }
757 }
758
759 MODULE_AUTHOR(DRIVER_AUTHOR);
760 MODULE_DESCRIPTION(DRIVER_DESC);
761 MODULE_VERSION(DRIVER_VERSION);
762 MODULE_LICENSE("GPL");
763
764 #ifdef CONFIG_USB_DEBUG
765 module_param(debug, bool, S_IRUGO | S_IWUSR);
766 MODULE_PARM_DESC(debug, "Debug messages");
767 #endif
768
USB Experimental Work