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