Merge branch 'for-linus' of git://brick.kernel.dk/data/git/linux-2.6-block
[linux-2.6] / 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 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 HUAWEI_PRODUCT_E600             0x1001
82 #define HUAWEI_PRODUCT_E220             0x1003
83 #define AUDIOVOX_PRODUCT_AIRCARD        0x0112
84 #define NOVATELWIRELESS_PRODUCT_U740    0x1400
85 #define ANYDATA_PRODUCT_ID              0x6501
86
87 static struct usb_device_id option_ids[] = {
88         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
89         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
90         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
91         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
92         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
93         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
94         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
95         { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
96         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
97         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
98         { } /* Terminating entry */
99 };
100
101 static struct usb_device_id option_ids1[] = {
102         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
103         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
104         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
105         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
106         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
107         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
108         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220) },
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
115 MODULE_DEVICE_TABLE(usb, option_ids);
116
117 static struct usb_driver option_driver = {
118         .name       = "option",
119         .probe      = usb_serial_probe,
120         .disconnect = usb_serial_disconnect,
121         .id_table   = option_ids,
122         .no_dynamic_id =        1,
123 };
124
125 /* The card has three separate interfaces, which the serial driver
126  * recognizes separately, thus num_port=1.
127  */
128
129 static struct usb_serial_driver option_1port_device = {
130         .driver = {
131                 .owner =        THIS_MODULE,
132                 .name =         "option1",
133         },
134         .description       = "GSM modem (1-port)",
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         portdata = usb_get_serial_port_data(port);
629
630         if (port->tty) {
631                 int val = 0;
632                 if (portdata->dtr_state)
633                         val |= 0x01;
634                 if (portdata->rts_state)
635                         val |= 0x02;
636
637                 return usb_control_msg(serial->dev,
638                                 usb_rcvctrlpipe(serial->dev, 0),
639                                 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
640         }
641
642         return 0;
643 }
644
645 static int option_startup(struct usb_serial *serial)
646 {
647         int i, err;
648         struct usb_serial_port *port;
649         struct option_port_private *portdata;
650
651         dbg("%s", __FUNCTION__);
652
653         /* Now setup per port private data */
654         for (i = 0; i < serial->num_ports; i++) {
655                 port = serial->port[i];
656                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
657                 if (!portdata) {
658                         dbg("%s: kmalloc for option_port_private (%d) failed!.",
659                                         __FUNCTION__, i);
660                         return (1);
661                 }
662
663                 usb_set_serial_port_data(port, portdata);
664
665                 if (! port->interrupt_in_urb)
666                         continue;
667                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
668                 if (err)
669                         dbg("%s: submit irq_in urb failed %d",
670                                 __FUNCTION__, err);
671         }
672
673         option_setup_urbs(serial);
674
675         return (0);
676 }
677
678 static void option_shutdown(struct usb_serial *serial)
679 {
680         int i, j;
681         struct usb_serial_port *port;
682         struct option_port_private *portdata;
683
684         dbg("%s", __FUNCTION__);
685
686         /* Stop reading/writing urbs */
687         for (i = 0; i < serial->num_ports; ++i) {
688                 port = serial->port[i];
689                 portdata = usb_get_serial_port_data(port);
690                 for (j = 0; j < N_IN_URB; j++)
691                         stop_urb(portdata->in_urbs[j]);
692                 for (j = 0; j < N_OUT_URB; j++)
693                         stop_urb(portdata->out_urbs[j]);
694         }
695
696         /* Now free them */
697         for (i = 0; i < serial->num_ports; ++i) {
698                 port = serial->port[i];
699                 portdata = usb_get_serial_port_data(port);
700
701                 for (j = 0; j < N_IN_URB; j++) {
702                         if (portdata->in_urbs[j]) {
703                                 usb_free_urb(portdata->in_urbs[j]);
704                                 portdata->in_urbs[j] = NULL;
705                         }
706                 }
707                 for (j = 0; j < N_OUT_URB; j++) {
708                         if (portdata->out_urbs[j]) {
709                                 usb_free_urb(portdata->out_urbs[j]);
710                                 portdata->out_urbs[j] = NULL;
711                         }
712                 }
713         }
714
715         /* Now free per port private data */
716         for (i = 0; i < serial->num_ports; i++) {
717                 port = serial->port[i];
718                 kfree(usb_get_serial_port_data(port));
719         }
720 }
721
722 MODULE_AUTHOR(DRIVER_AUTHOR);
723 MODULE_DESCRIPTION(DRIVER_DESC);
724 MODULE_VERSION(DRIVER_VERSION);
725 MODULE_LICENSE("GPL");
726
727 #ifdef CONFIG_USB_DEBUG
728 module_param(debug, bool, S_IRUGO | S_IWUSR);
729 MODULE_PARM_DESC(debug, "Debug messages");
730 #endif
731