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