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