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:
  13
  14   2005-05-19  v0.1   Initial version, based on incomplete docs
  15                      and analysis of misbehavior with the standard driver
  16   2005-05-20  v0.2   Extended the input buffer to avoid losing
  17                      random 64-byte chunks of data
  18   2005-05-21  v0.3   implemented chars_in_buffer()
  19                      turned on low_latency
  20                      simplified the code somewhat
  21   2005-05-24  v0.4   option_write() sometimes deadlocked under heavy load
  22                      removed some dead code
  23                      added sponsor notice
  24                      coding style clean-up
  25   2005-06-20  v0.4.1 add missing braces :-/
  26                      killed end-of-line whitespace
  27   2005-07-15  v0.4.2 rename WLAN product to FUSION, add FUSION2
  28   2005-09-10  v0.4.3 added HUAWEI E600 card and Audiovox AirCard
  29   2005-09-20  v0.4.4 increased recv buffer size: the card sometimes
  30                      wants to send >2000 bytes.
  31   2006-04-10  v0.5   fixed two array overrun errors :-/
  32   2006-04-21  v0.5.1 added support for Sierra Wireless MC8755
  33   2006-05-15  v0.6   re-enable multi-port support
  34   2006-06-01  v0.6.1 add COBRA
  35   2006-06-01  v0.6.2 add backwards-compatibility stuff
  36   2006-06-01  v0.6.3 add Novatel Wireless
  37   2006-06-01  v0.7   Option => GSM
  38
  39   Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
  40
  41   This driver exists because the "normal" serial driver doesn't work too well
  42   with GSM modems. Issues:
  43   - data loss -- one single Receive URB is not nearly enough
  44   - nonstandard flow (Option devices) and multiplex (Sierra) control
  45   - controlling the baud rate doesn't make sense
  46
  47   This driver is named "option" because the most common device it's
  48   used for is a PC-Card (with an internal OHCI-USB interface, behind
  49   which the GSM interface sits), made by Option Inc.
  50
  51   Some of the "one port" devices actually exhibit multiple USB instances
  52   on the USB bus. This is not a bug, these ports are used for different
  53   device features.
  54 */
  55
  56 #define DRIVER_VERSION "v0.7.0"
  57 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
  58 #define DRIVER_DESC "USB Driver for GSM modems"
  59
  60 #include <linux/kernel.h>
  61 #include <linux/jiffies.h>
  62 #include <linux/errno.h>
  63 #include <linux/tty.h>
  64 #include <linux/tty_flip.h>
  65 #include <linux/module.h>
  66 #include <linux/usb.h>
  67 #include "usb-serial.h"
  68
  69 /* Function prototypes */
  70 static int  option_open(struct usb_serial_port *port, struct file *filp);
  71 static void option_close(struct usb_serial_port *port, struct file *filp);
  72 static int  option_startup(struct usb_serial *serial);
  73 static void option_shutdown(struct usb_serial *serial);
  74 static void option_rx_throttle(struct usb_serial_port *port);
  75 static void option_rx_unthrottle(struct usb_serial_port *port);
  76 static int  option_write_room(struct usb_serial_port *port);
  77
  78 static void option_instat_callback(struct urb *urb, struct pt_regs *regs);
  79
  80 static int option_write(struct usb_serial_port *port,
  81                         const unsigned char *buf, int count);
  82
  83 static int  option_chars_in_buffer(struct usb_serial_port *port);
  84 static int  option_ioctl(struct usb_serial_port *port, struct file *file,
  85                         unsigned int cmd, unsigned long arg);
  86 static void option_set_termios(struct usb_serial_port *port,
  87                                 struct termios *old);
  88 static void option_break_ctl(struct usb_serial_port *port, int break_state);
  89 static int  option_tiocmget(struct usb_serial_port *port, struct file *file);
  90 static int  option_tiocmset(struct usb_serial_port *port, struct file *file,
  91                                 unsigned int set, unsigned int clear);
  92 static int  option_send_setup(struct usb_serial_port *port);
  93
  94 /* Vendor and product IDs */
  95 #define OPTION_VENDOR_ID                0x0AF0
  96 #define HUAWEI_VENDOR_ID                0x12D1
  97 #define AUDIOVOX_VENDOR_ID              0x0F3D
  98 #define SIERRAWIRELESS_VENDOR_ID        0x1199
  99 #define NOVATELWIRELESS_VENDOR_ID       0x1410
 100
 101 #define OPTION_PRODUCT_OLD              0x5000
 102 #define OPTION_PRODUCT_FUSION           0x6000
 103 #define OPTION_PRODUCT_FUSION2          0x6300
 104 #define OPTION_PRODUCT_COBRA            0x6500
 105 #define HUAWEI_PRODUCT_E600             0x1001
 106 #define AUDIOVOX_PRODUCT_AIRCARD        0x0112
 107 #define SIERRAWIRELESS_PRODUCT_MC8755   0x6802
 108 #define NOVATELWIRELESS_PRODUCT_U740    0x1400
 109
 110 static struct usb_device_id option_ids[] = {
 111         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
 112         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
 113         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
 114         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
 115         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
 116         { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
 117         { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) },
 118         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
 119         { } /* Terminating entry */
 120 };
 121
 122 static struct usb_device_id option_ids1[] = {
 123         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
 124         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
 125         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) },
 126         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
 127         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
 128         { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) },
 129         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) },
 130         { } /* Terminating entry */
 131 };
 132 static struct usb_device_id option_ids3[] = {
 133         { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) },
 134         { } /* Terminating entry */
 135 };
 136
 137 MODULE_DEVICE_TABLE(usb, option_ids);
 138
 139 static struct usb_driver option_driver = {
 140         .name       = "option",
 141         .probe      = usb_serial_probe,
 142         .disconnect = usb_serial_disconnect,
 143         .id_table   = option_ids,
 144         .no_dynamic_id =        1,
 145 };
 146
 147 /* The card has three separate interfaces, which the serial driver
 148  * recognizes separately, thus num_port=1.
 149  */
 150 static struct usb_serial_driver option_3port_device = {
 151         .driver = {
 152                 .owner =        THIS_MODULE,
 153                 .name =         "option",
 154         },
 155         .description       = "GSM modem (3-port)",
 156         .id_table          = option_ids3,
 157         .num_interrupt_in  = NUM_DONT_CARE,
 158         .num_bulk_in       = NUM_DONT_CARE,
 159         .num_bulk_out      = NUM_DONT_CARE,
 160         .num_ports         = 3,
 161         .open              = option_open,
 162         .close             = option_close,
 163         .write             = option_write,
 164         .write_room        = option_write_room,
 165         .chars_in_buffer   = option_chars_in_buffer,
 166         .throttle          = option_rx_throttle,
 167         .unthrottle        = option_rx_unthrottle,
 168         .set_termios       = option_set_termios,
 169         .break_ctl         = option_break_ctl,
 170         .tiocmget          = option_tiocmget,
 171         .tiocmset          = option_tiocmset,
 172         .attach            = option_startup,
 173         .shutdown          = option_shutdown,
 174         .read_int_callback = option_instat_callback,
 175 };
 176
 177 static struct usb_serial_driver option_1port_device = {
 178         .driver = {
 179                 .owner =        THIS_MODULE,
 180                 .name =         "option",
 181         },
 182         .description       = "GSM modem (1-port)",
 183         .id_table          = option_ids1,
 184         .num_interrupt_in  = NUM_DONT_CARE,
 185         .num_bulk_in       = NUM_DONT_CARE,
 186         .num_bulk_out      = NUM_DONT_CARE,
 187         .num_ports         = 1,
 188         .open              = option_open,
 189         .close             = option_close,
 190         .write             = option_write,
 191         .write_room        = option_write_room,
 192         .chars_in_buffer   = option_chars_in_buffer,
 193         .throttle          = option_rx_throttle,
 194         .unthrottle        = option_rx_unthrottle,
 195         .ioctl             = option_ioctl,
 196         .set_termios       = option_set_termios,
 197         .break_ctl         = option_break_ctl,
 198         .tiocmget          = option_tiocmget,
 199         .tiocmset          = option_tiocmset,
 200         .attach            = option_startup,
 201         .shutdown          = option_shutdown,
 202         .read_int_callback = option_instat_callback,
 203 };
 204
 205 #ifdef CONFIG_USB_DEBUG
 206 static int debug;
 207 #else
 208 #define debug 0
 209 #endif
 210
 211 /* per port private data */
 212
 213 #define N_IN_URB 4
 214 #define N_OUT_URB 1
 215 #define IN_BUFLEN 4096
 216 #define OUT_BUFLEN 128
 217
 218 struct option_port_private {
 219         /* Input endpoints and buffer for this port */
 220         struct urb *in_urbs[N_IN_URB];
 221         char in_buffer[N_IN_URB][IN_BUFLEN];
 222         /* Output endpoints and buffer for this port */
 223         struct urb *out_urbs[N_OUT_URB];
 224         char out_buffer[N_OUT_URB][OUT_BUFLEN];
 225
 226         /* Settings for the port */
 227         int rts_state;  /* Handshaking pins (outputs) */
 228         int dtr_state;
 229         int cts_state;  /* Handshaking pins (inputs) */
 230         int dsr_state;
 231         int dcd_state;
 232         int ri_state;
 233
 234         unsigned long tx_start_time[N_OUT_URB];
 235 };
 236
 237 /* Functions used by new usb-serial code. */
 238 static int __init option_init(void)
 239 {
 240         int retval;
 241         retval = usb_serial_register(&option_1port_device);
 242         if (retval)
 243                 goto failed_1port_device_register;
 244         retval = usb_serial_register(&option_3port_device);
 245         if (retval)
 246                 goto failed_3port_device_register;
 247         retval = usb_register(&option_driver);
 248         if (retval)
 249                 goto failed_driver_register;
 250
 251         info(DRIVER_DESC ": " DRIVER_VERSION);
 252
 253         return 0;
 254
 255 failed_driver_register:
 256         usb_serial_deregister (&option_3port_device);
 257 failed_3port_device_register:
 258         usb_serial_deregister (&option_1port_device);
 259 failed_1port_device_register:
 260         return retval;
 261 }
 262
 263 static void __exit option_exit(void)
 264 {
 265         usb_deregister (&option_driver);
 266         usb_serial_deregister (&option_3port_device);
 267         usb_serial_deregister (&option_1port_device);
 268 }
 269
 270 module_init(option_init);
 271 module_exit(option_exit);
 272
 273 static void option_rx_throttle(struct usb_serial_port *port)
 274 {
 275         dbg("%s", __FUNCTION__);
 276 }
 277
 278 static void option_rx_unthrottle(struct usb_serial_port *port)
 279 {
 280         dbg("%s", __FUNCTION__);
 281 }
 282
 283 static void option_break_ctl(struct usb_serial_port *port, int break_state)
 284 {
 285         /* Unfortunately, I don't know how to send a break */
 286         dbg("%s", __FUNCTION__);
 287 }
 288
 289 static void option_set_termios(struct usb_serial_port *port,
 290                         struct termios *old_termios)
 291 {
 292         dbg("%s", __FUNCTION__);
 293
 294         option_send_setup(port);
 295 }
 296
 297 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
 298 {
 299         unsigned int value;
 300         struct option_port_private *portdata;
 301
 302         portdata = usb_get_serial_port_data(port);
 303
 304         value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
 305                 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
 306                 ((portdata->cts_state) ? TIOCM_CTS : 0) |
 307                 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
 308                 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
 309                 ((portdata->ri_state) ? TIOCM_RNG : 0);
 310
 311         return value;
 312 }
 313
 314 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
 315                         unsigned int set, unsigned int clear)
 316 {
 317         struct option_port_private *portdata;
 318
 319         portdata = usb_get_serial_port_data(port);
 320
 321         if (set & TIOCM_RTS)
 322                 portdata->rts_state = 1;
 323         if (set & TIOCM_DTR)
 324                 portdata->dtr_state = 1;
 325
 326         if (clear & TIOCM_RTS)
 327                 portdata->rts_state = 0;
 328         if (clear & TIOCM_DTR)
 329                 portdata->dtr_state = 0;
 330         return option_send_setup(port);
 331 }
 332
 333 static int option_ioctl(struct usb_serial_port *port, struct file *file,
 334                         unsigned int cmd, unsigned long arg)
 335 {
 336         return -ENOIOCTLCMD;
 337 }
 338
 339 /* Write */
 340 static int option_write(struct usb_serial_port *port,
 341                         const unsigned char *buf, int count)
 342 {
 343         struct option_port_private *portdata;
 344         int i;
 345         int left, todo;
 346         struct urb *this_urb = NULL; /* spurious */
 347         int err;
 348
 349         portdata = usb_get_serial_port_data(port);
 350
 351         dbg("%s: write (%d chars)", __FUNCTION__, count);
 352
 353         i = 0;
 354         left = count;
 355         for (i=0; left > 0 && i < N_OUT_URB; i++) {
 356                 todo = left;
 357                 if (todo > OUT_BUFLEN)
 358                         todo = OUT_BUFLEN;
 359
 360                 this_urb = portdata->out_urbs[i];
 361                 if (this_urb->status == -EINPROGRESS) {
 362                         if (time_before(jiffies,
 363                                         portdata->tx_start_time[i] + 10 * HZ))
 364                                 continue;
 365                         usb_unlink_urb(this_urb);
 366                         continue;
 367                 }
 368                 if (this_urb->status != 0)
 369                         dbg("usb_write %p failed (err=%d)",
 370                                 this_urb, this_urb->status);
 371
 372                 dbg("%s: endpoint %d buf %d", __FUNCTION__,
 373                         usb_pipeendpoint(this_urb->pipe), i);
 374
 375                 /* send the data */
 376                 memcpy (this_urb->transfer_buffer, buf, todo);
 377                 this_urb->transfer_buffer_length = todo;
 378
 379                 this_urb->dev = port->serial->dev;
 380                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
 381                 if (err) {
 382                         dbg("usb_submit_urb %p (write bulk) failed "
 383                                 "(%d, has %d)", this_urb,
 384                                 err, this_urb->status);
 385                         continue;
 386                 }
 387                 portdata->tx_start_time[i] = jiffies;
 388                 buf += todo;
 389                 left -= todo;
 390         }
 391
 392         count -= left;
 393         dbg("%s: wrote (did %d)", __FUNCTION__, count);
 394         return count;
 395 }
 396
 397 static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
 398 {
 399         int err;
 400         int endpoint;
 401         struct usb_serial_port *port;
 402         struct tty_struct *tty;
 403         unsigned char *data = urb->transfer_buffer;
 404
 405         dbg("%s: %p", __FUNCTION__, urb);
 406
 407         endpoint = usb_pipeendpoint(urb->pipe);
 408         port = (struct usb_serial_port *) urb->context;
 409
 410         if (urb->status) {
 411                 dbg("%s: nonzero status: %d on endpoint %02x.",
 412                     __FUNCTION__, urb->status, endpoint);
 413         } else {
 414                 tty = port->tty;
 415                 if (urb->actual_length) {
 416                         tty_buffer_request_room(tty, urb->actual_length);
 417                         tty_insert_flip_string(tty, data, urb->actual_length);
 418                         tty_flip_buffer_push(tty);
 419                 } else {
 420                         dbg("%s: empty read urb received", __FUNCTION__);
 421                 }
 422
 423                 /* Resubmit urb so we continue receiving */
 424                 if (port->open_count && urb->status != -ESHUTDOWN) {
 425                         err = usb_submit_urb(urb, GFP_ATOMIC);
 426                         if (err)
 427                                 printk(KERN_ERR "%s: resubmit read urb failed. "
 428                                         "(%d)", __FUNCTION__, err);
 429                 }
 430         }
 431         return;
 432 }
 433
 434 static void option_outdat_callback(struct urb *urb, struct pt_regs *regs)
 435 {
 436         struct usb_serial_port *port;
 437
 438         dbg("%s", __FUNCTION__);
 439
 440         port = (struct usb_serial_port *) urb->context;
 441
 442         usb_serial_port_softint(port);
 443 }
 444
 445 static void option_instat_callback(struct urb *urb, struct pt_regs *regs)
 446 {
 447         int err;
 448         struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
 449         struct option_port_private *portdata = usb_get_serial_port_data(port);
 450         struct usb_serial *serial = port->serial;
 451
 452         dbg("%s", __FUNCTION__);
 453         dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
 454
 455         if (urb->status == 0) {
 456                 struct usb_ctrlrequest *req_pkt =
 457                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
 458
 459                 if (!req_pkt) {
 460                         dbg("%s: NULL req_pkt\n", __FUNCTION__);
 461                         return;
 462                 }
 463                 if ((req_pkt->bRequestType == 0xA1) &&
 464                                 (req_pkt->bRequest == 0x20)) {
 465                         int old_dcd_state;
 466                         unsigned char signals = *((unsigned char *)
 467                                         urb->transfer_buffer +
 468                                         sizeof(struct usb_ctrlrequest));
 469
 470                         dbg("%s: signal x%x", __FUNCTION__, signals);
 471
 472                         old_dcd_state = portdata->dcd_state;
 473                         portdata->cts_state = 1;
 474                         portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
 475                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
 476                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 477
 478                         if (port->tty && !C_CLOCAL(port->tty) &&
 479                                         old_dcd_state && !portdata->dcd_state)
 480                                 tty_hangup(port->tty);
 481                 } else {
 482                         dbg("%s: type %x req %x", __FUNCTION__,
 483                                 req_pkt->bRequestType,req_pkt->bRequest);
 484                 }
 485         } else
 486                 dbg("%s: error %d", __FUNCTION__, urb->status);
 487
 488         /* Resubmit urb so we continue receiving IRQ data */
 489         if (urb->status != -ESHUTDOWN) {
 490                 urb->dev = serial->dev;
 491                 err = usb_submit_urb(urb, GFP_ATOMIC);
 492                 if (err)
 493                         dbg("%s: resubmit intr urb failed. (%d)",
 494                                 __FUNCTION__, err);
 495         }
 496 }
 497
 498 static int option_write_room(struct usb_serial_port *port)
 499 {
 500         struct option_port_private *portdata;
 501         int i;
 502         int data_len = 0;
 503         struct urb *this_urb;
 504
 505         portdata = usb_get_serial_port_data(port);
 506
 507         for (i=0; i < N_OUT_URB; i++) {
 508                 this_urb = portdata->out_urbs[i];
 509                 if (this_urb && this_urb->status != -EINPROGRESS)
 510                         data_len += OUT_BUFLEN;
 511         }
 512
 513         dbg("%s: %d", __FUNCTION__, data_len);
 514         return data_len;
 515 }
 516
 517 static int option_chars_in_buffer(struct usb_serial_port *port)
 518 {
 519         struct option_port_private *portdata;
 520         int i;
 521         int data_len = 0;
 522         struct urb *this_urb;
 523
 524         portdata = usb_get_serial_port_data(port);
 525
 526         for (i=0; i < N_OUT_URB; i++) {
 527                 this_urb = portdata->out_urbs[i];
 528                 if (this_urb && this_urb->status == -EINPROGRESS)
 529                         data_len += this_urb->transfer_buffer_length;
 530         }
 531         dbg("%s: %d", __FUNCTION__, data_len);
 532         return data_len;
 533 }
 534
 535 static int option_open(struct usb_serial_port *port, struct file *filp)
 536 {
 537         struct option_port_private *portdata;
 538         struct usb_serial *serial = port->serial;
 539         int i, err;
 540         struct urb *urb;
 541
 542         portdata = usb_get_serial_port_data(port);
 543
 544         dbg("%s", __FUNCTION__);
 545
 546         /* Set some sane defaults */
 547         portdata->rts_state = 1;
 548         portdata->dtr_state = 1;
 549
 550         /* Reset low level data toggle and start reading from endpoints */
 551         for (i = 0; i < N_IN_URB; i++) {
 552                 urb = portdata->in_urbs[i];
 553                 if (! urb)
 554                         continue;
 555                 if (urb->dev != serial->dev) {
 556                         dbg("%s: dev %p != %p", __FUNCTION__,
 557                                 urb->dev, serial->dev);
 558                         continue;
 559                 }
 560
 561                 /*
 562                  * make sure endpoint data toggle is synchronized with the
 563                  * device
 564                  */
 565                 usb_clear_halt(urb->dev, urb->pipe);
 566
 567                 err = usb_submit_urb(urb, GFP_KERNEL);
 568                 if (err) {
 569                         dbg("%s: submit urb %d failed (%d) %d",
 570                                 __FUNCTION__, i, err,
 571                                 urb->transfer_buffer_length);
 572                 }
 573         }
 574
 575         /* Reset low level data toggle on out endpoints */
 576         for (i = 0; i < N_OUT_URB; i++) {
 577                 urb = portdata->out_urbs[i];
 578                 if (! urb)
 579                         continue;
 580                 urb->dev = serial->dev;
 581                 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
 582                                 usb_pipeout(urb->pipe), 0); */
 583         }
 584
 585         port->tty->low_latency = 1;
 586
 587         option_send_setup(port);
 588
 589         return (0);
 590 }
 591
 592 static inline void stop_urb(struct urb *urb)
 593 {
 594         if (urb && urb->status == -EINPROGRESS)
 595                 usb_kill_urb(urb);
 596 }
 597
 598 static void option_close(struct usb_serial_port *port, struct file *filp)
 599 {
 600         int i;
 601         struct usb_serial *serial = port->serial;
 602         struct option_port_private *portdata;
 603
 604         dbg("%s", __FUNCTION__);
 605         portdata = usb_get_serial_port_data(port);
 606
 607         portdata->rts_state = 0;
 608         portdata->dtr_state = 0;
 609
 610         if (serial->dev) {
 611                 option_send_setup(port);
 612
 613                 /* Stop reading/writing urbs */
 614                 for (i = 0; i < N_IN_URB; i++)
 615                         stop_urb(portdata->in_urbs[i]);
 616                 for (i = 0; i < N_OUT_URB; i++)
 617                         stop_urb(portdata->out_urbs[i]);
 618         }
 619         port->tty = NULL;
 620 }
 621
 622 /* Helper functions used by option_setup_urbs */
 623 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
 624                 int dir, void *ctx, char *buf, int len,
 625                 void (*callback)(struct urb *, struct pt_regs *regs))
 626 {
 627         struct urb *urb;
 628
 629         if (endpoint == -1)
 630                 return NULL;            /* endpoint not needed */
 631
 632         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
 633         if (urb == NULL) {
 634                 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
 635                 return NULL;
 636         }
 637
 638                 /* Fill URB using supplied data. */
 639         usb_fill_bulk_urb(urb, serial->dev,
 640                       usb_sndbulkpipe(serial->dev, endpoint) | dir,
 641                       buf, len, callback, ctx);
 642
 643         return urb;
 644 }
 645
 646 /* Setup urbs */
 647 static void option_setup_urbs(struct usb_serial *serial)
 648 {
 649         int i,j;
 650         struct usb_serial_port *port;
 651         struct option_port_private *portdata;
 652
 653         dbg("%s", __FUNCTION__);
 654
 655
 656         for (i = 0; i < serial->num_ports; i++) {
 657                 port = serial->port[i];
 658                 portdata = usb_get_serial_port_data(port);
 659
 660         /* Do indat endpoints first */
 661                 for (j = 0; j < N_IN_URB; ++j) {
 662                         portdata->in_urbs[j] = option_setup_urb (serial,
 663                         port->bulk_in_endpointAddress, USB_DIR_IN, port,
 664                         portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
 665                 }
 666
 667                 /* outdat endpoints */
 668                 for (j = 0; j < N_OUT_URB; ++j) {
 669                         portdata->out_urbs[j] = option_setup_urb (serial,
 670                         port->bulk_out_endpointAddress, USB_DIR_OUT, port,
 671                         portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
 672                 }
 673         }
 674 }
 675
 676 static int option_send_setup(struct usb_serial_port *port)
 677 {
 678         struct usb_serial *serial = port->serial;
 679         struct option_port_private *portdata;
 680
 681         dbg("%s", __FUNCTION__);
 682
 683         portdata = usb_get_serial_port_data(port);
 684
 685         if (port->tty) {
 686                 int val = 0;
 687                 if (portdata->dtr_state)
 688                         val |= 0x01;
 689                 if (portdata->rts_state)
 690                         val |= 0x02;
 691
 692                 return usb_control_msg(serial->dev,
 693                                 usb_rcvctrlpipe(serial->dev, 0),
 694                                 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
 695         }
 696
 697         return 0;
 698 }
 699
 700 static int option_startup(struct usb_serial *serial)
 701 {
 702         int i, err;
 703         struct usb_serial_port *port;
 704         struct option_port_private *portdata;
 705
 706         dbg("%s", __FUNCTION__);
 707
 708         /* Now setup per port private data */
 709         for (i = 0; i < serial->num_ports; i++) {
 710                 port = serial->port[i];
 711                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
 712                 if (!portdata) {
 713                         dbg("%s: kmalloc for option_port_private (%d) failed!.",
 714                                         __FUNCTION__, i);
 715                         return (1);
 716                 }
 717
 718                 usb_set_serial_port_data(port, portdata);
 719
 720                 if (! port->interrupt_in_urb)
 721                         continue;
 722                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 723                 if (err)
 724                         dbg("%s: submit irq_in urb failed %d",
 725                                 __FUNCTION__, err);
 726         }
 727
 728         option_setup_urbs(serial);
 729
 730         return (0);
 731 }
 732
 733 static void option_shutdown(struct usb_serial *serial)
 734 {
 735         int i, j;
 736         struct usb_serial_port *port;
 737         struct option_port_private *portdata;
 738
 739         dbg("%s", __FUNCTION__);
 740
 741         /* Stop reading/writing urbs */
 742         for (i = 0; i < serial->num_ports; ++i) {
 743                 port = serial->port[i];
 744                 portdata = usb_get_serial_port_data(port);
 745                 for (j = 0; j < N_IN_URB; j++)
 746                         stop_urb(portdata->in_urbs[j]);
 747                 for (j = 0; j < N_OUT_URB; j++)
 748                         stop_urb(portdata->out_urbs[j]);
 749         }
 750
 751         /* Now free them */
 752         for (i = 0; i < serial->num_ports; ++i) {
 753                 port = serial->port[i];
 754                 portdata = usb_get_serial_port_data(port);
 755
 756                 for (j = 0; j < N_IN_URB; j++) {
 757                         if (portdata->in_urbs[j]) {
 758                                 usb_free_urb(portdata->in_urbs[j]);
 759                                 portdata->in_urbs[j] = NULL;
 760                         }
 761                 }
 762                 for (j = 0; j < N_OUT_URB; j++) {
 763                         if (portdata->out_urbs[j]) {
 764                                 usb_free_urb(portdata->out_urbs[j]);
 765                                 portdata->out_urbs[j] = NULL;
 766                         }
 767                 }
 768         }
 769
 770         /* Now free per port private data */
 771         for (i = 0; i < serial->num_ports; i++) {
 772                 port = serial->port[i];
 773                 kfree(usb_get_serial_port_data(port));
 774         }
 775 }
 776
 777 MODULE_AUTHOR(DRIVER_AUTHOR);
 778 MODULE_DESCRIPTION(DRIVER_DESC);
 779 MODULE_VERSION(DRIVER_VERSION);
 780 MODULE_LICENSE("GPL");
 781
 782 #ifdef CONFIG_USB_DEBUG
 783 module_param(debug, bool, S_IRUGO | S_IWUSR);
 784 MODULE_PARM_DESC(debug, "Debug messages");
 785 #endif
 786