drivers/usb/serial/keyspan.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3   Keyspan USB to Serial Converter driver
   4
   5   (C) Copyright (C) 2000-2001   Hugh Blemings <hugh@blemings.org>
   6   (C) Copyright (C) 2002        Greg Kroah-Hartman <greg@kroah.com>
   7
   8   See http://blemings.org/hugh/keyspan.html for more information.
   9
  10   Code in this driver inspired by and in a number of places taken
  11   from Brian Warner's original Keyspan-PDA driver.
  12
  13   This driver has been put together with the support of Innosys, Inc.
  14   and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
  15   Thanks Guys :)
  16
  17   Thanks to Paulus for miscellaneous tidy ups, some largish chunks
  18   of much nicer and/or completely new code and (perhaps most uniquely)
  19   having the patience to sit down and explain why and where he'd changed
  20   stuff.
  21
  22   Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
  23   staff in their work on open source projects.
  24 */
  25
  26
  27 #include <linux/kernel.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/errno.h>
  30 #include <linux/slab.h>
  31 #include <linux/tty.h>
  32 #include <linux/tty_driver.h>
  33 #include <linux/tty_flip.h>
  34 #include <linux/module.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/uaccess.h>
  37 #include <linux/usb.h>
  38 #include <linux/usb/serial.h>
  39 #include <linux/usb/ezusb.h>
  40
  41 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
  42 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
  43
  44 /* Function prototypes for Keyspan serial converter */
  45 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port);
  46 static void keyspan_close(struct usb_serial_port *port);
  47 static void keyspan_dtr_rts(struct usb_serial_port *port, int on);
  48 static int keyspan_startup(struct usb_serial *serial);
  49 static void keyspan_disconnect(struct usb_serial *serial);
  50 static void keyspan_release(struct usb_serial *serial);
  51 static int keyspan_port_probe(struct usb_serial_port *port);
  52 static int keyspan_port_remove(struct usb_serial_port *port);
  53 static int keyspan_write_room(struct tty_struct *tty);
  54 static int keyspan_write(struct tty_struct *tty, struct usb_serial_port *port,
  55                          const unsigned char *buf, int count);
  56 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port);
  57 static void keyspan_set_termios(struct tty_struct *tty,
  58                                 struct usb_serial_port *port,
  59                                 struct ktermios *old);
  60 static void keyspan_break_ctl(struct tty_struct *tty, int break_state);
  61 static int keyspan_tiocmget(struct tty_struct *tty);
  62 static int keyspan_tiocmset(struct tty_struct *tty, unsigned int set,
  63                             unsigned int clear);
  64 static int keyspan_fake_startup(struct usb_serial *serial);
  65
  66 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
  67                                    u32 baud_rate, u32 baudclk,
  68                                    u8 *rate_hi, u8 *rate_low,
  69                                    u8 *prescaler, int portnum);
  70 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
  71                                     u32 baud_rate, u32 baudclk,
  72                                     u8 *rate_hi, u8 *rate_low,
  73                                     u8 *prescaler, int portnum);
  74 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
  75                                    u32 baud_rate, u32 baudclk,
  76                                    u8 *rate_hi, u8 *rate_low,
  77                                    u8 *prescaler, int portnum);
  78 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
  79                                      u32 baud_rate, u32 baudclk,
  80                                      u8 *rate_hi, u8 *rate_low,
  81                                      u8 *prescaler, int portnum);
  82
  83 static int keyspan_usa28_send_setup(struct usb_serial *serial,
  84                                     struct usb_serial_port *port,
  85                                     int reset_port);
  86 static int keyspan_usa26_send_setup(struct usb_serial *serial,
  87                                     struct usb_serial_port *port,
  88                                     int reset_port);
  89 static int keyspan_usa49_send_setup(struct usb_serial *serial,
  90                                     struct usb_serial_port *port,
  91                                     int reset_port);
  92 static int keyspan_usa90_send_setup(struct usb_serial *serial,
  93                                     struct usb_serial_port *port,
  94                                     int reset_port);
  95 static int keyspan_usa67_send_setup(struct usb_serial *serial,
  96                                     struct usb_serial_port *port,
  97                                     int reset_port);
  98
  99 /* Values used for baud rate calculation - device specific */
 100 #define KEYSPAN_INVALID_BAUD_RATE               (-1)
 101 #define KEYSPAN_BAUD_RATE_OK                    (0)
 102 #define KEYSPAN_USA18X_BAUDCLK                  (12000000L)     /* a guess */
 103 #define KEYSPAN_USA19_BAUDCLK                   (12000000L)
 104 #define KEYSPAN_USA19W_BAUDCLK                  (24000000L)
 105 #define KEYSPAN_USA19HS_BAUDCLK                 (14769231L)
 106 #define KEYSPAN_USA28_BAUDCLK                   (1843200L)
 107 #define KEYSPAN_USA28X_BAUDCLK                  (12000000L)
 108 #define KEYSPAN_USA49W_BAUDCLK                  (48000000L)
 109
 110 /* Some constants used to characterise each device.  */
 111 #define KEYSPAN_MAX_NUM_PORTS                   (4)
 112 #define KEYSPAN_MAX_FLIPS                       (2)
 113
 114 /*
 115  * Device info for the Keyspan serial converter, used by the overall
 116  * usb-serial probe function.
 117  */
 118 #define KEYSPAN_VENDOR_ID                       (0x06cd)
 119
 120 /* Product IDs for the products supported, pre-renumeration */
 121 #define keyspan_usa18x_pre_product_id           0x0105
 122 #define keyspan_usa19_pre_product_id            0x0103
 123 #define keyspan_usa19qi_pre_product_id          0x010b
 124 #define keyspan_mpr_pre_product_id              0x011b
 125 #define keyspan_usa19qw_pre_product_id          0x0118
 126 #define keyspan_usa19w_pre_product_id           0x0106
 127 #define keyspan_usa28_pre_product_id            0x0101
 128 #define keyspan_usa28x_pre_product_id           0x0102
 129 #define keyspan_usa28xa_pre_product_id          0x0114
 130 #define keyspan_usa28xb_pre_product_id          0x0113
 131 #define keyspan_usa49w_pre_product_id           0x0109
 132 #define keyspan_usa49wlc_pre_product_id         0x011a
 133
 134 /*
 135  * Product IDs post-renumeration.  Note that the 28x and 28xb have the same
 136  * id's post-renumeration but behave identically so it's not an issue. As
 137  * such, the 28xb is not listed in any of the device tables.
 138  */
 139 #define keyspan_usa18x_product_id               0x0112
 140 #define keyspan_usa19_product_id                0x0107
 141 #define keyspan_usa19qi_product_id              0x010c
 142 #define keyspan_usa19hs_product_id              0x0121
 143 #define keyspan_mpr_product_id                  0x011c
 144 #define keyspan_usa19qw_product_id              0x0119
 145 #define keyspan_usa19w_product_id               0x0108
 146 #define keyspan_usa28_product_id                0x010f
 147 #define keyspan_usa28x_product_id               0x0110
 148 #define keyspan_usa28xa_product_id              0x0115
 149 #define keyspan_usa28xb_product_id              0x0110
 150 #define keyspan_usa28xg_product_id              0x0135
 151 #define keyspan_usa49w_product_id               0x010a
 152 #define keyspan_usa49wlc_product_id             0x012a
 153 #define keyspan_usa49wg_product_id              0x0131
 154
 155 struct keyspan_device_details {
 156         /* product ID value */
 157         int     product_id;
 158
 159         enum    {msg_usa26, msg_usa28, msg_usa49, msg_usa90, msg_usa67} msg_format;
 160
 161                 /* Number of physical ports */
 162         int     num_ports;
 163
 164                 /* 1 if endpoint flipping used on input, 0 if not */
 165         int     indat_endp_flip;
 166
 167                 /* 1 if endpoint flipping used on output, 0 if not */
 168         int     outdat_endp_flip;
 169
 170                 /*
 171                  * Table mapping input data endpoint IDs to physical port
 172                  * number and flip if used
 173                  */
 174         int     indat_endpoints[KEYSPAN_MAX_NUM_PORTS];
 175
 176                 /* Same for output endpoints */
 177         int     outdat_endpoints[KEYSPAN_MAX_NUM_PORTS];
 178
 179                 /* Input acknowledge endpoints */
 180         int     inack_endpoints[KEYSPAN_MAX_NUM_PORTS];
 181
 182                 /* Output control endpoints */
 183         int     outcont_endpoints[KEYSPAN_MAX_NUM_PORTS];
 184
 185                 /* Endpoint used for input status */
 186         int     instat_endpoint;
 187
 188                 /* Endpoint used for input data 49WG only */
 189         int     indat_endpoint;
 190
 191                 /* Endpoint used for global control functions */
 192         int     glocont_endpoint;
 193
 194         int     (*calculate_baud_rate)(struct usb_serial_port *port,
 195                                        u32 baud_rate, u32 baudclk,
 196                                        u8 *rate_hi, u8 *rate_low, u8 *prescaler,
 197                                        int portnum);
 198         u32     baudclk;
 199 };
 200
 201 /*
 202  * Now for each device type we setup the device detail structure with the
 203  * appropriate information (provided in Keyspan's documentation)
 204  */
 205
 206 static const struct keyspan_device_details usa18x_device_details = {
 207         .product_id             = keyspan_usa18x_product_id,
 208         .msg_format             = msg_usa26,
 209         .num_ports              = 1,
 210         .indat_endp_flip        = 0,
 211         .outdat_endp_flip       = 1,
 212         .indat_endpoints        = {0x81},
 213         .outdat_endpoints       = {0x01},
 214         .inack_endpoints        = {0x85},
 215         .outcont_endpoints      = {0x05},
 216         .instat_endpoint        = 0x87,
 217         .indat_endpoint         = -1,
 218         .glocont_endpoint       = 0x07,
 219         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 220         .baudclk                = KEYSPAN_USA18X_BAUDCLK,
 221 };
 222
 223 static const struct keyspan_device_details usa19_device_details = {
 224         .product_id             = keyspan_usa19_product_id,
 225         .msg_format             = msg_usa28,
 226         .num_ports              = 1,
 227         .indat_endp_flip        = 1,
 228         .outdat_endp_flip       = 1,
 229         .indat_endpoints        = {0x81},
 230         .outdat_endpoints       = {0x01},
 231         .inack_endpoints        = {0x83},
 232         .outcont_endpoints      = {0x03},
 233         .instat_endpoint        = 0x84,
 234         .indat_endpoint         = -1,
 235         .glocont_endpoint       = -1,
 236         .calculate_baud_rate    = keyspan_usa19_calc_baud,
 237         .baudclk                = KEYSPAN_USA19_BAUDCLK,
 238 };
 239
 240 static const struct keyspan_device_details usa19qi_device_details = {
 241         .product_id             = keyspan_usa19qi_product_id,
 242         .msg_format             = msg_usa28,
 243         .num_ports              = 1,
 244         .indat_endp_flip        = 1,
 245         .outdat_endp_flip       = 1,
 246         .indat_endpoints        = {0x81},
 247         .outdat_endpoints       = {0x01},
 248         .inack_endpoints        = {0x83},
 249         .outcont_endpoints      = {0x03},
 250         .instat_endpoint        = 0x84,
 251         .indat_endpoint         = -1,
 252         .glocont_endpoint       = -1,
 253         .calculate_baud_rate    = keyspan_usa28_calc_baud,
 254         .baudclk                = KEYSPAN_USA19_BAUDCLK,
 255 };
 256
 257 static const struct keyspan_device_details mpr_device_details = {
 258         .product_id             = keyspan_mpr_product_id,
 259         .msg_format             = msg_usa28,
 260         .num_ports              = 1,
 261         .indat_endp_flip        = 1,
 262         .outdat_endp_flip       = 1,
 263         .indat_endpoints        = {0x81},
 264         .outdat_endpoints       = {0x01},
 265         .inack_endpoints        = {0x83},
 266         .outcont_endpoints      = {0x03},
 267         .instat_endpoint        = 0x84,
 268         .indat_endpoint         = -1,
 269         .glocont_endpoint       = -1,
 270         .calculate_baud_rate    = keyspan_usa28_calc_baud,
 271         .baudclk                = KEYSPAN_USA19_BAUDCLK,
 272 };
 273
 274 static const struct keyspan_device_details usa19qw_device_details = {
 275         .product_id             = keyspan_usa19qw_product_id,
 276         .msg_format             = msg_usa26,
 277         .num_ports              = 1,
 278         .indat_endp_flip        = 0,
 279         .outdat_endp_flip       = 1,
 280         .indat_endpoints        = {0x81},
 281         .outdat_endpoints       = {0x01},
 282         .inack_endpoints        = {0x85},
 283         .outcont_endpoints      = {0x05},
 284         .instat_endpoint        = 0x87,
 285         .indat_endpoint         = -1,
 286         .glocont_endpoint       = 0x07,
 287         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 288         .baudclk                = KEYSPAN_USA19W_BAUDCLK,
 289 };
 290
 291 static const struct keyspan_device_details usa19w_device_details = {
 292         .product_id             = keyspan_usa19w_product_id,
 293         .msg_format             = msg_usa26,
 294         .num_ports              = 1,
 295         .indat_endp_flip        = 0,
 296         .outdat_endp_flip       = 1,
 297         .indat_endpoints        = {0x81},
 298         .outdat_endpoints       = {0x01},
 299         .inack_endpoints        = {0x85},
 300         .outcont_endpoints      = {0x05},
 301         .instat_endpoint        = 0x87,
 302         .indat_endpoint         = -1,
 303         .glocont_endpoint       = 0x07,
 304         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 305         .baudclk                = KEYSPAN_USA19W_BAUDCLK,
 306 };
 307
 308 static const struct keyspan_device_details usa19hs_device_details = {
 309         .product_id             = keyspan_usa19hs_product_id,
 310         .msg_format             = msg_usa90,
 311         .num_ports              = 1,
 312         .indat_endp_flip        = 0,
 313         .outdat_endp_flip       = 0,
 314         .indat_endpoints        = {0x81},
 315         .outdat_endpoints       = {0x01},
 316         .inack_endpoints        = {-1},
 317         .outcont_endpoints      = {0x02},
 318         .instat_endpoint        = 0x82,
 319         .indat_endpoint         = -1,
 320         .glocont_endpoint       = -1,
 321         .calculate_baud_rate    = keyspan_usa19hs_calc_baud,
 322         .baudclk                = KEYSPAN_USA19HS_BAUDCLK,
 323 };
 324
 325 static const struct keyspan_device_details usa28_device_details = {
 326         .product_id             = keyspan_usa28_product_id,
 327         .msg_format             = msg_usa28,
 328         .num_ports              = 2,
 329         .indat_endp_flip        = 1,
 330         .outdat_endp_flip       = 1,
 331         .indat_endpoints        = {0x81, 0x83},
 332         .outdat_endpoints       = {0x01, 0x03},
 333         .inack_endpoints        = {0x85, 0x86},
 334         .outcont_endpoints      = {0x05, 0x06},
 335         .instat_endpoint        = 0x87,
 336         .indat_endpoint         = -1,
 337         .glocont_endpoint       = 0x07,
 338         .calculate_baud_rate    = keyspan_usa28_calc_baud,
 339         .baudclk                = KEYSPAN_USA28_BAUDCLK,
 340 };
 341
 342 static const struct keyspan_device_details usa28x_device_details = {
 343         .product_id             = keyspan_usa28x_product_id,
 344         .msg_format             = msg_usa26,
 345         .num_ports              = 2,
 346         .indat_endp_flip        = 0,
 347         .outdat_endp_flip       = 1,
 348         .indat_endpoints        = {0x81, 0x83},
 349         .outdat_endpoints       = {0x01, 0x03},
 350         .inack_endpoints        = {0x85, 0x86},
 351         .outcont_endpoints      = {0x05, 0x06},
 352         .instat_endpoint        = 0x87,
 353         .indat_endpoint         = -1,
 354         .glocont_endpoint       = 0x07,
 355         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 356         .baudclk                = KEYSPAN_USA28X_BAUDCLK,
 357 };
 358
 359 static const struct keyspan_device_details usa28xa_device_details = {
 360         .product_id             = keyspan_usa28xa_product_id,
 361         .msg_format             = msg_usa26,
 362         .num_ports              = 2,
 363         .indat_endp_flip        = 0,
 364         .outdat_endp_flip       = 1,
 365         .indat_endpoints        = {0x81, 0x83},
 366         .outdat_endpoints       = {0x01, 0x03},
 367         .inack_endpoints        = {0x85, 0x86},
 368         .outcont_endpoints      = {0x05, 0x06},
 369         .instat_endpoint        = 0x87,
 370         .indat_endpoint         = -1,
 371         .glocont_endpoint       = 0x07,
 372         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 373         .baudclk                = KEYSPAN_USA28X_BAUDCLK,
 374 };
 375
 376 static const struct keyspan_device_details usa28xg_device_details = {
 377         .product_id             = keyspan_usa28xg_product_id,
 378         .msg_format             = msg_usa67,
 379         .num_ports              = 2,
 380         .indat_endp_flip        = 0,
 381         .outdat_endp_flip       = 0,
 382         .indat_endpoints        = {0x84, 0x88},
 383         .outdat_endpoints       = {0x02, 0x06},
 384         .inack_endpoints        = {-1, -1},
 385         .outcont_endpoints      = {-1, -1},
 386         .instat_endpoint        = 0x81,
 387         .indat_endpoint         = -1,
 388         .glocont_endpoint       = 0x01,
 389         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 390         .baudclk                = KEYSPAN_USA28X_BAUDCLK,
 391 };
 392 /*
 393  * We don't need a separate entry for the usa28xb as it appears as a 28x
 394  * anyway.
 395  */
 396
 397 static const struct keyspan_device_details usa49w_device_details = {
 398         .product_id             = keyspan_usa49w_product_id,
 399         .msg_format             = msg_usa49,
 400         .num_ports              = 4,
 401         .indat_endp_flip        = 0,
 402         .outdat_endp_flip       = 0,
 403         .indat_endpoints        = {0x81, 0x82, 0x83, 0x84},
 404         .outdat_endpoints       = {0x01, 0x02, 0x03, 0x04},
 405         .inack_endpoints        = {-1, -1, -1, -1},
 406         .outcont_endpoints      = {-1, -1, -1, -1},
 407         .instat_endpoint        = 0x87,
 408         .indat_endpoint         = -1,
 409         .glocont_endpoint       = 0x07,
 410         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 411         .baudclk                = KEYSPAN_USA49W_BAUDCLK,
 412 };
 413
 414 static const struct keyspan_device_details usa49wlc_device_details = {
 415         .product_id             = keyspan_usa49wlc_product_id,
 416         .msg_format             = msg_usa49,
 417         .num_ports              = 4,
 418         .indat_endp_flip        = 0,
 419         .outdat_endp_flip       = 0,
 420         .indat_endpoints        = {0x81, 0x82, 0x83, 0x84},
 421         .outdat_endpoints       = {0x01, 0x02, 0x03, 0x04},
 422         .inack_endpoints        = {-1, -1, -1, -1},
 423         .outcont_endpoints      = {-1, -1, -1, -1},
 424         .instat_endpoint        = 0x87,
 425         .indat_endpoint         = -1,
 426         .glocont_endpoint       = 0x07,
 427         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 428         .baudclk                = KEYSPAN_USA19W_BAUDCLK,
 429 };
 430
 431 static const struct keyspan_device_details usa49wg_device_details = {
 432         .product_id             = keyspan_usa49wg_product_id,
 433         .msg_format             = msg_usa49,
 434         .num_ports              = 4,
 435         .indat_endp_flip        = 0,
 436         .outdat_endp_flip       = 0,
 437         .indat_endpoints        = {-1, -1, -1, -1},     /* single 'global' data in EP */
 438         .outdat_endpoints       = {0x01, 0x02, 0x04, 0x06},
 439         .inack_endpoints        = {-1, -1, -1, -1},
 440         .outcont_endpoints      = {-1, -1, -1, -1},
 441         .instat_endpoint        = 0x81,
 442         .indat_endpoint         = 0x88,
 443         .glocont_endpoint       = 0x00,                 /* uses control EP */
 444         .calculate_baud_rate    = keyspan_usa19w_calc_baud,
 445         .baudclk                = KEYSPAN_USA19W_BAUDCLK,
 446 };
 447
 448 static const struct keyspan_device_details *keyspan_devices[] = {
 449         &usa18x_device_details,
 450         &usa19_device_details,
 451         &usa19qi_device_details,
 452         &mpr_device_details,
 453         &usa19qw_device_details,
 454         &usa19w_device_details,
 455         &usa19hs_device_details,
 456         &usa28_device_details,
 457         &usa28x_device_details,
 458         &usa28xa_device_details,
 459         &usa28xg_device_details,
 460         /* 28xb not required as it renumerates as a 28x */
 461         &usa49w_device_details,
 462         &usa49wlc_device_details,
 463         &usa49wg_device_details,
 464         NULL,
 465 };
 466
 467 static const struct usb_device_id keyspan_ids_combined[] = {
 468         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
 469         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
 470         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
 471         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
 472         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
 473         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
 474         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
 475         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
 476         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
 477         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
 478         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
 479         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
 480         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
 481         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
 482         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
 483         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
 484         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
 485         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
 486         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
 487         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
 488         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
 489         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
 490         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
 491         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id)},
 492         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
 493         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
 494         { } /* Terminating entry */
 495 };
 496
 497 MODULE_DEVICE_TABLE(usb, keyspan_ids_combined);
 498
 499 /* usb_device_id table for the pre-firmware download keyspan devices */
 500 static const struct usb_device_id keyspan_pre_ids[] = {
 501         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
 502         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
 503         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
 504         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
 505         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
 506         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
 507         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
 508         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
 509         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
 510         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
 511         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
 512         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
 513         { } /* Terminating entry */
 514 };
 515
 516 static const struct usb_device_id keyspan_1port_ids[] = {
 517         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
 518         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
 519         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
 520         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
 521         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
 522         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
 523         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
 524         { } /* Terminating entry */
 525 };
 526
 527 static const struct usb_device_id keyspan_2port_ids[] = {
 528         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
 529         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
 530         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
 531         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
 532         { } /* Terminating entry */
 533 };
 534
 535 static const struct usb_device_id keyspan_4port_ids[] = {
 536         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id) },
 537         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
 538         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
 539         { } /* Terminating entry */
 540 };
 541
 542 #define INSTAT_BUFLEN   32
 543 #define GLOCONT_BUFLEN  64
 544 #define INDAT49W_BUFLEN 512
 545 #define IN_BUFLEN       64
 546 #define OUT_BUFLEN      64
 547 #define INACK_BUFLEN    1
 548 #define OUTCONT_BUFLEN  64
 549
 550         /* Per device and per port private data */
 551 struct keyspan_serial_private {
 552         const struct keyspan_device_details     *device_details;
 553
 554         struct urb      *instat_urb;
 555         char            *instat_buf;
 556
 557         /* added to support 49wg, where data from all 4 ports comes in
 558            on 1 EP and high-speed supported */
 559         struct urb      *indat_urb;
 560         char            *indat_buf;
 561
 562         /* XXX this one probably will need a lock */
 563         struct urb      *glocont_urb;
 564         char            *glocont_buf;
 565         char            *ctrl_buf;      /* for EP0 control message */
 566 };
 567
 568 struct keyspan_port_private {
 569         /* Keep track of which input & output endpoints to use */
 570         int             in_flip;
 571         int             out_flip;
 572
 573         /* Keep duplicate of device details in each port
 574            structure as well - simplifies some of the
 575            callback functions etc. */
 576         const struct keyspan_device_details     *device_details;
 577
 578         /* Input endpoints and buffer for this port */
 579         struct urb      *in_urbs[2];
 580         char            *in_buffer[2];
 581         /* Output endpoints and buffer for this port */
 582         struct urb      *out_urbs[2];
 583         char            *out_buffer[2];
 584
 585         /* Input ack endpoint */
 586         struct urb      *inack_urb;
 587         char            *inack_buffer;
 588
 589         /* Output control endpoint */
 590         struct urb      *outcont_urb;
 591         char            *outcont_buffer;
 592
 593         /* Settings for the port */
 594         int             baud;
 595         int             old_baud;
 596         unsigned int    cflag;
 597         unsigned int    old_cflag;
 598         enum            {flow_none, flow_cts, flow_xon} flow_control;
 599         int             rts_state;      /* Handshaking pins (outputs) */
 600         int             dtr_state;
 601         int             cts_state;      /* Handshaking pins (inputs) */
 602         int             dsr_state;
 603         int             dcd_state;
 604         int             ri_state;
 605         int             break_on;
 606
 607         unsigned long   tx_start_time[2];
 608         int             resend_cont;    /* need to resend control packet */
 609 };
 610
 611 /* Include Keyspan message headers.  All current Keyspan Adapters
 612    make use of one of five message formats which are referred
 613    to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
 614    within this driver. */
 615 #include "keyspan_usa26msg.h"
 616 #include "keyspan_usa28msg.h"
 617 #include "keyspan_usa49msg.h"
 618 #include "keyspan_usa90msg.h"
 619 #include "keyspan_usa67msg.h"
 620
 621
 622 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
 623 {
 624         struct usb_serial_port *port = tty->driver_data;
 625         struct keyspan_port_private     *p_priv;
 626
 627         p_priv = usb_get_serial_port_data(port);
 628
 629         if (break_state == -1)
 630                 p_priv->break_on = 1;
 631         else
 632                 p_priv->break_on = 0;
 633
 634         keyspan_send_setup(port, 0);
 635 }
 636
 637
 638 static void keyspan_set_termios(struct tty_struct *tty,
 639                 struct usb_serial_port *port, struct ktermios *old_termios)
 640 {
 641         int                             baud_rate, device_port;
 642         struct keyspan_port_private     *p_priv;
 643         const struct keyspan_device_details     *d_details;
 644         unsigned int                    cflag;
 645
 646         p_priv = usb_get_serial_port_data(port);
 647         d_details = p_priv->device_details;
 648         cflag = tty->termios.c_cflag;
 649         device_port = port->port_number;
 650
 651         /* Baud rate calculation takes baud rate as an integer
 652            so other rates can be generated if desired. */
 653         baud_rate = tty_get_baud_rate(tty);
 654         /* If no match or invalid, don't change */
 655         if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
 656                                 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
 657                 /* FIXME - more to do here to ensure rate changes cleanly */
 658                 /* FIXME - calculate exact rate from divisor ? */
 659                 p_priv->baud = baud_rate;
 660         } else
 661                 baud_rate = tty_termios_baud_rate(old_termios);
 662
 663         tty_encode_baud_rate(tty, baud_rate, baud_rate);
 664         /* set CTS/RTS handshake etc. */
 665         p_priv->cflag = cflag;
 666         p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
 667
 668         /* Mark/Space not supported */
 669         tty->termios.c_cflag &= ~CMSPAR;
 670
 671         keyspan_send_setup(port, 0);
 672 }
 673
 674 static int keyspan_tiocmget(struct tty_struct *tty)
 675 {
 676         struct usb_serial_port *port = tty->driver_data;
 677         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
 678         unsigned int                    value;
 679
 680         value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
 681                 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
 682                 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
 683                 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
 684                 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
 685                 ((p_priv->ri_state) ? TIOCM_RNG : 0);
 686
 687         return value;
 688 }
 689
 690 static int keyspan_tiocmset(struct tty_struct *tty,
 691                             unsigned int set, unsigned int clear)
 692 {
 693         struct usb_serial_port *port = tty->driver_data;
 694         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
 695
 696         if (set & TIOCM_RTS)
 697                 p_priv->rts_state = 1;
 698         if (set & TIOCM_DTR)
 699                 p_priv->dtr_state = 1;
 700         if (clear & TIOCM_RTS)
 701                 p_priv->rts_state = 0;
 702         if (clear & TIOCM_DTR)
 703                 p_priv->dtr_state = 0;
 704         keyspan_send_setup(port, 0);
 705         return 0;
 706 }
 707
 708 /* Write function is similar for the four protocols used
 709    with only a minor change for usa90 (usa19hs) required */
 710 static int keyspan_write(struct tty_struct *tty,
 711         struct usb_serial_port *port, const unsigned char *buf, int count)
 712 {
 713         struct keyspan_port_private     *p_priv;
 714         const struct keyspan_device_details     *d_details;
 715         int                             flip;
 716         int                             left, todo;
 717         struct urb                      *this_urb;
 718         int                             err, maxDataLen, dataOffset;
 719
 720         p_priv = usb_get_serial_port_data(port);
 721         d_details = p_priv->device_details;
 722
 723         if (d_details->msg_format == msg_usa90) {
 724                 maxDataLen = 64;
 725                 dataOffset = 0;
 726         } else {
 727                 maxDataLen = 63;
 728                 dataOffset = 1;
 729         }
 730
 731         dev_dbg(&port->dev, "%s - %d chars, flip=%d\n", __func__, count,
 732                 p_priv->out_flip);
 733
 734         for (left = count; left > 0; left -= todo) {
 735                 todo = left;
 736                 if (todo > maxDataLen)
 737                         todo = maxDataLen;
 738
 739                 flip = p_priv->out_flip;
 740
 741                 /* Check we have a valid urb/endpoint before we use it... */
 742                 this_urb = p_priv->out_urbs[flip];
 743                 if (this_urb == NULL) {
 744                         /* no bulk out, so return 0 bytes written */
 745                         dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
 746                         return count;
 747                 }
 748
 749                 dev_dbg(&port->dev, "%s - endpoint %x flip %d\n",
 750                         __func__, usb_pipeendpoint(this_urb->pipe), flip);
 751
 752                 if (this_urb->status == -EINPROGRESS) {
 753                         if (time_before(jiffies,
 754                                         p_priv->tx_start_time[flip] + 10 * HZ))
 755                                 break;
 756                         usb_unlink_urb(this_urb);
 757                         break;
 758                 }
 759
 760                 /* First byte in buffer is "last flag" (except for usa19hx)
 761                    - unused so for now so set to zero */
 762                 ((char *)this_urb->transfer_buffer)[0] = 0;
 763
 764                 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
 765                 buf += todo;
 766
 767                 /* send the data out the bulk port */
 768                 this_urb->transfer_buffer_length = todo + dataOffset;
 769
 770                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
 771                 if (err != 0)
 772                         dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
 773                 p_priv->tx_start_time[flip] = jiffies;
 774
 775                 /* Flip for next time if usa26 or usa28 interface
 776                    (not used on usa49) */
 777                 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
 778         }
 779
 780         return count - left;
 781 }
 782
 783 static void     usa26_indat_callback(struct urb *urb)
 784 {
 785         int                     i, err;
 786         int                     endpoint;
 787         struct usb_serial_port  *port;
 788         unsigned char           *data = urb->transfer_buffer;
 789         int status = urb->status;
 790
 791         endpoint = usb_pipeendpoint(urb->pipe);
 792
 793         if (status) {
 794                 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
 795                         __func__, status, endpoint);
 796                 return;
 797         }
 798
 799         port =  urb->context;
 800         if (urb->actual_length) {
 801                 /* 0x80 bit is error flag */
 802                 if ((data[0] & 0x80) == 0) {
 803                         /* no errors on individual bytes, only
 804                            possible overrun err */
 805                         if (data[0] & RXERROR_OVERRUN) {
 806                                 tty_insert_flip_char(&port->port, 0,
 807                                                                 TTY_OVERRUN);
 808                         }
 809                         for (i = 1; i < urb->actual_length ; ++i)
 810                                 tty_insert_flip_char(&port->port, data[i],
 811                                                                 TTY_NORMAL);
 812                 } else {
 813                         /* some bytes had errors, every byte has status */
 814                         dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
 815                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
 816                                 int stat = data[i];
 817                                 int flag = TTY_NORMAL;
 818
 819                                 if (stat & RXERROR_OVERRUN) {
 820                                         tty_insert_flip_char(&port->port, 0,
 821                                                                 TTY_OVERRUN);
 822                                 }
 823                                 /* XXX should handle break (0x10) */
 824                                 if (stat & RXERROR_PARITY)
 825                                         flag = TTY_PARITY;
 826                                 else if (stat & RXERROR_FRAMING)
 827                                         flag = TTY_FRAME;
 828
 829                                 tty_insert_flip_char(&port->port, data[i+1],
 830                                                 flag);
 831                         }
 832                 }
 833                 tty_flip_buffer_push(&port->port);
 834         }
 835
 836         /* Resubmit urb so we continue receiving */
 837         err = usb_submit_urb(urb, GFP_ATOMIC);
 838         if (err != 0)
 839                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 840 }
 841
 842 /* Outdat handling is common for all devices */
 843 static void     usa2x_outdat_callback(struct urb *urb)
 844 {
 845         struct usb_serial_port *port;
 846         struct keyspan_port_private *p_priv;
 847
 848         port =  urb->context;
 849         p_priv = usb_get_serial_port_data(port);
 850         dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
 851
 852         usb_serial_port_softint(port);
 853 }
 854
 855 static void     usa26_inack_callback(struct urb *urb)
 856 {
 857 }
 858
 859 static void     usa26_outcont_callback(struct urb *urb)
 860 {
 861         struct usb_serial_port *port;
 862         struct keyspan_port_private *p_priv;
 863
 864         port =  urb->context;
 865         p_priv = usb_get_serial_port_data(port);
 866
 867         if (p_priv->resend_cont) {
 868                 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
 869                 keyspan_usa26_send_setup(port->serial, port,
 870                                                 p_priv->resend_cont - 1);
 871         }
 872 }
 873
 874 static void     usa26_instat_callback(struct urb *urb)
 875 {
 876         unsigned char                           *data = urb->transfer_buffer;
 877         struct keyspan_usa26_portStatusMessage  *msg;
 878         struct usb_serial                       *serial;
 879         struct usb_serial_port                  *port;
 880         struct keyspan_port_private             *p_priv;
 881         int old_dcd_state, err;
 882         int status = urb->status;
 883
 884         serial =  urb->context;
 885
 886         if (status) {
 887                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
 888                                 __func__, status);
 889                 return;
 890         }
 891         if (urb->actual_length != 9) {
 892                 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
 893                 goto exit;
 894         }
 895
 896         msg = (struct keyspan_usa26_portStatusMessage *)data;
 897
 898         /* Check port number from message and retrieve private data */
 899         if (msg->port >= serial->num_ports) {
 900                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
 901                 goto exit;
 902         }
 903         port = serial->port[msg->port];
 904         p_priv = usb_get_serial_port_data(port);
 905         if (!p_priv)
 906                 goto resubmit;
 907
 908         /* Update handshaking pin state information */
 909         old_dcd_state = p_priv->dcd_state;
 910         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
 911         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
 912         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
 913         p_priv->ri_state = ((msg->ri) ? 1 : 0);
 914
 915         if (old_dcd_state != p_priv->dcd_state)
 916                 tty_port_tty_hangup(&port->port, true);
 917 resubmit:
 918         /* Resubmit urb so we continue receiving */
 919         err = usb_submit_urb(urb, GFP_ATOMIC);
 920         if (err != 0)
 921                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 922 exit: ;
 923 }
 924
 925 static void     usa26_glocont_callback(struct urb *urb)
 926 {
 927 }
 928
 929
 930 static void usa28_indat_callback(struct urb *urb)
 931 {
 932         int                     err;
 933         struct usb_serial_port  *port;
 934         unsigned char           *data;
 935         struct keyspan_port_private             *p_priv;
 936         int status = urb->status;
 937
 938         port =  urb->context;
 939         p_priv = usb_get_serial_port_data(port);
 940         data = urb->transfer_buffer;
 941
 942         if (urb != p_priv->in_urbs[p_priv->in_flip])
 943                 return;
 944
 945         do {
 946                 if (status) {
 947                         dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
 948                                 __func__, status, usb_pipeendpoint(urb->pipe));
 949                         return;
 950                 }
 951
 952                 port =  urb->context;
 953                 p_priv = usb_get_serial_port_data(port);
 954                 data = urb->transfer_buffer;
 955
 956                 if (urb->actual_length) {
 957                         tty_insert_flip_string(&port->port, data,
 958                                         urb->actual_length);
 959                         tty_flip_buffer_push(&port->port);
 960                 }
 961
 962                 /* Resubmit urb so we continue receiving */
 963                 err = usb_submit_urb(urb, GFP_ATOMIC);
 964                 if (err != 0)
 965                         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
 966                                                         __func__, err);
 967                 p_priv->in_flip ^= 1;
 968
 969                 urb = p_priv->in_urbs[p_priv->in_flip];
 970         } while (urb->status != -EINPROGRESS);
 971 }
 972
 973 static void     usa28_inack_callback(struct urb *urb)
 974 {
 975 }
 976
 977 static void     usa28_outcont_callback(struct urb *urb)
 978 {
 979         struct usb_serial_port *port;
 980         struct keyspan_port_private *p_priv;
 981
 982         port =  urb->context;
 983         p_priv = usb_get_serial_port_data(port);
 984
 985         if (p_priv->resend_cont) {
 986                 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
 987                 keyspan_usa28_send_setup(port->serial, port,
 988                                                 p_priv->resend_cont - 1);
 989         }
 990 }
 991
 992 static void     usa28_instat_callback(struct urb *urb)
 993 {
 994         int                                     err;
 995         unsigned char                           *data = urb->transfer_buffer;
 996         struct keyspan_usa28_portStatusMessage  *msg;
 997         struct usb_serial                       *serial;
 998         struct usb_serial_port                  *port;
 999         struct keyspan_port_private             *p_priv;
1000         int old_dcd_state;
1001         int status = urb->status;
1002
1003         serial =  urb->context;
1004
1005         if (status) {
1006                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1007                                 __func__, status);
1008                 return;
1009         }
1010
1011         if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
1012                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1013                 goto exit;
1014         }
1015
1016         msg = (struct keyspan_usa28_portStatusMessage *)data;
1017
1018         /* Check port number from message and retrieve private data */
1019         if (msg->port >= serial->num_ports) {
1020                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1021                 goto exit;
1022         }
1023         port = serial->port[msg->port];
1024         p_priv = usb_get_serial_port_data(port);
1025         if (!p_priv)
1026                 goto resubmit;
1027
1028         /* Update handshaking pin state information */
1029         old_dcd_state = p_priv->dcd_state;
1030         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1031         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1032         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1033         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1034
1035         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1036                 tty_port_tty_hangup(&port->port, true);
1037 resubmit:
1038                 /* Resubmit urb so we continue receiving */
1039         err = usb_submit_urb(urb, GFP_ATOMIC);
1040         if (err != 0)
1041                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1042 exit: ;
1043 }
1044
1045 static void     usa28_glocont_callback(struct urb *urb)
1046 {
1047 }
1048
1049
1050 static void     usa49_glocont_callback(struct urb *urb)
1051 {
1052         struct usb_serial *serial;
1053         struct usb_serial_port *port;
1054         struct keyspan_port_private *p_priv;
1055         int i;
1056
1057         serial =  urb->context;
1058         for (i = 0; i < serial->num_ports; ++i) {
1059                 port = serial->port[i];
1060                 p_priv = usb_get_serial_port_data(port);
1061                 if (!p_priv)
1062                         continue;
1063
1064                 if (p_priv->resend_cont) {
1065                         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1066                         keyspan_usa49_send_setup(serial, port,
1067                                                 p_priv->resend_cont - 1);
1068                         break;
1069                 }
1070         }
1071 }
1072
1073         /* This is actually called glostat in the Keyspan
1074            doco */
1075 static void     usa49_instat_callback(struct urb *urb)
1076 {
1077         int                                     err;
1078         unsigned char                           *data = urb->transfer_buffer;
1079         struct keyspan_usa49_portStatusMessage  *msg;
1080         struct usb_serial                       *serial;
1081         struct usb_serial_port                  *port;
1082         struct keyspan_port_private             *p_priv;
1083         int old_dcd_state;
1084         int status = urb->status;
1085
1086         serial =  urb->context;
1087
1088         if (status) {
1089                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1090                                 __func__, status);
1091                 return;
1092         }
1093
1094         if (urb->actual_length !=
1095                         sizeof(struct keyspan_usa49_portStatusMessage)) {
1096                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1097                 goto exit;
1098         }
1099
1100         msg = (struct keyspan_usa49_portStatusMessage *)data;
1101
1102         /* Check port number from message and retrieve private data */
1103         if (msg->portNumber >= serial->num_ports) {
1104                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1105                         __func__, msg->portNumber);
1106                 goto exit;
1107         }
1108         port = serial->port[msg->portNumber];
1109         p_priv = usb_get_serial_port_data(port);
1110         if (!p_priv)
1111                 goto resubmit;
1112
1113         /* Update handshaking pin state information */
1114         old_dcd_state = p_priv->dcd_state;
1115         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1116         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1117         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1118         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1119
1120         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1121                 tty_port_tty_hangup(&port->port, true);
1122 resubmit:
1123         /* Resubmit urb so we continue receiving */
1124         err = usb_submit_urb(urb, GFP_ATOMIC);
1125         if (err != 0)
1126                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1127 exit:   ;
1128 }
1129
1130 static void     usa49_inack_callback(struct urb *urb)
1131 {
1132 }
1133
1134 static void     usa49_indat_callback(struct urb *urb)
1135 {
1136         int                     i, err;
1137         int                     endpoint;
1138         struct usb_serial_port  *port;
1139         unsigned char           *data = urb->transfer_buffer;
1140         int status = urb->status;
1141
1142         endpoint = usb_pipeendpoint(urb->pipe);
1143
1144         if (status) {
1145                 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1146                         __func__, status, endpoint);
1147                 return;
1148         }
1149
1150         port =  urb->context;
1151         if (urb->actual_length) {
1152                 /* 0x80 bit is error flag */
1153                 if ((data[0] & 0x80) == 0) {
1154                         /* no error on any byte */
1155                         tty_insert_flip_string(&port->port, data + 1,
1156                                                 urb->actual_length - 1);
1157                 } else {
1158                         /* some bytes had errors, every byte has status */
1159                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
1160                                 int stat = data[i];
1161                                 int flag = TTY_NORMAL;
1162
1163                                 if (stat & RXERROR_OVERRUN) {
1164                                         tty_insert_flip_char(&port->port, 0,
1165                                                                 TTY_OVERRUN);
1166                                 }
1167                                 /* XXX should handle break (0x10) */
1168                                 if (stat & RXERROR_PARITY)
1169                                         flag = TTY_PARITY;
1170                                 else if (stat & RXERROR_FRAMING)
1171                                         flag = TTY_FRAME;
1172
1173                                 tty_insert_flip_char(&port->port, data[i+1],
1174                                                 flag);
1175                         }
1176                 }
1177                 tty_flip_buffer_push(&port->port);
1178         }
1179
1180         /* Resubmit urb so we continue receiving */
1181         err = usb_submit_urb(urb, GFP_ATOMIC);
1182         if (err != 0)
1183                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1184 }
1185
1186 static void usa49wg_indat_callback(struct urb *urb)
1187 {
1188         int                     i, len, x, err;
1189         struct usb_serial       *serial;
1190         struct usb_serial_port  *port;
1191         unsigned char           *data = urb->transfer_buffer;
1192         int status = urb->status;
1193
1194         serial = urb->context;
1195
1196         if (status) {
1197                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1198                                 __func__, status);
1199                 return;
1200         }
1201
1202         /* inbound data is in the form P#, len, status, data */
1203         i = 0;
1204         len = 0;
1205
1206         while (i < urb->actual_length) {
1207
1208                 /* Check port number from message */
1209                 if (data[i] >= serial->num_ports) {
1210                         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1211                                 __func__, data[i]);
1212                         return;
1213                 }
1214                 port = serial->port[data[i++]];
1215                 len = data[i++];
1216
1217                 /* 0x80 bit is error flag */
1218                 if ((data[i] & 0x80) == 0) {
1219                         /* no error on any byte */
1220                         i++;
1221                         for (x = 1; x < len && i < urb->actual_length; ++x)
1222                                 tty_insert_flip_char(&port->port,
1223                                                 data[i++], 0);
1224                 } else {
1225                         /*
1226                          * some bytes had errors, every byte has status
1227                          */
1228                         for (x = 0; x + 1 < len &&
1229                                     i + 1 < urb->actual_length; x += 2) {
1230                                 int stat = data[i];
1231                                 int flag = TTY_NORMAL;
1232
1233                                 if (stat & RXERROR_OVERRUN) {
1234                                         tty_insert_flip_char(&port->port, 0,
1235                                                                 TTY_OVERRUN);
1236                                 }
1237                                 /* XXX should handle break (0x10) */
1238                                 if (stat & RXERROR_PARITY)
1239                                         flag = TTY_PARITY;
1240                                 else if (stat & RXERROR_FRAMING)
1241                                         flag = TTY_FRAME;
1242
1243                                 tty_insert_flip_char(&port->port, data[i+1],
1244                                                      flag);
1245                                 i += 2;
1246                         }
1247                 }
1248                 tty_flip_buffer_push(&port->port);
1249         }
1250
1251         /* Resubmit urb so we continue receiving */
1252         err = usb_submit_urb(urb, GFP_ATOMIC);
1253         if (err != 0)
1254                 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1255 }
1256
1257 /* not used, usa-49 doesn't have per-port control endpoints */
1258 static void usa49_outcont_callback(struct urb *urb)
1259 {
1260 }
1261
1262 static void usa90_indat_callback(struct urb *urb)
1263 {
1264         int                     i, err;
1265         int                     endpoint;
1266         struct usb_serial_port  *port;
1267         struct keyspan_port_private             *p_priv;
1268         unsigned char           *data = urb->transfer_buffer;
1269         int status = urb->status;
1270
1271         endpoint = usb_pipeendpoint(urb->pipe);
1272
1273         if (status) {
1274                 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1275                         __func__, status, endpoint);
1276                 return;
1277         }
1278
1279         port =  urb->context;
1280         p_priv = usb_get_serial_port_data(port);
1281
1282         if (urb->actual_length) {
1283                 /* if current mode is DMA, looks like usa28 format
1284                    otherwise looks like usa26 data format */
1285
1286                 if (p_priv->baud > 57600)
1287                         tty_insert_flip_string(&port->port, data,
1288                                         urb->actual_length);
1289                 else {
1290                         /* 0x80 bit is error flag */
1291                         if ((data[0] & 0x80) == 0) {
1292                                 /* no errors on individual bytes, only
1293                                    possible overrun err*/
1294                                 if (data[0] & RXERROR_OVERRUN) {
1295                                         tty_insert_flip_char(&port->port, 0,
1296                                                                 TTY_OVERRUN);
1297                                 }
1298                                 for (i = 1; i < urb->actual_length ; ++i)
1299                                         tty_insert_flip_char(&port->port,
1300                                                         data[i], TTY_NORMAL);
1301                         }  else {
1302                         /* some bytes had errors, every byte has status */
1303                                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
1304                                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1305                                         int stat = data[i];
1306                                         int flag = TTY_NORMAL;
1307
1308                                         if (stat & RXERROR_OVERRUN) {
1309                                                 tty_insert_flip_char(
1310                                                                 &port->port, 0,
1311                                                                 TTY_OVERRUN);
1312                                         }
1313                                         /* XXX should handle break (0x10) */
1314                                         if (stat & RXERROR_PARITY)
1315                                                 flag = TTY_PARITY;
1316                                         else if (stat & RXERROR_FRAMING)
1317                                                 flag = TTY_FRAME;
1318
1319                                         tty_insert_flip_char(&port->port,
1320                                                         data[i+1], flag);
1321                                 }
1322                         }
1323                 }
1324                 tty_flip_buffer_push(&port->port);
1325         }
1326
1327         /* Resubmit urb so we continue receiving */
1328         err = usb_submit_urb(urb, GFP_ATOMIC);
1329         if (err != 0)
1330                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1331 }
1332
1333
1334 static void     usa90_instat_callback(struct urb *urb)
1335 {
1336         unsigned char                           *data = urb->transfer_buffer;
1337         struct keyspan_usa90_portStatusMessage  *msg;
1338         struct usb_serial                       *serial;
1339         struct usb_serial_port                  *port;
1340         struct keyspan_port_private             *p_priv;
1341         int old_dcd_state, err;
1342         int status = urb->status;
1343
1344         serial =  urb->context;
1345
1346         if (status) {
1347                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1348                                 __func__, status);
1349                 return;
1350         }
1351         if (urb->actual_length < 14) {
1352                 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
1353                 goto exit;
1354         }
1355
1356         msg = (struct keyspan_usa90_portStatusMessage *)data;
1357
1358         /* Now do something useful with the data */
1359
1360         port = serial->port[0];
1361         p_priv = usb_get_serial_port_data(port);
1362         if (!p_priv)
1363                 goto resubmit;
1364
1365         /* Update handshaking pin state information */
1366         old_dcd_state = p_priv->dcd_state;
1367         p_priv->cts_state = ((msg->cts) ? 1 : 0);
1368         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1369         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1370         p_priv->ri_state = ((msg->ri) ? 1 : 0);
1371
1372         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1373                 tty_port_tty_hangup(&port->port, true);
1374 resubmit:
1375         /* Resubmit urb so we continue receiving */
1376         err = usb_submit_urb(urb, GFP_ATOMIC);
1377         if (err != 0)
1378                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1379 exit:
1380         ;
1381 }
1382
1383 static void     usa90_outcont_callback(struct urb *urb)
1384 {
1385         struct usb_serial_port *port;
1386         struct keyspan_port_private *p_priv;
1387
1388         port =  urb->context;
1389         p_priv = usb_get_serial_port_data(port);
1390
1391         if (p_priv->resend_cont) {
1392                 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
1393                 keyspan_usa90_send_setup(port->serial, port,
1394                                                 p_priv->resend_cont - 1);
1395         }
1396 }
1397
1398 /* Status messages from the 28xg */
1399 static void     usa67_instat_callback(struct urb *urb)
1400 {
1401         int                                     err;
1402         unsigned char                           *data = urb->transfer_buffer;
1403         struct keyspan_usa67_portStatusMessage  *msg;
1404         struct usb_serial                       *serial;
1405         struct usb_serial_port                  *port;
1406         struct keyspan_port_private             *p_priv;
1407         int old_dcd_state;
1408         int status = urb->status;
1409
1410         serial = urb->context;
1411
1412         if (status) {
1413                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1414                                 __func__, status);
1415                 return;
1416         }
1417
1418         if (urb->actual_length !=
1419                         sizeof(struct keyspan_usa67_portStatusMessage)) {
1420                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1421                 return;
1422         }
1423
1424
1425         /* Now do something useful with the data */
1426         msg = (struct keyspan_usa67_portStatusMessage *)data;
1427
1428         /* Check port number from message and retrieve private data */
1429         if (msg->port >= serial->num_ports) {
1430                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1431                 return;
1432         }
1433
1434         port = serial->port[msg->port];
1435         p_priv = usb_get_serial_port_data(port);
1436         if (!p_priv)
1437                 goto resubmit;
1438
1439         /* Update handshaking pin state information */
1440         old_dcd_state = p_priv->dcd_state;
1441         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
1442         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
1443
1444         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1445                 tty_port_tty_hangup(&port->port, true);
1446 resubmit:
1447         /* Resubmit urb so we continue receiving */
1448         err = usb_submit_urb(urb, GFP_ATOMIC);
1449         if (err != 0)
1450                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1451 }
1452
1453 static void usa67_glocont_callback(struct urb *urb)
1454 {
1455         struct usb_serial *serial;
1456         struct usb_serial_port *port;
1457         struct keyspan_port_private *p_priv;
1458         int i;
1459
1460         serial = urb->context;
1461         for (i = 0; i < serial->num_ports; ++i) {
1462                 port = serial->port[i];
1463                 p_priv = usb_get_serial_port_data(port);
1464                 if (!p_priv)
1465                         continue;
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 = "/*(DEBLOBBED)*/";
1638                 break;
1639
1640         case keyspan_usa28x_pre_product_id:
1641                 fw_name = "/*(DEBLOBBED)*/";
1642                 break;
1643
1644         case keyspan_usa28xa_pre_product_id:
1645                 fw_name = "/*(DEBLOBBED)*/";
1646                 break;
1647
1648         case keyspan_usa28xb_pre_product_id:
1649                 fw_name = "/*(DEBLOBBED)*/";
1650                 break;
1651
1652         case keyspan_usa19_pre_product_id:
1653                 fw_name = "/*(DEBLOBBED)*/";
1654                 break;
1655
1656         case keyspan_usa19qi_pre_product_id:
1657                 fw_name = "/*(DEBLOBBED)*/";
1658                 break;
1659
1660         case keyspan_mpr_pre_product_id:
1661                 fw_name = "/*(DEBLOBBED)*/";
1662                 break;
1663
1664         case keyspan_usa19qw_pre_product_id:
1665                 fw_name = "/*(DEBLOBBED)*/";
1666                 break;
1667
1668         case keyspan_usa18x_pre_product_id:
1669                 fw_name = "/*(DEBLOBBED)*/";
1670                 break;
1671
1672         case keyspan_usa19w_pre_product_id:
1673                 fw_name = "/*(DEBLOBBED)*/";
1674                 break;
1675
1676         case keyspan_usa49w_pre_product_id:
1677                 fw_name = "/*(DEBLOBBED)*/";
1678                 break;
1679
1680         case keyspan_usa49wlc_pre_product_id:
1681                 fw_name = "/*(DEBLOBBED)*/";
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                 usb_free_urb(urb);
1749                 return NULL;
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_free_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_free_out_buffer;
2920         }
2921
2922         p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
2923         if (!p_priv->inack_buffer)
2924                 goto err_free_out_buffer;
2925
2926         p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
2927         if (!p_priv->outcont_buffer)
2928                 goto err_free_inack_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_free_inack_buffer:
2975         kfree(p_priv->inack_buffer);
2976 err_free_out_buffer:
2977         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2978                 kfree(p_priv->out_buffer[i]);
2979 err_free_in_buffer:
2980         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2981                 kfree(p_priv->in_buffer[i]);
2982         kfree(p_priv);
2983
2984         return -ENOMEM;
2985 }
2986
2987 static int keyspan_port_remove(struct usb_serial_port *port)
2988 {
2989         struct keyspan_port_private *p_priv;
2990         int i;
2991
2992         p_priv = usb_get_serial_port_data(port);
2993
2994         usb_kill_urb(p_priv->inack_urb);
2995         usb_kill_urb(p_priv->outcont_urb);
2996         for (i = 0; i < 2; i++) {
2997                 usb_kill_urb(p_priv->in_urbs[i]);
2998                 usb_kill_urb(p_priv->out_urbs[i]);
2999         }
3000
3001         usb_free_urb(p_priv->inack_urb);
3002         usb_free_urb(p_priv->outcont_urb);
3003         for (i = 0; i < 2; i++) {
3004                 usb_free_urb(p_priv->in_urbs[i]);
3005                 usb_free_urb(p_priv->out_urbs[i]);
3006         }
3007
3008         kfree(p_priv->outcont_buffer);
3009         kfree(p_priv->inack_buffer);
3010         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
3011                 kfree(p_priv->out_buffer[i]);
3012         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
3013                 kfree(p_priv->in_buffer[i]);
3014
3015         kfree(p_priv);
3016
3017         return 0;
3018 }
3019
3020 /* Structs for the devices, pre and post renumeration. */
3021 static struct usb_serial_driver keyspan_pre_device = {
3022         .driver = {
3023                 .owner          = THIS_MODULE,
3024                 .name           = "keyspan_no_firm",
3025         },
3026         .description            = "Keyspan - (without firmware)",
3027         .id_table               = keyspan_pre_ids,
3028         .num_ports              = 1,
3029         .attach                 = keyspan_fake_startup,
3030 };
3031
3032 static struct usb_serial_driver keyspan_1port_device = {
3033         .driver = {
3034                 .owner          = THIS_MODULE,
3035                 .name           = "keyspan_1",
3036         },
3037         .description            = "Keyspan 1 port adapter",
3038         .id_table               = keyspan_1port_ids,
3039         .num_ports              = 1,
3040         .open                   = keyspan_open,
3041         .close                  = keyspan_close,
3042         .dtr_rts                = keyspan_dtr_rts,
3043         .write                  = keyspan_write,
3044         .write_room             = keyspan_write_room,
3045         .set_termios            = keyspan_set_termios,
3046         .break_ctl              = keyspan_break_ctl,
3047         .tiocmget               = keyspan_tiocmget,
3048         .tiocmset               = keyspan_tiocmset,
3049         .attach                 = keyspan_startup,
3050         .disconnect             = keyspan_disconnect,
3051         .release                = keyspan_release,
3052         .port_probe             = keyspan_port_probe,
3053         .port_remove            = keyspan_port_remove,
3054 };
3055
3056 static struct usb_serial_driver keyspan_2port_device = {
3057         .driver = {
3058                 .owner          = THIS_MODULE,
3059                 .name           = "keyspan_2",
3060         },
3061         .description            = "Keyspan 2 port adapter",
3062         .id_table               = keyspan_2port_ids,
3063         .num_ports              = 2,
3064         .open                   = keyspan_open,
3065         .close                  = keyspan_close,
3066         .dtr_rts                = keyspan_dtr_rts,
3067         .write                  = keyspan_write,
3068         .write_room             = keyspan_write_room,
3069         .set_termios            = keyspan_set_termios,
3070         .break_ctl              = keyspan_break_ctl,
3071         .tiocmget               = keyspan_tiocmget,
3072         .tiocmset               = keyspan_tiocmset,
3073         .attach                 = keyspan_startup,
3074         .disconnect             = keyspan_disconnect,
3075         .release                = keyspan_release,
3076         .port_probe             = keyspan_port_probe,
3077         .port_remove            = keyspan_port_remove,
3078 };
3079
3080 static struct usb_serial_driver keyspan_4port_device = {
3081         .driver = {
3082                 .owner          = THIS_MODULE,
3083                 .name           = "keyspan_4",
3084         },
3085         .description            = "Keyspan 4 port adapter",
3086         .id_table               = keyspan_4port_ids,
3087         .num_ports              = 4,
3088         .open                   = keyspan_open,
3089         .close                  = keyspan_close,
3090         .dtr_rts                = keyspan_dtr_rts,
3091         .write                  = keyspan_write,
3092         .write_room             = keyspan_write_room,
3093         .set_termios            = keyspan_set_termios,
3094         .break_ctl              = keyspan_break_ctl,
3095         .tiocmget               = keyspan_tiocmget,
3096         .tiocmset               = keyspan_tiocmset,
3097         .attach                 = keyspan_startup,
3098         .disconnect             = keyspan_disconnect,
3099         .release                = keyspan_release,
3100         .port_probe             = keyspan_port_probe,
3101         .port_remove            = keyspan_port_remove,
3102 };
3103
3104 static struct usb_serial_driver * const serial_drivers[] = {
3105         &keyspan_pre_device, &keyspan_1port_device,
3106         &keyspan_2port_device, &keyspan_4port_device, NULL
3107 };
3108
3109 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
3110
3111 MODULE_AUTHOR(DRIVER_AUTHOR);
3112 MODULE_DESCRIPTION(DRIVER_DESC);
3113 MODULE_LICENSE("GPL");
3114
3115 /*(DEBLOBBED)*/