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