drivers/usb/serial/keyspan.c

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