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         data = urb->transfer_buffer;
 925
 926         if (urb != p_priv->in_urbs[p_priv->in_flip])
 927                 return;
 928
 929         do {
 930                 if (status) {
 931                         dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
 932                                 __func__, status, usb_pipeendpoint(urb->pipe));
 933                         return;
 934                 }
 935
 936                 port =  urb->context;
 937                 p_priv = usb_get_serial_port_data(port);
 938                 data = urb->transfer_buffer;
 939
 940                 if (urb->actual_length) {
 941                         tty_insert_flip_string(&port->port, data,
 942                                         urb->actual_length);
 943                         tty_flip_buffer_push(&port->port);
 944                 }
 945
 946                 /* Resubmit urb so we continue receiving */
 947                 err = usb_submit_urb(urb, GFP_ATOMIC);
 948                 if (err != 0)
 949                         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
 950                                                         __func__, err);
 951                 p_priv->in_flip ^= 1;
 952
 953                 urb = p_priv->in_urbs[p_priv->in_flip];
 954         } while (urb->status != -EINPROGRESS);
 955 }
 956
 957 static void     usa28_inack_callback(struct urb *urb)
 958 {
 959 }
 960
 961 static void     usa28_outcont_callback(struct urb *urb)
 962 {
 963         struct usb_serial_port *port;
 964         struct keyspan_port_private *p_priv;
 965
 966         port =  urb->context;
 967         p_priv = usb_get_serial_port_data(port);
 968
 969         if (p_priv->resend_cont) {
 970                 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
 971                 keyspan_usa28_send_setup(port->serial, port,
 972                                                 p_priv->resend_cont - 1);
 973         }
 974 }
 975
 976 static void     usa28_instat_callback(struct urb *urb)
 977 {
 978         int                                     err;
 979         unsigned char                           *data = urb->transfer_buffer;
 980         struct keyspan_usa28_portStatusMessage  *msg;
 981         struct usb_serial                       *serial;
 982         struct usb_serial_port                  *port;
 983         struct keyspan_port_private             *p_priv;
 984         int old_dcd_state;
 985         int status = urb->status;
 986
 987         serial =  urb->context;
 988
 989         if (status) {
 990                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
 991                                 __func__, status);
 992                 return;
 993         }
 994
 995         if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
 996                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
 997                 goto exit;
 998         }
 999
