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