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