drivers/usb/serial/keyspan.c

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