drivers/usb/serial/keyspan.c

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