1000         msg = (struct keyspan_usa28_portStatusMessage *)data;
1001
1002         /* Check port number from message and retrieve private data */
1003         if (msg->port >= serial->num_ports) {
1004                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1005                 goto exit;
1006         }
1007         port = serial->port[msg->port];
1008         p_priv = usb_get_serial_port_data(port);
1009         if (!p_priv)
1010                 goto resubmit;
1011
1012         /* Update handshaking pin state information */
1013         old_dcd_state = p_priv->dcd_state;
1014         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1015         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1016         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1017         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1018
1019         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1020                 tty_port_tty_hangup(&port->port, true);
1021 resubmit:
1022                 /* Resubmit urb so we continue receiving */
1023         err = usb_submit_urb(urb, GFP_ATOMIC);
1024         if (err != 0)
1025                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1026 exit: ;
1027 }
1028
1029 static void     usa28_glocont_callback(struct urb *urb)
1030 {
1031 }
1032
1033
1034 static void     usa49_glocont_callback(struct urb *urb)
1035 {
1036         struct usb_serial *serial;
1037         struct usb_serial_port *port;
1038         struct keyspan_port_private *p_priv;
1039         int i;
1040
1041         serial =  urb->context;
1042         for (i = 0; i < serial->num_ports; ++i) {
1043                 port = serial->port[i];
1044                 p_priv = usb_get_serial_port_data(port);
1045                 if (!p_priv)
1046                         continue;
1047
1048                 if (p_priv->resend_cont) {
1049                         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1050                         keyspan_usa49_send_setup(serial, port,
1051                                                 p_priv->resend_cont - 1);
1052                         break;
1053                 }
1054         }
1055 }
1056
1057         /* This is actually called glostat in the Keyspan
1058            doco */
1059 static void     usa49_instat_callback(struct urb *urb)
1060 {
1061         int                                     err;
1062         unsigned char                           *data = urb->transfer_buffer;
1063         struct keyspan_usa49_portStatusMessage  *msg;
1064         struct usb_serial                       *serial;
1065         struct usb_serial_port                  *port;
1066         struct keyspan_port_private             *p_priv;
1067         int old_dcd_state;
1068         int status = urb->status;
1069
1070         serial =  urb->context;
1071
1072         if (status) {
1073                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1074                                 __func__, status);
1075                 return;
1076         }
1077
1078         if (urb->actual_length !=
1079                         sizeof(struct keyspan_usa49_portStatusMessage)) {
1080                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1081                 goto exit;
1082         }
1083
1084         msg = (struct keyspan_usa49_portStatusMessage *)data;
1085
1086         /* Check port number from message and retrieve private data */
1087         if (msg->portNumber >= serial->num_ports) {
1088                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1089                         __func__, msg->portNumber);
1090                 goto exit;
1091         }
1092         port = serial->port[msg->portNumber];
1093         p_priv = usb_get_serial_port_data(port);
1094         if (!p_priv)
1095                 goto resubmit;
1096
1097         /* Update handshaking pin state information */
1098         old_dcd_state = p_priv->dcd_state;
1099         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1100         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1101         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1102         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1103
1104         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1105                 tty_port_tty_hangup(&port->port, true);
1106 resubmit:
1107         /* Resubmit urb so we continue receiving */
1108         err = usb_submit_urb(urb, GFP_ATOMIC);
1109         if (err != 0)
1110                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1111 exit:   ;
1112 }
1113
1114 static void     usa49_inack_callback(struct urb *urb)
1115 {
1116 }
1117
1118 static void     usa49_indat_callback(struct urb *urb)
1119 {
1120         int                     i, err;
1121         int                     endpoint;
1122         struct usb_serial_port  *port;
1123         unsigned char           *data = urb->transfer_buffer;
1124         int status = urb->status;
1125
1126         endpoint = usb_pipeendpoint(urb->pipe);
1127
1128         if (status) {
1129                 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1130                         __func__, status, endpoint);
1131                 return;
1132         }
1133
1134         port =  urb->context;
1135         if (urb->actual_length) {
1136                 /* 0x80 bit is error flag */
1137                 if ((data[0] & 0x80) == 0) {
1138                         /* no error on any byte */
1139                         tty_insert_flip_string(&port->port, data + 1,
1140                                                 urb->actual_length - 1);
1141                 } else {
1142                         /* some bytes had errors, every byte has status */
1143                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
1144                                 int stat = data[i];
1145                                 int flag = TTY_NORMAL;
1146
1147                                 if (stat & RXERROR_OVERRUN) {
1148                                         tty_insert_flip_char(&port->port, 0,
1149                                                                 TTY_OVERRUN);
1150                                 }
1151                                 /* XXX should handle break (0x10) */
1152                                 if (stat & RXERROR_PARITY)
1153                                         flag = TTY_PARITY;
1154                                 else if (stat & RXERROR_FRAMING)
1155                                         flag = TTY_FRAME;
1156
1157                                 tty_insert_flip_char(&port->port, data[i+1],
1158                                                 flag);
1159                         }
1160                 }
1161                 tty_flip_buffer_push(&port->port);
1162         }
1163
1164         /* Resubmit urb so we continue receiving */
1165         err = usb_submit_urb(urb, GFP_ATOMIC);
1166         if (err != 0)
1167                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1168 }
1169
1170 static void usa49wg_indat_callback(struct urb *urb)
1171 {
1172         int                     i, len, x, err;
1173         struct usb_serial       *serial;
1174         struct usb_serial_port  *port;
1175         unsigned char           *data = urb->transfer_buffer;
1176         int status = urb->status;
1177
1178         serial = urb->context;
1179
1180         if (status) {
1181                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1182                                 __func__, status);
1183                 return;
1184         }
1185
1186         /* inbound data is in the form P#, len, status, data */
1187         i = 0;
1188         len = 0;
1189
1190         while (i < urb->actual_length) {
1191
1192                 /* Check port number from message */
1193                 if (data[i] >= serial->num_ports) {
1194                         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1195                                 __func__, data[i]);
1196                         return;
1197                 }
1198                 port = serial->port[data[i++]];
1199                 len = data[i++];
1200
1201                 /* 0x80 bit is error flag */
1202                 if ((data[i] & 0x80) == 0) {
1203                         /* no error on any byte */
1204                         i++;
1205                         for (x = 1; x < len && i < urb->actual_length; ++x)
1206                                 tty_insert_flip_char(&port->port,
1207                                                 data[i++], 0);
1208                 } else {
1209                         /*
1210                          * some bytes had errors, every byte has status
1211                          */
1212                         for (x = 0; x + 1 < len &&
1213                                     i + 1 < urb->actual_length; x += 2) {
1214                                 int stat = data[i];
1215                                 int flag = TTY_NORMAL;
1216
1217                                 if (stat & RXERROR_OVERRUN) {
1218                                         tty_insert_flip_char(&port->port, 0,
1219                                                                 TTY_OVERRUN);
1220                                 }
1221                                 /* XXX should handle break (0x10) */
1222                                 if (stat & RXERROR_PARITY)
1223                                         flag = TTY_PARITY;
1224                                 else if (stat & RXERROR_FRAMING)
1225                                         flag = TTY_FRAME;
1226
1227                                 tty_insert_flip_char(&port->port, data[i+1],
1228                                                      flag);
1229                                 i += 2;
1230                         }
1231                 }
1232                 tty_flip_buffer_push(&port->port);
1233         }
1234
1235         /* Resubmit urb so we continue receiving */
1236         err = usb_submit_urb(urb, GFP_ATOMIC);
1237         if (err != 0)
1238                 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1239 }
1240
1241 /* not used, usa-49 doesn't have per-port control endpoints */
1242 static void usa49_outcont_callback(struct urb *urb)
1243 {
1244 }
1245
1246 static void usa90_indat_callback(struct urb *urb)
1247 {
1248         int                     i, err;
1249         int                     endpoint;
1250         struct usb_serial_port  *port;
1251         struct keyspan_port_private             *p_priv;
1252         unsigned char           *data = urb->transfer_buffer;
1253         int status = urb->status;
1254
1255         endpoint = usb_pipeendpoint(urb->pipe);
1256
1257         if (status) {
1258                 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1259                         __func__, status, endpoint);
1260                 return;
1261         }
1262
1263         port =  urb->context;
1264         p_priv = usb_get_serial_port_data(port);
1265
1266         if (urb->actual_length) {
1267                 /* if current mode is DMA, looks like usa28 format
1268                    otherwise looks like usa26 data format */
1269
1270                 if (p_priv->baud > 57600)
1271                         tty_insert_flip_string(&port->port, data,
1272                                         urb->actual_length);
1273                 else {
1274                         /* 0x80 bit is error flag */
1275                         if ((data[0] & 0x80) == 0) {
1276                                 /* no errors on individual bytes, only
1277                                    possible overrun err*/
1278                                 if (data[0] & RXERROR_OVERRUN) {
1279                                         tty_insert_flip_char(&port->port, 0,
1280                                                                 TTY_OVERRUN);
1281                                 }
1282                                 for (i = 1; i < urb->actual_length ; ++i)
1283                                         tty_insert_flip_char(&port->port,
1284                                                         data[i], TTY_NORMAL);
1285                         }  else {
1286                         /* some bytes had errors, every byte has status */
1287                                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
1288                                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1289                                         int stat = data[i];
1290                                         int flag = TTY_NORMAL;
1291
1292                                         if (stat & RXERROR_OVERRUN) {
1293                                                 tty_insert_flip_char(
1294                                                                 &port->port, 0,
1295                                                                 TTY_OVERRUN);
1296                                         }
1297                                         /* XXX should handle break (0x10) */
1298                                         if (stat & RXERROR_PARITY)
1299                                                 flag = TTY_PARITY;
1300                                         else if (stat & RXERROR_FRAMING)
1301                                                 flag = TTY_FRAME;
1302
1303                                         tty_insert_flip_char(&port->port,
1304                                                         data[i+1], flag);
1305                                 }
1306                         }
1307                 }
1308                 tty_flip_buffer_push(&port->port);
1309         }
1310
1311         /* Resubmit urb so we continue receiving */
1312         err = usb_submit_urb(urb, GFP_ATOMIC);
1313         if (err != 0)
1314                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1315 }
1316
1317
1318 static void     usa90_instat_callback(struct urb *urb)
1319 {
1320         unsigned char                           *data = urb->transfer_buffer;
1321         struct keyspan_usa90_portStatusMessage  *msg;
1322         struct usb_serial                       *serial;
1323         struct usb_serial_port                  *port;
1324         struct keyspan_port_private             *p_priv;
1325         int old_dcd_state, err;
1326         int status = urb->status;
1327
1328         serial =  urb->context;
1329
1330         if (status) {
1331                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1332                                 __func__, status);
1333                 return;
1334         }
1335         if (urb->actual_length < 14) {
1336                 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
1337                 goto exit;
1338         }
1339
1340         msg = (struct keyspan_usa90_portStatusMessage *)data;
1341
1342         /* Now do something useful with the data */
1343
1344         port = serial->port[0];
1345         p_priv = usb_get_serial_port_data(port);
1346         if (!p_priv)
1347                 goto resubmit;
1348
1349         /* Update handshaking pin state information */
1350         old_dcd_state = p_priv->dcd_state;
1351         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1352         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1353         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1354         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1355
1356         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1357                 tty_port_tty_hangup(&port->port, true);
1358 resubmit:
1359         /* Resubmit urb so we continue receiving */
1360         err = usb_submit_urb(urb, GFP_ATOMIC);
1361         if (err != 0)
1362                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1363 exit:
1364         ;
1365 }
1366
1367 static void     usa90_outcont_callback(struct urb *urb)
1368 {
1369         struct usb_serial_port *port;
1370         struct keyspan_port_private *p_priv;
1371
1372         port =  urb->context;
1373         p_priv = usb_get_serial_port_data(port);
1374
1375         if (p_priv->resend_cont) {
1376                 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
1377                 keyspan_usa90_send_setup(port->serial, port,
1378                                                 p_priv->resend_cont - 1);
1379         }
1380 }
1381
1382 /* Status messages from the 28xg */
1383 static void     usa67_instat_callback(struct urb *urb)
1384 {
1385         int                                     err;
1386         unsigned char                           *data = urb->transfer_buffer;
1387         struct keyspan_usa67_portStatusMessage  *msg;
1388         struct usb_serial                       *serial;
1389         struct usb_serial_port                  *port;
1390         struct keyspan_port_private             *p_priv;
1391         int old_dcd_state;
1392         int status = urb->status;
1393
1394         serial = urb->context;
1395
1396         if (status) {
1397                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1398                                 __func__, status);
1399                 return;
1400         }
1401
1402         if (urb->actual_length !=
1403                         sizeof(struct keyspan_usa67_portStatusMessage)) {
1404                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1405                 return;
1406         }
1407
1408
1409         /* Now do something useful with the data */
1410         msg = (struct keyspan_usa67_portStatusMessage *)data;
1411
1412         /* Check port number from message and retrieve private data */
1413         if (msg->port >= serial->num_ports) {
1414                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1415                 return;
1416         }
1417
1418         port = serial->port[msg->port];
1419         p_priv = usb_get_serial_port_data(port);
1420         if (!p_priv)
1421                 goto resubmit;
1422
1423         /* Update handshaking pin state information */
1424         old_dcd_state = p_priv->dcd_state;
1425         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
1426         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
1427
1428         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1429                 tty_port_tty_hangup(&port->port, true);
1430 resubmit:
1431         /* Resubmit urb so we continue receiving */
1432         err = usb_submit_urb(urb, GFP_ATOMIC);
1433         if (err != 0)
1434                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1435 }
1436
1437 static void usa67_glocont_callback(struct urb *urb)
1438 {
1439         struct usb_serial *serial;
1440         struct usb_serial_port *port;
1441         struct keyspan_port_private *p_priv;
1442         int i;
1443
1444         serial = urb->context;
1445         for (i = 0; i < serial->num_ports; ++i) {
1446                 port = serial->port[i];
1447                 p_priv = usb_get_serial_port_data(port);
1448                 if (!p_priv)
1449                         continue;
1450
1451                 if (p_priv->resend_cont) {
1452                         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1453                         keyspan_usa67_send_setup(serial, port,
1454                                                 p_priv->resend_cont - 1);
1455                         break;
1456                 }
1457         }
1458 }
1459
1460 static unsigned int keyspan_write_room(struct tty_struct *tty)
1461 {
1462         struct usb_serial_port *port = tty->driver_data;
1463         struct keyspan_port_private     *p_priv;
1464         const struct keyspan_device_details     *d_details;
1465         int                             flip;
1466         unsigned int                    data_len;
1467         struct urb                      *this_urb;
1468
1469         p_priv = usb_get_serial_port_data(port);
1470         d_details = p_priv->device_details;
1471
1472         /* FIXME: locking */
1473         if (d_details->msg_format == msg_usa90)
1474                 data_len = 64;
1475         else
1476                 data_len = 63;
1477
1478         flip = p_priv->out_flip;
1479
1480         /* Check both endpoints to see if any are available. */
1481         this_urb = p_priv->out_urbs[flip];
1482         if (this_urb != NULL) {
1483                 if (this_urb->status != -EINPROGRESS)
1484                         return data_len;
1485                 flip = (flip + 1) & d_details->outdat_endp_flip;
1486                 this_urb = p_priv->out_urbs[flip];
1487                 if (this_urb != NULL) {
1488                         if (this_urb->status != -EINPROGRESS)
1489                                 return data_len;
1490                 }
1491         }
1492         return 0;
1493 }
1494
1495
1496 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1497 {
1498         struct keyspan_port_private     *p_priv;
1499         const struct keyspan_device_details     *d_details;
1500         int                             i, err;
1501         int                             baud_rate, device_port;
1502         struct urb                      *urb;
1503         unsigned int                    cflag = 0;
1504
1505         p_priv = usb_get_serial_port_data(port);
1506         d_details = p_priv->device_details;
1507
1508         /* Set some sane defaults */
1509         p_priv->rts_state = 1;
1510         p_priv->dtr_state = 1;
1511         p_priv->baud = 9600;
1512
1513         /* force baud and lcr to be set on open */
1514         p_priv->old_baud = 0;
1515         p_priv->old_cflag = 0;
1516
1517         p_priv->out_flip = 0;
1518         p_priv->in_flip = 0;
1519
1520         /* Reset low level data toggle and start reading from endpoints */
1521         for (i = 0; i < 2; i++) {
1522                 urb = p_priv->in_urbs[i];
1523                 if (urb == NULL)
1524                         continue;
1525
1526                 /* make sure endpoint data toggle is synchronized
1527                    with the device */
1528                 usb_clear_halt(urb->dev, urb->pipe);
1529                 err = usb_submit_urb(urb, GFP_KERNEL);
1530                 if (err != 0)
1531                         dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1532         }
1533
1534         /* Reset low level data toggle on out endpoints */
1535         for (i = 0; i < 2; i++) {
1536                 urb = p_priv->out_urbs[i];
1537                 if (urb == NULL)
1538                         continue;
1539                 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1540                                                 usb_pipeout(urb->pipe), 0); */
1541         }
1542
1543         /* get the terminal config for the setup message now so we don't
1544          * need to send 2 of them */
1545
1546         device_port = port->port_number;
1547         if (tty) {
1548                 cflag = tty->termios.c_cflag;
1549                 /* Baud rate calculation takes baud rate as an integer
1550                    so other rates can be generated if desired. */
1551                 baud_rate = tty_get_baud_rate(tty);
1552                 /* If no match or invalid, leave as default */
1553                 if (baud_rate >= 0
1554                     && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1555                                         NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1556                         p_priv->baud = baud_rate;
1557                 }
1558         }
1559         /* set CTS/RTS handshake etc. */
1560         p_priv->cflag = cflag;
1561         p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1562
1563         keyspan_send_setup(port, 1);
1564         /* mdelay(100); */
1565         /* keyspan_set_termios(port, NULL); */
1566
1567         return 0;
1568 }
1569
1570 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1571 {
1572         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1573
1574         p_priv->rts_state = on;
1575         p_priv->dtr_state = on;
1576         keyspan_send_setup(port, 0);
1577 }
1578
1579 static void keyspan_close(struct usb_serial_port *port)
1580 {
1581         int                     i;
1582         struct keyspan_port_private     *p_priv;
1583
1584         p_priv = usb_get_serial_port_data(port);
1585
1586         p_priv->rts_state = 0;
1587         p_priv->dtr_state = 0;
1588
1589         keyspan_send_setup(port, 2);
1590         /* pilot-xfer seems to work best with this delay */
1591         mdelay(100);
1592
1593         p_priv->out_flip = 0;
1594         p_priv->in_flip = 0;
1595
1596         usb_kill_urb(p_priv->inack_urb);
1597         for (i = 0; i < 2; i++) {
1598                 usb_kill_urb(p_priv->in_urbs[i]);
1599                 usb_kill_urb(p_priv->out_urbs[i]);
1600         }
1601 }
1602
1603 /* download the firmware to a pre-renumeration device */
1604 static int keyspan_fake_startup(struct usb_serial *serial)
1605 {
1606         char    *fw_name;
1607
1608         dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1609                 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1610                 le16_to_cpu(serial->dev->descriptor.idProduct));
1611
1612         if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1613                                                                 != 0x8000) {
1614                 dev_dbg(&serial->dev->dev, "Firmware already loaded.  Quitting.\n");
1615                 return 1;
1616         }
1617
1618                 /* Select firmware image on the basis of idProduct */
1619         switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1620         case keyspan_usa28_pre_product_id:
1621                 fw_name = "/*(DEBLOBBED)*/";
1622                 break;
1623
1624         case keyspan_usa28x_pre_product_id:
1625                 fw_name = "/*(DEBLOBBED)*/";
1626                 break;
1627
1628         case keyspan_usa28xa_pre_product_id:
1629                 fw_name = "/*(DEBLOBBED)*/";
1630                 break;
1631
1632         case keyspan_usa28xb_pre_product_id:
1633                 fw_name = "/*(DEBLOBBED)*/";
1634                 break;
1635
1636         case keyspan_usa19_pre_product_id:
1637                 fw_name = "/*(DEBLOBBED)*/";
1638                 break;
1639
1640         case keyspan_usa19qi_pre_product_id:
1641                 fw_name = "/*(DEBLOBBED)*/";
1642                 break;
1643
1644         case keyspan_mpr_pre_product_id:
1645                 fw_name = "/*(DEBLOBBED)*/";
1646                 break;
1647
1648         case keyspan_usa19qw_pre_product_id:
1649                 fw_name = "/*(DEBLOBBED)*/";
1650                 break;
1651
1652         case keyspan_usa18x_pre_product_id:
1653                 fw_name = "/*(DEBLOBBED)*/";
1654                 break;
1655
1656         case keyspan_usa19w_pre_product_id:
1657                 fw_name = "/*(DEBLOBBED)*/";
1658                 break;
1659
1660         case keyspan_usa49w_pre_product_id:
1661                 fw_name = "/*(DEBLOBBED)*/";
1662                 break;
1663
1664         case keyspan_usa49wlc_pre_product_id:
1665                 fw_name = "/*(DEBLOBBED)*/";
1666                 break;
1667
1668         default:
1669                 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1670                         le16_to_cpu(serial->dev->descriptor.idProduct));
1671                 return 1;
1672         }
1673
1674         dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1675
1676         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1677                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1678                         fw_name);
1679                 return -ENOENT;
1680         }
1681
1682         /* after downloading firmware Renumeration will occur in a
1683           moment and the new device will bind to the real driver */
1684
1685         /* we don't want this device to have a driver assigned to it. */
1686         return 1;
1687 }
1688
1689 /* Helper functions used by keyspan_setup_urbs */
1690 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1691                                                      int endpoint)
1692 {
1693         struct usb_host_interface *iface_desc;
1694         struct usb_endpoint_descriptor *ep;
1695         int i;
1696
1697         iface_desc = serial->interface->cur_altsetting;
1698         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1699                 ep = &iface_desc->endpoint[i].desc;
1700                 if (ep->bEndpointAddress == endpoint)
1701                         return ep;
1702         }
1703         dev_warn(&serial->interface->dev, "found no endpoint descriptor for endpoint %x\n",
1704                         endpoint);
1705         return NULL;
1706 }
1707
1708 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1709                                       int dir, void *ctx, char *buf, int len,
1710                                       void (*callback)(struct urb *))
1711 {
1712         struct urb *urb;
1713         struct usb_endpoint_descriptor const *ep_desc;
1714         char const *ep_type_name;
1715
1716         if (endpoint == -1)
1717                 return NULL;            /* endpoint not needed */
1718
1719         dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %x\n",
1720                         __func__, endpoint);
1721         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
1722         if (!urb)
1723                 return NULL;
1724
1725         if (endpoint == 0) {
1726                 /* control EP filled in when used */
1727                 return urb;
1728         }
1729
1730         ep_desc = find_ep(serial, endpoint);
1731         if (!ep_desc) {
1732                 usb_free_urb(urb);
1733                 return NULL;
1734         }
1735         if (usb_endpoint_xfer_int(ep_desc)) {
1736                 ep_type_name = "INT";
1737                 usb_fill_int_urb(urb, serial->dev,
1738                                  usb_sndintpipe(serial->dev, endpoint) | dir,
1739                                  buf, len, callback, ctx,
1740                                  ep_desc->bInterval);
1741         } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1742                 ep_type_name = "BULK";
1743                 usb_fill_bulk_urb(urb, serial->dev,
1744                                   usb_sndbulkpipe(serial->dev, endpoint) | dir,
1745                                   buf, len, callback, ctx);
1746         } else {
1747                 dev_warn(&serial->interface->dev,
1748                          "unsupported endpoint type %x\n",
1749                          usb_endpoint_type(ep_desc));
1750                 usb_free_urb(urb);
1751                 return NULL;
1752         }
1753
1754         dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1755             __func__, urb, ep_type_name, endpoint);
1756         return urb;
1757 }
1758
1759 static struct callbacks {
1760         void    (*instat_callback)(struct urb *);
1761         void    (*glocont_callback)(struct urb *);
1762         void    (*indat_callback)(struct urb *);
1763         void    (*outdat_callback)(struct urb *);
1764         void    (*inack_callback)(struct urb *);
1765         void    (*outcont_callback)(struct urb *);
1766 } keyspan_callbacks[] = {
1767         {
1768                 /* msg_usa26 callbacks */
1769                 .instat_callback =      usa26_instat_callback,
1770                 .glocont_callback =     usa26_glocont_callback,
1771                 .indat_callback =       usa26_indat_callback,
1772                 .outdat_callback =      usa2x_outdat_callback,
1773                 .inack_callback =       usa26_inack_callback,
1774                 .outcont_callback =     usa26_outcont_callback,
1775         }, {
1776                 /* msg_usa28 callbacks */
1777                 .instat_callback =      usa28_instat_callback,
1778                 .glocont_callback =     usa28_glocont_callback,
1779                 .indat_callback =       usa28_indat_callback,
1780                 .outdat_callback =      usa2x_outdat_callback,
1781                 .inack_callback =       usa28_inack_callback,
1782                 .outcont_callback =     usa28_outcont_callback,
1783         }, {
1784                 /* msg_usa49 callbacks */
1785                 .instat_callback =      usa49_instat_callback,
1786                 .glocont_callback =     usa49_glocont_callback,
1787                 .indat_callback =       usa49_indat_callback,
1788                 .outdat_callback =      usa2x_outdat_callback,
1789                 .inack_callback =       usa49_inack_callback,
1790                 .outcont_callback =     usa49_outcont_callback,
1791         }, {
1792                 /* msg_usa90 callbacks */
1793                 .instat_callback =      usa90_instat_callback,
1794                 .glocont_callback =     usa28_glocont_callback,
1795                 .indat_callback =       usa90_indat_callback,
1796                 .outdat_callback =      usa2x_outdat_callback,
1797                 .inack_callback =       usa28_inack_callback,
1798                 .outcont_callback =     usa90_outcont_callback,
1799         }, {
1800                 /* msg_usa67 callbacks */
1801                 .instat_callback =      usa67_instat_callback,
1802                 .glocont_callback =     usa67_glocont_callback,
1803                 .indat_callback =       usa26_indat_callback,
1804                 .outdat_callback =      usa2x_outdat_callback,
1805                 .inack_callback =       usa26_inack_callback,
1806                 .outcont_callback =     usa26_outcont_callback,
1807         }
1808 };
1809
1810         /* Generic setup urbs function that uses
1811            data in device_details */
1812 static void keyspan_setup_urbs(struct usb_serial *serial)
1813 {
1814         struct keyspan_serial_private   *s_priv;
1815         const struct keyspan_device_details     *d_details;
1816         struct callbacks                *cback;
1817
1818         s_priv = usb_get_serial_data(serial);
1819         d_details = s_priv->device_details;
1820
1821         /* Setup values for the various callback routines */
1822         cback = &keyspan_callbacks[d_details->msg_format];
1823
1824         /* Allocate and set up urbs for each one that is in use,
1825            starting with instat endpoints */
1826         s_priv->instat_urb = keyspan_setup_urb
1827                 (serial, d_details->instat_endpoint, USB_DIR_IN,
1828                  serial, s_priv->instat_buf, INSTAT_BUFLEN,
1829                  cback->instat_callback);
1830
1831         s_priv->indat_urb = keyspan_setup_urb
1832                 (serial, d_details->indat_endpoint, USB_DIR_IN,
1833                  serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1834                  usa49wg_indat_callback);
1835
1836         s_priv->glocont_urb = keyspan_setup_urb
1837                 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1838                  serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1839                  cback->glocont_callback);
1840 }
1841
1842 /* usa19 function doesn't require prescaler */
1843 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1844                                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1845                                    u8 *rate_low, u8 *prescaler, int portnum)
1846 {
1847         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1848                 div,    /* divisor */
1849                 cnt;    /* inverse of divisor (programmed into 8051) */
1850
1851         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1852
1853         /* prevent divide by zero...  */
1854         b16 = baud_rate * 16L;
1855         if (b16 == 0)
1856                 return KEYSPAN_INVALID_BAUD_RATE;
1857         /* Any "standard" rate over 57k6 is marginal on the USA-19
1858            as we run out of divisor resolution. */
1859         if (baud_rate > 57600)
1860                 return KEYSPAN_INVALID_BAUD_RATE;
1861
1862         /* calculate the divisor and the counter (its inverse) */
1863         div = baudclk / b16;
1864         if (div == 0)
1865                 return KEYSPAN_INVALID_BAUD_RATE;
1866         else
1867                 cnt = 0 - div;
1868
1869         if (div > 0xffff)
1870                 return KEYSPAN_INVALID_BAUD_RATE;
1871
1872         /* return the counter values if non-null */
1873         if (rate_low)
1874                 *rate_low = (u8) (cnt & 0xff);
1875         if (rate_hi)
1876                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1877         if (rate_low && rate_hi)
1878                 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1879                                 __func__, baud_rate, *rate_hi, *rate_low);
1880         return KEYSPAN_BAUD_RATE_OK;
1881 }
1882
1883 /* usa19hs function doesn't require prescaler */
1884 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1885                                      u32 baud_rate, u32 baudclk, u8 *rate_hi,
1886                                      u8 *rate_low, u8 *prescaler, int portnum)
1887 {
1888         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1889                         div;    /* divisor */
1890
1891         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1892
1893         /* prevent divide by zero...  */
1894         b16 = baud_rate * 16L;
1895         if (b16 == 0)
1896                 return KEYSPAN_INVALID_BAUD_RATE;
1897
1898         /* calculate the divisor */
1899         div = baudclk / b16;
1900         if (div == 0)
1901                 return KEYSPAN_INVALID_BAUD_RATE;
1902
1903         if (div > 0xffff)
1904                 return KEYSPAN_INVALID_BAUD_RATE;
1905
1906         /* return the counter values if non-null */
1907         if (rate_low)
1908                 *rate_low = (u8) (div & 0xff);
1909
1910         if (rate_hi)
1911                 *rate_hi = (u8) ((div >> 8) & 0xff);
1912
1913         if (rate_low && rate_hi)
1914                 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1915                         __func__, baud_rate, *rate_hi, *rate_low);
1916
1917         return KEYSPAN_BAUD_RATE_OK;
1918 }
1919
1920 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1921                                     u32 baud_rate, u32 baudclk, u8 *rate_hi,
1922                                     u8 *rate_low, u8 *prescaler, int portnum)
1923 {
1924         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1925                 clk,    /* clock with 13/8 prescaler */
1926                 div,    /* divisor using 13/8 prescaler */
1927                 res,    /* resulting baud rate using 13/8 prescaler */
1928                 diff,   /* error using 13/8 prescaler */
1929                 smallest_diff;
1930         u8      best_prescaler;
1931         int     i;
1932
1933         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1934
1935         /* prevent divide by zero */
1936         b16 = baud_rate * 16L;
1937         if (b16 == 0)
1938                 return KEYSPAN_INVALID_BAUD_RATE;
1939
1940         /* Calculate prescaler by trying them all and looking
1941            for best fit */
1942
1943         /* start with largest possible difference */
1944         smallest_diff = 0xffffffff;
1945
1946                 /* 0 is an invalid prescaler, used as a flag */
1947         best_prescaler = 0;
1948
1949         for (i = 8; i <= 0xff; ++i) {
1950                 clk = (baudclk * 8) / (u32) i;
1951
1952                 div = clk / b16;
1953                 if (div == 0)
1954                         continue;
1955
1956                 res = clk / div;
1957                 diff = (res > b16) ? (res-b16) : (b16-res);
1958
1959                 if (diff < smallest_diff) {
1960                         best_prescaler = i;
1961                         smallest_diff = diff;
1962                 }
1963         }
1964
1965         if (best_prescaler == 0)
1966                 return KEYSPAN_INVALID_BAUD_RATE;
1967
1968         clk = (baudclk * 8) / (u32) best_prescaler;
1969         div = clk / b16;
1970
1971         /* return the divisor and prescaler if non-null */
1972         if (rate_low)
1973                 *rate_low = (u8) (div & 0xff);
1974         if (rate_hi)
1975                 *rate_hi = (u8) ((div >> 8) & 0xff);
1976         if (prescaler) {
1977                 *prescaler = best_prescaler;
1978                 /*  dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1979         }
1980         return KEYSPAN_BAUD_RATE_OK;
1981 }
1982
1983         /* USA-28 supports different maximum baud rates on each port */
1984 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1985                                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1986                                    u8 *rate_low, u8 *prescaler, int portnum)
1987 {
1988         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1989                 div,    /* divisor */
1990                 cnt;    /* inverse of divisor (programmed into 8051) */
1991
1992         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1993
1994                 /* prevent divide by zero */
1995         b16 = baud_rate * 16L;
1996         if (b16 == 0)
1997                 return KEYSPAN_INVALID_BAUD_RATE;
1998
1999         /* calculate the divisor and the counter (its inverse) */
2000         div = KEYSPAN_USA28_BAUDCLK / b16;
2001         if (div == 0)
2002                 return KEYSPAN_INVALID_BAUD_RATE;
2003         else
2004                 cnt = 0 - div;
2005
2006         /* check for out of range, based on portnum,
2007            and return result */
2008         if (portnum == 0) {
2009                 if (div > 0xffff)
2010                         return KEYSPAN_INVALID_BAUD_RATE;
2011         } else {
2012                 if (portnum == 1) {
2013                         if (div > 0xff)
2014                                 return KEYSPAN_INVALID_BAUD_RATE;
2015                 } else
2016                         return KEYSPAN_INVALID_BAUD_RATE;
2017         }
2018
2019                 /* return the counter values if not NULL
2020                    (port 1 will ignore retHi) */
2021         if (rate_low)
2022                 *rate_low = (u8) (cnt & 0xff);
2023         if (rate_hi)
2024                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
2025         dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
2026         return KEYSPAN_BAUD_RATE_OK;
2027 }
2028
2029 static int keyspan_usa26_send_setup(struct usb_serial *serial,
2030                                     struct usb_serial_port *port,
2031                                     int reset_port)
2032 {
2033         struct keyspan_usa26_portControlMessage msg;
2034         struct keyspan_serial_private           *s_priv;
2035         struct keyspan_port_private             *p_priv;
2036         const struct keyspan_device_details     *d_details;
2037         struct urb                              *this_urb;
2038         int                                     device_port, err;
2039
2040         dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
2041
2042         s_priv = usb_get_serial_data(serial);
2043         p_priv = usb_get_serial_port_data(port);
2044         d_details = s_priv->device_details;
2045         device_port = port->port_number;
2046
2047         this_urb = p_priv->outcont_urb;
2048
2049                 /* Make sure we have an urb then send the message */
2050         if (this_urb == NULL) {
2051                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2052                 return -1;
2053         }
2054
2055         dev_dbg(&port->dev, "%s - endpoint %x\n",
2056                         __func__, usb_pipeendpoint(this_urb->pipe));
2057
2058         /* Save reset port val for resend.
2059            Don't overwrite resend for open/close condition. */
2060         if ((reset_port + 1) > p_priv->resend_cont)
2061                 p_priv->resend_cont = reset_port + 1;
2062         if (this_urb->status == -EINPROGRESS) {
2063                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2064                 mdelay(5);
2065                 return -1;
2066         }
2067
2068         memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
2069
2070         /* Only set baud rate if it's changed */
2071         if (p_priv->old_baud != p_priv->baud) {
2072                 p_priv->old_baud = p_priv->baud;
2073                 msg.setClocking = 0xff;
2074                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2075                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
2076                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2077                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2078                                 __func__, p_priv->baud);
2079                         msg.baudLo = 0;
2080                         msg.baudHi = 125;       /* Values for 9600 baud */
2081                         msg.prescaler = 10;
2082                 }
2083                 msg.setPrescaler = 0xff;
2084         }
2085
2086         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2087         switch (p_priv->cflag & CSIZE) {
2088         case CS5:
2089                 msg.lcr |= USA_DATABITS_5;
2090                 break;
2091         case CS6:
2092                 msg.lcr |= USA_DATABITS_6;
2093                 break;
2094         case CS7:
2095                 msg.lcr |= USA_DATABITS_7;
2096                 break;
2097         case CS8:
2098                 msg.lcr |= USA_DATABITS_8;
2099                 break;
2100         }
2101         if (p_priv->cflag & PARENB) {
2102                 /* note USA_PARITY_NONE == 0 */
2103                 msg.lcr |= (p_priv->cflag & PARODD) ?
2104                         USA_PARITY_ODD : USA_PARITY_EVEN;
2105         }
2106         msg.setLcr = 0xff;
2107
2108         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2109         msg.xonFlowControl = 0;
2110         msg.setFlowControl = 0xff;
2111         msg.forwardingLength = 16;
2112         msg.xonChar = 17;
2113         msg.xoffChar = 19;
2114
2115         /* Opening port */
2116         if (reset_port == 1) {
2117                 msg._txOn = 1;
2118                 msg._txOff = 0;
2119                 msg.txFlush = 0;
2120                 msg.txBreak = 0;
2121                 msg.rxOn = 1;
2122                 msg.rxOff = 0;
2123                 msg.rxFlush = 1;
2124                 msg.rxForward = 0;
2125                 msg.returnStatus = 0;
2126                 msg.resetDataToggle = 0xff;
2127         }
2128
2129         /* Closing port */
2130         else if (reset_port == 2) {
2131                 msg._txOn = 0;
2132                 msg._txOff = 1;
2133                 msg.txFlush = 0;
2134                 msg.txBreak = 0;
2135                 msg.rxOn = 0;
2136                 msg.rxOff = 1;
2137                 msg.rxFlush = 1;
2138                 msg.rxForward = 0;
2139                 msg.returnStatus = 0;
2140                 msg.resetDataToggle = 0;
2141         }
2142
2143         /* Sending intermediate configs */
2144         else {
2145                 msg._txOn = (!p_priv->break_on);
2146                 msg._txOff = 0;
2147                 msg.txFlush = 0;
2148                 msg.txBreak = (p_priv->break_on);
2149                 msg.rxOn = 0;
2150                 msg.rxOff = 0;
2151                 msg.rxFlush = 0;
2152                 msg.rxForward = 0;
2153                 msg.returnStatus = 0;
2154                 msg.resetDataToggle = 0x0;
2155         }
2156
2157         /* Do handshaking outputs */
2158         msg.setTxTriState_setRts = 0xff;
2159         msg.txTriState_rts = p_priv->rts_state;
2160
2161         msg.setHskoa_setDtr = 0xff;
2162         msg.hskoa_dtr = p_priv->dtr_state;
2163
2164         p_priv->resend_cont = 0;
2165         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2166
2167         /* send the data out the device on control endpoint */
2168         this_urb->transfer_buffer_length = sizeof(msg);
2169
2170         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2171         if (err != 0)
2172                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2173         return 0;
2174 }
2175
2176 static int keyspan_usa28_send_setup(struct usb_serial *serial,
2177                                     struct usb_serial_port *port,
2178                                     int reset_port)
2179 {
2180         struct keyspan_usa28_portControlMessage msg;
2181         struct keyspan_serial_private           *s_priv;
2182         struct keyspan_port_private             *p_priv;
2183         const struct keyspan_device_details     *d_details;
2184         struct urb                              *this_urb;
2185         int                                     device_port, err;
2186
2187         s_priv = usb_get_serial_data(serial);
2188         p_priv = usb_get_serial_port_data(port);
2189         d_details = s_priv->device_details;
2190         device_port = port->port_number;
2191
2192         /* only do something if we have a bulk out endpoint */
2193         this_urb = p_priv->outcont_urb;
2194         if (this_urb == NULL) {
2195                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2196                 return -1;
2197         }
2198
2199         /* Save reset port val for resend.
2200            Don't overwrite resend for open/close condition. */
2201         if ((reset_port + 1) > p_priv->resend_cont)
2202                 p_priv->resend_cont = reset_port + 1;
2203         if (this_urb->status == -EINPROGRESS) {
2204                 dev_dbg(&port->dev, "%s already writing\n", __func__);
2205                 mdelay(5);
2206                 return -1;
2207         }
2208
2209         memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
2210
2211         msg.setBaudRate = 1;
2212         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2213                                            &msg.baudHi, &msg.baudLo, NULL,
2214                                            device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2215                 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
2216                                                 __func__, p_priv->baud);
2217                 msg.baudLo = 0xff;
2218                 msg.baudHi = 0xb2;      /* Values for 9600 baud */
2219         }
2220
2221         /* If parity is enabled, we must calculate it ourselves. */
2222         msg.parity = 0;         /* XXX for now */
2223
2224         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2225         msg.xonFlowControl = 0;
2226
2227         /* Do handshaking outputs, DTR is inverted relative to RTS */
2228         msg.rts = p_priv->rts_state;
2229         msg.dtr = p_priv->dtr_state;
2230
2231         msg.forwardingLength = 16;
2232         msg.forwardMs = 10;
2233         msg.breakThreshold = 45;
2234         msg.xonChar = 17;
2235         msg.xoffChar = 19;
2236
2237         /*msg.returnStatus = 1;
2238         msg.resetDataToggle = 0xff;*/
2239         /* Opening port */
2240         if (reset_port == 1) {
2241                 msg._txOn = 1;
2242                 msg._txOff = 0;
2243                 msg.txFlush = 0;
2244                 msg.txForceXoff = 0;
2245                 msg.txBreak = 0;
2246                 msg.rxOn = 1;
2247                 msg.rxOff = 0;
2248                 msg.rxFlush = 1;
2249                 msg.rxForward = 0;
2250                 msg.returnStatus = 0;
2251                 msg.resetDataToggle = 0xff;
2252         }
2253         /* Closing port */
2254         else if (reset_port == 2) {
2255                 msg._txOn = 0;
2256                 msg._txOff = 1;
2257                 msg.txFlush = 0;
2258                 msg.txForceXoff = 0;
2259                 msg.txBreak = 0;
2260                 msg.rxOn = 0;
2261                 msg.rxOff = 1;
2262                 msg.rxFlush = 1;
2263                 msg.rxForward = 0;
2264                 msg.returnStatus = 0;
2265                 msg.resetDataToggle = 0;
2266         }
2267         /* Sending intermediate configs */
2268         else {
2269                 msg._txOn = (!p_priv->break_on);
2270                 msg._txOff = 0;
2271                 msg.txFlush = 0;
2272                 msg.txForceXoff = 0;
2273                 msg.txBreak = (p_priv->break_on);
2274                 msg.rxOn = 0;
2275                 msg.rxOff = 0;
2276                 msg.rxFlush = 0;
2277                 msg.rxForward = 0;
2278                 msg.returnStatus = 0;
2279                 msg.resetDataToggle = 0x0;
2280         }
2281
2282         p_priv->resend_cont = 0;
2283         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2284
2285         /* send the data out the device on control endpoint */
2286         this_urb->transfer_buffer_length = sizeof(msg);
2287
2288         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2289         if (err != 0)
2290                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
2291
2292         return 0;
2293 }
2294
2295 static int keyspan_usa49_send_setup(struct usb_serial *serial,
2296                                     struct usb_serial_port *port,
2297                                     int reset_port)
2298 {
2299         struct keyspan_usa49_portControlMessage msg;
2300         struct usb_ctrlrequest                  *dr = NULL;
2301         struct keyspan_serial_private           *s_priv;
2302         struct keyspan_port_private             *p_priv;
2303         const struct keyspan_device_details     *d_details;
2304         struct urb                              *this_urb;
2305         int                                     err, device_port;
2306
2307         s_priv = usb_get_serial_data(serial);
2308         p_priv = usb_get_serial_port_data(port);
2309         d_details = s_priv->device_details;
2310
2311         this_urb = s_priv->glocont_urb;
2312
2313         /* Work out which port within the device is being setup */
2314         device_port = port->port_number;
2315
2316         /* Make sure we have an urb then send the message */
2317         if (this_urb == NULL) {
2318                 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2319                 return -1;
2320         }
2321
2322         dev_dbg(&port->dev, "%s - endpoint %x (%d)\n",
2323                 __func__, usb_pipeendpoint(this_urb->pipe), device_port);
2324
2325         /* Save reset port val for resend.
2326            Don't overwrite resend for open/close condition. */
2327         if ((reset_port + 1) > p_priv->resend_cont)
2328                 p_priv->resend_cont = reset_port + 1;
2329
2330         if (this_urb->status == -EINPROGRESS) {
2331                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2332                 mdelay(5);
2333                 return -1;
2334         }
2335
2336         memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
2337
2338         msg.portNumber = device_port;
2339
2340         /* Only set baud rate if it's changed */
2341         if (p_priv->old_baud != p_priv->baud) {
2342                 p_priv->old_baud = p_priv->baud;
2343                 msg.setClocking = 0xff;
2344                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2345                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
2346                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2347                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2348                                 __func__, p_priv->baud);
2349                         msg.baudLo = 0;
2350                         msg.baudHi = 125;       /* Values for 9600 baud */
2351                         msg.prescaler = 10;
2352                 }
2353                 /* msg.setPrescaler = 0xff; */
2354         }
2355
2356         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2357         switch (p_priv->cflag & CSIZE) {
2358         case CS5:
2359                 msg.lcr |= USA_DATABITS_5;
2360                 break;
2361         case CS6:
2362                 msg.lcr |= USA_DATABITS_6;
2363                 break;
2364         case CS7:
2365                 msg.lcr |= USA_DATABITS_7;
2366                 break;
2367         case CS8:
2368                 msg.lcr |= USA_DATABITS_8;
2369                 break;
2370         }
2371         if (p_priv->cflag & PARENB) {
2372                 /* note USA_PARITY_NONE == 0 */
2373                 msg.lcr |= (p_priv->cflag & PARODD) ?
2374                         USA_PARITY_ODD : USA_PARITY_EVEN;
2375         }
2376         msg.setLcr = 0xff;
2377
2378         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2379         msg.xonFlowControl = 0;
2380         msg.setFlowControl = 0xff;
2381
2382         msg.forwardingLength = 16;
2383         msg.xonChar = 17;
2384         msg.xoffChar = 19;
2385
2386         /* Opening port */
2387         if (reset_port == 1) {
2388                 msg._txOn = 1;
2389                 msg._txOff = 0;
2390                 msg.txFlush = 0;
2391                 msg.txBreak = 0;
2392                 msg.rxOn = 1;
2393                 msg.rxOff = 0;
2394                 msg.rxFlush = 1;
2395                 msg.rxForward = 0;
2396                 msg.returnStatus = 0;
2397                 msg.resetDataToggle = 0xff;
2398                 msg.enablePort = 1;
2399                 msg.disablePort = 0;
2400         }
2401         /* Closing port */
2402         else if (reset_port == 2) {
2403                 msg._txOn = 0;
2404                 msg._txOff = 1;
2405                 msg.txFlush = 0;
2406                 msg.txBreak = 0;
2407                 msg.rxOn = 0;
2408                 msg.rxOff = 1;
2409                 msg.rxFlush = 1;
2410                 msg.rxForward = 0;
2411                 msg.returnStatus = 0;
2412                 msg.resetDataToggle = 0;
2413                 msg.enablePort = 0;
2414                 msg.disablePort = 1;
2415         }
2416         /* Sending intermediate configs */
2417         else {
2418                 msg._txOn = (!p_priv->break_on);
2419                 msg._txOff = 0;
2420                 msg.txFlush = 0;
2421                 msg.txBreak = (p_priv->break_on);
2422                 msg.rxOn = 0;
2423                 msg.rxOff = 0;
2424                 msg.rxFlush = 0;
2425                 msg.rxForward = 0;
2426                 msg.returnStatus = 0;
2427                 msg.resetDataToggle = 0x0;
2428                 msg.enablePort = 0;
2429                 msg.disablePort = 0;
2430         }
2431
2432         /* Do handshaking outputs */
2433         msg.setRts = 0xff;
2434         msg.rts = p_priv->rts_state;
2435
2436         msg.setDtr = 0xff;
2437         msg.dtr = p_priv->dtr_state;
2438
2439         p_priv->resend_cont = 0;
2440
2441         /* if the device is a 49wg, we send control message on usb
2442            control EP 0 */
2443
2444         if (d_details->product_id == keyspan_usa49wg_product_id) {
2445                 dr = (void *)(s_priv->ctrl_buf);
2446                 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2447                 dr->bRequest = 0xB0;    /* 49wg control message */
2448                 dr->wValue = 0;
2449                 dr->wIndex = 0;
2450                 dr->wLength = cpu_to_le16(sizeof(msg));
2451
2452                 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2453
2454                 usb_fill_control_urb(this_urb, serial->dev,
2455                                 usb_sndctrlpipe(serial->dev, 0),
2456                                 (unsigned char *)dr, s_priv->glocont_buf,
2457                                 sizeof(msg), usa49_glocont_callback, serial);
2458
2459         } else {
2460                 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2461
2462                 /* send the data out the device on control endpoint */
2463                 this_urb->transfer_buffer_length = sizeof(msg);
2464         }
2465         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2466         if (err != 0)
2467                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2468
2469         return 0;
2470 }
2471
2472 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2473                                     struct usb_serial_port *port,
2474                                     int reset_port)
2475 {
2476         struct keyspan_usa90_portControlMessage msg;
2477         struct keyspan_serial_private           *s_priv;
2478         struct keyspan_port_private             *p_priv;
2479         const struct keyspan_device_details     *d_details;
2480         struct urb                              *this_urb;
2481         int                                     err;
2482         u8                                              prescaler;
2483
2484         s_priv = usb_get_serial_data(serial);
2485         p_priv = usb_get_serial_port_data(port);
2486         d_details = s_priv->device_details;
2487
2488         /* only do something if we have a bulk out endpoint */
2489         this_urb = p_priv->outcont_urb;
2490         if (this_urb == NULL) {
2491                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2492                 return -1;
2493         }
2494
2495         /* Save reset port val for resend.
2496            Don't overwrite resend for open/close condition. */
2497         if ((reset_port + 1) > p_priv->resend_cont)
2498                 p_priv->resend_cont = reset_port + 1;
2499         if (this_urb->status == -EINPROGRESS) {
2500                 dev_dbg(&port->dev, "%s already writing\n", __func__);
2501                 mdelay(5);
2502                 return -1;
2503         }
2504
2505         memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2506
2507         /* Only set baud rate if it's changed */
2508         if (p_priv->old_baud != p_priv->baud) {
2509                 p_priv->old_baud = p_priv->baud;
2510                 msg.setClocking = 0x01;
2511                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2512                                                    &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2513                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2514                                 __func__, p_priv->baud);
2515                         p_priv->baud = 9600;
2516                         d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2517                                 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2518                 }
2519                 msg.setRxMode = 1;
2520                 msg.setTxMode = 1;
2521         }
2522
2523         /* modes must always be correctly specified */
2524         if (p_priv->baud > 57600) {
2525                 msg.rxMode = RXMODE_DMA;
2526                 msg.txMode = TXMODE_DMA;
2527         } else {
2528                 msg.rxMode = RXMODE_BYHAND;
2529                 msg.txMode = TXMODE_BYHAND;
2530         }
2531
2532         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2533         switch (p_priv->cflag & CSIZE) {
2534         case CS5:
2535                 msg.lcr |= USA_DATABITS_5;
2536                 break;
2537         case CS6:
2538                 msg.lcr |= USA_DATABITS_6;
2539                 break;
2540         case CS7:
2541                 msg.lcr |= USA_DATABITS_7;
2542                 break;
2543         case CS8:
2544                 msg.lcr |= USA_DATABITS_8;
2545                 break;
2546         }
2547         if (p_priv->cflag & PARENB) {
2548                 /* note USA_PARITY_NONE == 0 */
2549                 msg.lcr |= (p_priv->cflag & PARODD) ?
2550                         USA_PARITY_ODD : USA_PARITY_EVEN;
2551         }
2552         if (p_priv->old_cflag != p_priv->cflag) {
2553                 p_priv->old_cflag = p_priv->cflag;
2554                 msg.setLcr = 0x01;
2555         }
2556
2557         if (p_priv->flow_control == flow_cts)
2558                 msg.txFlowControl = TXFLOW_CTS;
2559         msg.setTxFlowControl = 0x01;
2560         msg.setRxFlowControl = 0x01;
2561
2562         msg.rxForwardingLength = 16;
2563         msg.rxForwardingTimeout = 16;
2564         msg.txAckSetting = 0;
2565         msg.xonChar = 17;
2566         msg.xoffChar = 19;
2567
2568         /* Opening port */
2569         if (reset_port == 1) {
2570                 msg.portEnabled = 1;
2571                 msg.rxFlush = 1;
2572                 msg.txBreak = (p_priv->break_on);
2573         }
2574         /* Closing port */
2575         else if (reset_port == 2)
2576                 msg.portEnabled = 0;
2577         /* Sending intermediate configs */
2578         else {
2579                 msg.portEnabled = 1;
2580                 msg.txBreak = (p_priv->break_on);
2581         }
2582
2583         /* Do handshaking outputs */
2584         msg.setRts = 0x01;
2585         msg.rts = p_priv->rts_state;
2586
2587         msg.setDtr = 0x01;
2588         msg.dtr = p_priv->dtr_state;
2589
2590         p_priv->resend_cont = 0;
2591         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2592
2593         /* send the data out the device on control endpoint */
2594         this_urb->transfer_buffer_length = sizeof(msg);
2595
2596         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2597         if (err != 0)
2598                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2599         return 0;
2600 }
2601
2602 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2603                                     struct usb_serial_port *port,
2604                                     int reset_port)
2605 {
2606         struct keyspan_usa67_portControlMessage msg;
2607         struct keyspan_serial_private           *s_priv;
2608         struct keyspan_port_private             *p_priv;
2609         const struct keyspan_device_details     *d_details;
2610         struct urb                              *this_urb;
2611         int                                     err, device_port;
2612
2613         s_priv = usb_get_serial_data(serial);
2614         p_priv = usb_get_serial_port_data(port);
2615         d_details = s_priv->device_details;
2616
2617         this_urb = s_priv->glocont_urb;
2618
2619         /* Work out which port within the device is being setup */
2620         device_port = port->port_number;
2621
2622         /* Make sure we have an urb then send the message */
2623         if (this_urb == NULL) {
2624                 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2625                 return -1;
2626         }
2627
2628         /* Save reset port val for resend.
2629            Don't overwrite resend for open/close condition. */
2630         if ((reset_port + 1) > p_priv->resend_cont)
2631                 p_priv->resend_cont = reset_port + 1;
2632         if (this_urb->status == -EINPROGRESS) {
2633                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2634                 mdelay(5);
2635                 return -1;
2636         }
2637
2638         memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2639
2640         msg.port = device_port;
2641
2642         /* Only set baud rate if it's changed */
2643         if (p_priv->old_baud != p_priv->baud) {
2644                 p_priv->old_baud = p_priv->baud;
2645                 msg.setClocking = 0xff;
2646                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2647                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
2648                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2649                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2650                                 __func__, p_priv->baud);
2651                         msg.baudLo = 0;
2652                         msg.baudHi = 125;       /* Values for 9600 baud */
2653                         msg.prescaler = 10;
2654                 }
2655                 msg.setPrescaler = 0xff;
2656         }
2657
2658         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2659         switch (p_priv->cflag & CSIZE) {
2660         case CS5:
2661                 msg.lcr |= USA_DATABITS_5;
2662                 break;
2663         case CS6:
2664                 msg.lcr |= USA_DATABITS_6;
2665                 break;
2666         case CS7:
2667                 msg.lcr |= USA_DATABITS_7;
2668                 break;
2669         case CS8:
2670                 msg.lcr |= USA_DATABITS_8;
2671                 break;
2672         }
2673         if (p_priv->cflag & PARENB) {
2674                 /* note USA_PARITY_NONE == 0 */
2675                 msg.lcr |= (p_priv->cflag & PARODD) ?
2676                                         USA_PARITY_ODD : USA_PARITY_EVEN;
2677         }
2678         msg.setLcr = 0xff;
2679
2680         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2681         msg.xonFlowControl = 0;
2682         msg.setFlowControl = 0xff;
2683         msg.forwardingLength = 16;
2684         msg.xonChar = 17;
2685         msg.xoffChar = 19;
2686
2687         if (reset_port == 1) {
2688                 /* Opening port */
2689                 msg._txOn = 1;
2690                 msg._txOff = 0;
2691                 msg.txFlush = 0;
2692                 msg.txBreak = 0;
2693                 msg.rxOn = 1;
2694                 msg.rxOff = 0;
2695                 msg.rxFlush = 1;
2696                 msg.rxForward = 0;
2697                 msg.returnStatus = 0;
2698                 msg.resetDataToggle = 0xff;
2699         } else if (reset_port == 2) {
2700                 /* Closing port */
2701                 msg._txOn = 0;
2702                 msg._txOff = 1;
2703                 msg.txFlush = 0;
2704                 msg.txBreak = 0;
2705                 msg.rxOn = 0;
2706                 msg.rxOff = 1;
2707                 msg.rxFlush = 1;
2708                 msg.rxForward = 0;
2709                 msg.returnStatus = 0;
2710                 msg.resetDataToggle = 0;
2711         } else {
2712                 /* Sending intermediate configs */
2713                 msg._txOn = (!p_priv->break_on);
2714                 msg._txOff = 0;
2715                 msg.txFlush = 0;
2716                 msg.txBreak = (p_priv->break_on);
2717                 msg.rxOn = 0;
2718                 msg.rxOff = 0;
2719                 msg.rxFlush = 0;
2720                 msg.rxForward = 0;
2721                 msg.returnStatus = 0;
2722                 msg.resetDataToggle = 0x0;
2723         }
2724
2725         /* Do handshaking outputs */
2726         msg.setTxTriState_setRts = 0xff;
2727         msg.txTriState_rts = p_priv->rts_state;
2728
2729         msg.setHskoa_setDtr = 0xff;
2730         msg.hskoa_dtr = p_priv->dtr_state;
2731
2732         p_priv->resend_cont = 0;
2733
2734         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2735
2736         /* send the data out the device on control endpoint */
2737         this_urb->transfer_buffer_length = sizeof(msg);
2738
2739         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2740         if (err != 0)
2741                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2742         return 0;
2743 }
2744
2745 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2746 {
2747         struct usb_serial *serial = port->serial;
2748         struct keyspan_serial_private *s_priv;
2749         const struct keyspan_device_details *d_details;
2750
2751         s_priv = usb_get_serial_data(serial);
2752         d_details = s_priv->device_details;
2753
2754         switch (d_details->msg_format) {
2755         case msg_usa26:
2756                 keyspan_usa26_send_setup(serial, port, reset_port);
2757                 break;
2758         case msg_usa28:
2759                 keyspan_usa28_send_setup(serial, port, reset_port);
2760                 break;
2761         case msg_usa49:
2762                 keyspan_usa49_send_setup(serial, port, reset_port);
2763                 break;
2764         case msg_usa90:
2765                 keyspan_usa90_send_setup(serial, port, reset_port);
2766                 break;
2767         case msg_usa67:
2768                 keyspan_usa67_send_setup(serial, port, reset_port);
2769                 break;
2770         }
2771 }
2772
2773
2774 /* Gets called by the "real" driver (ie once firmware is loaded
2775    and renumeration has taken place. */
2776 static int keyspan_startup(struct usb_serial *serial)
2777 {
2778         int                             i, err;
2779         struct keyspan_serial_private   *s_priv;
2780         const struct keyspan_device_details     *d_details;
2781
2782         for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2783                 if (d_details->product_id ==
2784                                 le16_to_cpu(serial->dev->descriptor.idProduct))
2785                         break;
2786         if (d_details == NULL) {
2787                 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2788                     __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2789                 return -ENODEV;
2790         }
2791
2792         /* Setup private data for serial driver */
2793         s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2794         if (!s_priv)
2795                 return -ENOMEM;
2796
2797         s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL);
2798         if (!s_priv->instat_buf)
2799                 goto err_instat_buf;
2800
2801         s_priv->indat_buf = kzalloc(INDAT49W_BUFLEN, GFP_KERNEL);
2802         if (!s_priv->indat_buf)
2803                 goto err_indat_buf;
2804
2805         s_priv->glocont_buf = kzalloc(GLOCONT_BUFLEN, GFP_KERNEL);
2806         if (!s_priv->glocont_buf)
2807                 goto err_glocont_buf;
2808
2809         s_priv->ctrl_buf = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
2810         if (!s_priv->ctrl_buf)
2811                 goto err_ctrl_buf;
2812
2813         s_priv->device_details = d_details;
2814         usb_set_serial_data(serial, s_priv);
2815
2816         keyspan_setup_urbs(serial);
2817
2818         if (s_priv->instat_urb != NULL) {
2819                 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2820                 if (err != 0)
2821                         dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2822         }
2823         if (s_priv->indat_urb != NULL) {
2824                 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2825                 if (err != 0)
2826                         dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2827         }
2828
2829         return 0;
2830
2831 err_ctrl_buf:
2832         kfree(s_priv->glocont_buf);
2833 err_glocont_buf:
2834         kfree(s_priv->indat_buf);
2835 err_indat_buf:
2836         kfree(s_priv->instat_buf);
2837 err_instat_buf:
2838         kfree(s_priv);
2839
2840         return -ENOMEM;
2841 }
2842
2843 static void keyspan_disconnect(struct usb_serial *serial)
2844 {
2845         struct keyspan_serial_private *s_priv;
2846
2847         s_priv = usb_get_serial_data(serial);
2848
2849         usb_kill_urb(s_priv->instat_urb);
2850         usb_kill_urb(s_priv->glocont_urb);
2851         usb_kill_urb(s_priv->indat_urb);
2852 }
2853
2854 static void keyspan_release(struct usb_serial *serial)
2855 {
2856         struct keyspan_serial_private *s_priv;
2857
2858         s_priv = usb_get_serial_data(serial);
2859
2860         /* Make sure to unlink the URBs submitted in attach. */
2861         usb_kill_urb(s_priv->instat_urb);
2862         usb_kill_urb(s_priv->indat_urb);
2863
2864         usb_free_urb(s_priv->instat_urb);
2865         usb_free_urb(s_priv->indat_urb);
2866         usb_free_urb(s_priv->glocont_urb);
2867
2868         kfree(s_priv->ctrl_buf);
2869         kfree(s_priv->glocont_buf);
2870         kfree(s_priv->indat_buf);
2871         kfree(s_priv->instat_buf);
2872
2873         kfree(s_priv);
2874 }
2875
2876 static int keyspan_port_probe(struct usb_serial_port *port)
2877 {
2878         struct usb_serial *serial = port->serial;
2879         struct keyspan_serial_private *s_priv;
2880         struct keyspan_port_private *p_priv;
2881         const struct keyspan_device_details *d_details;
2882         struct callbacks *cback;
2883         int endp;
2884         int port_num;
2885         int i;
2886
2887         s_priv = usb_get_serial_data(serial);
2888         d_details = s_priv->device_details;
2889
2890         p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2891         if (!p_priv)
2892                 return -ENOMEM;
2893
2894         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) {
2895                 p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL);
2896                 if (!p_priv->in_buffer[i])
2897                         goto err_free_in_buffer;
2898         }
2899
2900         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) {
2901                 p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL);
2902                 if (!p_priv->out_buffer[i])
2903                         goto err_free_out_buffer;
2904         }
2905
2906         p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
2907         if (!p_priv->inack_buffer)
2908                 goto err_free_out_buffer;
2909
2910         p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
2911         if (!p_priv->outcont_buffer)
2912                 goto err_free_inack_buffer;
2913
2914         p_priv->device_details = d_details;
2915
2916         /* Setup values for the various callback routines */
2917         cback = &keyspan_callbacks[d_details->msg_format];
2918
2919         port_num = port->port_number;
2920
2921         /* Do indat endpoints first, once for each flip */
2922         endp = d_details->indat_endpoints[port_num];
2923         for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2924                 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2925                                                 USB_DIR_IN, port,
2926                                                 p_priv->in_buffer[i],
2927                                                 IN_BUFLEN,
2928                                                 cback->indat_callback);
2929         }
2930         /* outdat endpoints also have flip */
2931         endp = d_details->outdat_endpoints[port_num];
2932         for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2933                 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2934                                                 USB_DIR_OUT, port,
2935                                                 p_priv->out_buffer[i],
2936                                                 OUT_BUFLEN,
2937                                                 cback->outdat_callback);
2938         }
2939         /* inack endpoint */
2940         p_priv->inack_urb = keyspan_setup_urb(serial,
2941                                         d_details->inack_endpoints[port_num],
2942                                         USB_DIR_IN, port,
2943                                         p_priv->inack_buffer,
2944                                         INACK_BUFLEN,
2945                                         cback->inack_callback);
2946         /* outcont endpoint */
2947         p_priv->outcont_urb = keyspan_setup_urb(serial,
2948                                         d_details->outcont_endpoints[port_num],
2949                                         USB_DIR_OUT, port,
2950                                         p_priv->outcont_buffer,
2951                                         OUTCONT_BUFLEN,
2952                                          cback->outcont_callback);
2953
2954         usb_set_serial_port_data(port, p_priv);
2955
2956         return 0;
2957
2958 err_free_inack_buffer:
2959         kfree(p_priv->inack_buffer);
2960 err_free_out_buffer:
2961         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2962                 kfree(p_priv->out_buffer[i]);
2963 err_free_in_buffer:
2964         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2965                 kfree(p_priv->in_buffer[i]);
2966         kfree(p_priv);
2967
2968         return -ENOMEM;
2969 }
2970
2971 static void keyspan_port_remove(struct usb_serial_port *port)
2972 {
2973         struct keyspan_port_private *p_priv;
2974         int i;
2975
2976         p_priv = usb_get_serial_port_data(port);
2977
2978         usb_kill_urb(p_priv->inack_urb);
2979         usb_kill_urb(p_priv->outcont_urb);
2980         for (i = 0; i < 2; i++) {
2981                 usb_kill_urb(p_priv->in_urbs[i]);
2982                 usb_kill_urb(p_priv->out_urbs[i]);
2983         }
2984
2985         usb_free_urb(p_priv->inack_urb);
2986         usb_free_urb(p_priv->outcont_urb);
2987         for (i = 0; i < 2; i++) {
2988                 usb_free_urb(p_priv->in_urbs[i]);
2989                 usb_free_urb(p_priv->out_urbs[i]);
2990         }
2991
2992         kfree(p_priv->outcont_buffer);
2993         kfree(p_priv->inack_buffer);
2994         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2995                 kfree(p_priv->out_buffer[i]);
2996         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2997                 kfree(p_priv->in_buffer[i]);
2998
2999         kfree(p_priv);
3000 }
3001
3002 /* Structs for the devices, pre and post renumeration. */
3003 static struct usb_serial_driver keyspan_pre_device = {
3004         .driver = {
3005                 .owner          = THIS_MODULE,
3006                 .name           = "keyspan_no_firm",
3007         },
3008         .description            = "Keyspan - (without firmware)",
3009         .id_table               = keyspan_pre_ids,
3010         .num_ports              = 1,
3011         .attach                 = keyspan_fake_startup,
3012 };
3013
3014 static struct usb_serial_driver keyspan_1port_device = {
3015         .driver = {
3016                 .owner          = THIS_MODULE,
3017                 .name           = "keyspan_1",
3018         },
3019         .description            = "Keyspan 1 port adapter",
3020         .id_table               = keyspan_1port_ids,
3021         .num_ports              = 1,
3022         .open                   = keyspan_open,
3023         .close                  = keyspan_close,
3024         .dtr_rts                = keyspan_dtr_rts,
3025         .write                  = keyspan_write,
3026         .write_room             = keyspan_write_room,
3027         .set_termios            = keyspan_set_termios,
3028         .break_ctl              = keyspan_break_ctl,
3029         .tiocmget               = keyspan_tiocmget,
3030         .tiocmset               = keyspan_tiocmset,
3031         .attach                 = keyspan_startup,
3032         .disconnect             = keyspan_disconnect,
3033         .release                = keyspan_release,
3034         .port_probe             = keyspan_port_probe,
3035         .port_remove            = keyspan_port_remove,
3036 };
3037
3038 static struct usb_serial_driver keyspan_2port_device = {
3039         .driver = {
3040                 .owner          = THIS_MODULE,
3041                 .name           = "keyspan_2",
3042         },
3043         .description            = "Keyspan 2 port adapter",
3044         .id_table               = keyspan_2port_ids,
3045         .num_ports              = 2,
3046         .open                   = keyspan_open,
3047         .close                  = keyspan_close,
3048         .dtr_rts                = keyspan_dtr_rts,
3049         .write                  = keyspan_write,
3050         .write_room             = keyspan_write_room,
3051         .set_termios            = keyspan_set_termios,
3052         .break_ctl              = keyspan_break_ctl,
3053         .tiocmget               = keyspan_tiocmget,
3054         .tiocmset               = keyspan_tiocmset,
3055         .attach                 = keyspan_startup,
3056         .disconnect             = keyspan_disconnect,
3057         .release                = keyspan_release,
3058         .port_probe             = keyspan_port_probe,
3059         .port_remove            = keyspan_port_remove,
3060 };
3061
3062 static struct usb_serial_driver keyspan_4port_device = {
3063         .driver = {
3064                 .owner          = THIS_MODULE,
3065                 .name           = "keyspan_4",
3066         },
3067         .description            = "Keyspan 4 port adapter",
3068         .id_table               = keyspan_4port_ids,
3069         .num_ports              = 4,
3070         .open                   = keyspan_open,
3071         .close                  = keyspan_close,
3072         .dtr_rts                = keyspan_dtr_rts,
3073         .write                  = keyspan_write,
3074         .write_room             = keyspan_write_room,
3075         .set_termios            = keyspan_set_termios,
3076         .break_ctl              = keyspan_break_ctl,
3077         .tiocmget               = keyspan_tiocmget,
3078         .tiocmset               = keyspan_tiocmset,
3079         .attach                 = keyspan_startup,
3080         .disconnect             = keyspan_disconnect,
3081         .release                = keyspan_release,
3082         .port_probe             = keyspan_port_probe,
3083         .port_remove            = keyspan_port_remove,
3084 };
3085
3086 static struct usb_serial_driver * const serial_drivers[] = {
3087         &keyspan_pre_device, &keyspan_1port_device,
3088         &keyspan_2port_device, &keyspan_4port_device, NULL
3089 };
3090
3091 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
3092
3093 MODULE_AUTHOR(DRIVER_AUTHOR);
3094 MODULE_DESCRIPTION(DRIVER_DESC);
3095 MODULE_LICENSE("GPL");
3096
3097 /*(DEBLOBBED)*/