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