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