SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/serial/option.c

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