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