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