1 /* 2 Keyspan USB to Serial Converter driver 3 4 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org> 5 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 See http://misc.nu/hugh/keyspan.html for more information. 13 14 Code in this driver inspired by and in a number of places taken 15 from Brian Warner's original Keyspan-PDA driver. 16 17 This driver has been put together with the support of Innosys, Inc. 18 and Keyspan, Inc the manufacturers of the Keyspan USB-serial products. 19 Thanks Guys :) 20 21 Thanks to Paulus for miscellaneous tidy ups, some largish chunks 22 of much nicer and/or completely new code and (perhaps most uniquely) 23 having the patience to sit down and explain why and where he'd changed 24 stuff. 25 26 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting 27 staff in their work on open source projects. 28 29 Change History 30 31 2003sep04 LPM (Keyspan) add support for new single port product USA19HS. 32 Improve setup message handling for all devices. 33 34 Wed Feb 19 22:00:00 PST 2003 (Jeffrey S. Laing <keyspan@jsl.com>) 35 Merged the current (1/31/03) Keyspan code with the current (2.4.21-pre4) 36 Linux source tree. The Linux tree lacked support for the 49WLC and 37 others. The Keyspan patches didn't work with the current kernel. 38 39 2003jan30 LPM add support for the 49WLC and MPR 40 41 Wed Apr 25 12:00:00 PST 2002 (Keyspan) 42 Started with Hugh Blemings' code dated Jan 17, 2002. All adapters 43 now supported (including QI and QW). Modified port open, port 44 close, and send setup() logic to fix various data and endpoint 45 synchronization bugs and device LED status bugs. Changed keyspan_ 46 write_room() to accurately return transmit buffer availability. 47 Changed forwardingLength from 1 to 16 for all adapters. 48 49 Fri Oct 12 16:45:00 EST 2001 50 Preliminary USA-19QI and USA-28 support (both test OK for me, YMMV) 51 52 Wed Apr 25 12:00:00 PST 2002 (Keyspan) 53 Started with Hugh Blemings' code dated Jan 17, 2002. All adapters 54 now supported (including QI and QW). Modified port open, port 55 close, and send setup() logic to fix various data and endpoint 56 synchronization bugs and device LED status bugs. Changed keyspan_ 57 write_room() to accurately return transmit buffer availability. 58 Changed forwardingLength from 1 to 16 for all adapters. 59 60 Fri Oct 12 16:45:00 EST 2001 61 Preliminary USA-19QI and USA-28 support (both test OK for me, YMMV) 62 63 Mon Oct 8 14:29:00 EST 2001 hugh 64 Fixed bug that prevented mulitport devices operating correctly 65 if they weren't the first unit attached. 66 67 Sat Oct 6 12:31:21 EST 2001 hugh 68 Added support for USA-28XA and -28XB, misc cleanups, break support 69 for usa26 based models thanks to David Gibson. 70 71 Thu May 31 11:56:42 PDT 2001 gkh 72 switched from using spinlock to a semaphore 73 74 (04/08/2001) gb 75 Identify version on module load. 76 77 (11/01/2000) Adam J. Richter 78 usb_device_id table support. 79 80 Tue Oct 10 23:15:33 EST 2000 Hugh 81 Merged Paul's changes with my USA-49W mods. Work in progress 82 still... 83 84 Wed Jul 19 14:00:42 EST 2000 gkh 85 Added module_init and module_exit functions to handle the fact that 86 this driver is a loadable module now. 87 88 Tue Jul 18 16:14:52 EST 2000 Hugh 89 Basic character input/output for USA-19 now mostly works, 90 fixed at 9600 baud for the moment. 91 92 Sat Jul 8 11:11:48 EST 2000 Hugh 93 First public release - nothing works except the firmware upload. 94 Tested on PPC and x86 architectures, seems to behave... 95 */ 96 97 98 #include <linux/kernel.h> 99 #include <linux/jiffies.h> 100 #include <linux/errno.h> 101 #include <linux/init.h> 102 #include <linux/slab.h> 103 #include <linux/tty.h> 104 #include <linux/tty_driver.h> 105 #include <linux/tty_flip.h> 106 #include <linux/module.h> 107 #include <linux/spinlock.h> 108 #include <asm/uaccess.h> 109 #include <linux/usb.h> 110 #include "usb-serial.h" 111 #include "keyspan.h" 112 113 static int debug; 114 115 /* 116 * Version Information 117 */ 118 #define DRIVER_VERSION "v1.1.4" 119 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu" 120 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver" 121 122 #define INSTAT_BUFLEN 32 123 #define GLOCONT_BUFLEN 64 124 125 /* Per device and per port private data */ 126 struct keyspan_serial_private { 127 const struct keyspan_device_details *device_details; 128 129 struct urb *instat_urb; 130 char instat_buf[INSTAT_BUFLEN]; 131 132 /* XXX this one probably will need a lock */ 133 struct urb *glocont_urb; 134 char glocont_buf[GLOCONT_BUFLEN]; 135 }; 136 137 struct keyspan_port_private { 138 /* Keep track of which input & output endpoints to use */ 139 int in_flip; 140 int out_flip; 141 142 /* Keep duplicate of device details in each port 143 structure as well - simplifies some of the 144 callback functions etc. */ 145 const struct keyspan_device_details *device_details; 146 147 /* Input endpoints and buffer for this port */ 148 struct urb *in_urbs[2]; 149 char in_buffer[2][64]; 150 /* Output endpoints and buffer for this port */ 151 struct urb *out_urbs[2]; 152 char out_buffer[2][64]; 153 154 /* Input ack endpoint */ 155 struct urb *inack_urb; 156 char inack_buffer[1]; 157 158 /* Output control endpoint */ 159 struct urb *outcont_urb; 160 char outcont_buffer[64]; 161 162 /* Settings for the port */ 163 int baud; 164 int old_baud; 165 unsigned int cflag; 166 unsigned int old_cflag; 167 enum {flow_none, flow_cts, flow_xon} flow_control; 168 int rts_state; /* Handshaking pins (outputs) */ 169 int dtr_state; 170 int cts_state; /* Handshaking pins (inputs) */ 171 int dsr_state; 172 int dcd_state; 173 int ri_state; 174 int break_on; 175 176 unsigned long tx_start_time[2]; 177 int resend_cont; /* need to resend control packet */ 178 }; 179 180 181 /* Include Keyspan message headers. All current Keyspan Adapters 182 make use of one of four message formats which are referred 183 to as USA-26, USA-28 and USA-49, USA-90 by Keyspan and within this driver. */ 184 #include "keyspan_usa26msg.h" 185 #include "keyspan_usa28msg.h" 186 #include "keyspan_usa49msg.h" 187 #include "keyspan_usa90msg.h" 188 189 190 /* Functions used by new usb-serial code. */ 191 static int __init keyspan_init (void) 192 { 193 int retval; 194 retval = usb_serial_register(&keyspan_pre_device); 195 if (retval) 196 goto failed_pre_device_register; 197 retval = usb_serial_register(&keyspan_1port_device); 198 if (retval) 199 goto failed_1port_device_register; 200 retval = usb_serial_register(&keyspan_2port_device); 201 if (retval) 202 goto failed_2port_device_register; 203 retval = usb_serial_register(&keyspan_4port_device); 204 if (retval) 205 goto failed_4port_device_register; 206 retval = usb_register(&keyspan_driver); 207 if (retval) 208 goto failed_usb_register; 209 210 info(DRIVER_VERSION ":" DRIVER_DESC); 211 212 return 0; 213 failed_usb_register: 214 usb_serial_deregister(&keyspan_4port_device); 215 failed_4port_device_register: 216 usb_serial_deregister(&keyspan_2port_device); 217 failed_2port_device_register: 218 usb_serial_deregister(&keyspan_1port_device); 219 failed_1port_device_register: 220 usb_serial_deregister(&keyspan_pre_device); 221 failed_pre_device_register: 222 return retval; 223 } 224 225 static void __exit keyspan_exit (void) 226 { 227 usb_deregister (&keyspan_driver); 228 usb_serial_deregister (&keyspan_pre_device); 229 usb_serial_deregister (&keyspan_1port_device); 230 usb_serial_deregister (&keyspan_2port_device); 231 usb_serial_deregister (&keyspan_4port_device); 232 } 233 234 module_init(keyspan_init); 235 module_exit(keyspan_exit); 236 237 static void keyspan_rx_throttle (struct usb_serial_port *port) 238 { 239 dbg("%s - port %d", __FUNCTION__, port->number); 240 } 241 242 243 static void keyspan_rx_unthrottle (struct usb_serial_port *port) 244 { 245 dbg("%s - port %d", __FUNCTION__, port->number); 246 } 247 248 249 static void keyspan_break_ctl (struct usb_serial_port *port, int break_state) 250 { 251 struct keyspan_port_private *p_priv; 252 253 dbg("%s", __FUNCTION__); 254 255 p_priv = usb_get_serial_port_data(port); 256 257 if (break_state == -1) 258 p_priv->break_on = 1; 259 else 260 p_priv->break_on = 0; 261 262 keyspan_send_setup(port, 0); 263 } 264 265 266 static void keyspan_set_termios (struct usb_serial_port *port, 267 struct termios *old_termios) 268 { 269 int baud_rate, device_port; 270 struct keyspan_port_private *p_priv; 271 const struct keyspan_device_details *d_details; 272 unsigned int cflag; 273 274 dbg("%s", __FUNCTION__); 275 276 p_priv = usb_get_serial_port_data(port); 277 d_details = p_priv->device_details; 278 cflag = port->tty->termios->c_cflag; 279 device_port = port->number - port->serial->minor; 280 281 /* Baud rate calculation takes baud rate as an integer 282 so other rates can be generated if desired. */ 283 baud_rate = tty_get_baud_rate(port->tty); 284 /* If no match or invalid, don't change */ 285 if (baud_rate >= 0 286 && d_details->calculate_baud_rate(baud_rate, d_details->baudclk, 287 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 288 /* FIXME - more to do here to ensure rate changes cleanly */ 289 p_priv->baud = baud_rate; 290 } 291 292 /* set CTS/RTS handshake etc. */ 293 p_priv->cflag = cflag; 294 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none; 295 296 keyspan_send_setup(port, 0); 297 } 298 299 static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file) 300 { 301 unsigned int value; 302 struct keyspan_port_private *p_priv; 303 304 p_priv = usb_get_serial_port_data(port); 305 306 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) | 307 ((p_priv->dtr_state) ? TIOCM_DTR : 0) | 308 ((p_priv->cts_state) ? TIOCM_CTS : 0) | 309 ((p_priv->dsr_state) ? TIOCM_DSR : 0) | 310 ((p_priv->dcd_state) ? TIOCM_CAR : 0) | 311 ((p_priv->ri_state) ? TIOCM_RNG : 0); 312 313 return value; 314 } 315 316 static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file, 317 unsigned int set, unsigned int clear) 318 { 319 struct keyspan_port_private *p_priv; 320 321 p_priv = usb_get_serial_port_data(port); 322 323 if (set & TIOCM_RTS) 324 p_priv->rts_state = 1; 325 if (set & TIOCM_DTR) 326 p_priv->dtr_state = 1; 327 328 if (clear & TIOCM_RTS) 329 p_priv->rts_state = 0; 330 if (clear & TIOCM_DTR) 331 p_priv->dtr_state = 0; 332 keyspan_send_setup(port, 0); 333 return 0; 334 } 335 336 static int keyspan_ioctl(struct usb_serial_port *port, struct file *file, 337 unsigned int cmd, unsigned long arg) 338 { 339 return -ENOIOCTLCMD; 340 } 341 342 /* Write function is similar for the four protocols used 343 with only a minor change for usa90 (usa19hs) required */ 344 static int keyspan_write(struct usb_serial_port *port, 345 const unsigned char *buf, int count) 346 { 347 struct keyspan_port_private *p_priv; 348 const struct keyspan_device_details *d_details; 349 int flip; 350 int left, todo; 351 struct urb *this_urb; 352 int err, maxDataLen, dataOffset; 353 354 p_priv = usb_get_serial_port_data(port); 355 d_details = p_priv->device_details; 356 357 if (d_details->msg_format == msg_usa90) { 358 maxDataLen = 64; 359 dataOffset = 0; 360 } else { 361 maxDataLen = 63; 362 dataOffset = 1; 363 } 364 365 dbg("%s - for port %d (%d chars), flip=%d", 366 __FUNCTION__, port->number, count, p_priv->out_flip); 367 368 for (left = count; left > 0; left -= todo) { 369 todo = left; 370 if (todo > maxDataLen) 371 todo = maxDataLen; 372 373 flip = p_priv->out_flip; 374 375 /* Check we have a valid urb/endpoint before we use it... */ 376 if ((this_urb = p_priv->out_urbs[flip]) == NULL) { 377 /* no bulk out, so return 0 bytes written */ 378 dbg("%s - no output urb :(", __FUNCTION__); 379 return count; 380 } 381 382 dbg("%s - endpoint %d flip %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), flip); 383 384 if (this_urb->status == -EINPROGRESS) { 385 if (time_before(jiffies, p_priv->tx_start_time[flip] + 10 * HZ)) 386 break; 387 usb_unlink_urb(this_urb); 388 break; 389 } 390 391 /* First byte in buffer is "last flag" (except for usa19hx) - unused so 392 for now so set to zero */ 393 ((char *)this_urb->transfer_buffer)[0] = 0; 394 395 memcpy (this_urb->transfer_buffer + dataOffset, buf, todo); 396 buf += todo; 397 398 /* send the data out the bulk port */ 399 this_urb->transfer_buffer_length = todo + dataOffset; 400 401 this_urb->dev = port->serial->dev; 402 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) { 403 dbg("usb_submit_urb(write bulk) failed (%d)", err); 404 } 405 p_priv->tx_start_time[flip] = jiffies; 406 407 /* Flip for next time if usa26 or usa28 interface 408 (not used on usa49) */ 409 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip; 410 } 411 412 return count - left; 413 } 414 415 static void usa26_indat_callback(struct urb *urb, struct pt_regs *regs) 416 { 417 int i, err; 418 int endpoint; 419 struct usb_serial_port *port; 420 struct tty_struct *tty; 421 unsigned char *data = urb->transfer_buffer; 422 423 dbg ("%s", __FUNCTION__); 424 425 endpoint = usb_pipeendpoint(urb->pipe); 426 427 if (urb->status) { 428 dbg("%s - nonzero status: %x on endpoint %d.", 429 __FUNCTION__, urb->status, endpoint); 430 return; 431 } 432 433 port = (struct usb_serial_port *) urb->context; 434 tty = port->tty; 435 if (urb->actual_length) { 436 /* 0x80 bit is error flag */ 437 if ((data[0] & 0x80) == 0) { 438 /* no errors on individual bytes, only possible overrun err*/ 439 if (data[0] & RXERROR_OVERRUN) 440 err = TTY_OVERRUN; 441 else err = 0; 442 for (i = 1; i < urb->actual_length ; ++i) { 443 tty_insert_flip_char(tty, data[i], err); 444 } 445 } else { 446 /* some bytes had errors, every byte has status */ 447 dbg("%s - RX error!!!!", __FUNCTION__); 448 for (i = 0; i + 1 < urb->actual_length; i += 2) { 449 int stat = data[i], flag = 0; 450 if (stat & RXERROR_OVERRUN) 451 flag |= TTY_OVERRUN; 452 if (stat & RXERROR_FRAMING) 453 flag |= TTY_FRAME; 454 if (stat & RXERROR_PARITY) 455 flag |= TTY_PARITY; 456 /* XXX should handle break (0x10) */ 457 tty_insert_flip_char(tty, data[i+1], flag); 458 } 459 } 460 tty_flip_buffer_push(tty); 461 } 462 463 /* Resubmit urb so we continue receiving */ 464 urb->dev = port->serial->dev; 465 if (port->open_count) 466 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 467 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 468 } 469 return; 470 } 471 472 /* Outdat handling is common for all devices */ 473 static void usa2x_outdat_callback(struct urb *urb, struct pt_regs *regs) 474 { 475 struct usb_serial_port *port; 476 struct keyspan_port_private *p_priv; 477 478 port = (struct usb_serial_port *) urb->context; 479 p_priv = usb_get_serial_port_data(port); 480 dbg ("%s - urb %d", __FUNCTION__, urb == p_priv->out_urbs[1]); 481 482 if (port->open_count) 483 usb_serial_port_softint(port); 484 } 485 486 static void usa26_inack_callback(struct urb *urb, struct pt_regs *regs) 487 { 488 dbg ("%s", __FUNCTION__); 489 490 } 491 492 static void usa26_outcont_callback(struct urb *urb, struct pt_regs *regs) 493 { 494 struct usb_serial_port *port; 495 struct keyspan_port_private *p_priv; 496 497 port = (struct usb_serial_port *) urb->context; 498 p_priv = usb_get_serial_port_data(port); 499 500 if (p_priv->resend_cont) { 501 dbg ("%s - sending setup", __FUNCTION__); 502 keyspan_usa26_send_setup(port->serial, port, p_priv->resend_cont - 1); 503 } 504 } 505 506 static void usa26_instat_callback(struct urb *urb, struct pt_regs *regs) 507 { 508 unsigned char *data = urb->transfer_buffer; 509 struct keyspan_usa26_portStatusMessage *msg; 510 struct usb_serial *serial; 511 struct usb_serial_port *port; 512 struct keyspan_port_private *p_priv; 513 int old_dcd_state, err; 514 515 serial = (struct usb_serial *) urb->context; 516 517 if (urb->status) { 518 dbg("%s - nonzero status: %x", __FUNCTION__, urb->status); 519 return; 520 } 521 if (urb->actual_length != 9) { 522 dbg("%s - %d byte report??", __FUNCTION__, urb->actual_length); 523 goto exit; 524 } 525 526 msg = (struct keyspan_usa26_portStatusMessage *)data; 527 528 #if 0 529 dbg("%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d", 530 __FUNCTION__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff, 531 msg->_txXoff, msg->rxEnabled, msg->controlResponse); 532 #endif 533 534 /* Now do something useful with the data */ 535 536 537 /* Check port number from message and retrieve private data */ 538 if (msg->port >= serial->num_ports) { 539 dbg ("%s - Unexpected port number %d", __FUNCTION__, msg->port); 540 goto exit; 541 } 542 port = serial->port[msg->port]; 543 p_priv = usb_get_serial_port_data(port); 544 545 /* Update handshaking pin state information */ 546 old_dcd_state = p_priv->dcd_state; 547 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0); 548 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 549 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0); 550 p_priv->ri_state = ((msg->ri) ? 1 : 0); 551 552 if (port->tty && !C_CLOCAL(port->tty) 553 && old_dcd_state != p_priv->dcd_state) { 554 if (old_dcd_state) 555 tty_hangup(port->tty); 556 /* else */ 557 /* wake_up_interruptible(&p_priv->open_wait); */ 558 } 559 560 /* Resubmit urb so we continue receiving */ 561 urb->dev = serial->dev; 562 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 563 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 564 } 565 exit: ; 566 } 567 568 static void usa26_glocont_callback(struct urb *urb, struct pt_regs *regs) 569 { 570 dbg ("%s", __FUNCTION__); 571 572 } 573 574 575 static void usa28_indat_callback(struct urb *urb, struct pt_regs *regs) 576 { 577 int i, err; 578 struct usb_serial_port *port; 579 struct tty_struct *tty; 580 unsigned char *data; 581 struct keyspan_port_private *p_priv; 582 583 dbg ("%s", __FUNCTION__); 584 585 port = (struct usb_serial_port *) urb->context; 586 p_priv = usb_get_serial_port_data(port); 587 data = urb->transfer_buffer; 588 589 if (urb != p_priv->in_urbs[p_priv->in_flip]) 590 return; 591 592 do { 593 if (urb->status) { 594 dbg("%s - nonzero status: %x on endpoint %d.", 595 __FUNCTION__, urb->status, usb_pipeendpoint(urb->pipe)); 596 return; 597 } 598 599 port = (struct usb_serial_port *) urb->context; 600 p_priv = usb_get_serial_port_data(port); 601 data = urb->transfer_buffer; 602 603 tty = port->tty; 604 if (urb->actual_length) { 605 for (i = 0; i < urb->actual_length ; ++i) { 606 tty_insert_flip_char(tty, data[i], 0); 607 } 608 tty_flip_buffer_push(tty); 609 } 610 611 /* Resubmit urb so we continue receiving */ 612 urb->dev = port->serial->dev; 613 if (port->open_count) 614 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 615 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 616 } 617 p_priv->in_flip ^= 1; 618 619 urb = p_priv->in_urbs[p_priv->in_flip]; 620 } while (urb->status != -EINPROGRESS); 621 } 622 623 static void usa28_inack_callback(struct urb *urb, struct pt_regs *regs) 624 { 625 dbg ("%s", __FUNCTION__); 626 } 627 628 static void usa28_outcont_callback(struct urb *urb, struct pt_regs *regs) 629 { 630 struct usb_serial_port *port; 631 struct keyspan_port_private *p_priv; 632 633 port = (struct usb_serial_port *) urb->context; 634 p_priv = usb_get_serial_port_data(port); 635 636 if (p_priv->resend_cont) { 637 dbg ("%s - sending setup", __FUNCTION__); 638 keyspan_usa28_send_setup(port->serial, port, p_priv->resend_cont - 1); 639 } 640 } 641 642 static void usa28_instat_callback(struct urb *urb, struct pt_regs *regs) 643 { 644 int err; 645 unsigned char *data = urb->transfer_buffer; 646 struct keyspan_usa28_portStatusMessage *msg; 647 struct usb_serial *serial; 648 struct usb_serial_port *port; 649 struct keyspan_port_private *p_priv; 650 int old_dcd_state; 651 652 serial = (struct usb_serial *) urb->context; 653 654 if (urb->status) { 655 dbg("%s - nonzero status: %x", __FUNCTION__, urb->status); 656 return; 657 } 658 659 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) { 660 dbg("%s - bad length %d", __FUNCTION__, urb->actual_length); 661 goto exit; 662 } 663 664 /*dbg("%s %x %x %x %x %x %x %x %x %x %x %x %x", __FUNCTION__ 665 data[0], data[1], data[2], data[3], data[4], data[5], 666 data[6], data[7], data[8], data[9], data[10], data[11]);*/ 667 668 /* Now do something useful with the data */ 669 msg = (struct keyspan_usa28_portStatusMessage *)data; 670 671 672 /* Check port number from message and retrieve private data */ 673 if (msg->port >= serial->num_ports) { 674 dbg ("%s - Unexpected port number %d", __FUNCTION__, msg->port); 675 goto exit; 676 } 677 port = serial->port[msg->port]; 678 p_priv = usb_get_serial_port_data(port); 679 680 /* Update handshaking pin state information */ 681 old_dcd_state = p_priv->dcd_state; 682 p_priv->cts_state = ((msg->cts) ? 1 : 0); 683 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 684 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 685 p_priv->ri_state = ((msg->ri) ? 1 : 0); 686 687 if (port->tty && !C_CLOCAL(port->tty) 688 && old_dcd_state != p_priv->dcd_state) { 689 if (old_dcd_state) 690 tty_hangup(port->tty); 691 /* else */ 692 /* wake_up_interruptible(&p_priv->open_wait); */ 693 } 694 695 /* Resubmit urb so we continue receiving */ 696 urb->dev = serial->dev; 697 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 698 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 699 } 700 exit: ; 701 } 702 703 static void usa28_glocont_callback(struct urb *urb, struct pt_regs *regs) 704 { 705 dbg ("%s", __FUNCTION__); 706 } 707 708 709 static void usa49_glocont_callback(struct urb *urb, struct pt_regs *regs) 710 { 711 struct usb_serial *serial; 712 struct usb_serial_port *port; 713 struct keyspan_port_private *p_priv; 714 int i; 715 716 dbg ("%s", __FUNCTION__); 717 718 serial = (struct usb_serial *) urb->context; 719 for (i = 0; i < serial->num_ports; ++i) { 720 port = serial->port[i]; 721 p_priv = usb_get_serial_port_data(port); 722 723 if (p_priv->resend_cont) { 724 dbg ("%s - sending setup", __FUNCTION__); 725 keyspan_usa49_send_setup(serial, port, p_priv->resend_cont - 1); 726 break; 727 } 728 } 729 } 730 731 /* This is actually called glostat in the Keyspan 732 doco */ 733 static void usa49_instat_callback(struct urb *urb, struct pt_regs *regs) 734 { 735 int err; 736 unsigned char *data = urb->transfer_buffer; 737 struct keyspan_usa49_portStatusMessage *msg; 738 struct usb_serial *serial; 739 struct usb_serial_port *port; 740 struct keyspan_port_private *p_priv; 741 int old_dcd_state; 742 743 dbg ("%s", __FUNCTION__); 744 745 serial = (struct usb_serial *) urb->context; 746 747 if (urb->status) { 748 dbg("%s - nonzero status: %x", __FUNCTION__, urb->status); 749 return; 750 } 751 752 if (urb->actual_length != sizeof(struct keyspan_usa49_portStatusMessage)) { 753 dbg("%s - bad length %d", __FUNCTION__, urb->actual_length); 754 goto exit; 755 } 756 757 /*dbg(" %x %x %x %x %x %x %x %x %x %x %x", __FUNCTION__, 758 data[0], data[1], data[2], data[3], data[4], data[5], 759 data[6], data[7], data[8], data[9], data[10]);*/ 760 761 /* Now do something useful with the data */ 762 msg = (struct keyspan_usa49_portStatusMessage *)data; 763 764 /* Check port number from message and retrieve private data */ 765 if (msg->portNumber >= serial->num_ports) { 766 dbg ("%s - Unexpected port number %d", __FUNCTION__, msg->portNumber); 767 goto exit; 768 } 769 port = serial->port[msg->portNumber]; 770 p_priv = usb_get_serial_port_data(port); 771 772 /* Update handshaking pin state information */ 773 old_dcd_state = p_priv->dcd_state; 774 p_priv->cts_state = ((msg->cts) ? 1 : 0); 775 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 776 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 777 p_priv->ri_state = ((msg->ri) ? 1 : 0); 778 779 if (port->tty && !C_CLOCAL(port->tty) 780 && old_dcd_state != p_priv->dcd_state) { 781 if (old_dcd_state) 782 tty_hangup(port->tty); 783 /* else */ 784 /* wake_up_interruptible(&p_priv->open_wait); */ 785 } 786 787 /* Resubmit urb so we continue receiving */ 788 urb->dev = serial->dev; 789 790 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 791 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 792 } 793 exit: ; 794 } 795 796 static void usa49_inack_callback(struct urb *urb, struct pt_regs *regs) 797 { 798 dbg ("%s", __FUNCTION__); 799 } 800 801 static void usa49_indat_callback(struct urb *urb, struct pt_regs *regs) 802 { 803 int i, err; 804 int endpoint; 805 struct usb_serial_port *port; 806 struct tty_struct *tty; 807 unsigned char *data = urb->transfer_buffer; 808 809 dbg ("%s", __FUNCTION__); 810 811 endpoint = usb_pipeendpoint(urb->pipe); 812 813 if (urb->status) { 814 dbg("%s - nonzero status: %x on endpoint %d.", __FUNCTION__, 815 urb->status, endpoint); 816 return; 817 } 818 819 port = (struct usb_serial_port *) urb->context; 820 tty = port->tty; 821 if (urb->actual_length) { 822 /* 0x80 bit is error flag */ 823 if ((data[0] & 0x80) == 0) { 824 /* no error on any byte */ 825 for (i = 1; i < urb->actual_length ; ++i) { 826 tty_insert_flip_char(tty, data[i], 0); 827 } 828 } else { 829 /* some bytes had errors, every byte has status */ 830 for (i = 0; i + 1 < urb->actual_length; i += 2) { 831 int stat = data[i], flag = 0; 832 if (stat & RXERROR_OVERRUN) 833 flag |= TTY_OVERRUN; 834 if (stat & RXERROR_FRAMING) 835 flag |= TTY_FRAME; 836 if (stat & RXERROR_PARITY) 837 flag |= TTY_PARITY; 838 /* XXX should handle break (0x10) */ 839 tty_insert_flip_char(tty, data[i+1], flag); 840 } 841 } 842 tty_flip_buffer_push(tty); 843 } 844 845 /* Resubmit urb so we continue receiving */ 846 urb->dev = port->serial->dev; 847 if (port->open_count) 848 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 849 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 850 } 851 } 852 853 /* not used, usa-49 doesn't have per-port control endpoints */ 854 static void usa49_outcont_callback(struct urb *urb, struct pt_regs *regs) 855 { 856 dbg ("%s", __FUNCTION__); 857 } 858 859 static void usa90_indat_callback(struct urb *urb, struct pt_regs *regs) 860 { 861 int i, err; 862 int endpoint; 863 struct usb_serial_port *port; 864 struct keyspan_port_private *p_priv; 865 struct tty_struct *tty; 866 unsigned char *data = urb->transfer_buffer; 867 868 dbg ("%s", __FUNCTION__); 869 870 endpoint = usb_pipeendpoint(urb->pipe); 871 872 873 if (urb->status) { 874 dbg("%s - nonzero status: %x on endpoint %d.", 875 __FUNCTION__, urb->status, endpoint); 876 return; 877 } 878 879 port = (struct usb_serial_port *) urb->context; 880 p_priv = usb_get_serial_port_data(port); 881 882 tty = port->tty; 883 if (urb->actual_length) { 884 885 /* if current mode is DMA, looks like usa28 format 886 otherwise looks like usa26 data format */ 887 888 if (p_priv->baud > 57600) { 889 for (i = 0; i < urb->actual_length ; ++i) 890 tty_insert_flip_char(tty, data[i], 0); 891 } 892 else { 893 894 /* 0x80 bit is error flag */ 895 if ((data[0] & 0x80) == 0) { 896 /* no errors on individual bytes, only possible overrun err*/ 897 if (data[0] & RXERROR_OVERRUN) 898 err = TTY_OVERRUN; 899 else err = 0; 900 for (i = 1; i < urb->actual_length ; ++i) 901 tty_insert_flip_char(tty, data[i], err); 902 903 } 904 else { 905 /* some bytes had errors, every byte has status */ 906 dbg("%s - RX error!!!!", __FUNCTION__); 907 for (i = 0; i + 1 < urb->actual_length; i += 2) { 908 int stat = data[i], flag = 0; 909 if (stat & RXERROR_OVERRUN) 910 flag |= TTY_OVERRUN; 911 if (stat & RXERROR_FRAMING) 912 flag |= TTY_FRAME; 913 if (stat & RXERROR_PARITY) 914 flag |= TTY_PARITY; 915 /* XXX should handle break (0x10) */ 916 tty_insert_flip_char(tty, data[i+1], flag); 917 } 918 } 919 } 920 tty_flip_buffer_push(tty); 921 } 922 923 /* Resubmit urb so we continue receiving */ 924 urb->dev = port->serial->dev; 925 if (port->open_count) 926 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 927 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 928 } 929 return; 930 } 931 932 933 static void usa90_instat_callback(struct urb *urb, struct pt_regs *regs) 934 { 935 unsigned char *data = urb->transfer_buffer; 936 struct keyspan_usa90_portStatusMessage *msg; 937 struct usb_serial *serial; 938 struct usb_serial_port *port; 939 struct keyspan_port_private *p_priv; 940 int old_dcd_state, err; 941 942 serial = (struct usb_serial *) urb->context; 943 944 if (urb->status) { 945 dbg("%s - nonzero status: %x", __FUNCTION__, urb->status); 946 return; 947 } 948 if (urb->actual_length < 14) { 949 dbg("%s - %d byte report??", __FUNCTION__, urb->actual_length); 950 goto exit; 951 } 952 953 msg = (struct keyspan_usa90_portStatusMessage *)data; 954 955 /* Now do something useful with the data */ 956 957 port = serial->port[0]; 958 p_priv = usb_get_serial_port_data(port); 959 960 /* Update handshaking pin state information */ 961 old_dcd_state = p_priv->dcd_state; 962 p_priv->cts_state = ((msg->cts) ? 1 : 0); 963 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 964 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 965 p_priv->ri_state = ((msg->ri) ? 1 : 0); 966 967 if (port->tty && !C_CLOCAL(port->tty) 968 && old_dcd_state != p_priv->dcd_state) { 969 if (old_dcd_state) 970 tty_hangup(port->tty); 971 /* else */ 972 /* wake_up_interruptible(&p_priv->open_wait); */ 973 } 974 975 /* Resubmit urb so we continue receiving */ 976 urb->dev = serial->dev; 977 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 978 dbg("%s - resubmit read urb failed. (%d)", __FUNCTION__, err); 979 } 980 exit: 981 ; 982 } 983 984 static void usa90_outcont_callback(struct urb *urb, struct pt_regs *regs) 985 { 986 struct usb_serial_port *port; 987 struct keyspan_port_private *p_priv; 988 989 port = (struct usb_serial_port *) urb->context; 990 p_priv = usb_get_serial_port_data(port); 991 992 if (p_priv->resend_cont) { 993 dbg ("%s - sending setup", __FUNCTION__); 994 keyspan_usa90_send_setup(port->serial, port, p_priv->resend_cont - 1); 995 } 996 } 997 998 static int keyspan_write_room (struct usb_serial_port *port) 999 { 1000 struct keyspan_port_private *p_priv; 1001 const struct keyspan_device_details *d_details; 1002 int flip; 1003 int data_len; 1004 struct urb *this_urb; 1005 1006 dbg("%s", __FUNCTION__); 1007 p_priv = usb_get_serial_port_data(port); 1008 d_details = p_priv->device_details; 1009 1010 if (d_details->msg_format == msg_usa90) 1011 data_len = 64; 1012 else 1013 data_len = 63; 1014 1015 flip = p_priv->out_flip; 1016 1017 /* Check both endpoints to see if any are available. */ 1018 if ((this_urb = p_priv->out_urbs[flip]) != NULL) { 1019 if (this_urb->status != -EINPROGRESS) 1020 return (data_len); 1021 flip = (flip + 1) & d_details->outdat_endp_flip; 1022 if ((this_urb = p_priv->out_urbs[flip]) != NULL) 1023 if (this_urb->status != -EINPROGRESS) 1024 return (data_len); 1025 } 1026 return (0); 1027 } 1028 1029 1030 static int keyspan_chars_in_buffer (struct usb_serial_port *port) 1031 { 1032 return (0); 1033 } 1034 1035 1036 static int keyspan_open (struct usb_serial_port *port, struct file *filp) 1037 { 1038 struct keyspan_port_private *p_priv; 1039 struct keyspan_serial_private *s_priv; 1040 struct usb_serial *serial = port->serial; 1041 const struct keyspan_device_details *d_details; 1042 int i, err; 1043 int baud_rate, device_port; 1044 struct urb *urb; 1045 unsigned int cflag; 1046 1047 s_priv = usb_get_serial_data(serial); 1048 p_priv = usb_get_serial_port_data(port); 1049 d_details = p_priv->device_details; 1050 1051 dbg("%s - port%d.", __FUNCTION__, port->number); 1052 1053 /* Set some sane defaults */ 1054 p_priv->rts_state = 1; 1055 p_priv->dtr_state = 1; 1056 p_priv->baud = 9600; 1057 1058 /* force baud and lcr to be set on open */ 1059 p_priv->old_baud = 0; 1060 p_priv->old_cflag = 0; 1061 1062 p_priv->out_flip = 0; 1063 p_priv->in_flip = 0; 1064 1065 /* Reset low level data toggle and start reading from endpoints */ 1066 for (i = 0; i < 2; i++) { 1067 if ((urb = p_priv->in_urbs[i]) == NULL) 1068 continue; 1069 urb->dev = serial->dev; 1070 1071 /* make sure endpoint data toggle is synchronized with the device */ 1072 1073 usb_clear_halt(urb->dev, urb->pipe); 1074 1075 if ((err = usb_submit_urb(urb, GFP_KERNEL)) != 0) { 1076 dbg("%s - submit urb %d failed (%d)", __FUNCTION__, i, err); 1077 } 1078 } 1079 1080 /* Reset low level data toggle on out endpoints */ 1081 for (i = 0; i < 2; i++) { 1082 if ((urb = p_priv->out_urbs[i]) == NULL) 1083 continue; 1084 urb->dev = serial->dev; 1085 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe), 0); */ 1086 } 1087 1088 /* get the terminal config for the setup message now so we don't 1089 * need to send 2 of them */ 1090 1091 cflag = port->tty->termios->c_cflag; 1092 device_port = port->number - port->serial->minor; 1093 1094 /* Baud rate calculation takes baud rate as an integer 1095 so other rates can be generated if desired. */ 1096 baud_rate = tty_get_baud_rate(port->tty); 1097 /* If no match or invalid, leave as default */ 1098 if (baud_rate >= 0 1099 && d_details->calculate_baud_rate(baud_rate, d_details->baudclk, 1100 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 1101 p_priv->baud = baud_rate; 1102 } 1103 1104 /* set CTS/RTS handshake etc. */ 1105 p_priv->cflag = cflag; 1106 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none; 1107 1108 keyspan_send_setup(port, 1); 1109 //mdelay(100); 1110 //keyspan_set_termios(port, NULL); 1111 1112 return (0); 1113 } 1114 1115 static inline void stop_urb(struct urb *urb) 1116 { 1117 if (urb && urb->status == -EINPROGRESS) 1118 usb_kill_urb(urb); 1119 } 1120 1121 static void keyspan_close(struct usb_serial_port *port, struct file *filp) 1122 { 1123 int i; 1124 struct usb_serial *serial = port->serial; 1125 struct keyspan_serial_private *s_priv; 1126 struct keyspan_port_private *p_priv; 1127 1128 dbg("%s", __FUNCTION__); 1129 s_priv = usb_get_serial_data(serial); 1130 p_priv = usb_get_serial_port_data(port); 1131 1132 p_priv->rts_state = 0; 1133 p_priv->dtr_state = 0; 1134 1135 if (serial->dev) { 1136 keyspan_send_setup(port, 2); 1137 /* pilot-xfer seems to work best with this delay */ 1138 mdelay(100); 1139 // keyspan_set_termios(port, NULL); 1140 } 1141 1142 /*while (p_priv->outcont_urb->status == -EINPROGRESS) { 1143 dbg("%s - urb in progress", __FUNCTION__); 1144 }*/ 1145 1146 p_priv->out_flip = 0; 1147 p_priv->in_flip = 0; 1148 1149 if (serial->dev) { 1150 /* Stop reading/writing urbs */ 1151 stop_urb(p_priv->inack_urb); 1152 /* stop_urb(p_priv->outcont_urb); */ 1153 for (i = 0; i < 2; i++) { 1154 stop_urb(p_priv->in_urbs[i]); 1155 stop_urb(p_priv->out_urbs[i]); 1156 } 1157 } 1158 port->tty = NULL; 1159 } 1160 1161 1162 /* download the firmware to a pre-renumeration device */ 1163 static int keyspan_fake_startup (struct usb_serial *serial) 1164 { 1165 int response; 1166 const struct ezusb_hex_record *record; 1167 char *fw_name; 1168 1169 dbg("Keyspan startup version %04x product %04x", 1170 le16_to_cpu(serial->dev->descriptor.bcdDevice), 1171 le16_to_cpu(serial->dev->descriptor.idProduct)); 1172 1173 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000) != 0x8000) { 1174 dbg("Firmware already loaded. Quitting."); 1175 return(1); 1176 } 1177 1178 /* Select firmware image on the basis of idProduct */ 1179 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) { 1180 case keyspan_usa28_pre_product_id: 1181 record = &keyspan_usa28_firmware[0]; 1182 fw_name = "USA28"; 1183 break; 1184 1185 case keyspan_usa28x_pre_product_id: 1186 record = &keyspan_usa28x_firmware[0]; 1187 fw_name = "USA28X"; 1188 break; 1189 1190 case keyspan_usa28xa_pre_product_id: 1191 record = &keyspan_usa28xa_firmware[0]; 1192 fw_name = "USA28XA"; 1193 break; 1194 1195 case keyspan_usa28xb_pre_product_id: 1196 record = &keyspan_usa28xb_firmware[0]; 1197 fw_name = "USA28XB"; 1198 break; 1199 1200 case keyspan_usa19_pre_product_id: 1201 record = &keyspan_usa19_firmware[0]; 1202 fw_name = "USA19"; 1203 break; 1204 1205 case keyspan_usa19qi_pre_product_id: 1206 record = &keyspan_usa19qi_firmware[0]; 1207 fw_name = "USA19QI"; 1208 break; 1209 1210 case keyspan_mpr_pre_product_id: 1211 record = &keyspan_mpr_firmware[0]; 1212 fw_name = "MPR"; 1213 break; 1214 1215 case keyspan_usa19qw_pre_product_id: 1216 record = &keyspan_usa19qw_firmware[0]; 1217 fw_name = "USA19QI"; 1218 break; 1219 1220 case keyspan_usa18x_pre_product_id: 1221 record = &keyspan_usa18x_firmware[0]; 1222 fw_name = "USA18X"; 1223 break; 1224 1225 case keyspan_usa19w_pre_product_id: 1226 record = &keyspan_usa19w_firmware[0]; 1227 fw_name = "USA19W"; 1228 break; 1229 1230 case keyspan_usa49w_pre_product_id: 1231 record = &keyspan_usa49w_firmware[0]; 1232 fw_name = "USA49W"; 1233 break; 1234 1235 case keyspan_usa49wlc_pre_product_id: 1236 record = &keyspan_usa49wlc_firmware[0]; 1237 fw_name = "USA49WLC"; 1238 break; 1239 1240 default: 1241 record = NULL; 1242 fw_name = "Unknown"; 1243 break; 1244 } 1245 1246 if (record == NULL) { 1247 dev_err(&serial->dev->dev, "Required keyspan firmware image (%s) unavailable.\n", fw_name); 1248 return(1); 1249 } 1250 1251 dbg("Uploading Keyspan %s firmware.", fw_name); 1252 1253 /* download the firmware image */ 1254 response = ezusb_set_reset(serial, 1); 1255 1256 while(record->address != 0xffff) { 1257 response = ezusb_writememory(serial, record->address, 1258 (unsigned char *)record->data, 1259 record->data_size, 0xa0); 1260 if (response < 0) { 1261 dev_err(&serial->dev->dev, "ezusb_writememory failed for Keyspan" 1262 "firmware (%d %04X %p %d)\n", 1263 response, 1264 record->address, record->data, record->data_size); 1265 break; 1266 } 1267 record++; 1268 } 1269 /* bring device out of reset. Renumeration will occur in a 1270 moment and the new device will bind to the real driver */ 1271 response = ezusb_set_reset(serial, 0); 1272 1273 /* we don't want this device to have a driver assigned to it. */ 1274 return (1); 1275 } 1276 1277 /* Helper functions used by keyspan_setup_urbs */ 1278 static struct urb *keyspan_setup_urb (struct usb_serial *serial, int endpoint, 1279 int dir, void *ctx, char *buf, int len, 1280 void (*callback)(struct urb *, struct pt_regs *regs)) 1281 { 1282 struct urb *urb; 1283 1284 if (endpoint == -1) 1285 return NULL; /* endpoint not needed */ 1286 1287 dbg ("%s - alloc for endpoint %d.", __FUNCTION__, endpoint); 1288 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 1289 if (urb == NULL) { 1290 dbg ("%s - alloc for endpoint %d failed.", __FUNCTION__, endpoint); 1291 return NULL; 1292 } 1293 1294 /* Fill URB using supplied data. */ 1295 usb_fill_bulk_urb(urb, serial->dev, 1296 usb_sndbulkpipe(serial->dev, endpoint) | dir, 1297 buf, len, callback, ctx); 1298 1299 return urb; 1300 } 1301 1302 static struct callbacks { 1303 void (*instat_callback)(struct urb *, struct pt_regs *regs); 1304 void (*glocont_callback)(struct urb *, struct pt_regs *regs); 1305 void (*indat_callback)(struct urb *, struct pt_regs *regs); 1306 void (*outdat_callback)(struct urb *, struct pt_regs *regs); 1307 void (*inack_callback)(struct urb *, struct pt_regs *regs); 1308 void (*outcont_callback)(struct urb *, struct pt_regs *regs); 1309 } keyspan_callbacks[] = { 1310 { 1311 /* msg_usa26 callbacks */ 1312 .instat_callback = usa26_instat_callback, 1313 .glocont_callback = usa26_glocont_callback, 1314 .indat_callback = usa26_indat_callback, 1315 .outdat_callback = usa2x_outdat_callback, 1316 .inack_callback = usa26_inack_callback, 1317 .outcont_callback = usa26_outcont_callback, 1318 }, { 1319 /* msg_usa28 callbacks */ 1320 .instat_callback = usa28_instat_callback, 1321 .glocont_callback = usa28_glocont_callback, 1322 .indat_callback = usa28_indat_callback, 1323 .outdat_callback = usa2x_outdat_callback, 1324 .inack_callback = usa28_inack_callback, 1325 .outcont_callback = usa28_outcont_callback, 1326 }, { 1327 /* msg_usa49 callbacks */ 1328 .instat_callback = usa49_instat_callback, 1329 .glocont_callback = usa49_glocont_callback, 1330 .indat_callback = usa49_indat_callback, 1331 .outdat_callback = usa2x_outdat_callback, 1332 .inack_callback = usa49_inack_callback, 1333 .outcont_callback = usa49_outcont_callback, 1334 }, { 1335 /* msg_usa90 callbacks */ 1336 .instat_callback = usa90_instat_callback, 1337 .glocont_callback = usa28_glocont_callback, 1338 .indat_callback = usa90_indat_callback, 1339 .outdat_callback = usa2x_outdat_callback, 1340 .inack_callback = usa28_inack_callback, 1341 .outcont_callback = usa90_outcont_callback, 1342 } 1343 }; 1344 1345 /* Generic setup urbs function that uses 1346 data in device_details */ 1347 static void keyspan_setup_urbs(struct usb_serial *serial) 1348 { 1349 int i, j; 1350 struct keyspan_serial_private *s_priv; 1351 const struct keyspan_device_details *d_details; 1352 struct usb_serial_port *port; 1353 struct keyspan_port_private *p_priv; 1354 struct callbacks *cback; 1355 int endp; 1356 1357 dbg ("%s", __FUNCTION__); 1358 1359 s_priv = usb_get_serial_data(serial); 1360 d_details = s_priv->device_details; 1361 1362 /* Setup values for the various callback routines */ 1363 cback = &keyspan_callbacks[d_details->msg_format]; 1364 1365 /* Allocate and set up urbs for each one that is in use, 1366 starting with instat endpoints */ 1367 s_priv->instat_urb = keyspan_setup_urb 1368 (serial, d_details->instat_endpoint, USB_DIR_IN, 1369 serial, s_priv->instat_buf, INSTAT_BUFLEN, 1370 cback->instat_callback); 1371 1372 s_priv->glocont_urb = keyspan_setup_urb 1373 (serial, d_details->glocont_endpoint, USB_DIR_OUT, 1374 serial, s_priv->glocont_buf, GLOCONT_BUFLEN, 1375 cback->glocont_callback); 1376 1377 /* Setup endpoints for each port specific thing */ 1378 for (i = 0; i < d_details->num_ports; i ++) { 1379 port = serial->port[i]; 1380 p_priv = usb_get_serial_port_data(port); 1381 1382 /* Do indat endpoints first, once for each flip */ 1383 endp = d_details->indat_endpoints[i]; 1384 for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) { 1385 p_priv->in_urbs[j] = keyspan_setup_urb 1386 (serial, endp, USB_DIR_IN, port, 1387 p_priv->in_buffer[j], 64, 1388 cback->indat_callback); 1389 } 1390 for (; j < 2; ++j) 1391 p_priv->in_urbs[j] = NULL; 1392 1393 /* outdat endpoints also have flip */ 1394 endp = d_details->outdat_endpoints[i]; 1395 for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) { 1396 p_priv->out_urbs[j] = keyspan_setup_urb 1397 (serial, endp, USB_DIR_OUT, port, 1398 p_priv->out_buffer[j], 64, 1399 cback->outdat_callback); 1400 } 1401 for (; j < 2; ++j) 1402 p_priv->out_urbs[j] = NULL; 1403 1404 /* inack endpoint */ 1405 p_priv->inack_urb = keyspan_setup_urb 1406 (serial, d_details->inack_endpoints[i], USB_DIR_IN, 1407 port, p_priv->inack_buffer, 1, cback->inack_callback); 1408 1409 /* outcont endpoint */ 1410 p_priv->outcont_urb = keyspan_setup_urb 1411 (serial, d_details->outcont_endpoints[i], USB_DIR_OUT, 1412 port, p_priv->outcont_buffer, 64, 1413 cback->outcont_callback); 1414 } 1415 1416 } 1417 1418 /* usa19 function doesn't require prescaler */ 1419 static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1420 u8 *rate_low, u8 *prescaler, int portnum) 1421 { 1422 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1423 div, /* divisor */ 1424 cnt; /* inverse of divisor (programmed into 8051) */ 1425 1426 dbg ("%s - %d.", __FUNCTION__, baud_rate); 1427 1428 /* prevent divide by zero... */ 1429 if( (b16 = (baud_rate * 16L)) == 0) { 1430 return (KEYSPAN_INVALID_BAUD_RATE); 1431 } 1432 1433 /* Any "standard" rate over 57k6 is marginal on the USA-19 1434 as we run out of divisor resolution. */ 1435 if (baud_rate > 57600) { 1436 return (KEYSPAN_INVALID_BAUD_RATE); 1437 } 1438 1439 /* calculate the divisor and the counter (its inverse) */ 1440 if( (div = (baudclk / b16)) == 0) { 1441 return (KEYSPAN_INVALID_BAUD_RATE); 1442 } 1443 else { 1444 cnt = 0 - div; 1445 } 1446 1447 if(div > 0xffff) { 1448 return (KEYSPAN_INVALID_BAUD_RATE); 1449 } 1450 1451 /* return the counter values if non-null */ 1452 if (rate_low) { 1453 *rate_low = (u8) (cnt & 0xff); 1454 } 1455 if (rate_hi) { 1456 *rate_hi = (u8) ((cnt >> 8) & 0xff); 1457 } 1458 if (rate_low && rate_hi) { 1459 dbg ("%s - %d %02x %02x.", __FUNCTION__, baud_rate, *rate_hi, *rate_low); 1460 } 1461 1462 return (KEYSPAN_BAUD_RATE_OK); 1463 } 1464 1465 /* usa19hs function doesn't require prescaler */ 1466 static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1467 u8 *rate_low, u8 *prescaler, int portnum) 1468 { 1469 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1470 div; /* divisor */ 1471 1472 dbg ("%s - %d.", __FUNCTION__, baud_rate); 1473 1474 /* prevent divide by zero... */ 1475 if( (b16 = (baud_rate * 16L)) == 0) 1476 return (KEYSPAN_INVALID_BAUD_RATE); 1477 1478 1479 1480 /* calculate the divisor */ 1481 if( (div = (baudclk / b16)) == 0) 1482 return (KEYSPAN_INVALID_BAUD_RATE); 1483 1484 if(div > 0xffff) 1485 return (KEYSPAN_INVALID_BAUD_RATE); 1486 1487 /* return the counter values if non-null */ 1488 if (rate_low) 1489 *rate_low = (u8) (div & 0xff); 1490 1491 if (rate_hi) 1492 *rate_hi = (u8) ((div >> 8) & 0xff); 1493 1494 if (rate_low && rate_hi) 1495 dbg ("%s - %d %02x %02x.", __FUNCTION__, baud_rate, *rate_hi, *rate_low); 1496 1497 return (KEYSPAN_BAUD_RATE_OK); 1498 } 1499 1500 static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1501 u8 *rate_low, u8 *prescaler, int portnum) 1502 { 1503 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1504 clk, /* clock with 13/8 prescaler */ 1505 div, /* divisor using 13/8 prescaler */ 1506 res, /* resulting baud rate using 13/8 prescaler */ 1507 diff, /* error using 13/8 prescaler */ 1508 smallest_diff; 1509 u8 best_prescaler; 1510 int i; 1511 1512 dbg ("%s - %d.", __FUNCTION__, baud_rate); 1513 1514 /* prevent divide by zero */ 1515 if( (b16 = baud_rate * 16L) == 0) { 1516 return (KEYSPAN_INVALID_BAUD_RATE); 1517 } 1518 1519 /* Calculate prescaler by trying them all and looking 1520 for best fit */ 1521 1522 /* start with largest possible difference */ 1523 smallest_diff = 0xffffffff; 1524 1525 /* 0 is an invalid prescaler, used as a flag */ 1526 best_prescaler = 0; 1527 1528 for(i = 8; i <= 0xff; ++i) { 1529 clk = (baudclk * 8) / (u32) i; 1530 1531 if( (div = clk / b16) == 0) { 1532 continue; 1533 } 1534 1535 res = clk / div; 1536 diff= (res > b16) ? (res-b16) : (b16-res); 1537 1538 if(diff < smallest_diff) { 1539 best_prescaler = i; 1540 smallest_diff = diff; 1541 } 1542 } 1543 1544 if(best_prescaler == 0) { 1545 return (KEYSPAN_INVALID_BAUD_RATE); 1546 } 1547 1548 clk = (baudclk * 8) / (u32) best_prescaler; 1549 div = clk / b16; 1550 1551 /* return the divisor and prescaler if non-null */ 1552 if (rate_low) { 1553 *rate_low = (u8) (div & 0xff); 1554 } 1555 if (rate_hi) { 1556 *rate_hi = (u8) ((div >> 8) & 0xff); 1557 } 1558 if (prescaler) { 1559 *prescaler = best_prescaler; 1560 /* dbg("%s - %d %d", __FUNCTION__, *prescaler, div); */ 1561 } 1562 return (KEYSPAN_BAUD_RATE_OK); 1563 } 1564 1565 /* USA-28 supports different maximum baud rates on each port */ 1566 static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1567 u8 *rate_low, u8 *prescaler, int portnum) 1568 { 1569 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1570 div, /* divisor */ 1571 cnt; /* inverse of divisor (programmed into 8051) */ 1572 1573 dbg ("%s - %d.", __FUNCTION__, baud_rate); 1574 1575 /* prevent divide by zero */ 1576 if ((b16 = baud_rate * 16L) == 0) 1577 return (KEYSPAN_INVALID_BAUD_RATE); 1578 1579 /* calculate the divisor and the counter (its inverse) */ 1580 if ((div = (KEYSPAN_USA28_BAUDCLK / b16)) == 0) { 1581 return (KEYSPAN_INVALID_BAUD_RATE); 1582 } 1583 else { 1584 cnt = 0 - div; 1585 } 1586 1587 /* check for out of range, based on portnum, 1588 and return result */ 1589 if(portnum == 0) { 1590 if(div > 0xffff) 1591 return (KEYSPAN_INVALID_BAUD_RATE); 1592 } 1593 else { 1594 if(portnum == 1) { 1595 if(div > 0xff) { 1596 return (KEYSPAN_INVALID_BAUD_RATE); 1597 } 1598 } 1599 else { 1600 return (KEYSPAN_INVALID_BAUD_RATE); 1601 } 1602 } 1603 1604 /* return the counter values if not NULL 1605 (port 1 will ignore retHi) */ 1606 if (rate_low) { 1607 *rate_low = (u8) (cnt & 0xff); 1608 } 1609 if (rate_hi) { 1610 *rate_hi = (u8) ((cnt >> 8) & 0xff); 1611 } 1612 dbg ("%s - %d OK.", __FUNCTION__, baud_rate); 1613 return (KEYSPAN_BAUD_RATE_OK); 1614 } 1615 1616 static int keyspan_usa26_send_setup(struct usb_serial *serial, 1617 struct usb_serial_port *port, 1618 int reset_port) 1619 { 1620 struct keyspan_usa26_portControlMessage msg; 1621 struct keyspan_serial_private *s_priv; 1622 struct keyspan_port_private *p_priv; 1623 const struct keyspan_device_details *d_details; 1624 int outcont_urb; 1625 struct urb *this_urb; 1626 int device_port, err; 1627 1628 dbg ("%s reset=%d", __FUNCTION__, reset_port); 1629 1630 s_priv = usb_get_serial_data(serial); 1631 p_priv = usb_get_serial_port_data(port); 1632 d_details = s_priv->device_details; 1633 device_port = port->number - port->serial->minor; 1634 1635 outcont_urb = d_details->outcont_endpoints[port->number]; 1636 this_urb = p_priv->outcont_urb; 1637 1638 dbg("%s - endpoint %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe)); 1639 1640 /* Make sure we have an urb then send the message */ 1641 if (this_urb == NULL) { 1642 dbg("%s - oops no urb.", __FUNCTION__); 1643 return -1; 1644 } 1645 1646 /* Save reset port val for resend. 1647 Don't overwrite resend for close condition. */ 1648 if (p_priv->resend_cont != 3) 1649 p_priv->resend_cont = reset_port + 1; 1650 if (this_urb->status == -EINPROGRESS) { 1651 /* dbg ("%s - already writing", __FUNCTION__); */ 1652 mdelay(5); 1653 return(-1); 1654 } 1655 1656 memset(&msg, 0, sizeof (struct keyspan_usa26_portControlMessage)); 1657 1658 /* Only set baud rate if it's changed */ 1659 if (p_priv->old_baud != p_priv->baud) { 1660 p_priv->old_baud = p_priv->baud; 1661 msg.setClocking = 0xff; 1662 if (d_details->calculate_baud_rate 1663 (p_priv->baud, d_details->baudclk, &msg.baudHi, 1664 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE ) { 1665 dbg("%s - Invalid baud rate %d requested, using 9600.", __FUNCTION__, 1666 p_priv->baud); 1667 msg.baudLo = 0; 1668 msg.baudHi = 125; /* Values for 9600 baud */ 1669 msg.prescaler = 10; 1670 } 1671 msg.setPrescaler = 0xff; 1672 } 1673 1674 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 1675 switch (p_priv->cflag & CSIZE) { 1676 case CS5: 1677 msg.lcr |= USA_DATABITS_5; 1678 break; 1679 case CS6: 1680 msg.lcr |= USA_DATABITS_6; 1681 break; 1682 case CS7: 1683 msg.lcr |= USA_DATABITS_7; 1684 break; 1685 case CS8: 1686 msg.lcr |= USA_DATABITS_8; 1687 break; 1688 } 1689 if (p_priv->cflag & PARENB) { 1690 /* note USA_PARITY_NONE == 0 */ 1691 msg.lcr |= (p_priv->cflag & PARODD)? 1692 USA_PARITY_ODD: USA_PARITY_EVEN; 1693 } 1694 msg.setLcr = 0xff; 1695 1696 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 1697 msg.xonFlowControl = 0; 1698 msg.setFlowControl = 0xff; 1699 msg.forwardingLength = 16; 1700 msg.xonChar = 17; 1701 msg.xoffChar = 19; 1702 1703 /* Opening port */ 1704 if (reset_port == 1) { 1705 msg._txOn = 1; 1706 msg._txOff = 0; 1707 msg.txFlush = 0; 1708 msg.txBreak = 0; 1709 msg.rxOn = 1; 1710 msg.rxOff = 0; 1711 msg.rxFlush = 1; 1712 msg.rxForward = 0; 1713 msg.returnStatus = 0; 1714 msg.resetDataToggle = 0xff; 1715 } 1716 1717 /* Closing port */ 1718 else if (reset_port == 2) { 1719 msg._txOn = 0; 1720 msg._txOff = 1; 1721 msg.txFlush = 0; 1722 msg.txBreak = 0; 1723 msg.rxOn = 0; 1724 msg.rxOff = 1; 1725 msg.rxFlush = 1; 1726 msg.rxForward = 0; 1727 msg.returnStatus = 0; 1728 msg.resetDataToggle = 0; 1729 } 1730 1731 /* Sending intermediate configs */ 1732 else { 1733 msg._txOn = (! p_priv->break_on); 1734 msg._txOff = 0; 1735 msg.txFlush = 0; 1736 msg.txBreak = (p_priv->break_on); 1737 msg.rxOn = 0; 1738 msg.rxOff = 0; 1739 msg.rxFlush = 0; 1740 msg.rxForward = 0; 1741 msg.returnStatus = 0; 1742 msg.resetDataToggle = 0x0; 1743 } 1744 1745 /* Do handshaking outputs */ 1746 msg.setTxTriState_setRts = 0xff; 1747 msg.txTriState_rts = p_priv->rts_state; 1748 1749 msg.setHskoa_setDtr = 0xff; 1750 msg.hskoa_dtr = p_priv->dtr_state; 1751 1752 p_priv->resend_cont = 0; 1753 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg)); 1754 1755 /* send the data out the device on control endpoint */ 1756 this_urb->transfer_buffer_length = sizeof(msg); 1757 1758 this_urb->dev = serial->dev; 1759 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) { 1760 dbg("%s - usb_submit_urb(setup) failed (%d)", __FUNCTION__, err); 1761 } 1762 #if 0 1763 else { 1764 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __FUNCTION__ 1765 outcont_urb, this_urb->transfer_buffer_length, 1766 usb_pipeendpoint(this_urb->pipe)); 1767 } 1768 #endif 1769 1770 return (0); 1771 } 1772 1773 static int keyspan_usa28_send_setup(struct usb_serial *serial, 1774 struct usb_serial_port *port, 1775 int reset_port) 1776 { 1777 struct keyspan_usa28_portControlMessage msg; 1778 struct keyspan_serial_private *s_priv; 1779 struct keyspan_port_private *p_priv; 1780 const struct keyspan_device_details *d_details; 1781 struct urb *this_urb; 1782 int device_port, err; 1783 1784 dbg ("%s", __FUNCTION__); 1785 1786 s_priv = usb_get_serial_data(serial); 1787 p_priv = usb_get_serial_port_data(port); 1788 d_details = s_priv->device_details; 1789 device_port = port->number - port->serial->minor; 1790 1791 /* only do something if we have a bulk out endpoint */ 1792 if ((this_urb = p_priv->outcont_urb) == NULL) { 1793 dbg("%s - oops no urb.", __FUNCTION__); 1794 return -1; 1795 } 1796 1797 /* Save reset port val for resend. 1798 Don't overwrite resend for close condition. */ 1799 if (p_priv->resend_cont != 3) 1800 p_priv->resend_cont = reset_port + 1; 1801 if (this_urb->status == -EINPROGRESS) { 1802 dbg ("%s already writing", __FUNCTION__); 1803 mdelay(5); 1804 return(-1); 1805 } 1806 1807 memset(&msg, 0, sizeof (struct keyspan_usa28_portControlMessage)); 1808 1809 msg.setBaudRate = 1; 1810 if (d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk, 1811 &msg.baudHi, &msg.baudLo, NULL, device_port) == KEYSPAN_INVALID_BAUD_RATE ) { 1812 dbg("%s - Invalid baud rate requested %d.", __FUNCTION__, p_priv->baud); 1813 msg.baudLo = 0xff; 1814 msg.baudHi = 0xb2; /* Values for 9600 baud */ 1815 } 1816 1817 /* If parity is enabled, we must calculate it ourselves. */ 1818 msg.parity = 0; /* XXX for now */ 1819 1820 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 1821 msg.xonFlowControl = 0; 1822 1823 /* Do handshaking outputs, DTR is inverted relative to RTS */ 1824 msg.rts = p_priv->rts_state; 1825 msg.dtr = p_priv->dtr_state; 1826 1827 msg.forwardingLength = 16; 1828 msg.forwardMs = 10; 1829 msg.breakThreshold = 45; 1830 msg.xonChar = 17; 1831 msg.xoffChar = 19; 1832 1833 /*msg.returnStatus = 1; 1834 msg.resetDataToggle = 0xff;*/ 1835 /* Opening port */ 1836 if (reset_port == 1) { 1837 msg._txOn = 1; 1838 msg._txOff = 0; 1839 msg.txFlush = 0; 1840 msg.txForceXoff = 0; 1841 msg.txBreak = 0; 1842 msg.rxOn = 1; 1843 msg.rxOff = 0; 1844 msg.rxFlush = 1; 1845 msg.rxForward = 0; 1846 msg.returnStatus = 0; 1847 msg.resetDataToggle = 0xff; 1848 } 1849 /* Closing port */ 1850 else if (reset_port == 2) { 1851 msg._txOn = 0; 1852 msg._txOff = 1; 1853 msg.txFlush = 0; 1854 msg.txForceXoff = 0; 1855 msg.txBreak = 0; 1856 msg.rxOn = 0; 1857 msg.rxOff = 1; 1858 msg.rxFlush = 1; 1859 msg.rxForward = 0; 1860 msg.returnStatus = 0; 1861 msg.resetDataToggle = 0; 1862 } 1863 /* Sending intermediate configs */ 1864 else { 1865 msg._txOn = (! p_priv->break_on); 1866 msg._txOff = 0; 1867 msg.txFlush = 0; 1868 msg.txForceXoff = 0; 1869 msg.txBreak = (p_priv->break_on); 1870 msg.rxOn = 0; 1871 msg.rxOff = 0; 1872 msg.rxFlush = 0; 1873 msg.rxForward = 0; 1874 msg.returnStatus = 0; 1875 msg.resetDataToggle = 0x0; 1876 } 1877 1878 p_priv->resend_cont = 0; 1879 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg)); 1880 1881 /* send the data out the device on control endpoint */ 1882 this_urb->transfer_buffer_length = sizeof(msg); 1883 1884 this_urb->dev = serial->dev; 1885 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) { 1886 dbg("%s - usb_submit_urb(setup) failed", __FUNCTION__); 1887 } 1888 #if 0 1889 else { 1890 dbg("%s - usb_submit_urb(setup) OK %d bytes", __FUNCTION__, 1891 this_urb->transfer_buffer_length); 1892 } 1893 #endif 1894 1895 return (0); 1896 } 1897 1898 static int keyspan_usa49_send_setup(struct usb_serial *serial, 1899 struct usb_serial_port *port, 1900 int reset_port) 1901 { 1902 struct keyspan_usa49_portControlMessage msg; 1903 struct keyspan_serial_private *s_priv; 1904 struct keyspan_port_private *p_priv; 1905 const struct keyspan_device_details *d_details; 1906 int glocont_urb; 1907 struct urb *this_urb; 1908 int err, device_port; 1909 1910 dbg ("%s", __FUNCTION__); 1911 1912 s_priv = usb_get_serial_data(serial); 1913 p_priv = usb_get_serial_port_data(port); 1914 d_details = s_priv->device_details; 1915 1916 glocont_urb = d_details->glocont_endpoint; 1917 this_urb = s_priv->glocont_urb; 1918 1919 /* Work out which port within the device is being setup */ 1920 device_port = port->number - port->serial->minor; 1921 1922 dbg("%s - endpoint %d port %d (%d)",__FUNCTION__, usb_pipeendpoint(this_urb->pipe), port->number, device_port); 1923 1924 /* Make sure we have an urb then send the message */ 1925 if (this_urb == NULL) { 1926 dbg("%s - oops no urb for port %d.", __FUNCTION__, port->number); 1927 return -1; 1928 } 1929 1930 /* Save reset port val for resend. 1931 Don't overwrite resend for close condition. */ 1932 if (p_priv->resend_cont != 3) 1933 p_priv->resend_cont = reset_port + 1; 1934 if (this_urb->status == -EINPROGRESS) { 1935 /* dbg ("%s - already writing", __FUNCTION__); */ 1936 mdelay(5); 1937 return(-1); 1938 } 1939 1940 memset(&msg, 0, sizeof (struct keyspan_usa49_portControlMessage)); 1941 1942 /*msg.portNumber = port->number;*/ 1943 msg.portNumber = device_port; 1944 1945 /* Only set baud rate if it's changed */ 1946 if (p_priv->old_baud != p_priv->baud) { 1947 p_priv->old_baud = p_priv->baud; 1948 msg.setClocking = 0xff; 1949 if (d_details->calculate_baud_rate 1950 (p_priv->baud, d_details->baudclk, &msg.baudHi, 1951 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE ) { 1952 dbg("%s - Invalid baud rate %d requested, using 9600.", __FUNCTION__, 1953 p_priv->baud); 1954 msg.baudLo = 0; 1955 msg.baudHi = 125; /* Values for 9600 baud */ 1956 msg.prescaler = 10; 1957 } 1958 //msg.setPrescaler = 0xff; 1959 } 1960 1961 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 1962 switch (p_priv->cflag & CSIZE) { 1963 case CS5: 1964 msg.lcr |= USA_DATABITS_5; 1965 break; 1966 case CS6: 1967 msg.lcr |= USA_DATABITS_6; 1968 break; 1969 case CS7: 1970 msg.lcr |= USA_DATABITS_7; 1971 break; 1972 case CS8: 1973 msg.lcr |= USA_DATABITS_8; 1974 break; 1975 } 1976 if (p_priv->cflag & PARENB) { 1977 /* note USA_PARITY_NONE == 0 */ 1978 msg.lcr |= (p_priv->cflag & PARODD)? 1979 USA_PARITY_ODD: USA_PARITY_EVEN; 1980 } 1981 msg.setLcr = 0xff; 1982 1983 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 1984 msg.xonFlowControl = 0; 1985 msg.setFlowControl = 0xff; 1986 1987 msg.forwardingLength = 16; 1988 msg.xonChar = 17; 1989 msg.xoffChar = 19; 1990 1991 /* Opening port */ 1992 if (reset_port == 1) { 1993 msg._txOn = 1; 1994 msg._txOff = 0; 1995 msg.txFlush = 0; 1996 msg.txBreak = 0; 1997 msg.rxOn = 1; 1998 msg.rxOff = 0; 1999 msg.rxFlush = 1; 2000 msg.rxForward = 0; 2001 msg.returnStatus = 0; 2002 msg.resetDataToggle = 0xff; 2003 msg.enablePort = 1; 2004 msg.disablePort = 0; 2005 } 2006 /* Closing port */ 2007 else if (reset_port == 2) { 2008 msg._txOn = 0; 2009 msg._txOff = 1; 2010 msg.txFlush = 0; 2011 msg.txBreak = 0; 2012 msg.rxOn = 0; 2013 msg.rxOff = 1; 2014 msg.rxFlush = 1; 2015 msg.rxForward = 0; 2016 msg.returnStatus = 0; 2017 msg.resetDataToggle = 0; 2018 msg.enablePort = 0; 2019 msg.disablePort = 1; 2020 } 2021 /* Sending intermediate configs */ 2022 else { 2023 msg._txOn = (! p_priv->break_on); 2024 msg._txOff = 0; 2025 msg.txFlush = 0; 2026 msg.txBreak = (p_priv->break_on); 2027 msg.rxOn = 0; 2028 msg.rxOff = 0; 2029 msg.rxFlush = 0; 2030 msg.rxForward = 0; 2031 msg.returnStatus = 0; 2032 msg.resetDataToggle = 0x0; 2033 msg.enablePort = 0; 2034 msg.disablePort = 0; 2035 } 2036 2037 /* Do handshaking outputs */ 2038 msg.setRts = 0xff; 2039 msg.rts = p_priv->rts_state; 2040 2041 msg.setDtr = 0xff; 2042 msg.dtr = p_priv->dtr_state; 2043 2044 p_priv->resend_cont = 0; 2045 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg)); 2046 2047 /* send the data out the device on control endpoint */ 2048 this_urb->transfer_buffer_length = sizeof(msg); 2049 2050 this_urb->dev = serial->dev; 2051 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) { 2052 dbg("%s - usb_submit_urb(setup) failed (%d)", __FUNCTION__, err); 2053 } 2054 #if 0 2055 else { 2056 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __FUNCTION__, 2057 outcont_urb, this_urb->transfer_buffer_length, 2058 usb_pipeendpoint(this_urb->pipe)); 2059 } 2060 #endif 2061 2062 return (0); 2063 } 2064 2065 static int keyspan_usa90_send_setup(struct usb_serial *serial, 2066 struct usb_serial_port *port, 2067 int reset_port) 2068 { 2069 struct keyspan_usa90_portControlMessage msg; 2070 struct keyspan_serial_private *s_priv; 2071 struct keyspan_port_private *p_priv; 2072 const struct keyspan_device_details *d_details; 2073 struct urb *this_urb; 2074 int err; 2075 u8 prescaler; 2076 2077 dbg ("%s", __FUNCTION__); 2078 2079 s_priv = usb_get_serial_data(serial); 2080 p_priv = usb_get_serial_port_data(port); 2081 d_details = s_priv->device_details; 2082 2083 /* only do something if we have a bulk out endpoint */ 2084 if ((this_urb = p_priv->outcont_urb) == NULL) { 2085 dbg("%s - oops no urb.", __FUNCTION__); 2086 return -1; 2087 } 2088 2089 /* Save reset port val for resend. 2090 Don't overwrite resend for open/close condition. */ 2091 if ((reset_port + 1) > p_priv->resend_cont) 2092 p_priv->resend_cont = reset_port + 1; 2093 if (this_urb->status == -EINPROGRESS) { 2094 dbg ("%s already writing", __FUNCTION__); 2095 mdelay(5); 2096 return(-1); 2097 } 2098 2099 memset(&msg, 0, sizeof (struct keyspan_usa90_portControlMessage)); 2100 2101 /* Only set baud rate if it's changed */ 2102 if (p_priv->old_baud != p_priv->baud) { 2103 p_priv->old_baud = p_priv->baud; 2104 msg.setClocking = 0x01; 2105 if (d_details->calculate_baud_rate 2106 (p_priv->baud, d_details->baudclk, &msg.baudHi, 2107 &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE ) { 2108 dbg("%s - Invalid baud rate %d requested, using 9600.", __FUNCTION__, 2109 p_priv->baud); 2110 p_priv->baud = 9600; 2111 d_details->calculate_baud_rate (p_priv->baud, d_details->baudclk, 2112 &msg.baudHi, &msg.baudLo, &prescaler, 0); 2113 } 2114 msg.setRxMode = 1; 2115 msg.setTxMode = 1; 2116 } 2117 2118 /* modes must always be correctly specified */ 2119 if (p_priv->baud > 57600) 2120 { 2121 msg.rxMode = RXMODE_DMA; 2122 msg.txMode = TXMODE_DMA; 2123 } 2124 else 2125 { 2126 msg.rxMode = RXMODE_BYHAND; 2127 msg.txMode = TXMODE_BYHAND; 2128 } 2129 2130 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 2131 switch (p_priv->cflag & CSIZE) { 2132 case CS5: 2133 msg.lcr |= USA_DATABITS_5; 2134 break; 2135 case CS6: 2136 msg.lcr |= USA_DATABITS_6; 2137 break; 2138 case CS7: 2139 msg.lcr |= USA_DATABITS_7; 2140 break; 2141 case CS8: 2142 msg.lcr |= USA_DATABITS_8; 2143 break; 2144 } 2145 if (p_priv->cflag & PARENB) { 2146 /* note USA_PARITY_NONE == 0 */ 2147 msg.lcr |= (p_priv->cflag & PARODD)? 2148 USA_PARITY_ODD: USA_PARITY_EVEN; 2149 } 2150 if (p_priv->old_cflag != p_priv->cflag) { 2151 p_priv->old_cflag = p_priv->cflag; 2152 msg.setLcr = 0x01; 2153 } 2154 2155 if (p_priv->flow_control == flow_cts) 2156 msg.txFlowControl = TXFLOW_CTS; 2157 msg.setTxFlowControl = 0x01; 2158 msg.setRxFlowControl = 0x01; 2159 2160 msg.rxForwardingLength = 16; 2161 msg.rxForwardingTimeout = 16; 2162 msg.txAckSetting = 0; 2163 msg.xonChar = 17; 2164 msg.xoffChar = 19; 2165 2166 /* Opening port */ 2167 if (reset_port == 1) { 2168 msg.portEnabled = 1; 2169 msg.rxFlush = 1; 2170 msg.txBreak = (p_priv->break_on); 2171 } 2172 /* Closing port */ 2173 else if (reset_port == 2) { 2174 msg.portEnabled = 0; 2175 } 2176 /* Sending intermediate configs */ 2177 else { 2178 if (port->open_count) 2179 msg.portEnabled = 1; 2180 msg.txBreak = (p_priv->break_on); 2181 } 2182 2183 /* Do handshaking outputs */ 2184 msg.setRts = 0x01; 2185 msg.rts = p_priv->rts_state; 2186 2187 msg.setDtr = 0x01; 2188 msg.dtr = p_priv->dtr_state; 2189 2190 p_priv->resend_cont = 0; 2191 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg)); 2192 2193 /* send the data out the device on control endpoint */ 2194 this_urb->transfer_buffer_length = sizeof(msg); 2195 2196 this_urb->dev = serial->dev; 2197 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) { 2198 dbg("%s - usb_submit_urb(setup) failed (%d)", __FUNCTION__, err); 2199 } 2200 return (0); 2201 } 2202 2203 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port) 2204 { 2205 struct usb_serial *serial = port->serial; 2206 struct keyspan_serial_private *s_priv; 2207 const struct keyspan_device_details *d_details; 2208 2209 dbg ("%s", __FUNCTION__); 2210 2211 s_priv = usb_get_serial_data(serial); 2212 d_details = s_priv->device_details; 2213 2214 switch (d_details->msg_format) { 2215 case msg_usa26: 2216 keyspan_usa26_send_setup(serial, port, reset_port); 2217 break; 2218 case msg_usa28: 2219 keyspan_usa28_send_setup(serial, port, reset_port); 2220 break; 2221 case msg_usa49: 2222 keyspan_usa49_send_setup(serial, port, reset_port); 2223 break; 2224 case msg_usa90: 2225 keyspan_usa90_send_setup(serial, port, reset_port); 2226 break; 2227 } 2228 } 2229 2230 2231 /* Gets called by the "real" driver (ie once firmware is loaded 2232 and renumeration has taken place. */ 2233 static int keyspan_startup (struct usb_serial *serial) 2234 { 2235 int i, err; 2236 struct usb_serial_port *port; 2237 struct keyspan_serial_private *s_priv; 2238 struct keyspan_port_private *p_priv; 2239 const struct keyspan_device_details *d_details; 2240 2241 dbg("%s", __FUNCTION__); 2242 2243 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i) 2244 if (d_details->product_id == le16_to_cpu(serial->dev->descriptor.idProduct)) 2245 break; 2246 if (d_details == NULL) { 2247 dev_err(&serial->dev->dev, "%s - unknown product id %x\n", __FUNCTION__, le16_to_cpu(serial->dev->descriptor.idProduct)); 2248 return 1; 2249 } 2250 2251 /* Setup private data for serial driver */ 2252 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL); 2253 if (!s_priv) { 2254 dbg("%s - kmalloc for keyspan_serial_private failed.", __FUNCTION__); 2255 return -ENOMEM; 2256 } 2257 2258 s_priv->device_details = d_details; 2259 usb_set_serial_data(serial, s_priv); 2260 2261 /* Now setup per port private data */ 2262 for (i = 0; i < serial->num_ports; i++) { 2263 port = serial->port[i]; 2264 p_priv = kzalloc(sizeof(struct keyspan_port_private), GFP_KERNEL); 2265 if (!p_priv) { 2266 dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __FUNCTION__, i); 2267 return (1); 2268 } 2269 p_priv->device_details = d_details; 2270 usb_set_serial_port_data(port, p_priv); 2271 } 2272 2273 keyspan_setup_urbs(serial); 2274 2275 s_priv->instat_urb->dev = serial->dev; 2276 if ((err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL)) != 0) { 2277 dbg("%s - submit instat urb failed %d", __FUNCTION__, err); 2278 } 2279 2280 return (0); 2281 } 2282 2283 static void keyspan_shutdown (struct usb_serial *serial) 2284 { 2285 int i, j; 2286 struct usb_serial_port *port; 2287 struct keyspan_serial_private *s_priv; 2288 struct keyspan_port_private *p_priv; 2289 2290 dbg("%s", __FUNCTION__); 2291 2292 s_priv = usb_get_serial_data(serial); 2293 2294 /* Stop reading/writing urbs */ 2295 stop_urb(s_priv->instat_urb); 2296 stop_urb(s_priv->glocont_urb); 2297 for (i = 0; i < serial->num_ports; ++i) { 2298 port = serial->port[i]; 2299 p_priv = usb_get_serial_port_data(port); 2300 stop_urb(p_priv->inack_urb); 2301 stop_urb(p_priv->outcont_urb); 2302 for (j = 0; j < 2; j++) { 2303 stop_urb(p_priv->in_urbs[j]); 2304 stop_urb(p_priv->out_urbs[j]); 2305 } 2306 } 2307 2308 /* Now free them */ 2309 if (s_priv->instat_urb) 2310 usb_free_urb(s_priv->instat_urb); 2311 if (s_priv->glocont_urb) 2312 usb_free_urb(s_priv->glocont_urb); 2313 for (i = 0; i < serial->num_ports; ++i) { 2314 port = serial->port[i]; 2315 p_priv = usb_get_serial_port_data(port); 2316 if (p_priv->inack_urb) 2317 usb_free_urb(p_priv->inack_urb); 2318 if (p_priv->outcont_urb) 2319 usb_free_urb(p_priv->outcont_urb); 2320 for (j = 0; j < 2; j++) { 2321 if (p_priv->in_urbs[j]) 2322 usb_free_urb(p_priv->in_urbs[j]); 2323 if (p_priv->out_urbs[j]) 2324 usb_free_urb(p_priv->out_urbs[j]); 2325 } 2326 } 2327 2328 /* dbg("Freeing serial->private."); */ 2329 kfree(s_priv); 2330 2331 /* dbg("Freeing port->private."); */ 2332 /* Now free per port private data */ 2333 for (i = 0; i < serial->num_ports; i++) { 2334 port = serial->port[i]; 2335 kfree(usb_get_serial_port_data(port)); 2336 } 2337 } 2338 2339 MODULE_AUTHOR( DRIVER_AUTHOR ); 2340 MODULE_DESCRIPTION( DRIVER_DESC ); 2341 MODULE_LICENSE("GPL"); 2342 2343 module_param(debug, bool, S_IRUGO | S_IWUSR); 2344 MODULE_PARM_DESC(debug, "Debug enabled or not"); 2345 2346