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