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