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