drivers/usb/serial/keyspan.c

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