drivers/usb/serial/option.c.2.6.19

   1 /*
   2   USB Driver for GSM modems
   3
   4   Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>
   5
   6   This driver is free software; you can redistribute it and/or modify
   7   it under the terms of Version 2 of the GNU General Public License as
   8   published by the Free Software Foundation.
   9
  10   Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
  11
  12   History: see the git log.
  13
  14   Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
  15
  16   This driver exists because the "normal" serial driver doesn't work too well
  17   with GSM modems. Issues:
  18   - data loss -- one single Receive URB is not nearly enough
  19   - nonstandard flow (Option devices) control
  20   - controlling the baud rate doesn't make sense
  21
  22   This driver is named "option" because the most common device it's
  23   used for is a PC-Card (with an internal OHCI-USB interface, behind
  24   which the GSM interface sits), made by Option Inc.
  25
  26   Some of the "one port" devices actually exhibit multiple USB instances
  27   on the USB bus. This is not a bug, these ports are used for different
  28   device features.
  29 */
  30
  31 #define DRIVER_VERSION "v0.7.1"
  32 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
  33 #define DRIVER_DESC "USB Driver for GSM modems"
  34
  35 #include <linux/kernel.h>
  36 #include <linux/jiffies.h>
  37 #include <linux/errno.h>
  38 #include <linux/tty.h>
  39 #include <linux/tty_flip.h>
  40 #include <linux/module.h>
  41 #include <linux/usb.h>
  42 #include <linux/usb/serial.h>
  43
  44 /* Function prototypes */
  45 static int  option_open(struct usb_serial_port *port, struct file *filp);
  46 static void option_close(struct usb_serial_port *port, struct file *filp);
  47 static int  option_startup(struct usb_serial *serial);
  48 static void option_shutdown(struct usb_serial *serial);
  49 static void option_rx_throttle(struct usb_serial_port *port);
  50 static void option_rx_unthrottle(struct usb_serial_port *port);
  51 static int  option_write_room(struct usb_serial_port *port);
  52
  53 static void option_instat_callback(struct urb *urb);
  54
  55 static int option_write(struct usb_serial_port *port,
  56                         const unsigned char *buf, int count);
  57
  58 static int  option_chars_in_buffer(struct usb_serial_port *port);
  59 static int  option_ioctl(struct usb_serial_port *port, struct file *file,
  60                         unsigned int cmd, unsigned long arg);
  61 static void option_set_termios(struct usb_serial_port *port,
  62                                 struct termios *old);
  63 static void option_break_ctl(struct usb_serial_port *port, int break_state);
  64 static int  option_tiocmget(struct usb_serial_port *port, struct file *file);
  65 static int  option_tiocmset(struct usb_serial_port *port, struct file *file,
  66                                 unsigned int set, unsigned int clear);
  67 static int  option_send_setup(struct usb_serial_port *port);
  68
  69 /* Vendor and product IDs */
  70 #define OPTION_VENDOR_ID                0x0AF0
  71 #define HUAWEI_VENDOR_ID                0x12D1
  72 #define AUDIOVOX_VENDOR_ID              0x0F3D
  73 #define NOVATELWIRELESS_VENDOR_ID       0x1410
  74 #define ANYDATA_VENDOR_ID               0x16d5
  75
  76 #define OPTION_PRODUCT_OLD              0x5000
  77 #define OPTION_PRODUCT_FUSION           0x6000
  78 #define OPTION_PRODUCT_FUSION2          0x6300
  79 #define OPTION_PRODUCT_COBRA            0x6500
  80 #define OPTION_PRODUCT_COBRA2           0x6600
  81 #define HUAWEI_PRODUCT_E600             0x1001
  82 #define AUDIOVOX_PRODUCT_AIRCARD        0x0112
  83 #define NOVATELWIRELESS_PRODUCT_U740    0x1400
  84 #define ANYDATA_PRODUCT_ID              0x6501
  85
  86 static struct usb_device_id option_ids[] = {
  87         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
  88         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
  89         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
  90         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
  91         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
  92         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
  93         { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
  94         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
  95         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
  96         { } /* Terminating entry */
  97 };
  98
  99 static struct usb_device_id option_ids1[] = {
 100         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
 101         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
 102         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
 103         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
 104         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) },
 105         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
 106         { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
 107         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
 108         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
 109         { } /* Terminating entry */
 110 };
 111
 112 MODULE_DEVICE_TABLE(usb, option_ids);
 113
 114 static struct usb_driver option_driver = {
 115         .name       = "option",
 116         .probe      = usb_serial_probe,
 117         .disconnect = usb_serial_disconnect,
 118         .id_table   = option_ids,
 119         .no_dynamic_id =        1,
 120 };
 121
 122 /* The card has three separate interfaces, which the serial driver
 123  * recognizes separately, thus num_port=1.
 124  */
 125
 126 static struct usb_serial_device_type option_1port_device = {
 127         /*
 128         .driver = {
 129                 .owner =        THIS_MODULE,
 130                 .name =         "option1",
 131         },
 132         */
 133         .owner =        THIS_MODULE,
 134         .name              = "Option 3G data card",
 135         .short_name        = "option",
 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 termios *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         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