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