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