SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/serial/option.c

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