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