drivers/usb/serial/keyspan.c

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