drivers/usb/serial/keyspan.c

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