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