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