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