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