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