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