Pileus Git - ~andy/linux/blob - drivers/usb/serial/keyspan.c

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