drivers/usb/serial/keyspan.c

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