drivers/usb/serial/keyspan.c

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