1 /* 2 Option Card (PCMCIA to) USB to Serial Driver 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: 13 14 2005-05-19 v0.1 Initial version, based on incomplete docs 15 and analysis of misbehavior with the standard driver 16 2005-05-20 v0.2 Extended the input buffer to avoid losing 17 random 64-byte chunks of data 18 2005-05-21 v0.3 implemented chars_in_buffer() 19 turned on low_latency 20 simplified the code somewhat 21 2005-05-24 v0.4 option_write() sometimes deadlocked under heavy load 22 removed some dead code 23 added sponsor notice 24 coding style clean-up 25 2005-06-20 v0.4.1 add missing braces :-/ 26 killed end-of-line whitespace 27 2005-07-15 v0.4.2 rename WLAN product to FUSION, add FUSION2 28 29 Work sponsored by: Sigos GmbH, Germany <info@sigos.de> 30 31 */ 32 33 #define DRIVER_VERSION "v0.4" 34 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 35 #define DRIVER_DESC "Option Card (PC-Card to) USB to Serial Driver" 36 37 #include <linux/config.h> 38 #include <linux/kernel.h> 39 #include <linux/jiffies.h> 40 #include <linux/errno.h> 41 #include <linux/tty.h> 42 #include <linux/tty_flip.h> 43 #include <linux/module.h> 44 #include <linux/usb.h> 45 #include "usb-serial.h" 46 47 /* Function prototypes */ 48 static int option_open (struct usb_serial_port *port, struct file *filp); 49 static void option_close (struct usb_serial_port *port, struct file *filp); 50 static int option_startup (struct usb_serial *serial); 51 static void option_shutdown (struct usb_serial *serial); 52 static void option_rx_throttle (struct usb_serial_port *port); 53 static void option_rx_unthrottle (struct usb_serial_port *port); 54 static int option_write_room (struct usb_serial_port *port); 55 56 static void option_instat_callback(struct urb *urb, struct pt_regs *regs); 57 58 static int option_write (struct usb_serial_port *port, 59 const unsigned char *buf, int count); 60 61 static int option_chars_in_buffer (struct usb_serial_port *port); 62 static int option_ioctl (struct usb_serial_port *port, struct file *file, 63 unsigned int cmd, unsigned long arg); 64 static void option_set_termios (struct usb_serial_port *port, 65 struct termios *old); 66 static void option_break_ctl (struct usb_serial_port *port, int break_state); 67 static int option_tiocmget (struct usb_serial_port *port, struct file *file); 68 static int option_tiocmset (struct usb_serial_port *port, struct file *file, 69 unsigned int set, unsigned int clear); 70 static int option_send_setup (struct usb_serial_port *port); 71 72 /* Vendor and product IDs */ 73 #define OPTION_VENDOR_ID 0x0AF0 74 75 #define OPTION_PRODUCT_OLD 0x5000 76 #define OPTION_PRODUCT_FUSION 0x6000 77 #define OPTION_PRODUCT_FUSION2 0x6300 78 79 80 static struct usb_device_id option_ids[] = { 81 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) }, 82 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) }, 83 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) }, 84 { } /* Terminating entry */ 85 }; 86 87 MODULE_DEVICE_TABLE(usb, option_ids); 88 89 static struct usb_driver option_driver = { 90 .owner = THIS_MODULE, 91 .name = "option", 92 .probe = usb_serial_probe, 93 .disconnect = usb_serial_disconnect, 94 .id_table = option_ids, 95 }; 96 97 /* The card has three separate interfaces, wich the serial driver 98 * recognizes separately, thus num_port=1. 99 */ 100 static struct usb_serial_device_type option_3port_device = { 101 .owner = THIS_MODULE, 102 .name = "Option 3G data card", 103 .short_name = "option", 104 .id_table = option_ids, 105 .num_interrupt_in = NUM_DONT_CARE, 106 .num_bulk_in = NUM_DONT_CARE, 107 .num_bulk_out = NUM_DONT_CARE, 108 .num_ports = 1, /* 3, but the card reports its ports separately */ 109 .open = option_open, 110 .close = option_close, 111 .write = option_write, 112 .write_room = option_write_room, 113 .chars_in_buffer = option_chars_in_buffer, 114 .throttle = option_rx_throttle, 115 .unthrottle = option_rx_unthrottle, 116 .ioctl = option_ioctl, 117 .set_termios = option_set_termios, 118 .break_ctl = option_break_ctl, 119 .tiocmget = option_tiocmget, 120 .tiocmset = option_tiocmset, 121 .attach = option_startup, 122 .shutdown = option_shutdown, 123 .read_int_callback = option_instat_callback, 124 }; 125 126 #ifdef CONFIG_USB_DEBUG 127 static int debug; 128 #else 129 #define debug 0 130 #endif 131 132 133 /* per port private data */ 134 135 #define N_IN_URB 4 136 #define N_OUT_URB 1 137 #define IN_BUFLEN 1024 138 #define OUT_BUFLEN 128 139 140 struct option_port_private { 141 /* Input endpoints and buffer for this port */ 142 struct urb *in_urbs[N_IN_URB]; 143 char in_buffer[N_IN_URB][IN_BUFLEN]; 144 /* Output endpoints and buffer for this port */ 145 struct urb *out_urbs[N_OUT_URB]; 146 char out_buffer[N_OUT_URB][OUT_BUFLEN]; 147 148 /* Settings for the port */ 149 int rts_state; /* Handshaking pins (outputs) */ 150 int dtr_state; 151 int cts_state; /* Handshaking pins (inputs) */ 152 int dsr_state; 153 int dcd_state; 154 int ri_state; 155 156 unsigned long tx_start_time[N_OUT_URB]; 157 }; 158 159 160 /* Functions used by new usb-serial code. */ 161 static int __init 162 option_init (void) 163 { 164 int retval; 165 retval = usb_serial_register(&option_3port_device); 166 if (retval) 167 goto failed_3port_device_register; 168 retval = usb_register(&option_driver); 169 if (retval) 170 goto failed_driver_register; 171 172 info(DRIVER_DESC ": " DRIVER_VERSION); 173 174 return 0; 175 176 failed_driver_register: 177 usb_serial_deregister (&option_3port_device); 178 failed_3port_device_register: 179 return retval; 180 } 181 182 static void __exit 183 option_exit (void) 184 { 185 usb_deregister (&option_driver); 186 usb_serial_deregister (&option_3port_device); 187 } 188 189 module_init(option_init); 190 module_exit(option_exit); 191 192 static void 193 option_rx_throttle (struct usb_serial_port *port) 194 { 195 dbg("%s", __FUNCTION__); 196 } 197 198 199 static void 200 option_rx_unthrottle (struct usb_serial_port *port) 201 { 202 dbg("%s", __FUNCTION__); 203 } 204 205 206 static void 207 option_break_ctl (struct usb_serial_port *port, int break_state) 208 { 209 /* Unfortunately, I don't know how to send a break */ 210 dbg("%s", __FUNCTION__); 211 } 212 213 214 static void 215 option_set_termios (struct usb_serial_port *port, 216 struct termios *old_termios) 217 { 218 dbg("%s", __FUNCTION__); 219 220 option_send_setup(port); 221 } 222 223 static int 224 option_tiocmget (struct usb_serial_port *port, struct file *file) 225 { 226 unsigned int value; 227 struct option_port_private *portdata; 228 229 portdata = usb_get_serial_port_data(port); 230 231 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 232 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 233 ((portdata->cts_state) ? TIOCM_CTS : 0) | 234 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 235 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 236 ((portdata->ri_state) ? TIOCM_RNG : 0); 237 238 return value; 239 } 240 241 static int 242 option_tiocmset (struct usb_serial_port *port, struct file *file, 243 unsigned int set, unsigned int clear) 244 { 245 struct option_port_private *portdata; 246 247 portdata = usb_get_serial_port_data(port); 248 249 if (set & TIOCM_RTS) 250 portdata->rts_state = 1; 251 if (set & TIOCM_DTR) 252 portdata->dtr_state = 1; 253 254 if (clear & TIOCM_RTS) 255 portdata->rts_state = 0; 256 if (clear & TIOCM_DTR) 257 portdata->dtr_state = 0; 258 return option_send_setup(port); 259 } 260 261 static int 262 option_ioctl (struct usb_serial_port *port, struct file *file, 263 unsigned int cmd, unsigned long arg) 264 { 265 return -ENOIOCTLCMD; 266 } 267 268 /* Write */ 269 static int 270 option_write (struct usb_serial_port *port, 271 const unsigned char *buf, int count) 272 { 273 struct option_port_private *portdata; 274 int i; 275 int left, todo; 276 struct urb *this_urb = NULL; /* spurious */ 277 int err; 278 279 portdata = usb_get_serial_port_data(port); 280 281 dbg("%s: write (%d chars)", __FUNCTION__, count); 282 283 i = 0; 284 left = count; 285 for (i=0; left > 0 && i < N_OUT_URB; i++) { 286 todo = left; 287 if (todo > OUT_BUFLEN) 288 todo = OUT_BUFLEN; 289 290 this_urb = portdata->out_urbs[i]; 291 if (this_urb->status == -EINPROGRESS) { 292 if (this_urb->transfer_flags & URB_ASYNC_UNLINK) 293 continue; 294 if (time_before(jiffies, portdata->tx_start_time[i] + 10 * HZ)) 295 continue; 296 this_urb->transfer_flags |= URB_ASYNC_UNLINK; 297 usb_unlink_urb(this_urb); 298 continue; 299 } 300 if (this_urb->status != 0) 301 dbg("usb_write %p failed (err=%d)", this_urb, this_urb->status); 302 303 dbg("%s: endpoint %d buf %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), i); 304 305 /* send the data */ 306 memcpy (this_urb->transfer_buffer, buf, todo); 307 this_urb->transfer_buffer_length = todo; 308 309 this_urb->transfer_flags &= ~URB_ASYNC_UNLINK; 310 this_urb->dev = port->serial->dev; 311 err = usb_submit_urb(this_urb, GFP_ATOMIC); 312 if (err) { 313 dbg("usb_submit_urb %p (write bulk) failed (%d, has %d)", this_urb, err, this_urb->status); 314 continue; 315 } 316 portdata->tx_start_time[i] = jiffies; 317 buf += todo; 318 left -= todo; 319 } 320 321 count -= left; 322 dbg("%s: wrote (did %d)", __FUNCTION__, count); 323 return count; 324 } 325 326 static void 327 option_indat_callback (struct urb *urb, struct pt_regs *regs) 328 { 329 int i, err; 330 int endpoint; 331 struct usb_serial_port *port; 332 struct tty_struct *tty; 333 unsigned char *data = urb->transfer_buffer; 334 335 dbg("%s: %p", __FUNCTION__, urb); 336 337 endpoint = usb_pipeendpoint(urb->pipe); 338 port = (struct usb_serial_port *) urb->context; 339 340 if (urb->status) { 341 dbg("%s: nonzero status: %d on endpoint %02x.", 342 __FUNCTION__, urb->status, endpoint); 343 } else { 344 tty = port->tty; 345 if (urb->actual_length) { 346 for (i = 0; i < urb->actual_length ; ++i) { 347 if (tty->flip.count >= TTY_FLIPBUF_SIZE) 348 tty_flip_buffer_push(tty); 349 tty_insert_flip_char(tty, data[i], 0); 350 } 351 tty_flip_buffer_push(tty); 352 } else { 353 dbg("%s: empty read urb received", __FUNCTION__); 354 } 355 356 /* Resubmit urb so we continue receiving */ 357 if (port->open_count && urb->status != -ESHUTDOWN) { 358 err = usb_submit_urb(urb, GFP_ATOMIC); 359 if (err) 360 printk(KERN_ERR "%s: resubmit read urb failed. (%d)", __FUNCTION__, err); 361 } 362 } 363 return; 364 } 365 366 static void 367 option_outdat_callback (struct urb *urb, struct pt_regs *regs) 368 { 369 struct usb_serial_port *port; 370 371 dbg("%s", __FUNCTION__); 372 373 port = (struct usb_serial_port *) urb->context; 374 375 if (port->open_count) 376 schedule_work(&port->work); 377 } 378 379 static void 380 option_instat_callback (struct urb *urb, struct pt_regs *regs) 381 { 382 int err; 383 struct usb_serial_port *port = (struct usb_serial_port *) urb->context; 384 struct option_port_private *portdata = usb_get_serial_port_data(port); 385 struct usb_serial *serial = port->serial; 386 387 dbg("%s", __FUNCTION__); 388 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata); 389 390 if (urb->status == 0) { 391 struct usb_ctrlrequest *req_pkt = 392 (struct usb_ctrlrequest *)urb->transfer_buffer; 393 394 if (!req_pkt) { 395 dbg("%s: NULL req_pkt\n", __FUNCTION__); 396 return; 397 } 398 if ((req_pkt->bRequestType == 0xA1) && (req_pkt->bRequest == 0x20)) { 399 int old_dcd_state; 400 unsigned char signals = *((unsigned char *) 401 urb->transfer_buffer + sizeof(struct usb_ctrlrequest)); 402 403 dbg("%s: signal x%x", __FUNCTION__, signals); 404 405 old_dcd_state = portdata->dcd_state; 406 portdata->cts_state = 1; 407 portdata->dcd_state = ((signals & 0x01) ? 1 : 0); 408 portdata->dsr_state = ((signals & 0x02) ? 1 : 0); 409 portdata->ri_state = ((signals & 0x08) ? 1 : 0); 410 411 if (port->tty && !C_CLOCAL(port->tty) 412 && old_dcd_state && !portdata->dcd_state) { 413 tty_hangup(port->tty); 414 } 415 } else 416 dbg("%s: type %x req %x", __FUNCTION__, req_pkt->bRequestType,req_pkt->bRequest); 417 } else 418 dbg("%s: error %d", __FUNCTION__, urb->status); 419 420 /* Resubmit urb so we continue receiving IRQ data */ 421 if (urb->status != -ESHUTDOWN) { 422 urb->dev = serial->dev; 423 err = usb_submit_urb(urb, GFP_ATOMIC); 424 if (err) 425 dbg("%s: resubmit intr urb failed. (%d)", __FUNCTION__, err); 426 } 427 } 428 429 430 static int 431 option_write_room (struct usb_serial_port *port) 432 { 433 struct option_port_private *portdata; 434 int i; 435 int data_len = 0; 436 struct urb *this_urb; 437 438 portdata = usb_get_serial_port_data(port); 439 440 for (i=0; i < N_OUT_URB; i++) { 441 this_urb = portdata->out_urbs[i]; 442 if (this_urb && this_urb->status != -EINPROGRESS) 443 data_len += OUT_BUFLEN; 444 } 445 446 dbg("%s: %d", __FUNCTION__, data_len); 447 return data_len; 448 } 449 450 451 static int 452 option_chars_in_buffer (struct usb_serial_port *port) 453 { 454 struct option_port_private *portdata; 455 int i; 456 int data_len = 0; 457 struct urb *this_urb; 458 459 portdata = usb_get_serial_port_data(port); 460 461 for (i=0; i < N_OUT_URB; i++) { 462 this_urb = portdata->out_urbs[i]; 463 if (this_urb && this_urb->status == -EINPROGRESS) 464 data_len += this_urb->transfer_buffer_length; 465 } 466 dbg("%s: %d", __FUNCTION__, data_len); 467 return data_len; 468 } 469 470 471 static int 472 option_open (struct usb_serial_port *port, struct file *filp) 473 { 474 struct option_port_private *portdata; 475 struct usb_serial *serial = port->serial; 476 int i, err; 477 struct urb *urb; 478 479 portdata = usb_get_serial_port_data(port); 480 481 dbg("%s", __FUNCTION__); 482 483 /* Set some sane defaults */ 484 portdata->rts_state = 1; 485 portdata->dtr_state = 1; 486 487 /* Reset low level data toggle and start reading from endpoints */ 488 for (i = 0; i < N_IN_URB; i++) { 489 urb = portdata->in_urbs[i]; 490 if (! urb) 491 continue; 492 if (urb->dev != serial->dev) { 493 dbg("%s: dev %p != %p", __FUNCTION__, urb->dev, serial->dev); 494 continue; 495 } 496 497 /* make sure endpoint data toggle is synchronized with the device */ 498 499 usb_clear_halt(urb->dev, urb->pipe); 500 501 err = usb_submit_urb(urb, GFP_KERNEL); 502 if (err) { 503 dbg("%s: submit urb %d failed (%d) %d", __FUNCTION__, i, err, 504 urb->transfer_buffer_length); 505 } 506 } 507 508 /* Reset low level data toggle on out endpoints */ 509 for (i = 0; i < N_OUT_URB; i++) { 510 urb = portdata->out_urbs[i]; 511 if (! urb) 512 continue; 513 urb->dev = serial->dev; 514 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe), 0); */ 515 } 516 517 port->tty->low_latency = 1; 518 519 option_send_setup(port); 520 521 return (0); 522 } 523 524 static inline void 525 stop_urb (struct urb *urb) 526 { 527 if (urb && urb->status == -EINPROGRESS) { 528 urb->transfer_flags &= ~URB_ASYNC_UNLINK; 529 usb_kill_urb(urb); 530 } 531 } 532 533 static void 534 option_close (struct usb_serial_port *port, struct file *filp) 535 { 536 int i; 537 struct usb_serial *serial = port->serial; 538 struct option_port_private *portdata; 539 540 dbg("%s", __FUNCTION__); 541 portdata = usb_get_serial_port_data(port); 542 543 portdata->rts_state = 0; 544 portdata->dtr_state = 0; 545 546 if (serial->dev) { 547 option_send_setup(port); 548 549 /* Stop reading/writing urbs */ 550 for (i = 0; i < N_IN_URB; i++) 551 stop_urb(portdata->in_urbs[i]); 552 for (i = 0; i < N_OUT_URB; i++) 553 stop_urb(portdata->out_urbs[i]); 554 } 555 port->tty = NULL; 556 } 557 558 559 /* Helper functions used by option_setup_urbs */ 560 static struct urb * 561 option_setup_urb (struct usb_serial *serial, int endpoint, 562 int dir, void *ctx, char *buf, int len, 563 void (*callback)(struct urb *, struct pt_regs *regs)) 564 { 565 struct urb *urb; 566 567 if (endpoint == -1) 568 return NULL; /* endpoint not needed */ 569 570 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 571 if (urb == NULL) { 572 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint); 573 return NULL; 574 } 575 576 /* Fill URB using supplied data. */ 577 usb_fill_bulk_urb(urb, serial->dev, 578 usb_sndbulkpipe(serial->dev, endpoint) | dir, 579 buf, len, callback, ctx); 580 581 return urb; 582 } 583 584 /* Setup urbs */ 585 static void 586 option_setup_urbs (struct usb_serial *serial) 587 { 588 int j; 589 struct usb_serial_port *port; 590 struct option_port_private *portdata; 591 592 dbg("%s", __FUNCTION__); 593 594 port = serial->port[0]; 595 portdata = usb_get_serial_port_data(port); 596 597 /* Do indat endpoints first */ 598 for (j = 0; j <= N_IN_URB; ++j) { 599 portdata->in_urbs[j] = option_setup_urb (serial, 600 port->bulk_in_endpointAddress, USB_DIR_IN, port, 601 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback); 602 } 603 604 /* outdat endpoints */ 605 for (j = 0; j <= N_OUT_URB; ++j) { 606 portdata->out_urbs[j] = option_setup_urb (serial, 607 port->bulk_out_endpointAddress, USB_DIR_OUT, port, 608 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback); 609 } 610 } 611 612 613 static int 614 option_send_setup (struct usb_serial_port *port) 615 { 616 struct usb_serial *serial = port->serial; 617 struct option_port_private *portdata; 618 619 dbg("%s", __FUNCTION__); 620 621 portdata = usb_get_serial_port_data(port); 622 623 if (port->tty) { 624 int val = 0; 625 if (portdata->dtr_state) 626 val |= 0x01; 627 if (portdata->rts_state) 628 val |= 0x02; 629 630 return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 631 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT); 632 } 633 634 return 0; 635 } 636 637 638 static int 639 option_startup (struct usb_serial *serial) 640 { 641 int i, err; 642 struct usb_serial_port *port; 643 struct option_port_private *portdata; 644 645 dbg("%s", __FUNCTION__); 646 647 /* Now setup per port private data */ 648 for (i = 0; i < serial->num_ports; i++) { 649 port = serial->port[i]; 650 portdata = kmalloc(sizeof(struct option_port_private), GFP_KERNEL); 651 if (!portdata) { 652 dbg("%s: kmalloc for option_port_private (%d) failed!.", __FUNCTION__, i); 653 return (1); 654 } 655 memset(portdata, 0, sizeof(struct option_port_private)); 656 657 usb_set_serial_port_data(port, portdata); 658 659 if (! port->interrupt_in_urb) 660 continue; 661 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 662 if (err) 663 dbg("%s: submit irq_in urb failed %d", __FUNCTION__, err); 664 } 665 666 option_setup_urbs(serial); 667 668 return (0); 669 } 670 671 static void 672 option_shutdown (struct usb_serial *serial) 673 { 674 int i, j; 675 struct usb_serial_port *port; 676 struct option_port_private *portdata; 677 678 dbg("%s", __FUNCTION__); 679 680 /* Stop reading/writing urbs */ 681 for (i = 0; i < serial->num_ports; ++i) { 682 port = serial->port[i]; 683 portdata = usb_get_serial_port_data(port); 684 for (j = 0; j < N_IN_URB; j++) 685 stop_urb(portdata->in_urbs[j]); 686 for (j = 0; j < N_OUT_URB; j++) 687 stop_urb(portdata->out_urbs[j]); 688 } 689 690 /* Now free them */ 691 for (i = 0; i < serial->num_ports; ++i) { 692 port = serial->port[i]; 693 portdata = usb_get_serial_port_data(port); 694 695 for (j = 0; j < N_IN_URB; j++) { 696 if (portdata->in_urbs[j]) { 697 usb_free_urb(portdata->in_urbs[j]); 698 portdata->in_urbs[j] = NULL; 699 } 700 } 701 for (j = 0; j < N_OUT_URB; j++) { 702 if (portdata->out_urbs[j]) { 703 usb_free_urb(portdata->out_urbs[j]); 704 portdata->out_urbs[j] = NULL; 705 } 706 } 707 } 708 709 /* Now free per port private data */ 710 for (i = 0; i < serial->num_ports; i++) { 711 port = serial->port[i]; 712 kfree(usb_get_serial_port_data(port)); 713 } 714 } 715 716 MODULE_AUTHOR(DRIVER_AUTHOR); 717 MODULE_DESCRIPTION(DRIVER_DESC); 718 MODULE_VERSION(DRIVER_VERSION); 719 MODULE_LICENSE("GPL"); 720 721 #ifdef CONFIG_USB_DEBUG 722 module_param(debug, bool, S_IRUGO | S_IWUSR); 723 MODULE_PARM_DESC(debug, "Debug messages"); 724 #endif 725 726