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