drivers/usb/serial/keyspan.c

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