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