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