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