projects / deliverable / linux.git / blob
? search:


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