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