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