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