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