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