git.oblomov.eu Git - linux-2.6/blob - drivers/usb/serial/keyspan.c

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