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