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