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