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 <linux/firmware.h> 109 #include <linux/ihex.h> 110 #include <linux/uaccess.h> 111 #include <linux/usb.h> 112 #include <linux/usb/serial.h> 113 #include "keyspan.h" 114 115 static int debug; 116 117 /* 118 * Version Information 119 */ 120 #define DRIVER_VERSION "v1.1.5" 121 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu" 122 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver" 123 124 #define INSTAT_BUFLEN 32 125 #define GLOCONT_BUFLEN 64 126 #define INDAT49W_BUFLEN 512 127 128 /* Per device and per port private data */ 129 struct keyspan_serial_private { 130 const struct keyspan_device_details *device_details; 131 132 struct urb *instat_urb; 133 char instat_buf[INSTAT_BUFLEN]; 134 135 /* added to support 49wg, where data from all 4 ports comes in 136 on 1 EP and high-speed supported */ 137 struct urb *indat_urb; 138 char indat_buf[INDAT49W_BUFLEN]; 139 140 /* XXX this one probably will need a lock */ 141 struct urb *glocont_urb; 142 char glocont_buf[GLOCONT_BUFLEN]; 143 char ctrl_buf[8]; /* for EP0 control message */ 144 }; 145 146 struct keyspan_port_private { 147 /* Keep track of which input & output endpoints to use */ 148 int in_flip; 149 int out_flip; 150 151 /* Keep duplicate of device details in each port 152 structure as well - simplifies some of the 153 callback functions etc. */ 154 const struct keyspan_device_details *device_details; 155 156 /* Input endpoints and buffer for this port */ 157 struct urb *in_urbs[2]; 158 char in_buffer[2][64]; 159 /* Output endpoints and buffer for this port */ 160 struct urb *out_urbs[2]; 161 char out_buffer[2][64]; 162 163 /* Input ack endpoint */ 164 struct urb *inack_urb; 165 char inack_buffer[1]; 166 167 /* Output control endpoint */ 168 struct urb *outcont_urb; 169 char outcont_buffer[64]; 170 171 /* Settings for the port */ 172 int baud; 173 int old_baud; 174 unsigned int cflag; 175 unsigned int old_cflag; 176 enum {flow_none, flow_cts, flow_xon} flow_control; 177 int rts_state; /* Handshaking pins (outputs) */ 178 int dtr_state; 179 int cts_state; /* Handshaking pins (inputs) */ 180 int dsr_state; 181 int dcd_state; 182 int ri_state; 183 int break_on; 184 185 unsigned long tx_start_time[2]; 186 int resend_cont; /* need to resend control packet */ 187 }; 188 189 /* Include Keyspan message headers. All current Keyspan Adapters 190 make use of one of five message formats which are referred 191 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and 192 within this driver. */ 193 #include "keyspan_usa26msg.h" 194 #include "keyspan_usa28msg.h" 195 #include "keyspan_usa49msg.h" 196 #include "keyspan_usa90msg.h" 197 #include "keyspan_usa67msg.h" 198 199 200 /* Functions used by new usb-serial code. */ 201 static int __init keyspan_init(void) 202 { 203 int retval; 204 retval = usb_serial_register(&keyspan_pre_device); 205 if (retval) 206 goto failed_pre_device_register; 207 retval = usb_serial_register(&keyspan_1port_device); 208 if (retval) 209 goto failed_1port_device_register; 210 retval = usb_serial_register(&keyspan_2port_device); 211 if (retval) 212 goto failed_2port_device_register; 213 retval = usb_serial_register(&keyspan_4port_device); 214 if (retval) 215 goto failed_4port_device_register; 216 retval = usb_register(&keyspan_driver); 217 if (retval) 218 goto failed_usb_register; 219 220 info(DRIVER_VERSION ":" DRIVER_DESC); 221 222 return 0; 223 failed_usb_register: 224 usb_serial_deregister(&keyspan_4port_device); 225 failed_4port_device_register: 226 usb_serial_deregister(&keyspan_2port_device); 227 failed_2port_device_register: 228 usb_serial_deregister(&keyspan_1port_device); 229 failed_1port_device_register: 230 usb_serial_deregister(&keyspan_pre_device); 231 failed_pre_device_register: 232 return retval; 233 } 234 235 static void __exit keyspan_exit(void) 236 { 237 usb_deregister(&keyspan_driver); 238 usb_serial_deregister(&keyspan_pre_device); 239 usb_serial_deregister(&keyspan_1port_device); 240 usb_serial_deregister(&keyspan_2port_device); 241 usb_serial_deregister(&keyspan_4port_device); 242 } 243 244 module_init(keyspan_init); 245 module_exit(keyspan_exit); 246 247 static void keyspan_break_ctl(struct tty_struct *tty, int break_state) 248 { 249 struct usb_serial_port *port = tty->driver_data; 250 struct keyspan_port_private *p_priv; 251 252 dbg("%s", __func__); 253 254 p_priv = usb_get_serial_port_data(port); 255 256 if (break_state == -1) 257 p_priv->break_on = 1; 258 else 259 p_priv->break_on = 0; 260 261 keyspan_send_setup(port, 0); 262 } 263 264 265 static void keyspan_set_termios(struct tty_struct *tty, 266 struct usb_serial_port *port, struct ktermios *old_termios) 267 { 268 int baud_rate, device_port; 269 struct keyspan_port_private *p_priv; 270 const struct keyspan_device_details *d_details; 271 unsigned int cflag; 272 273 dbg("%s", __func__); 274 275 p_priv = usb_get_serial_port_data(port); 276 d_details = p_priv->device_details; 277 cflag = tty->termios->c_cflag; 278 device_port = port->number - port->serial->minor; 279 280 /* Baud rate calculation takes baud rate as an integer 281 so other rates can be generated if desired. */ 282 baud_rate = tty_get_baud_rate(tty); 283 /* If no match or invalid, don't change */ 284 if (d_details->calculate_baud_rate(baud_rate, d_details->baudclk, 285 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 286 /* FIXME - more to do here to ensure rate changes cleanly */ 287 /* FIXME - calcuate exact rate from divisor ? */ 288 p_priv->baud = baud_rate; 289 } else 290 baud_rate = tty_termios_baud_rate(old_termios); 291 292 tty_encode_baud_rate(tty, baud_rate, baud_rate); 293 /* set CTS/RTS handshake etc. */ 294 p_priv->cflag = cflag; 295 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none; 296 297 /* Mark/Space not supported */ 298 tty->termios->c_cflag &= ~CMSPAR; 299 300 keyspan_send_setup(port, 0); 301 } 302 303 static int keyspan_tiocmget(struct tty_struct *tty, struct file *file) 304 { 305 struct usb_serial_port *port = tty->driver_data; 306 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port); 307 unsigned int value; 308 309 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) | 310 ((p_priv->dtr_state) ? TIOCM_DTR : 0) | 311 ((p_priv->cts_state) ? TIOCM_CTS : 0) | 312 ((p_priv->dsr_state) ? TIOCM_DSR : 0) | 313 ((p_priv->dcd_state) ? TIOCM_CAR : 0) | 314 ((p_priv->ri_state) ? TIOCM_RNG : 0); 315 316 return value; 317 } 318 319 static int keyspan_tiocmset(struct tty_struct *tty, struct file *file, 320 unsigned int set, unsigned int clear) 321 { 322 struct usb_serial_port *port = tty->driver_data; 323 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port); 324 325 if (set & TIOCM_RTS) 326 p_priv->rts_state = 1; 327 if (set & TIOCM_DTR) 328 p_priv->dtr_state = 1; 329 if (clear & TIOCM_RTS) 330 p_priv->rts_state = 0; 331 if (clear & TIOCM_DTR) 332 p_priv->dtr_state = 0; 333 keyspan_send_setup(port, 0); 334 return 0; 335 } 336 337 /* Write function is similar for the four protocols used 338 with only a minor change for usa90 (usa19hs) required */ 339 static int keyspan_write(struct tty_struct *tty, 340 struct usb_serial_port *port, const unsigned char *buf, int count) 341 { 342 struct keyspan_port_private *p_priv; 343 const struct keyspan_device_details *d_details; 344 int flip; 345 int left, todo; 346 struct urb *this_urb; 347 int err, maxDataLen, dataOffset; 348 349 p_priv = usb_get_serial_port_data(port); 350 d_details = p_priv->device_details; 351 352 if (d_details->msg_format == msg_usa90) { 353 maxDataLen = 64; 354 dataOffset = 0; 355 } else { 356 maxDataLen = 63; 357 dataOffset = 1; 358 } 359 360 dbg("%s - for port %d (%d chars), flip=%d", 361 __func__, port->number, count, p_priv->out_flip); 362 363 for (left = count; left > 0; left -= todo) { 364 todo = left; 365 if (todo > maxDataLen) 366 todo = maxDataLen; 367 368 flip = p_priv->out_flip; 369 370 /* Check we have a valid urb/endpoint before we use it... */ 371 this_urb = p_priv->out_urbs[flip]; 372 if (this_urb == NULL) { 373 /* no bulk out, so return 0 bytes written */ 374 dbg("%s - no output urb :(", __func__); 375 return count; 376 } 377 378 dbg("%s - endpoint %d flip %d", 379 __func__, usb_pipeendpoint(this_urb->pipe), flip); 380 381 if (this_urb->status == -EINPROGRESS) { 382 if (time_before(jiffies, 383 p_priv->tx_start_time[flip] + 10 * HZ)) 384 break; 385 usb_unlink_urb(this_urb); 386 break; 387 } 388 389 /* First byte in buffer is "last flag" (except for usa19hx) 390 - unused so for now so set to zero */ 391 ((char *)this_urb->transfer_buffer)[0] = 0; 392 393 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo); 394 buf += todo; 395 396 /* send the data out the bulk port */ 397 this_urb->transfer_buffer_length = todo + dataOffset; 398 399 this_urb->dev = port->serial->dev; 400 err = usb_submit_urb(this_urb, GFP_ATOMIC); 401 if (err != 0) 402 dbg("usb_submit_urb(write bulk) failed (%d)", err); 403 p_priv->tx_start_time[flip] = jiffies; 404 405 /* Flip for next time if usa26 or usa28 interface 406 (not used on usa49) */ 407 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip; 408 } 409 410 return count - left; 411 } 412 413 static void usa26_indat_callback(struct urb *urb) 414 { 415 int i, err; 416 int endpoint; 417 struct usb_serial_port *port; 418 struct tty_struct *tty; 419 unsigned char *data = urb->transfer_buffer; 420 int status = urb->status; 421 422 dbg("%s", __func__); 423 424 endpoint = usb_pipeendpoint(urb->pipe); 425 426 if (status) { 427 dbg("%s - nonzero status: %x on endpoint %d.", 428 __func__, status, endpoint); 429 return; 430 } 431 432 port = urb->context; 433 tty = port->port.tty; 434 if (tty && urb->actual_length) { 435 /* 0x80 bit is error flag */ 436 if ((data[0] & 0x80) == 0) { 437 /* no errors on individual bytes, only 438 possible overrun err */ 439 if (data[0] & RXERROR_OVERRUN) 440 err = TTY_OVERRUN; 441 else 442 err = 0; 443 for (i = 1; i < urb->actual_length ; ++i) 444 tty_insert_flip_char(tty, data[i], err); 445 } else { 446 /* some bytes had errors, every byte has status */ 447 dbg("%s - RX error!!!!", __func__); 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->port.count) { 466 err = usb_submit_urb(urb, GFP_ATOMIC); 467 if (err != 0) 468 dbg("%s - resubmit read urb failed. (%d)", 469 __func__, err); 470 } 471 return; 472 } 473 474 /* Outdat handling is common for all devices */ 475 static void usa2x_outdat_callback(struct urb *urb) 476 { 477 struct usb_serial_port *port; 478 struct keyspan_port_private *p_priv; 479 480 port = urb->context; 481 p_priv = usb_get_serial_port_data(port); 482 dbg("%s - urb %d", __func__, urb == p_priv->out_urbs[1]); 483 484 if (port->port.count) 485 usb_serial_port_softint(port); 486 } 487 488 static void usa26_inack_callback(struct urb *urb) 489 { 490 dbg("%s", __func__); 491 492 } 493 494 static void usa26_outcont_callback(struct urb *urb) 495 { 496 struct usb_serial_port *port; 497 struct keyspan_port_private *p_priv; 498 499 port = urb->context; 500 p_priv = usb_get_serial_port_data(port); 501 502 if (p_priv->resend_cont) { 503 dbg("%s - sending setup", __func__); 504 keyspan_usa26_send_setup(port->serial, port, 505 p_priv->resend_cont - 1); 506 } 507 } 508 509 static void usa26_instat_callback(struct urb *urb) 510 { 511 unsigned char *data = urb->transfer_buffer; 512 struct keyspan_usa26_portStatusMessage *msg; 513 struct usb_serial *serial; 514 struct usb_serial_port *port; 515 struct keyspan_port_private *p_priv; 516 int old_dcd_state, err; 517 int status = urb->status; 518 519 serial = urb->context; 520 521 if (status) { 522 dbg("%s - nonzero status: %x", __func__, status); 523 return; 524 } 525 if (urb->actual_length != 9) { 526 dbg("%s - %d byte report??", __func__, urb->actual_length); 527 goto exit; 528 } 529 530 msg = (struct keyspan_usa26_portStatusMessage *)data; 531 532 #if 0 533 dbg("%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d", 534 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff, 535 msg->_txXoff, msg->rxEnabled, msg->controlResponse); 536 #endif 537 538 /* Now do something useful with the data */ 539 540 541 /* Check port number from message and retrieve private data */ 542 if (msg->port >= serial->num_ports) { 543 dbg("%s - Unexpected port number %d", __func__, msg->port); 544 goto exit; 545 } 546 port = serial->port[msg->port]; 547 p_priv = usb_get_serial_port_data(port); 548 549 /* Update handshaking pin state information */ 550 old_dcd_state = p_priv->dcd_state; 551 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0); 552 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 553 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0); 554 p_priv->ri_state = ((msg->ri) ? 1 : 0); 555 556 if (port->port.tty && !C_CLOCAL(port->port.tty) 557 && old_dcd_state != p_priv->dcd_state) { 558 if (old_dcd_state) 559 tty_hangup(port->port.tty); 560 /* else */ 561 /* wake_up_interruptible(&p_priv->open_wait); */ 562 } 563 564 /* Resubmit urb so we continue receiving */ 565 urb->dev = serial->dev; 566 err = usb_submit_urb(urb, GFP_ATOMIC); 567 if (err != 0) 568 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 569 exit: ; 570 } 571 572 static void usa26_glocont_callback(struct urb *urb) 573 { 574 dbg("%s", __func__); 575 } 576 577 578 static void usa28_indat_callback(struct urb *urb) 579 { 580 int err; 581 struct usb_serial_port *port; 582 struct tty_struct *tty; 583 unsigned char *data; 584 struct keyspan_port_private *p_priv; 585 int status = urb->status; 586 587 dbg("%s", __func__); 588 589 port = urb->context; 590 p_priv = usb_get_serial_port_data(port); 591 data = urb->transfer_buffer; 592 593 if (urb != p_priv->in_urbs[p_priv->in_flip]) 594 return; 595 596 do { 597 if (status) { 598 dbg("%s - nonzero status: %x on endpoint %d.", 599 __func__, status, usb_pipeendpoint(urb->pipe)); 600 return; 601 } 602 603 port = urb->context; 604 p_priv = usb_get_serial_port_data(port); 605 data = urb->transfer_buffer; 606 607 tty = port->port.tty; 608 if (urb->actual_length) { 609 tty_insert_flip_string(tty, data, urb->actual_length); 610 tty_flip_buffer_push(tty); 611 } 612 613 /* Resubmit urb so we continue receiving */ 614 urb->dev = port->serial->dev; 615 if (port->port.count) { 616 err = usb_submit_urb(urb, GFP_ATOMIC); 617 if (err != 0) 618 dbg("%s - resubmit read urb failed. (%d)", 619 __func__, err); 620 } 621 p_priv->in_flip ^= 1; 622 623 urb = p_priv->in_urbs[p_priv->in_flip]; 624 } while (urb->status != -EINPROGRESS); 625 } 626 627 static void usa28_inack_callback(struct urb *urb) 628 { 629 dbg("%s", __func__); 630 } 631 632 static void usa28_outcont_callback(struct urb *urb) 633 { 634 struct usb_serial_port *port; 635 struct keyspan_port_private *p_priv; 636 637 port = urb->context; 638 p_priv = usb_get_serial_port_data(port); 639 640 if (p_priv->resend_cont) { 641 dbg("%s - sending setup", __func__); 642 keyspan_usa28_send_setup(port->serial, port, 643 p_priv->resend_cont - 1); 644 } 645 } 646 647 static void usa28_instat_callback(struct urb *urb) 648 { 649 int err; 650 unsigned char *data = urb->transfer_buffer; 651 struct keyspan_usa28_portStatusMessage *msg; 652 struct usb_serial *serial; 653 struct usb_serial_port *port; 654 struct keyspan_port_private *p_priv; 655 int old_dcd_state; 656 int status = urb->status; 657 658 serial = urb->context; 659 660 if (status) { 661 dbg("%s - nonzero status: %x", __func__, status); 662 return; 663 } 664 665 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) { 666 dbg("%s - bad length %d", __func__, urb->actual_length); 667 goto exit; 668 } 669 670 /*dbg("%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__ 671 data[0], data[1], data[2], data[3], data[4], data[5], 672 data[6], data[7], data[8], data[9], data[10], data[11]);*/ 673 674 /* Now do something useful with the data */ 675 msg = (struct keyspan_usa28_portStatusMessage *)data; 676 677 /* Check port number from message and retrieve private data */ 678 if (msg->port >= serial->num_ports) { 679 dbg("%s - Unexpected port number %d", __func__, msg->port); 680 goto exit; 681 } 682 port = serial->port[msg->port]; 683 p_priv = usb_get_serial_port_data(port); 684 685 /* Update handshaking pin state information */ 686 old_dcd_state = p_priv->dcd_state; 687 p_priv->cts_state = ((msg->cts) ? 1 : 0); 688 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 689 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 690 p_priv->ri_state = ((msg->ri) ? 1 : 0); 691 692 if (port->port.tty && !C_CLOCAL(port->port.tty) 693 && old_dcd_state != p_priv->dcd_state) { 694 if (old_dcd_state) 695 tty_hangup(port->port.tty); 696 /* else */ 697 /* wake_up_interruptible(&p_priv->open_wait); */ 698 } 699 700 /* Resubmit urb so we continue receiving */ 701 urb->dev = serial->dev; 702 err = usb_submit_urb(urb, GFP_ATOMIC); 703 if (err != 0) 704 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 705 exit: ; 706 } 707 708 static void usa28_glocont_callback(struct urb *urb) 709 { 710 dbg("%s", __func__); 711 } 712 713 714 static void usa49_glocont_callback(struct urb *urb) 715 { 716 struct usb_serial *serial; 717 struct usb_serial_port *port; 718 struct keyspan_port_private *p_priv; 719 int i; 720 721 dbg("%s", __func__); 722 723 serial = urb->context; 724 for (i = 0; i < serial->num_ports; ++i) { 725 port = serial->port[i]; 726 p_priv = usb_get_serial_port_data(port); 727 728 if (p_priv->resend_cont) { 729 dbg("%s - sending setup", __func__); 730 keyspan_usa49_send_setup(serial, port, 731 p_priv->resend_cont - 1); 732 break; 733 } 734 } 735 } 736 737 /* This is actually called glostat in the Keyspan 738 doco */ 739 static void usa49_instat_callback(struct urb *urb) 740 { 741 int err; 742 unsigned char *data = urb->transfer_buffer; 743 struct keyspan_usa49_portStatusMessage *msg; 744 struct usb_serial *serial; 745 struct usb_serial_port *port; 746 struct keyspan_port_private *p_priv; 747 int old_dcd_state; 748 int status = urb->status; 749 750 dbg("%s", __func__); 751 752 serial = urb->context; 753 754 if (status) { 755 dbg("%s - nonzero status: %x", __func__, status); 756 return; 757 } 758 759 if (urb->actual_length != 760 sizeof(struct keyspan_usa49_portStatusMessage)) { 761 dbg("%s - bad length %d", __func__, urb->actual_length); 762 goto exit; 763 } 764 765 /*dbg(" %x %x %x %x %x %x %x %x %x %x %x", __func__, 766 data[0], data[1], data[2], data[3], data[4], data[5], 767 data[6], data[7], data[8], data[9], data[10]);*/ 768 769 /* Now do something useful with the data */ 770 msg = (struct keyspan_usa49_portStatusMessage *)data; 771 772 /* Check port number from message and retrieve private data */ 773 if (msg->portNumber >= serial->num_ports) { 774 dbg("%s - Unexpected port number %d", 775 __func__, msg->portNumber); 776 goto exit; 777 } 778 port = serial->port[msg->portNumber]; 779 p_priv = usb_get_serial_port_data(port); 780 781 /* Update handshaking pin state information */ 782 old_dcd_state = p_priv->dcd_state; 783 p_priv->cts_state = ((msg->cts) ? 1 : 0); 784 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 785 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 786 p_priv->ri_state = ((msg->ri) ? 1 : 0); 787 788 if (port->port.tty && !C_CLOCAL(port->port.tty) 789 && old_dcd_state != p_priv->dcd_state) { 790 if (old_dcd_state) 791 tty_hangup(port->port.tty); 792 /* else */ 793 /* wake_up_interruptible(&p_priv->open_wait); */ 794 } 795 796 /* Resubmit urb so we continue receiving */ 797 urb->dev = serial->dev; 798 799 err = usb_submit_urb(urb, GFP_ATOMIC); 800 if (err != 0) 801 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 802 exit: ; 803 } 804 805 static void usa49_inack_callback(struct urb *urb) 806 { 807 dbg("%s", __func__); 808 } 809 810 static void usa49_indat_callback(struct urb *urb) 811 { 812 int i, err; 813 int endpoint; 814 struct usb_serial_port *port; 815 struct tty_struct *tty; 816 unsigned char *data = urb->transfer_buffer; 817 int status = urb->status; 818 819 dbg("%s", __func__); 820 821 endpoint = usb_pipeendpoint(urb->pipe); 822 823 if (status) { 824 dbg("%s - nonzero status: %x on endpoint %d.", __func__, 825 status, endpoint); 826 return; 827 } 828 829 port = urb->context; 830 tty = port->port.tty; 831 if (tty && urb->actual_length) { 832 /* 0x80 bit is error flag */ 833 if ((data[0] & 0x80) == 0) { 834 /* no error on any byte */ 835 tty_insert_flip_string(tty, data + 1, 836 urb->actual_length - 1); 837 } else { 838 /* some bytes had errors, every byte has status */ 839 for (i = 0; i + 1 < urb->actual_length; i += 2) { 840 int stat = data[i], flag = 0; 841 if (stat & RXERROR_OVERRUN) 842 flag |= TTY_OVERRUN; 843 if (stat & RXERROR_FRAMING) 844 flag |= TTY_FRAME; 845 if (stat & RXERROR_PARITY) 846 flag |= TTY_PARITY; 847 /* XXX should handle break (0x10) */ 848 tty_insert_flip_char(tty, data[i+1], flag); 849 } 850 } 851 tty_flip_buffer_push(tty); 852 } 853 854 /* Resubmit urb so we continue receiving */ 855 urb->dev = port->serial->dev; 856 if (port->port.count) { 857 err = usb_submit_urb(urb, GFP_ATOMIC); 858 if (err != 0) 859 dbg("%s - resubmit read urb failed. (%d)", 860 __func__, err); 861 } 862 } 863 864 static void usa49wg_indat_callback(struct urb *urb) 865 { 866 int i, len, x, err; 867 struct usb_serial *serial; 868 struct usb_serial_port *port; 869 struct tty_struct *tty; 870 unsigned char *data = urb->transfer_buffer; 871 int status = urb->status; 872 873 dbg("%s", __func__); 874 875 serial = urb->context; 876 877 if (status) { 878 dbg("%s - nonzero status: %x", __func__, status); 879 return; 880 } 881 882 /* inbound data is in the form P#, len, status, data */ 883 i = 0; 884 len = 0; 885 886 if (urb->actual_length) { 887 while (i < urb->actual_length) { 888 889 /* Check port number from message*/ 890 if (data[i] >= serial->num_ports) { 891 dbg("%s - Unexpected port number %d", 892 __func__, data[i]); 893 return; 894 } 895 port = serial->port[data[i++]]; 896 tty = port->port.tty; 897 len = data[i++]; 898 899 /* 0x80 bit is error flag */ 900 if ((data[i] & 0x80) == 0) { 901 /* no error on any byte */ 902 i++; 903 for (x = 1; x < len ; ++x) 904 if (port->port.count) 905 tty_insert_flip_char(tty, 906 data[i++], 0); 907 else 908 i++; 909 } else { 910 /* 911 * some bytes had errors, every byte has status 912 */ 913 for (x = 0; x + 1 < len; x += 2) { 914 int stat = data[i], flag = 0; 915 if (stat & RXERROR_OVERRUN) 916 flag |= TTY_OVERRUN; 917 if (stat & RXERROR_FRAMING) 918 flag |= TTY_FRAME; 919 if (stat & RXERROR_PARITY) 920 flag |= TTY_PARITY; 921 /* XXX should handle break (0x10) */ 922 if (port->port.count) 923 tty_insert_flip_char(tty, 924 data[i+1], flag); 925 i += 2; 926 } 927 } 928 if (port->port.count) 929 tty_flip_buffer_push(tty); 930 } 931 } 932 933 /* Resubmit urb so we continue receiving */ 934 urb->dev = serial->dev; 935 936 err = usb_submit_urb(urb, GFP_ATOMIC); 937 if (err != 0) 938 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 939 } 940 941 /* not used, usa-49 doesn't have per-port control endpoints */ 942 static void usa49_outcont_callback(struct urb *urb) 943 { 944 dbg("%s", __func__); 945 } 946 947 static void usa90_indat_callback(struct urb *urb) 948 { 949 int i, err; 950 int endpoint; 951 struct usb_serial_port *port; 952 struct keyspan_port_private *p_priv; 953 struct tty_struct *tty; 954 unsigned char *data = urb->transfer_buffer; 955 int status = urb->status; 956 957 dbg("%s", __func__); 958 959 endpoint = usb_pipeendpoint(urb->pipe); 960 961 if (status) { 962 dbg("%s - nonzero status: %x on endpoint %d.", 963 __func__, status, endpoint); 964 return; 965 } 966 967 port = urb->context; 968 p_priv = usb_get_serial_port_data(port); 969 970 tty = port->port.tty; 971 if (urb->actual_length) { 972 /* if current mode is DMA, looks like usa28 format 973 otherwise looks like usa26 data format */ 974 975 if (p_priv->baud > 57600) 976 tty_insert_flip_string(tty, data, urb->actual_length); 977 else { 978 /* 0x80 bit is error flag */ 979 if ((data[0] & 0x80) == 0) { 980 /* no errors on individual bytes, only 981 possible overrun err*/ 982 if (data[0] & RXERROR_OVERRUN) 983 err = TTY_OVERRUN; 984 else 985 err = 0; 986 for (i = 1; i < urb->actual_length ; ++i) 987 tty_insert_flip_char(tty, data[i], 988 err); 989 } else { 990 /* some bytes had errors, every byte has status */ 991 dbg("%s - RX error!!!!", __func__); 992 for (i = 0; i + 1 < urb->actual_length; i += 2) { 993 int stat = data[i], flag = 0; 994 if (stat & RXERROR_OVERRUN) 995 flag |= TTY_OVERRUN; 996 if (stat & RXERROR_FRAMING) 997 flag |= TTY_FRAME; 998 if (stat & RXERROR_PARITY) 999 flag |= TTY_PARITY; 1000 /* XXX should handle break (0x10) */ 1001 tty_insert_flip_char(tty, data[i+1], 1002 flag); 1003 } 1004 } 1005 } 1006 tty_flip_buffer_push(tty); 1007 } 1008 1009 /* Resubmit urb so we continue receiving */ 1010 urb->dev = port->serial->dev; 1011 if (port->port.count) { 1012 err = usb_submit_urb(urb, GFP_ATOMIC); 1013 if (err != 0) 1014 dbg("%s - resubmit read urb failed. (%d)", 1015 __func__, err); 1016 } 1017 return; 1018 } 1019 1020 1021 static void usa90_instat_callback(struct urb *urb) 1022 { 1023 unsigned char *data = urb->transfer_buffer; 1024 struct keyspan_usa90_portStatusMessage *msg; 1025 struct usb_serial *serial; 1026 struct usb_serial_port *port; 1027 struct keyspan_port_private *p_priv; 1028 int old_dcd_state, err; 1029 int status = urb->status; 1030 1031 serial = urb->context; 1032 1033 if (status) { 1034 dbg("%s - nonzero status: %x", __func__, status); 1035 return; 1036 } 1037 if (urb->actual_length < 14) { 1038 dbg("%s - %d byte report??", __func__, urb->actual_length); 1039 goto exit; 1040 } 1041 1042 msg = (struct keyspan_usa90_portStatusMessage *)data; 1043 1044 /* Now do something useful with the data */ 1045 1046 port = serial->port[0]; 1047 p_priv = usb_get_serial_port_data(port); 1048 1049 /* Update handshaking pin state information */ 1050 old_dcd_state = p_priv->dcd_state; 1051 p_priv->cts_state = ((msg->cts) ? 1 : 0); 1052 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 1053 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 1054 p_priv->ri_state = ((msg->ri) ? 1 : 0); 1055 1056 if (port->port.tty && !C_CLOCAL(port->port.tty) 1057 && old_dcd_state != p_priv->dcd_state) { 1058 if (old_dcd_state) 1059 tty_hangup(port->port.tty); 1060 /* else */ 1061 /* wake_up_interruptible(&p_priv->open_wait); */ 1062 } 1063 1064 /* Resubmit urb so we continue receiving */ 1065 urb->dev = serial->dev; 1066 err = usb_submit_urb(urb, GFP_ATOMIC); 1067 if (err != 0) 1068 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 1069 exit: 1070 ; 1071 } 1072 1073 static void usa90_outcont_callback(struct urb *urb) 1074 { 1075 struct usb_serial_port *port; 1076 struct keyspan_port_private *p_priv; 1077 1078 port = urb->context; 1079 p_priv = usb_get_serial_port_data(port); 1080 1081 if (p_priv->resend_cont) { 1082 dbg("%s - sending setup", __func__); 1083 keyspan_usa90_send_setup(port->serial, port, 1084 p_priv->resend_cont - 1); 1085 } 1086 } 1087 1088 /* Status messages from the 28xg */ 1089 static void usa67_instat_callback(struct urb *urb) 1090 { 1091 int err; 1092 unsigned char *data = urb->transfer_buffer; 1093 struct keyspan_usa67_portStatusMessage *msg; 1094 struct usb_serial *serial; 1095 struct usb_serial_port *port; 1096 struct keyspan_port_private *p_priv; 1097 int old_dcd_state; 1098 int status = urb->status; 1099 1100 dbg("%s", __func__); 1101 1102 serial = urb->context; 1103 1104 if (status) { 1105 dbg("%s - nonzero status: %x", __func__, status); 1106 return; 1107 } 1108 1109 if (urb->actual_length != 1110 sizeof(struct keyspan_usa67_portStatusMessage)) { 1111 dbg("%s - bad length %d", __func__, urb->actual_length); 1112 return; 1113 } 1114 1115 1116 /* Now do something useful with the data */ 1117 msg = (struct keyspan_usa67_portStatusMessage *)data; 1118 1119 /* Check port number from message and retrieve private data */ 1120 if (msg->port >= serial->num_ports) { 1121 dbg("%s - Unexpected port number %d", __func__, msg->port); 1122 return; 1123 } 1124 1125 port = serial->port[msg->port]; 1126 p_priv = usb_get_serial_port_data(port); 1127 1128 /* Update handshaking pin state information */ 1129 old_dcd_state = p_priv->dcd_state; 1130 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0); 1131 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0); 1132 1133 if (port->port.tty && !C_CLOCAL(port->port.tty) 1134 && old_dcd_state != p_priv->dcd_state) { 1135 if (old_dcd_state) 1136 tty_hangup(port->port.tty); 1137 /* else */ 1138 /* wake_up_interruptible(&p_priv->open_wait); */ 1139 } 1140 1141 /* Resubmit urb so we continue receiving */ 1142 urb->dev = serial->dev; 1143 err = usb_submit_urb(urb, GFP_ATOMIC); 1144 if (err != 0) 1145 dbg("%s - resubmit read urb failed. (%d)", __func__, err); 1146 } 1147 1148 static void usa67_glocont_callback(struct urb *urb) 1149 { 1150 struct usb_serial *serial; 1151 struct usb_serial_port *port; 1152 struct keyspan_port_private *p_priv; 1153 int i; 1154 1155 dbg("%s", __func__); 1156 1157 serial = urb->context; 1158 for (i = 0; i < serial->num_ports; ++i) { 1159 port = serial->port[i]; 1160 p_priv = usb_get_serial_port_data(port); 1161 1162 if (p_priv->resend_cont) { 1163 dbg("%s - sending setup", __func__); 1164 keyspan_usa67_send_setup(serial, port, 1165 p_priv->resend_cont - 1); 1166 break; 1167 } 1168 } 1169 } 1170 1171 static int keyspan_write_room(struct tty_struct *tty) 1172 { 1173 struct usb_serial_port *port = tty->driver_data; 1174 struct keyspan_port_private *p_priv; 1175 const struct keyspan_device_details *d_details; 1176 int flip; 1177 int data_len; 1178 struct urb *this_urb; 1179 1180 dbg("%s", __func__); 1181 p_priv = usb_get_serial_port_data(port); 1182 d_details = p_priv->device_details; 1183 1184 /* FIXME: locking */ 1185 if (d_details->msg_format == msg_usa90) 1186 data_len = 64; 1187 else 1188 data_len = 63; 1189 1190 flip = p_priv->out_flip; 1191 1192 /* Check both endpoints to see if any are available. */ 1193 this_urb = p_priv->out_urbs[flip]; 1194 if (this_urb != NULL) { 1195 if (this_urb->status != -EINPROGRESS) 1196 return data_len; 1197 flip = (flip + 1) & d_details->outdat_endp_flip; 1198 this_urb = p_priv->out_urbs[flip]; 1199 if (this_urb != NULL) { 1200 if (this_urb->status != -EINPROGRESS) 1201 return data_len; 1202 } 1203 } 1204 return 0; 1205 } 1206 1207 1208 static int keyspan_open(struct tty_struct *tty, 1209 struct usb_serial_port *port, struct file *filp) 1210 { 1211 struct keyspan_port_private *p_priv; 1212 struct keyspan_serial_private *s_priv; 1213 struct usb_serial *serial = port->serial; 1214 const struct keyspan_device_details *d_details; 1215 int i, err; 1216 int baud_rate, device_port; 1217 struct urb *urb; 1218 unsigned int cflag = 0; 1219 1220 s_priv = usb_get_serial_data(serial); 1221 p_priv = usb_get_serial_port_data(port); 1222 d_details = p_priv->device_details; 1223 1224 dbg("%s - port%d.", __func__, port->number); 1225 1226 /* Set some sane defaults */ 1227 p_priv->rts_state = 1; 1228 p_priv->dtr_state = 1; 1229 p_priv->baud = 9600; 1230 1231 /* force baud and lcr to be set on open */ 1232 p_priv->old_baud = 0; 1233 p_priv->old_cflag = 0; 1234 1235 p_priv->out_flip = 0; 1236 p_priv->in_flip = 0; 1237 1238 /* Reset low level data toggle and start reading from endpoints */ 1239 for (i = 0; i < 2; i++) { 1240 urb = p_priv->in_urbs[i]; 1241 if (urb == NULL) 1242 continue; 1243 urb->dev = serial->dev; 1244 1245 /* make sure endpoint data toggle is synchronized 1246 with the device */ 1247 usb_clear_halt(urb->dev, urb->pipe); 1248 err = usb_submit_urb(urb, GFP_KERNEL); 1249 if (err != 0) 1250 dbg("%s - submit urb %d failed (%d)", 1251 __func__, i, err); 1252 } 1253 1254 /* Reset low level data toggle on out endpoints */ 1255 for (i = 0; i < 2; i++) { 1256 urb = p_priv->out_urbs[i]; 1257 if (urb == NULL) 1258 continue; 1259 urb->dev = serial->dev; 1260 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 1261 usb_pipeout(urb->pipe), 0); */ 1262 } 1263 1264 /* get the terminal config for the setup message now so we don't 1265 * need to send 2 of them */ 1266 1267 device_port = port->number - port->serial->minor; 1268 if (tty) { 1269 cflag = tty->termios->c_cflag; 1270 /* Baud rate calculation takes baud rate as an integer 1271 so other rates can be generated if desired. */ 1272 baud_rate = tty_get_baud_rate(tty); 1273 /* If no match or invalid, leave as default */ 1274 if (baud_rate >= 0 1275 && d_details->calculate_baud_rate(baud_rate, d_details->baudclk, 1276 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 1277 p_priv->baud = baud_rate; 1278 } 1279 } 1280 /* set CTS/RTS handshake etc. */ 1281 p_priv->cflag = cflag; 1282 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none; 1283 1284 keyspan_send_setup(port, 1); 1285 /* mdelay(100); */ 1286 /* keyspan_set_termios(port, NULL); */ 1287 1288 return 0; 1289 } 1290 1291 static inline void stop_urb(struct urb *urb) 1292 { 1293 if (urb && urb->status == -EINPROGRESS) 1294 usb_kill_urb(urb); 1295 } 1296 1297 static void keyspan_close(struct tty_struct *tty, 1298 struct usb_serial_port *port, struct file *filp) 1299 { 1300 int i; 1301 struct usb_serial *serial = port->serial; 1302 struct keyspan_serial_private *s_priv; 1303 struct keyspan_port_private *p_priv; 1304 1305 dbg("%s", __func__); 1306 s_priv = usb_get_serial_data(serial); 1307 p_priv = usb_get_serial_port_data(port); 1308 1309 p_priv->rts_state = 0; 1310 p_priv->dtr_state = 0; 1311 1312 if (serial->dev) { 1313 keyspan_send_setup(port, 2); 1314 /* pilot-xfer seems to work best with this delay */ 1315 mdelay(100); 1316 /* keyspan_set_termios(port, NULL); */ 1317 } 1318 1319 /*while (p_priv->outcont_urb->status == -EINPROGRESS) { 1320 dbg("%s - urb in progress", __func__); 1321 }*/ 1322 1323 p_priv->out_flip = 0; 1324 p_priv->in_flip = 0; 1325 1326 if (serial->dev) { 1327 /* Stop reading/writing urbs */ 1328 stop_urb(p_priv->inack_urb); 1329 /* stop_urb(p_priv->outcont_urb); */ 1330 for (i = 0; i < 2; i++) { 1331 stop_urb(p_priv->in_urbs[i]); 1332 stop_urb(p_priv->out_urbs[i]); 1333 } 1334 } 1335 port->port.tty = NULL; 1336 } 1337 1338 /* download the firmware to a pre-renumeration device */ 1339 static int keyspan_fake_startup(struct usb_serial *serial) 1340 { 1341 int response; 1342 const struct ihex_binrec *record; 1343 char *fw_name; 1344 const struct firmware *fw; 1345 1346 dbg("Keyspan startup version %04x product %04x", 1347 le16_to_cpu(serial->dev->descriptor.bcdDevice), 1348 le16_to_cpu(serial->dev->descriptor.idProduct)); 1349 1350 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000) 1351 != 0x8000) { 1352 dbg("Firmware already loaded. Quitting."); 1353 return 1; 1354 } 1355 1356 /* Select firmware image on the basis of idProduct */ 1357 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) { 1358 case keyspan_usa28_pre_product_id: 1359 fw_name = "keyspan/usa28.fw"; 1360 break; 1361 1362 case keyspan_usa28x_pre_product_id: 1363 fw_name = "keyspan/usa28x.fw"; 1364 break; 1365 1366 case keyspan_usa28xa_pre_product_id: 1367 fw_name = "keyspan/usa28xa.fw"; 1368 break; 1369 1370 case keyspan_usa28xb_pre_product_id: 1371 fw_name = "keyspan/usa28xb.fw"; 1372 break; 1373 1374 case keyspan_usa19_pre_product_id: 1375 fw_name = "keyspan/usa19.fw"; 1376 break; 1377 1378 case keyspan_usa19qi_pre_product_id: 1379 fw_name = "keyspan/usa19qi.fw"; 1380 break; 1381 1382 case keyspan_mpr_pre_product_id: 1383 fw_name = "keyspan/mpr.fw"; 1384 break; 1385 1386 case keyspan_usa19qw_pre_product_id: 1387 fw_name = "keyspan/usa19qw.fw"; 1388 break; 1389 1390 case keyspan_usa18x_pre_product_id: 1391 fw_name = "keyspan/usa18x.fw"; 1392 break; 1393 1394 case keyspan_usa19w_pre_product_id: 1395 fw_name = "keyspan/usa19w.fw"; 1396 break; 1397 1398 case keyspan_usa49w_pre_product_id: 1399 fw_name = "keyspan/usa49w.fw"; 1400 break; 1401 1402 case keyspan_usa49wlc_pre_product_id: 1403 fw_name = "keyspan/usa49wlc.fw"; 1404 break; 1405 1406 default: 1407 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n", 1408 le16_to_cpu(serial->dev->descriptor.idProduct)); 1409 return 1; 1410 } 1411 1412 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) { 1413 dev_err(&serial->dev->dev, "Required keyspan firmware image (%s) unavailable.\n", fw_name); 1414 return(1); 1415 } 1416 1417 dbg("Uploading Keyspan %s firmware.", fw_name); 1418 1419 /* download the firmware image */ 1420 response = ezusb_set_reset(serial, 1); 1421 1422 record = (const struct ihex_binrec *)fw->data; 1423 1424 while (record) { 1425 response = ezusb_writememory(serial, be32_to_cpu(record->addr), 1426 (unsigned char *)record->data, 1427 be16_to_cpu(record->len), 0xa0); 1428 if (response < 0) { 1429 dev_err(&serial->dev->dev, "ezusb_writememory failed for Keyspan firmware (%d %04X %p %d)\n", 1430 response, be32_to_cpu(record->addr), 1431 record->data, be16_to_cpu(record->len)); 1432 break; 1433 } 1434 record = ihex_next_binrec(record); 1435 } 1436 release_firmware(fw); 1437 /* bring device out of reset. Renumeration will occur in a 1438 moment and the new device will bind to the real driver */ 1439 response = ezusb_set_reset(serial, 0); 1440 1441 /* we don't want this device to have a driver assigned to it. */ 1442 return 1; 1443 } 1444 1445 /* Helper functions used by keyspan_setup_urbs */ 1446 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial, 1447 int endpoint) 1448 { 1449 struct usb_host_interface *iface_desc; 1450 struct usb_endpoint_descriptor *ep; 1451 int i; 1452 1453 iface_desc = serial->interface->cur_altsetting; 1454 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1455 ep = &iface_desc->endpoint[i].desc; 1456 if (ep->bEndpointAddress == endpoint) 1457 return ep; 1458 } 1459 dev_warn(&serial->interface->dev, "found no endpoint descriptor for " 1460 "endpoint %x\n", endpoint); 1461 return NULL; 1462 } 1463 1464 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint, 1465 int dir, void *ctx, char *buf, int len, 1466 void (*callback)(struct urb *)) 1467 { 1468 struct urb *urb; 1469 struct usb_endpoint_descriptor const *ep_desc; 1470 char const *ep_type_name; 1471 1472 if (endpoint == -1) 1473 return NULL; /* endpoint not needed */ 1474 1475 dbg("%s - alloc for endpoint %d.", __func__, endpoint); 1476 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 1477 if (urb == NULL) { 1478 dbg("%s - alloc for endpoint %d failed.", __func__, endpoint); 1479 return NULL; 1480 } 1481 1482 if (endpoint == 0) { 1483 /* control EP filled in when used */ 1484 return urb; 1485 } 1486 1487 ep_desc = find_ep(serial, endpoint); 1488 if (!ep_desc) { 1489 /* leak the urb, something's wrong and the callers don't care */ 1490 return urb; 1491 } 1492 if (usb_endpoint_xfer_int(ep_desc)) { 1493 ep_type_name = "INT"; 1494 usb_fill_int_urb(urb, serial->dev, 1495 usb_sndintpipe(serial->dev, endpoint) | dir, 1496 buf, len, callback, ctx, 1497 ep_desc->bInterval); 1498 } else if (usb_endpoint_xfer_bulk(ep_desc)) { 1499 ep_type_name = "BULK"; 1500 usb_fill_bulk_urb(urb, serial->dev, 1501 usb_sndbulkpipe(serial->dev, endpoint) | dir, 1502 buf, len, callback, ctx); 1503 } else { 1504 dev_warn(&serial->interface->dev, 1505 "unsupported endpoint type %x\n", 1506 ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK); 1507 usb_free_urb(urb); 1508 return NULL; 1509 } 1510 1511 dbg("%s - using urb %p for %s endpoint %x", 1512 __func__, urb, ep_type_name, endpoint); 1513 return urb; 1514 } 1515 1516 static struct callbacks { 1517 void (*instat_callback)(struct urb *); 1518 void (*glocont_callback)(struct urb *); 1519 void (*indat_callback)(struct urb *); 1520 void (*outdat_callback)(struct urb *); 1521 void (*inack_callback)(struct urb *); 1522 void (*outcont_callback)(struct urb *); 1523 } keyspan_callbacks[] = { 1524 { 1525 /* msg_usa26 callbacks */ 1526 .instat_callback = usa26_instat_callback, 1527 .glocont_callback = usa26_glocont_callback, 1528 .indat_callback = usa26_indat_callback, 1529 .outdat_callback = usa2x_outdat_callback, 1530 .inack_callback = usa26_inack_callback, 1531 .outcont_callback = usa26_outcont_callback, 1532 }, { 1533 /* msg_usa28 callbacks */ 1534 .instat_callback = usa28_instat_callback, 1535 .glocont_callback = usa28_glocont_callback, 1536 .indat_callback = usa28_indat_callback, 1537 .outdat_callback = usa2x_outdat_callback, 1538 .inack_callback = usa28_inack_callback, 1539 .outcont_callback = usa28_outcont_callback, 1540 }, { 1541 /* msg_usa49 callbacks */ 1542 .instat_callback = usa49_instat_callback, 1543 .glocont_callback = usa49_glocont_callback, 1544 .indat_callback = usa49_indat_callback, 1545 .outdat_callback = usa2x_outdat_callback, 1546 .inack_callback = usa49_inack_callback, 1547 .outcont_callback = usa49_outcont_callback, 1548 }, { 1549 /* msg_usa90 callbacks */ 1550 .instat_callback = usa90_instat_callback, 1551 .glocont_callback = usa28_glocont_callback, 1552 .indat_callback = usa90_indat_callback, 1553 .outdat_callback = usa2x_outdat_callback, 1554 .inack_callback = usa28_inack_callback, 1555 .outcont_callback = usa90_outcont_callback, 1556 }, { 1557 /* msg_usa67 callbacks */ 1558 .instat_callback = usa67_instat_callback, 1559 .glocont_callback = usa67_glocont_callback, 1560 .indat_callback = usa26_indat_callback, 1561 .outdat_callback = usa2x_outdat_callback, 1562 .inack_callback = usa26_inack_callback, 1563 .outcont_callback = usa26_outcont_callback, 1564 } 1565 }; 1566 1567 /* Generic setup urbs function that uses 1568 data in device_details */ 1569 static void keyspan_setup_urbs(struct usb_serial *serial) 1570 { 1571 int i, j; 1572 struct keyspan_serial_private *s_priv; 1573 const struct keyspan_device_details *d_details; 1574 struct usb_serial_port *port; 1575 struct keyspan_port_private *p_priv; 1576 struct callbacks *cback; 1577 int endp; 1578 1579 dbg("%s", __func__); 1580 1581 s_priv = usb_get_serial_data(serial); 1582 d_details = s_priv->device_details; 1583 1584 /* Setup values for the various callback routines */ 1585 cback = &keyspan_callbacks[d_details->msg_format]; 1586 1587 /* Allocate and set up urbs for each one that is in use, 1588 starting with instat endpoints */ 1589 s_priv->instat_urb = keyspan_setup_urb 1590 (serial, d_details->instat_endpoint, USB_DIR_IN, 1591 serial, s_priv->instat_buf, INSTAT_BUFLEN, 1592 cback->instat_callback); 1593 1594 s_priv->indat_urb = keyspan_setup_urb 1595 (serial, d_details->indat_endpoint, USB_DIR_IN, 1596 serial, s_priv->indat_buf, INDAT49W_BUFLEN, 1597 usa49wg_indat_callback); 1598 1599 s_priv->glocont_urb = keyspan_setup_urb 1600 (serial, d_details->glocont_endpoint, USB_DIR_OUT, 1601 serial, s_priv->glocont_buf, GLOCONT_BUFLEN, 1602 cback->glocont_callback); 1603 1604 /* Setup endpoints for each port specific thing */ 1605 for (i = 0; i < d_details->num_ports; i++) { 1606 port = serial->port[i]; 1607 p_priv = usb_get_serial_port_data(port); 1608 1609 /* Do indat endpoints first, once for each flip */ 1610 endp = d_details->indat_endpoints[i]; 1611 for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) { 1612 p_priv->in_urbs[j] = keyspan_setup_urb 1613 (serial, endp, USB_DIR_IN, port, 1614 p_priv->in_buffer[j], 64, 1615 cback->indat_callback); 1616 } 1617 for (; j < 2; ++j) 1618 p_priv->in_urbs[j] = NULL; 1619 1620 /* outdat endpoints also have flip */ 1621 endp = d_details->outdat_endpoints[i]; 1622 for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) { 1623 p_priv->out_urbs[j] = keyspan_setup_urb 1624 (serial, endp, USB_DIR_OUT, port, 1625 p_priv->out_buffer[j], 64, 1626 cback->outdat_callback); 1627 } 1628 for (; j < 2; ++j) 1629 p_priv->out_urbs[j] = NULL; 1630 1631 /* inack endpoint */ 1632 p_priv->inack_urb = keyspan_setup_urb 1633 (serial, d_details->inack_endpoints[i], USB_DIR_IN, 1634 port, p_priv->inack_buffer, 1, cback->inack_callback); 1635 1636 /* outcont endpoint */ 1637 p_priv->outcont_urb = keyspan_setup_urb 1638 (serial, d_details->outcont_endpoints[i], USB_DIR_OUT, 1639 port, p_priv->outcont_buffer, 64, 1640 cback->outcont_callback); 1641 } 1642 } 1643 1644 /* usa19 function doesn't require prescaler */ 1645 static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1646 u8 *rate_low, u8 *prescaler, int portnum) 1647 { 1648 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1649 div, /* divisor */ 1650 cnt; /* inverse of divisor (programmed into 8051) */ 1651 1652 dbg("%s - %d.", __func__, baud_rate); 1653 1654 /* prevent divide by zero... */ 1655 b16 = baud_rate * 16L; 1656 if (b16 == 0) 1657 return KEYSPAN_INVALID_BAUD_RATE; 1658 /* Any "standard" rate over 57k6 is marginal on the USA-19 1659 as we run out of divisor resolution. */ 1660 if (baud_rate > 57600) 1661 return KEYSPAN_INVALID_BAUD_RATE; 1662 1663 /* calculate the divisor and the counter (its inverse) */ 1664 div = baudclk / b16; 1665 if (div == 0) 1666 return KEYSPAN_INVALID_BAUD_RATE; 1667 else 1668 cnt = 0 - div; 1669 1670 if (div > 0xffff) 1671 return KEYSPAN_INVALID_BAUD_RATE; 1672 1673 /* return the counter values if non-null */ 1674 if (rate_low) 1675 *rate_low = (u8) (cnt & 0xff); 1676 if (rate_hi) 1677 *rate_hi = (u8) ((cnt >> 8) & 0xff); 1678 if (rate_low && rate_hi) 1679 dbg("%s - %d %02x %02x.", 1680 __func__, baud_rate, *rate_hi, *rate_low); 1681 return KEYSPAN_BAUD_RATE_OK; 1682 } 1683 1684 /* usa19hs function doesn't require prescaler */ 1685 static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1686 u8 *rate_low, u8 *prescaler, int portnum) 1687 { 1688 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1689 div; /* divisor */ 1690 1691 dbg("%s - %d.", __func__, baud_rate); 1692 1693 /* prevent divide by zero... */ 1694 b16 = baud_rate * 16L; 1695 if (b16 == 0) 1696 return KEYSPAN_INVALID_BAUD_RATE; 1697 1698 /* calculate the divisor */ 1699 div = baudclk / b16; 1700 if (div == 0) 1701 return KEYSPAN_INVALID_BAUD_RATE; 1702 1703 if (div > 0xffff) 1704 return KEYSPAN_INVALID_BAUD_RATE; 1705 1706 /* return the counter values if non-null */ 1707 if (rate_low) 1708 *rate_low = (u8) (div & 0xff); 1709 1710 if (rate_hi) 1711 *rate_hi = (u8) ((div >> 8) & 0xff); 1712 1713 if (rate_low && rate_hi) 1714 dbg("%s - %d %02x %02x.", 1715 __func__, baud_rate, *rate_hi, *rate_low); 1716 1717 return KEYSPAN_BAUD_RATE_OK; 1718 } 1719 1720 static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1721 u8 *rate_low, u8 *prescaler, int portnum) 1722 { 1723 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1724 clk, /* clock with 13/8 prescaler */ 1725 div, /* divisor using 13/8 prescaler */ 1726 res, /* resulting baud rate using 13/8 prescaler */ 1727 diff, /* error using 13/8 prescaler */ 1728 smallest_diff; 1729 u8 best_prescaler; 1730 int i; 1731 1732 dbg("%s - %d.", __func__, baud_rate); 1733 1734 /* prevent divide by zero */ 1735 b16 = baud_rate * 16L; 1736 if (b16 == 0) 1737 return KEYSPAN_INVALID_BAUD_RATE; 1738 1739 /* Calculate prescaler by trying them all and looking 1740 for best fit */ 1741 1742 /* start with largest possible difference */ 1743 smallest_diff = 0xffffffff; 1744 1745 /* 0 is an invalid prescaler, used as a flag */ 1746 best_prescaler = 0; 1747 1748 for (i = 8; i <= 0xff; ++i) { 1749 clk = (baudclk * 8) / (u32) i; 1750 1751 div = clk / b16; 1752 if (div == 0) 1753 continue; 1754 1755 res = clk / div; 1756 diff = (res > b16) ? (res-b16) : (b16-res); 1757 1758 if (diff < smallest_diff) { 1759 best_prescaler = i; 1760 smallest_diff = diff; 1761 } 1762 } 1763 1764 if (best_prescaler == 0) 1765 return KEYSPAN_INVALID_BAUD_RATE; 1766 1767 clk = (baudclk * 8) / (u32) best_prescaler; 1768 div = clk / b16; 1769 1770 /* return the divisor and prescaler if non-null */ 1771 if (rate_low) 1772 *rate_low = (u8) (div & 0xff); 1773 if (rate_hi) 1774 *rate_hi = (u8) ((div >> 8) & 0xff); 1775 if (prescaler) { 1776 *prescaler = best_prescaler; 1777 /* dbg("%s - %d %d", __func__, *prescaler, div); */ 1778 } 1779 return KEYSPAN_BAUD_RATE_OK; 1780 } 1781 1782 /* USA-28 supports different maximum baud rates on each port */ 1783 static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi, 1784 u8 *rate_low, u8 *prescaler, int portnum) 1785 { 1786 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1787 div, /* divisor */ 1788 cnt; /* inverse of divisor (programmed into 8051) */ 1789 1790 dbg("%s - %d.", __func__, baud_rate); 1791 1792 /* prevent divide by zero */ 1793 b16 = baud_rate * 16L; 1794 if (b16 == 0) 1795 return KEYSPAN_INVALID_BAUD_RATE; 1796 1797 /* calculate the divisor and the counter (its inverse) */ 1798 div = KEYSPAN_USA28_BAUDCLK / b16; 1799 if (div == 0) 1800 return KEYSPAN_INVALID_BAUD_RATE; 1801 else 1802 cnt = 0 - div; 1803 1804 /* check for out of range, based on portnum, 1805 and return result */ 1806 if (portnum == 0) { 1807 if (div > 0xffff) 1808 return KEYSPAN_INVALID_BAUD_RATE; 1809 } else { 1810 if (portnum == 1) { 1811 if (div > 0xff) 1812 return KEYSPAN_INVALID_BAUD_RATE; 1813 } else 1814 return KEYSPAN_INVALID_BAUD_RATE; 1815 } 1816 1817 /* return the counter values if not NULL 1818 (port 1 will ignore retHi) */ 1819 if (rate_low) 1820 *rate_low = (u8) (cnt & 0xff); 1821 if (rate_hi) 1822 *rate_hi = (u8) ((cnt >> 8) & 0xff); 1823 dbg("%s - %d OK.", __func__, baud_rate); 1824 return KEYSPAN_BAUD_RATE_OK; 1825 } 1826 1827 static int keyspan_usa26_send_setup(struct usb_serial *serial, 1828 struct usb_serial_port *port, 1829 int reset_port) 1830 { 1831 struct keyspan_usa26_portControlMessage msg; 1832 struct keyspan_serial_private *s_priv; 1833 struct keyspan_port_private *p_priv; 1834 const struct keyspan_device_details *d_details; 1835 int outcont_urb; 1836 struct urb *this_urb; 1837 int device_port, err; 1838 1839 dbg("%s reset=%d", __func__, reset_port); 1840 1841 s_priv = usb_get_serial_data(serial); 1842 p_priv = usb_get_serial_port_data(port); 1843 d_details = s_priv->device_details; 1844 device_port = port->number - port->serial->minor; 1845 1846 outcont_urb = d_details->outcont_endpoints[port->number]; 1847 this_urb = p_priv->outcont_urb; 1848 1849 dbg("%s - endpoint %d", __func__, usb_pipeendpoint(this_urb->pipe)); 1850 1851 /* Make sure we have an urb then send the message */ 1852 if (this_urb == NULL) { 1853 dbg("%s - oops no urb.", __func__); 1854 return -1; 1855 } 1856 1857 /* Save reset port val for resend. 1858 Don't overwrite resend for open/close condition. */ 1859 if ((reset_port + 1) > p_priv->resend_cont) 1860 p_priv->resend_cont = reset_port + 1; 1861 if (this_urb->status == -EINPROGRESS) { 1862 /* dbg("%s - already writing", __func__); */ 1863 mdelay(5); 1864 return -1; 1865 } 1866 1867 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage)); 1868 1869 /* Only set baud rate if it's changed */ 1870 if (p_priv->old_baud != p_priv->baud) { 1871 p_priv->old_baud = p_priv->baud; 1872 msg.setClocking = 0xff; 1873 if (d_details->calculate_baud_rate 1874 (p_priv->baud, d_details->baudclk, &msg.baudHi, 1875 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) { 1876 dbg("%s - Invalid baud rate %d requested, using 9600.", 1877 __func__, p_priv->baud); 1878 msg.baudLo = 0; 1879 msg.baudHi = 125; /* Values for 9600 baud */ 1880 msg.prescaler = 10; 1881 } 1882 msg.setPrescaler = 0xff; 1883 } 1884 1885 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 1886 switch (p_priv->cflag & CSIZE) { 1887 case CS5: 1888 msg.lcr |= USA_DATABITS_5; 1889 break; 1890 case CS6: 1891 msg.lcr |= USA_DATABITS_6; 1892 break; 1893 case CS7: 1894 msg.lcr |= USA_DATABITS_7; 1895 break; 1896 case CS8: 1897 msg.lcr |= USA_DATABITS_8; 1898 break; 1899 } 1900 if (p_priv->cflag & PARENB) { 1901 /* note USA_PARITY_NONE == 0 */ 1902 msg.lcr |= (p_priv->cflag & PARODD)? 1903 USA_PARITY_ODD : USA_PARITY_EVEN; 1904 } 1905 msg.setLcr = 0xff; 1906 1907 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 1908 msg.xonFlowControl = 0; 1909 msg.setFlowControl = 0xff; 1910 msg.forwardingLength = 16; 1911 msg.xonChar = 17; 1912 msg.xoffChar = 19; 1913 1914 /* Opening port */ 1915 if (reset_port == 1) { 1916 msg._txOn = 1; 1917 msg._txOff = 0; 1918 msg.txFlush = 0; 1919 msg.txBreak = 0; 1920 msg.rxOn = 1; 1921 msg.rxOff = 0; 1922 msg.rxFlush = 1; 1923 msg.rxForward = 0; 1924 msg.returnStatus = 0; 1925 msg.resetDataToggle = 0xff; 1926 } 1927 1928 /* Closing port */ 1929 else if (reset_port == 2) { 1930 msg._txOn = 0; 1931 msg._txOff = 1; 1932 msg.txFlush = 0; 1933 msg.txBreak = 0; 1934 msg.rxOn = 0; 1935 msg.rxOff = 1; 1936 msg.rxFlush = 1; 1937 msg.rxForward = 0; 1938 msg.returnStatus = 0; 1939 msg.resetDataToggle = 0; 1940 } 1941 1942 /* Sending intermediate configs */ 1943 else { 1944 msg._txOn = (!p_priv->break_on); 1945 msg._txOff = 0; 1946 msg.txFlush = 0; 1947 msg.txBreak = (p_priv->break_on); 1948 msg.rxOn = 0; 1949 msg.rxOff = 0; 1950 msg.rxFlush = 0; 1951 msg.rxForward = 0; 1952 msg.returnStatus = 0; 1953 msg.resetDataToggle = 0x0; 1954 } 1955 1956 /* Do handshaking outputs */ 1957 msg.setTxTriState_setRts = 0xff; 1958 msg.txTriState_rts = p_priv->rts_state; 1959 1960 msg.setHskoa_setDtr = 0xff; 1961 msg.hskoa_dtr = p_priv->dtr_state; 1962 1963 p_priv->resend_cont = 0; 1964 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 1965 1966 /* send the data out the device on control endpoint */ 1967 this_urb->transfer_buffer_length = sizeof(msg); 1968 1969 this_urb->dev = serial->dev; 1970 err = usb_submit_urb(this_urb, GFP_ATOMIC); 1971 if (err != 0) 1972 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err); 1973 #if 0 1974 else { 1975 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__ 1976 outcont_urb, this_urb->transfer_buffer_length, 1977 usb_pipeendpoint(this_urb->pipe)); 1978 } 1979 #endif 1980 1981 return 0; 1982 } 1983 1984 static int keyspan_usa28_send_setup(struct usb_serial *serial, 1985 struct usb_serial_port *port, 1986 int reset_port) 1987 { 1988 struct keyspan_usa28_portControlMessage msg; 1989 struct keyspan_serial_private *s_priv; 1990 struct keyspan_port_private *p_priv; 1991 const struct keyspan_device_details *d_details; 1992 struct urb *this_urb; 1993 int device_port, err; 1994 1995 dbg("%s", __func__); 1996 1997 s_priv = usb_get_serial_data(serial); 1998 p_priv = usb_get_serial_port_data(port); 1999 d_details = s_priv->device_details; 2000 device_port = port->number - port->serial->minor; 2001 2002 /* only do something if we have a bulk out endpoint */ 2003 this_urb = p_priv->outcont_urb; 2004 if (this_urb == NULL) { 2005 dbg("%s - oops no urb.", __func__); 2006 return -1; 2007 } 2008 2009 /* Save reset port val for resend. 2010 Don't overwrite resend for open/close condition. */ 2011 if ((reset_port + 1) > p_priv->resend_cont) 2012 p_priv->resend_cont = reset_port + 1; 2013 if (this_urb->status == -EINPROGRESS) { 2014 dbg("%s already writing", __func__); 2015 mdelay(5); 2016 return -1; 2017 } 2018 2019 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage)); 2020 2021 msg.setBaudRate = 1; 2022 if (d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk, 2023 &msg.baudHi, &msg.baudLo, NULL, device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2024 dbg("%s - Invalid baud rate requested %d.", 2025 __func__, p_priv->baud); 2026 msg.baudLo = 0xff; 2027 msg.baudHi = 0xb2; /* Values for 9600 baud */ 2028 } 2029 2030 /* If parity is enabled, we must calculate it ourselves. */ 2031 msg.parity = 0; /* XXX for now */ 2032 2033 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2034 msg.xonFlowControl = 0; 2035 2036 /* Do handshaking outputs, DTR is inverted relative to RTS */ 2037 msg.rts = p_priv->rts_state; 2038 msg.dtr = p_priv->dtr_state; 2039 2040 msg.forwardingLength = 16; 2041 msg.forwardMs = 10; 2042 msg.breakThreshold = 45; 2043 msg.xonChar = 17; 2044 msg.xoffChar = 19; 2045 2046 /*msg.returnStatus = 1; 2047 msg.resetDataToggle = 0xff;*/ 2048 /* Opening port */ 2049 if (reset_port == 1) { 2050 msg._txOn = 1; 2051 msg._txOff = 0; 2052 msg.txFlush = 0; 2053 msg.txForceXoff = 0; 2054 msg.txBreak = 0; 2055 msg.rxOn = 1; 2056 msg.rxOff = 0; 2057 msg.rxFlush = 1; 2058 msg.rxForward = 0; 2059 msg.returnStatus = 0; 2060 msg.resetDataToggle = 0xff; 2061 } 2062 /* Closing port */ 2063 else if (reset_port == 2) { 2064 msg._txOn = 0; 2065 msg._txOff = 1; 2066 msg.txFlush = 0; 2067 msg.txForceXoff = 0; 2068 msg.txBreak = 0; 2069 msg.rxOn = 0; 2070 msg.rxOff = 1; 2071 msg.rxFlush = 1; 2072 msg.rxForward = 0; 2073 msg.returnStatus = 0; 2074 msg.resetDataToggle = 0; 2075 } 2076 /* Sending intermediate configs */ 2077 else { 2078 msg._txOn = (!p_priv->break_on); 2079 msg._txOff = 0; 2080 msg.txFlush = 0; 2081 msg.txForceXoff = 0; 2082 msg.txBreak = (p_priv->break_on); 2083 msg.rxOn = 0; 2084 msg.rxOff = 0; 2085 msg.rxFlush = 0; 2086 msg.rxForward = 0; 2087 msg.returnStatus = 0; 2088 msg.resetDataToggle = 0x0; 2089 } 2090 2091 p_priv->resend_cont = 0; 2092 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2093 2094 /* send the data out the device on control endpoint */ 2095 this_urb->transfer_buffer_length = sizeof(msg); 2096 2097 this_urb->dev = serial->dev; 2098 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2099 if (err != 0) 2100 dbg("%s - usb_submit_urb(setup) failed", __func__); 2101 #if 0 2102 else { 2103 dbg("%s - usb_submit_urb(setup) OK %d bytes", __func__, 2104 this_urb->transfer_buffer_length); 2105 } 2106 #endif 2107 2108 return 0; 2109 } 2110 2111 static int keyspan_usa49_send_setup(struct usb_serial *serial, 2112 struct usb_serial_port *port, 2113 int reset_port) 2114 { 2115 struct keyspan_usa49_portControlMessage msg; 2116 struct usb_ctrlrequest *dr = NULL; 2117 struct keyspan_serial_private *s_priv; 2118 struct keyspan_port_private *p_priv; 2119 const struct keyspan_device_details *d_details; 2120 struct urb *this_urb; 2121 int err, device_port; 2122 2123 dbg("%s", __func__); 2124 2125 s_priv = usb_get_serial_data(serial); 2126 p_priv = usb_get_serial_port_data(port); 2127 d_details = s_priv->device_details; 2128 2129 this_urb = s_priv->glocont_urb; 2130 2131 /* Work out which port within the device is being setup */ 2132 device_port = port->number - port->serial->minor; 2133 2134 dbg("%s - endpoint %d port %d (%d)", 2135 __func__, usb_pipeendpoint(this_urb->pipe), 2136 port->number, device_port); 2137 2138 /* Make sure we have an urb then send the message */ 2139 if (this_urb == NULL) { 2140 dbg("%s - oops no urb for port %d.", __func__, port->number); 2141 return -1; 2142 } 2143 2144 /* Save reset port val for resend. 2145 Don't overwrite resend for open/close condition. */ 2146 if ((reset_port + 1) > p_priv->resend_cont) 2147 p_priv->resend_cont = reset_port + 1; 2148 2149 if (this_urb->status == -EINPROGRESS) { 2150 /* dbg("%s - already writing", __func__); */ 2151 mdelay(5); 2152 return -1; 2153 } 2154 2155 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage)); 2156 2157 /*msg.portNumber = port->number;*/ 2158 msg.portNumber = device_port; 2159 2160 /* Only set baud rate if it's changed */ 2161 if (p_priv->old_baud != p_priv->baud) { 2162 p_priv->old_baud = p_priv->baud; 2163 msg.setClocking = 0xff; 2164 if (d_details->calculate_baud_rate 2165 (p_priv->baud, d_details->baudclk, &msg.baudHi, 2166 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2167 dbg("%s - Invalid baud rate %d requested, using 9600.", 2168 __func__, p_priv->baud); 2169 msg.baudLo = 0; 2170 msg.baudHi = 125; /* Values for 9600 baud */ 2171 msg.prescaler = 10; 2172 } 2173 /* msg.setPrescaler = 0xff; */ 2174 } 2175 2176 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 2177 switch (p_priv->cflag & CSIZE) { 2178 case CS5: 2179 msg.lcr |= USA_DATABITS_5; 2180 break; 2181 case CS6: 2182 msg.lcr |= USA_DATABITS_6; 2183 break; 2184 case CS7: 2185 msg.lcr |= USA_DATABITS_7; 2186 break; 2187 case CS8: 2188 msg.lcr |= USA_DATABITS_8; 2189 break; 2190 } 2191 if (p_priv->cflag & PARENB) { 2192 /* note USA_PARITY_NONE == 0 */ 2193 msg.lcr |= (p_priv->cflag & PARODD)? 2194 USA_PARITY_ODD : USA_PARITY_EVEN; 2195 } 2196 msg.setLcr = 0xff; 2197 2198 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2199 msg.xonFlowControl = 0; 2200 msg.setFlowControl = 0xff; 2201 2202 msg.forwardingLength = 16; 2203 msg.xonChar = 17; 2204 msg.xoffChar = 19; 2205 2206 /* Opening port */ 2207 if (reset_port == 1) { 2208 msg._txOn = 1; 2209 msg._txOff = 0; 2210 msg.txFlush = 0; 2211 msg.txBreak = 0; 2212 msg.rxOn = 1; 2213 msg.rxOff = 0; 2214 msg.rxFlush = 1; 2215 msg.rxForward = 0; 2216 msg.returnStatus = 0; 2217 msg.resetDataToggle = 0xff; 2218 msg.enablePort = 1; 2219 msg.disablePort = 0; 2220 } 2221 /* Closing port */ 2222 else if (reset_port == 2) { 2223 msg._txOn = 0; 2224 msg._txOff = 1; 2225 msg.txFlush = 0; 2226 msg.txBreak = 0; 2227 msg.rxOn = 0; 2228 msg.rxOff = 1; 2229 msg.rxFlush = 1; 2230 msg.rxForward = 0; 2231 msg.returnStatus = 0; 2232 msg.resetDataToggle = 0; 2233 msg.enablePort = 0; 2234 msg.disablePort = 1; 2235 } 2236 /* Sending intermediate configs */ 2237 else { 2238 msg._txOn = (!p_priv->break_on); 2239 msg._txOff = 0; 2240 msg.txFlush = 0; 2241 msg.txBreak = (p_priv->break_on); 2242 msg.rxOn = 0; 2243 msg.rxOff = 0; 2244 msg.rxFlush = 0; 2245 msg.rxForward = 0; 2246 msg.returnStatus = 0; 2247 msg.resetDataToggle = 0x0; 2248 msg.enablePort = 0; 2249 msg.disablePort = 0; 2250 } 2251 2252 /* Do handshaking outputs */ 2253 msg.setRts = 0xff; 2254 msg.rts = p_priv->rts_state; 2255 2256 msg.setDtr = 0xff; 2257 msg.dtr = p_priv->dtr_state; 2258 2259 p_priv->resend_cont = 0; 2260 2261 /* if the device is a 49wg, we send control message on usb 2262 control EP 0 */ 2263 2264 if (d_details->product_id == keyspan_usa49wg_product_id) { 2265 dr = (void *)(s_priv->ctrl_buf); 2266 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT; 2267 dr->bRequest = 0xB0; /* 49wg control message */; 2268 dr->wValue = 0; 2269 dr->wIndex = 0; 2270 dr->wLength = cpu_to_le16(sizeof(msg)); 2271 2272 memcpy(s_priv->glocont_buf, &msg, sizeof(msg)); 2273 2274 usb_fill_control_urb(this_urb, serial->dev, 2275 usb_sndctrlpipe(serial->dev, 0), 2276 (unsigned char *)dr, s_priv->glocont_buf, 2277 sizeof(msg), usa49_glocont_callback, serial); 2278 2279 } else { 2280 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2281 2282 /* send the data out the device on control endpoint */ 2283 this_urb->transfer_buffer_length = sizeof(msg); 2284 2285 this_urb->dev = serial->dev; 2286 } 2287 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2288 if (err != 0) 2289 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err); 2290 #if 0 2291 else { 2292 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__, 2293 outcont_urb, this_urb->transfer_buffer_length, 2294 usb_pipeendpoint(this_urb->pipe)); 2295 } 2296 #endif 2297 2298 return 0; 2299 } 2300 2301 static int keyspan_usa90_send_setup(struct usb_serial *serial, 2302 struct usb_serial_port *port, 2303 int reset_port) 2304 { 2305 struct keyspan_usa90_portControlMessage msg; 2306 struct keyspan_serial_private *s_priv; 2307 struct keyspan_port_private *p_priv; 2308 const struct keyspan_device_details *d_details; 2309 struct urb *this_urb; 2310 int err; 2311 u8 prescaler; 2312 2313 dbg("%s", __func__); 2314 2315 s_priv = usb_get_serial_data(serial); 2316 p_priv = usb_get_serial_port_data(port); 2317 d_details = s_priv->device_details; 2318 2319 /* only do something if we have a bulk out endpoint */ 2320 this_urb = p_priv->outcont_urb; 2321 if (this_urb == NULL) { 2322 dbg("%s - oops no urb.", __func__); 2323 return -1; 2324 } 2325 2326 /* Save reset port val for resend. 2327 Don't overwrite resend for open/close condition. */ 2328 if ((reset_port + 1) > p_priv->resend_cont) 2329 p_priv->resend_cont = reset_port + 1; 2330 if (this_urb->status == -EINPROGRESS) { 2331 dbg("%s already writing", __func__); 2332 mdelay(5); 2333 return -1; 2334 } 2335 2336 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage)); 2337 2338 /* Only set baud rate if it's changed */ 2339 if (p_priv->old_baud != p_priv->baud) { 2340 p_priv->old_baud = p_priv->baud; 2341 msg.setClocking = 0x01; 2342 if (d_details->calculate_baud_rate 2343 (p_priv->baud, d_details->baudclk, &msg.baudHi, 2344 &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) { 2345 dbg("%s - Invalid baud rate %d requested, using 9600.", 2346 __func__, p_priv->baud); 2347 p_priv->baud = 9600; 2348 d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk, 2349 &msg.baudHi, &msg.baudLo, &prescaler, 0); 2350 } 2351 msg.setRxMode = 1; 2352 msg.setTxMode = 1; 2353 } 2354 2355 /* modes must always be correctly specified */ 2356 if (p_priv->baud > 57600) { 2357 msg.rxMode = RXMODE_DMA; 2358 msg.txMode = TXMODE_DMA; 2359 } else { 2360 msg.rxMode = RXMODE_BYHAND; 2361 msg.txMode = TXMODE_BYHAND; 2362 } 2363 2364 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1; 2365 switch (p_priv->cflag & CSIZE) { 2366 case CS5: 2367 msg.lcr |= USA_DATABITS_5; 2368 break; 2369 case CS6: 2370 msg.lcr |= USA_DATABITS_6; 2371 break; 2372 case CS7: 2373 msg.lcr |= USA_DATABITS_7; 2374 break; 2375 case CS8: 2376 msg.lcr |= USA_DATABITS_8; 2377 break; 2378 } 2379 if (p_priv->cflag & PARENB) { 2380 /* note USA_PARITY_NONE == 0 */ 2381 msg.lcr |= (p_priv->cflag & PARODD)? 2382 USA_PARITY_ODD : USA_PARITY_EVEN; 2383 } 2384 if (p_priv->old_cflag != p_priv->cflag) { 2385 p_priv->old_cflag = p_priv->cflag; 2386 msg.setLcr = 0x01; 2387 } 2388 2389 if (p_priv->flow_control == flow_cts) 2390 msg.txFlowControl = TXFLOW_CTS; 2391 msg.setTxFlowControl = 0x01; 2392 msg.setRxFlowControl = 0x01; 2393 2394 msg.rxForwardingLength = 16; 2395 msg.rxForwardingTimeout = 16; 2396 msg.txAckSetting = 0; 2397 msg.xonChar = 17; 2398 msg.xoffChar = 19; 2399 2400 /* Opening port */ 2401 if (reset_port == 1) { 2402 msg.portEnabled = 1; 2403 msg.rxFlush = 1; 2404 msg.txBreak = (p_priv->break_on); 2405 } 2406 /* Closing port */ 2407 else if (reset_port == 2) 2408 msg.portEnabled = 0; 2409 /* Sending intermediate configs */ 2410 else { 2411 if (port->port.count) 2412 msg.portEnabled = 1; 2413 msg.txBreak = (p_priv->break_on); 2414 } 2415 2416 /* Do handshaking outputs */ 2417 msg.setRts = 0x01; 2418 msg.rts = p_priv->rts_state; 2419 2420 msg.setDtr = 0x01; 2421 msg.dtr = p_priv->dtr_state; 2422 2423 p_priv->resend_cont = 0; 2424 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2425 2426 /* send the data out the device on control endpoint */ 2427 this_urb->transfer_buffer_length = sizeof(msg); 2428 2429 this_urb->dev = serial->dev; 2430 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2431 if (err != 0) 2432 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err); 2433 return 0; 2434 } 2435 2436 static int keyspan_usa67_send_setup(struct usb_serial *serial, 2437 struct usb_serial_port *port, 2438 int reset_port) 2439 { 2440 struct keyspan_usa67_portControlMessage msg; 2441 struct keyspan_serial_private *s_priv; 2442 struct keyspan_port_private *p_priv; 2443 const struct keyspan_device_details *d_details; 2444 struct urb *this_urb; 2445 int err, device_port; 2446 2447 dbg("%s", __func__); 2448 2449 s_priv = usb_get_serial_data(serial); 2450 p_priv = usb_get_serial_port_data(port); 2451 d_details = s_priv->device_details; 2452 2453 this_urb = s_priv->glocont_urb; 2454 2455 /* Work out which port within the device is being setup */ 2456 device_port = port->number - port->serial->minor; 2457 2458 /* Make sure we have an urb then send the message */ 2459 if (this_urb == NULL) { 2460 dbg("%s - oops no urb for port %d.", __func__, 2461 port->number); 2462 return -1; 2463 } 2464 2465 /* Save reset port val for resend. 2466 Don't overwrite resend for open/close condition. */ 2467 if ((reset_port + 1) > p_priv->resend_cont) 2468 p_priv->resend_cont = reset_port + 1; 2469 if (this_urb->status == -EINPROGRESS) { 2470 /* dbg("%s - already writing", __func__); */ 2471 mdelay(5); 2472 return -1; 2473 } 2474 2475 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage)); 2476 2477 msg.port = device_port; 2478 2479 /* Only set baud rate if it's changed */ 2480 if (p_priv->old_baud != p_priv->baud) { 2481 p_priv->old_baud = p_priv->baud; 2482 msg.setClocking = 0xff; 2483 if (d_details->calculate_baud_rate 2484 (p_priv->baud, d_details->baudclk, &msg.baudHi, 2485 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2486 dbg("%s - Invalid baud rate %d requested, using 9600.", 2487 __func__, p_priv->baud); 2488 msg.baudLo = 0; 2489 msg.baudHi = 125; /* Values for 9600 baud */ 2490 msg.prescaler = 10; 2491 } 2492 msg.setPrescaler = 0xff; 2493 } 2494 2495 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1; 2496 switch (p_priv->cflag & CSIZE) { 2497 case CS5: 2498 msg.lcr |= USA_DATABITS_5; 2499 break; 2500 case CS6: 2501 msg.lcr |= USA_DATABITS_6; 2502 break; 2503 case CS7: 2504 msg.lcr |= USA_DATABITS_7; 2505 break; 2506 case CS8: 2507 msg.lcr |= USA_DATABITS_8; 2508 break; 2509 } 2510 if (p_priv->cflag & PARENB) { 2511 /* note USA_PARITY_NONE == 0 */ 2512 msg.lcr |= (p_priv->cflag & PARODD)? 2513 USA_PARITY_ODD : USA_PARITY_EVEN; 2514 } 2515 msg.setLcr = 0xff; 2516 2517 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2518 msg.xonFlowControl = 0; 2519 msg.setFlowControl = 0xff; 2520 msg.forwardingLength = 16; 2521 msg.xonChar = 17; 2522 msg.xoffChar = 19; 2523 2524 if (reset_port == 1) { 2525 /* Opening port */ 2526 msg._txOn = 1; 2527 msg._txOff = 0; 2528 msg.txFlush = 0; 2529 msg.txBreak = 0; 2530 msg.rxOn = 1; 2531 msg.rxOff = 0; 2532 msg.rxFlush = 1; 2533 msg.rxForward = 0; 2534 msg.returnStatus = 0; 2535 msg.resetDataToggle = 0xff; 2536 } else if (reset_port == 2) { 2537 /* Closing port */ 2538 msg._txOn = 0; 2539 msg._txOff = 1; 2540 msg.txFlush = 0; 2541 msg.txBreak = 0; 2542 msg.rxOn = 0; 2543 msg.rxOff = 1; 2544 msg.rxFlush = 1; 2545 msg.rxForward = 0; 2546 msg.returnStatus = 0; 2547 msg.resetDataToggle = 0; 2548 } else { 2549 /* Sending intermediate configs */ 2550 msg._txOn = (!p_priv->break_on); 2551 msg._txOff = 0; 2552 msg.txFlush = 0; 2553 msg.txBreak = (p_priv->break_on); 2554 msg.rxOn = 0; 2555 msg.rxOff = 0; 2556 msg.rxFlush = 0; 2557 msg.rxForward = 0; 2558 msg.returnStatus = 0; 2559 msg.resetDataToggle = 0x0; 2560 } 2561 2562 /* Do handshaking outputs */ 2563 msg.setTxTriState_setRts = 0xff; 2564 msg.txTriState_rts = p_priv->rts_state; 2565 2566 msg.setHskoa_setDtr = 0xff; 2567 msg.hskoa_dtr = p_priv->dtr_state; 2568 2569 p_priv->resend_cont = 0; 2570 2571 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2572 2573 /* send the data out the device on control endpoint */ 2574 this_urb->transfer_buffer_length = sizeof(msg); 2575 this_urb->dev = serial->dev; 2576 2577 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2578 if (err != 0) 2579 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, 2580 err); 2581 return 0; 2582 } 2583 2584 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port) 2585 { 2586 struct usb_serial *serial = port->serial; 2587 struct keyspan_serial_private *s_priv; 2588 const struct keyspan_device_details *d_details; 2589 2590 dbg("%s", __func__); 2591 2592 s_priv = usb_get_serial_data(serial); 2593 d_details = s_priv->device_details; 2594 2595 switch (d_details->msg_format) { 2596 case msg_usa26: 2597 keyspan_usa26_send_setup(serial, port, reset_port); 2598 break; 2599 case msg_usa28: 2600 keyspan_usa28_send_setup(serial, port, reset_port); 2601 break; 2602 case msg_usa49: 2603 keyspan_usa49_send_setup(serial, port, reset_port); 2604 break; 2605 case msg_usa90: 2606 keyspan_usa90_send_setup(serial, port, reset_port); 2607 break; 2608 case msg_usa67: 2609 keyspan_usa67_send_setup(serial, port, reset_port); 2610 break; 2611 } 2612 } 2613 2614 2615 /* Gets called by the "real" driver (ie once firmware is loaded 2616 and renumeration has taken place. */ 2617 static int keyspan_startup(struct usb_serial *serial) 2618 { 2619 int i, err; 2620 struct usb_serial_port *port; 2621 struct keyspan_serial_private *s_priv; 2622 struct keyspan_port_private *p_priv; 2623 const struct keyspan_device_details *d_details; 2624 2625 dbg("%s", __func__); 2626 2627 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i) 2628 if (d_details->product_id == 2629 le16_to_cpu(serial->dev->descriptor.idProduct)) 2630 break; 2631 if (d_details == NULL) { 2632 dev_err(&serial->dev->dev, "%s - unknown product id %x\n", 2633 __func__, le16_to_cpu(serial->dev->descriptor.idProduct)); 2634 return 1; 2635 } 2636 2637 /* Setup private data for serial driver */ 2638 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL); 2639 if (!s_priv) { 2640 dbg("%s - kmalloc for keyspan_serial_private failed.", 2641 __func__); 2642 return -ENOMEM; 2643 } 2644 2645 s_priv->device_details = d_details; 2646 usb_set_serial_data(serial, s_priv); 2647 2648 /* Now setup per port private data */ 2649 for (i = 0; i < serial->num_ports; i++) { 2650 port = serial->port[i]; 2651 p_priv = kzalloc(sizeof(struct keyspan_port_private), 2652 GFP_KERNEL); 2653 if (!p_priv) { 2654 dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __func__, i); 2655 return 1; 2656 } 2657 p_priv->device_details = d_details; 2658 usb_set_serial_port_data(port, p_priv); 2659 } 2660 2661 keyspan_setup_urbs(serial); 2662 2663 if (s_priv->instat_urb != NULL) { 2664 s_priv->instat_urb->dev = serial->dev; 2665 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL); 2666 if (err != 0) 2667 dbg("%s - submit instat urb failed %d", __func__, 2668 err); 2669 } 2670 if (s_priv->indat_urb != NULL) { 2671 s_priv->indat_urb->dev = serial->dev; 2672 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL); 2673 if (err != 0) 2674 dbg("%s - submit indat urb failed %d", __func__, 2675 err); 2676 } 2677 2678 return 0; 2679 } 2680 2681 static void keyspan_shutdown(struct usb_serial *serial) 2682 { 2683 int i, j; 2684 struct usb_serial_port *port; 2685 struct keyspan_serial_private *s_priv; 2686 struct keyspan_port_private *p_priv; 2687 2688 dbg("%s", __func__); 2689 2690 s_priv = usb_get_serial_data(serial); 2691 2692 /* Stop reading/writing urbs */ 2693 stop_urb(s_priv->instat_urb); 2694 stop_urb(s_priv->glocont_urb); 2695 stop_urb(s_priv->indat_urb); 2696 for (i = 0; i < serial->num_ports; ++i) { 2697 port = serial->port[i]; 2698 p_priv = usb_get_serial_port_data(port); 2699 stop_urb(p_priv->inack_urb); 2700 stop_urb(p_priv->outcont_urb); 2701 for (j = 0; j < 2; j++) { 2702 stop_urb(p_priv->in_urbs[j]); 2703 stop_urb(p_priv->out_urbs[j]); 2704 } 2705 } 2706 2707 /* Now free them */ 2708 usb_free_urb(s_priv->instat_urb); 2709 usb_free_urb(s_priv->indat_urb); 2710 usb_free_urb(s_priv->glocont_urb); 2711 for (i = 0; i < serial->num_ports; ++i) { 2712 port = serial->port[i]; 2713 p_priv = usb_get_serial_port_data(port); 2714 usb_free_urb(p_priv->inack_urb); 2715 usb_free_urb(p_priv->outcont_urb); 2716 for (j = 0; j < 2; j++) { 2717 usb_free_urb(p_priv->in_urbs[j]); 2718 usb_free_urb(p_priv->out_urbs[j]); 2719 } 2720 } 2721 2722 /* dbg("Freeing serial->private."); */ 2723 kfree(s_priv); 2724 2725 /* dbg("Freeing port->private."); */ 2726 /* Now free per port private data */ 2727 for (i = 0; i < serial->num_ports; i++) { 2728 port = serial->port[i]; 2729 kfree(usb_get_serial_port_data(port)); 2730 } 2731 } 2732 2733 MODULE_AUTHOR(DRIVER_AUTHOR); 2734 MODULE_DESCRIPTION(DRIVER_DESC); 2735 MODULE_LICENSE("GPL"); 2736 2737 MODULE_FIRMWARE("keyspan/usa28.fw"); 2738 MODULE_FIRMWARE("keyspan/usa28x.fw"); 2739 MODULE_FIRMWARE("keyspan/usa28xa.fw"); 2740 MODULE_FIRMWARE("keyspan/usa28xb.fw"); 2741 MODULE_FIRMWARE("keyspan/usa19.fw"); 2742 MODULE_FIRMWARE("keyspan/usa19qi.fw"); 2743 MODULE_FIRMWARE("keyspan/mpr.fw"); 2744 MODULE_FIRMWARE("keyspan/usa19qw.fw"); 2745 MODULE_FIRMWARE("keyspan/usa18x.fw"); 2746 MODULE_FIRMWARE("keyspan/usa19w.fw"); 2747 MODULE_FIRMWARE("keyspan/usa49w.fw"); 2748 MODULE_FIRMWARE("keyspan/usa49wlc.fw"); 2749 2750 module_param(debug, bool, S_IRUGO | S_IWUSR); 2751 MODULE_PARM_DESC(debug, "Debug enabled or not"); 2752 2753