drivers/usb/serial/keyspan.c

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