usb/serial/keyspan.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003   Keyspan USB to Serial Converter driver
0004
0005   (C) Copyright (C) 2000-2001   Hugh Blemings <hugh@blemings.org>
0006   (C) Copyright (C) 2002    Greg Kroah-Hartman <greg@kroah.com>
0007
0008   See http://blemings.org/hugh/keyspan.html for more information.
0009
0010   Code in this driver inspired by and in a number of places taken
0011   from Brian Warner's original Keyspan-PDA driver.
0012
0013   This driver has been put together with the support of Innosys, Inc.
0014   and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
0015   Thanks Guys :)
0016
0017   Thanks to Paulus for miscellaneous tidy ups, some largish chunks
0018   of much nicer and/or completely new code and (perhaps most uniquely)
0019   having the patience to sit down and explain why and where he'd changed
0020   stuff.
0021
0022   Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
0023   staff in their work on open source projects.
0024 */
0025
0026
0027 #include <linux/kernel.h>
0028 #include <linux/jiffies.h>
0029 #include <linux/errno.h>
0030 #include <linux/slab.h>
0031 #include <linux/tty.h>
0032 #include <linux/tty_driver.h>
0033 #include <linux/tty_flip.h>
0034 #include <linux/module.h>
0035 #include <linux/spinlock.h>
0036 #include <linux/uaccess.h>
0037 #include <linux/usb.h>
0038 #include <linux/usb/serial.h>
0039 #include <linux/usb/ezusb.h>
0040
0041 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
0042 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
0043
0044 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port);
0045
0046 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
0047                    u32 baud_rate, u32 baudclk,
0048                    u8 *rate_hi, u8 *rate_low,
0049                    u8 *prescaler, int portnum);
0050 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
0051                     u32 baud_rate, u32 baudclk,
0052                     u8 *rate_hi, u8 *rate_low,
0053                     u8 *prescaler, int portnum);
0054 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
0055                    u32 baud_rate, u32 baudclk,
0056                    u8 *rate_hi, u8 *rate_low,
0057                    u8 *prescaler, int portnum);
0058 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
0059                      u32 baud_rate, u32 baudclk,
0060                      u8 *rate_hi, u8 *rate_low,
0061                      u8 *prescaler, int portnum);
0062
0063 static int keyspan_usa28_send_setup(struct usb_serial *serial,
0064                     struct usb_serial_port *port,
0065                     int reset_port);
0066 static int keyspan_usa26_send_setup(struct usb_serial *serial,
0067                     struct usb_serial_port *port,
0068                     int reset_port);
0069 static int keyspan_usa49_send_setup(struct usb_serial *serial,
0070                     struct usb_serial_port *port,
0071                     int reset_port);
0072 static int keyspan_usa90_send_setup(struct usb_serial *serial,
0073                     struct usb_serial_port *port,
0074                     int reset_port);
0075 static int keyspan_usa67_send_setup(struct usb_serial *serial,
0076                     struct usb_serial_port *port,
0077                     int reset_port);
0078
0079 /* Values used for baud rate calculation - device specific */
0080 #define KEYSPAN_INVALID_BAUD_RATE       (-1)
0081 #define KEYSPAN_BAUD_RATE_OK            (0)
0082 #define KEYSPAN_USA18X_BAUDCLK          (12000000L) /* a guess */
0083 #define KEYSPAN_USA19_BAUDCLK           (12000000L)
0084 #define KEYSPAN_USA19W_BAUDCLK          (24000000L)
0085 #define KEYSPAN_USA19HS_BAUDCLK         (14769231L)
0086 #define KEYSPAN_USA28_BAUDCLK           (1843200L)
0087 #define KEYSPAN_USA28X_BAUDCLK          (12000000L)
0088 #define KEYSPAN_USA49W_BAUDCLK          (48000000L)
0089
0090 /* Some constants used to characterise each device.  */
0091 #define KEYSPAN_MAX_NUM_PORTS           (4)
0092 #define KEYSPAN_MAX_FLIPS           (2)
0093
0094 /*
0095  * Device info for the Keyspan serial converter, used by the overall
0096  * usb-serial probe function.
0097  */
0098 #define KEYSPAN_VENDOR_ID           (0x06cd)
0099
0100 /* Product IDs for the products supported, pre-renumeration */
0101 #define keyspan_usa18x_pre_product_id       0x0105
0102 #define keyspan_usa19_pre_product_id        0x0103
0103 #define keyspan_usa19qi_pre_product_id      0x010b
0104 #define keyspan_mpr_pre_product_id      0x011b
0105 #define keyspan_usa19qw_pre_product_id      0x0118
0106 #define keyspan_usa19w_pre_product_id       0x0106
0107 #define keyspan_usa28_pre_product_id        0x0101
0108 #define keyspan_usa28x_pre_product_id       0x0102
0109 #define keyspan_usa28xa_pre_product_id      0x0114
0110 #define keyspan_usa28xb_pre_product_id      0x0113
0111 #define keyspan_usa49w_pre_product_id       0x0109
0112 #define keyspan_usa49wlc_pre_product_id     0x011a
0113
0114 /*
0115  * Product IDs post-renumeration.  Note that the 28x and 28xb have the same
0116  * id's post-renumeration but behave identically so it's not an issue. As
0117  * such, the 28xb is not listed in any of the device tables.
0118  */
0119 #define keyspan_usa18x_product_id       0x0112
0120 #define keyspan_usa19_product_id        0x0107
0121 #define keyspan_usa19qi_product_id      0x010c
0122 #define keyspan_usa19hs_product_id      0x0121
0123 #define keyspan_mpr_product_id          0x011c
0124 #define keyspan_usa19qw_product_id      0x0119
0125 #define keyspan_usa19w_product_id       0x0108
0126 #define keyspan_usa28_product_id        0x010f
0127 #define keyspan_usa28x_product_id       0x0110
0128 #define keyspan_usa28xa_product_id      0x0115
0129 #define keyspan_usa28xb_product_id      0x0110
0130 #define keyspan_usa28xg_product_id      0x0135
0131 #define keyspan_usa49w_product_id       0x010a
0132 #define keyspan_usa49wlc_product_id     0x012a
0133 #define keyspan_usa49wg_product_id      0x0131
0134
0135 struct keyspan_device_details {
0136     /* product ID value */
0137     int product_id;
0138
0139     enum    {msg_usa26, msg_usa28, msg_usa49, msg_usa90, msg_usa67} msg_format;
0140
0141         /* Number of physical ports */
0142     int num_ports;
0143
0144         /* 1 if endpoint flipping used on input, 0 if not */
0145     int indat_endp_flip;
0146
0147         /* 1 if endpoint flipping used on output, 0 if not */
0148     int outdat_endp_flip;
0149
0150         /*
0151          * Table mapping input data endpoint IDs to physical port
0152          * number and flip if used
0153          */
0154     int indat_endpoints[KEYSPAN_MAX_NUM_PORTS];
0155
0156         /* Same for output endpoints */
0157     int outdat_endpoints[KEYSPAN_MAX_NUM_PORTS];
0158
0159         /* Input acknowledge endpoints */
0160     int inack_endpoints[KEYSPAN_MAX_NUM_PORTS];
0161
0162         /* Output control endpoints */
0163     int outcont_endpoints[KEYSPAN_MAX_NUM_PORTS];
0164
0165         /* Endpoint used for input status */
0166     int instat_endpoint;
0167
0168         /* Endpoint used for input data 49WG only */
0169     int indat_endpoint;
0170
0171         /* Endpoint used for global control functions */
0172     int glocont_endpoint;
0173
0174     int (*calculate_baud_rate)(struct usb_serial_port *port,
0175                        u32 baud_rate, u32 baudclk,
0176                        u8 *rate_hi, u8 *rate_low, u8 *prescaler,
0177                        int portnum);
0178     u32 baudclk;
0179 };
0180
0181 /*
0182  * Now for each device type we setup the device detail structure with the
0183  * appropriate information (provided in Keyspan's documentation)
0184  */
0185
0186 static const struct keyspan_device_details usa18x_device_details = {
0187     .product_id     = keyspan_usa18x_product_id,
0188     .msg_format     = msg_usa26,
0189     .num_ports      = 1,
0190     .indat_endp_flip    = 0,
0191     .outdat_endp_flip   = 1,
0192     .indat_endpoints    = {0x81},
0193     .outdat_endpoints   = {0x01},
0194     .inack_endpoints    = {0x85},
0195     .outcont_endpoints  = {0x05},
0196     .instat_endpoint    = 0x87,
0197     .indat_endpoint     = -1,
0198     .glocont_endpoint   = 0x07,
0199     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0200     .baudclk        = KEYSPAN_USA18X_BAUDCLK,
0201 };
0202
0203 static const struct keyspan_device_details usa19_device_details = {
0204     .product_id     = keyspan_usa19_product_id,
0205     .msg_format     = msg_usa28,
0206     .num_ports      = 1,
0207     .indat_endp_flip    = 1,
0208     .outdat_endp_flip   = 1,
0209     .indat_endpoints    = {0x81},
0210     .outdat_endpoints   = {0x01},
0211     .inack_endpoints    = {0x83},
0212     .outcont_endpoints  = {0x03},
0213     .instat_endpoint    = 0x84,
0214     .indat_endpoint     = -1,
0215     .glocont_endpoint   = -1,
0216     .calculate_baud_rate    = keyspan_usa19_calc_baud,
0217     .baudclk        = KEYSPAN_USA19_BAUDCLK,
0218 };
0219
0220 static const struct keyspan_device_details usa19qi_device_details = {
0221     .product_id     = keyspan_usa19qi_product_id,
0222     .msg_format     = msg_usa28,
0223     .num_ports      = 1,
0224     .indat_endp_flip    = 1,
0225     .outdat_endp_flip   = 1,
0226     .indat_endpoints    = {0x81},
0227     .outdat_endpoints   = {0x01},
0228     .inack_endpoints    = {0x83},
0229     .outcont_endpoints  = {0x03},
0230     .instat_endpoint    = 0x84,
0231     .indat_endpoint     = -1,
0232     .glocont_endpoint   = -1,
0233     .calculate_baud_rate    = keyspan_usa28_calc_baud,
0234     .baudclk        = KEYSPAN_USA19_BAUDCLK,
0235 };
0236
0237 static const struct keyspan_device_details mpr_device_details = {
0238     .product_id     = keyspan_mpr_product_id,
0239     .msg_format     = msg_usa28,
0240     .num_ports      = 1,
0241     .indat_endp_flip    = 1,
0242     .outdat_endp_flip   = 1,
0243     .indat_endpoints    = {0x81},
0244     .outdat_endpoints   = {0x01},
0245     .inack_endpoints    = {0x83},
0246     .outcont_endpoints  = {0x03},
0247     .instat_endpoint    = 0x84,
0248     .indat_endpoint     = -1,
0249     .glocont_endpoint   = -1,
0250     .calculate_baud_rate    = keyspan_usa28_calc_baud,
0251     .baudclk        = KEYSPAN_USA19_BAUDCLK,
0252 };
0253
0254 static const struct keyspan_device_details usa19qw_device_details = {
0255     .product_id     = keyspan_usa19qw_product_id,
0256     .msg_format     = msg_usa26,
0257     .num_ports      = 1,
0258     .indat_endp_flip    = 0,
0259     .outdat_endp_flip   = 1,
0260     .indat_endpoints    = {0x81},
0261     .outdat_endpoints   = {0x01},
0262     .inack_endpoints    = {0x85},
0263     .outcont_endpoints  = {0x05},
0264     .instat_endpoint    = 0x87,
0265     .indat_endpoint     = -1,
0266     .glocont_endpoint   = 0x07,
0267     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0268     .baudclk        = KEYSPAN_USA19W_BAUDCLK,
0269 };
0270
0271 static const struct keyspan_device_details usa19w_device_details = {
0272     .product_id     = keyspan_usa19w_product_id,
0273     .msg_format     = msg_usa26,
0274     .num_ports      = 1,
0275     .indat_endp_flip    = 0,
0276     .outdat_endp_flip   = 1,
0277     .indat_endpoints    = {0x81},
0278     .outdat_endpoints   = {0x01},
0279     .inack_endpoints    = {0x85},
0280     .outcont_endpoints  = {0x05},
0281     .instat_endpoint    = 0x87,
0282     .indat_endpoint     = -1,
0283     .glocont_endpoint   = 0x07,
0284     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0285     .baudclk        = KEYSPAN_USA19W_BAUDCLK,
0286 };
0287
0288 static const struct keyspan_device_details usa19hs_device_details = {
0289     .product_id     = keyspan_usa19hs_product_id,
0290     .msg_format     = msg_usa90,
0291     .num_ports      = 1,
0292     .indat_endp_flip    = 0,
0293     .outdat_endp_flip   = 0,
0294     .indat_endpoints    = {0x81},
0295     .outdat_endpoints   = {0x01},
0296     .inack_endpoints    = {-1},
0297     .outcont_endpoints  = {0x02},
0298     .instat_endpoint    = 0x82,
0299     .indat_endpoint     = -1,
0300     .glocont_endpoint   = -1,
0301     .calculate_baud_rate    = keyspan_usa19hs_calc_baud,
0302     .baudclk        = KEYSPAN_USA19HS_BAUDCLK,
0303 };
0304
0305 static const struct keyspan_device_details usa28_device_details = {
0306     .product_id     = keyspan_usa28_product_id,
0307     .msg_format     = msg_usa28,
0308     .num_ports      = 2,
0309     .indat_endp_flip    = 1,
0310     .outdat_endp_flip   = 1,
0311     .indat_endpoints    = {0x81, 0x83},
0312     .outdat_endpoints   = {0x01, 0x03},
0313     .inack_endpoints    = {0x85, 0x86},
0314     .outcont_endpoints  = {0x05, 0x06},
0315     .instat_endpoint    = 0x87,
0316     .indat_endpoint     = -1,
0317     .glocont_endpoint   = 0x07,
0318     .calculate_baud_rate    = keyspan_usa28_calc_baud,
0319     .baudclk        = KEYSPAN_USA28_BAUDCLK,
0320 };
0321
0322 static const struct keyspan_device_details usa28x_device_details = {
0323     .product_id     = keyspan_usa28x_product_id,
0324     .msg_format     = msg_usa26,
0325     .num_ports      = 2,
0326     .indat_endp_flip    = 0,
0327     .outdat_endp_flip   = 1,
0328     .indat_endpoints    = {0x81, 0x83},
0329     .outdat_endpoints   = {0x01, 0x03},
0330     .inack_endpoints    = {0x85, 0x86},
0331     .outcont_endpoints  = {0x05, 0x06},
0332     .instat_endpoint    = 0x87,
0333     .indat_endpoint     = -1,
0334     .glocont_endpoint   = 0x07,
0335     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0336     .baudclk        = KEYSPAN_USA28X_BAUDCLK,
0337 };
0338
0339 static const struct keyspan_device_details usa28xa_device_details = {
0340     .product_id     = keyspan_usa28xa_product_id,
0341     .msg_format     = msg_usa26,
0342     .num_ports      = 2,
0343     .indat_endp_flip    = 0,
0344     .outdat_endp_flip   = 1,
0345     .indat_endpoints    = {0x81, 0x83},
0346     .outdat_endpoints   = {0x01, 0x03},
0347     .inack_endpoints    = {0x85, 0x86},
0348     .outcont_endpoints  = {0x05, 0x06},
0349     .instat_endpoint    = 0x87,
0350     .indat_endpoint     = -1,
0351     .glocont_endpoint   = 0x07,
0352     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0353     .baudclk        = KEYSPAN_USA28X_BAUDCLK,
0354 };
0355
0356 static const struct keyspan_device_details usa28xg_device_details = {
0357     .product_id     = keyspan_usa28xg_product_id,
0358     .msg_format     = msg_usa67,
0359     .num_ports      = 2,
0360     .indat_endp_flip    = 0,
0361     .outdat_endp_flip   = 0,
0362     .indat_endpoints    = {0x84, 0x88},
0363     .outdat_endpoints   = {0x02, 0x06},
0364     .inack_endpoints    = {-1, -1},
0365     .outcont_endpoints  = {-1, -1},
0366     .instat_endpoint    = 0x81,
0367     .indat_endpoint     = -1,
0368     .glocont_endpoint   = 0x01,
0369     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0370     .baudclk        = KEYSPAN_USA28X_BAUDCLK,
0371 };
0372 /*
0373  * We don't need a separate entry for the usa28xb as it appears as a 28x
0374  * anyway.
0375  */
0376
0377 static const struct keyspan_device_details usa49w_device_details = {
0378     .product_id     = keyspan_usa49w_product_id,
0379     .msg_format     = msg_usa49,
0380     .num_ports      = 4,
0381     .indat_endp_flip    = 0,
0382     .outdat_endp_flip   = 0,
0383     .indat_endpoints    = {0x81, 0x82, 0x83, 0x84},
0384     .outdat_endpoints   = {0x01, 0x02, 0x03, 0x04},
0385     .inack_endpoints    = {-1, -1, -1, -1},
0386     .outcont_endpoints  = {-1, -1, -1, -1},
0387     .instat_endpoint    = 0x87,
0388     .indat_endpoint     = -1,
0389     .glocont_endpoint   = 0x07,
0390     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0391     .baudclk        = KEYSPAN_USA49W_BAUDCLK,
0392 };
0393
0394 static const struct keyspan_device_details usa49wlc_device_details = {
0395     .product_id     = keyspan_usa49wlc_product_id,
0396     .msg_format     = msg_usa49,
0397     .num_ports      = 4,
0398     .indat_endp_flip    = 0,
0399     .outdat_endp_flip   = 0,
0400     .indat_endpoints    = {0x81, 0x82, 0x83, 0x84},
0401     .outdat_endpoints   = {0x01, 0x02, 0x03, 0x04},
0402     .inack_endpoints    = {-1, -1, -1, -1},
0403     .outcont_endpoints  = {-1, -1, -1, -1},
0404     .instat_endpoint    = 0x87,
0405     .indat_endpoint     = -1,
0406     .glocont_endpoint   = 0x07,
0407     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0408     .baudclk        = KEYSPAN_USA19W_BAUDCLK,
0409 };
0410
0411 static const struct keyspan_device_details usa49wg_device_details = {
0412     .product_id     = keyspan_usa49wg_product_id,
0413     .msg_format     = msg_usa49,
0414     .num_ports      = 4,
0415     .indat_endp_flip    = 0,
0416     .outdat_endp_flip   = 0,
0417     .indat_endpoints    = {-1, -1, -1, -1}, /* single 'global' data in EP */
0418     .outdat_endpoints   = {0x01, 0x02, 0x04, 0x06},
0419     .inack_endpoints    = {-1, -1, -1, -1},
0420     .outcont_endpoints  = {-1, -1, -1, -1},
0421     .instat_endpoint    = 0x81,
0422     .indat_endpoint     = 0x88,
0423     .glocont_endpoint   = 0x00,         /* uses control EP */
0424     .calculate_baud_rate    = keyspan_usa19w_calc_baud,
0425     .baudclk        = KEYSPAN_USA19W_BAUDCLK,
0426 };
0427
0428 static const struct keyspan_device_details *keyspan_devices[] = {
0429     &usa18x_device_details,
0430     &usa19_device_details,
0431     &usa19qi_device_details,
0432     &mpr_device_details,
0433     &usa19qw_device_details,
0434     &usa19w_device_details,
0435     &usa19hs_device_details,
0436     &usa28_device_details,
0437     &usa28x_device_details,
0438     &usa28xa_device_details,
0439     &usa28xg_device_details,
0440     /* 28xb not required as it renumerates as a 28x */
0441     &usa49w_device_details,
0442     &usa49wlc_device_details,
0443     &usa49wg_device_details,
0444     NULL,
0445 };
0446
0447 static const struct usb_device_id keyspan_ids_combined[] = {
0448     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
0449     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
0450     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
0451     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
0452     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
0453     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
0454     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
0455     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
0456     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
0457     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
0458     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
0459     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
0460     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
0461     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
0462     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
0463     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
0464     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
0465     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
0466     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
0467     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
0468     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
0469     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
0470     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
0471     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id)},
0472     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
0473     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
0474     { } /* Terminating entry */
0475 };
0476
0477 MODULE_DEVICE_TABLE(usb, keyspan_ids_combined);
0478
0479 /* usb_device_id table for the pre-firmware download keyspan devices */
0480 static const struct usb_device_id keyspan_pre_ids[] = {
0481     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
0482     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
0483     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
0484     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
0485     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
0486     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
0487     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
0488     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
0489     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
0490     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
0491     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
0492     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
0493     { } /* Terminating entry */
0494 };
0495
0496 static const struct usb_device_id keyspan_1port_ids[] = {
0497     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
0498     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
0499     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
0500     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
0501     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
0502     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
0503     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
0504     { } /* Terminating entry */
0505 };
0506
0507 static const struct usb_device_id keyspan_2port_ids[] = {
0508     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
0509     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
0510     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
0511     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
0512     { } /* Terminating entry */
0513 };
0514
0515 static const struct usb_device_id keyspan_4port_ids[] = {
0516     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id) },
0517     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
0518     { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
0519     { } /* Terminating entry */
0520 };
0521
0522 #define INSTAT_BUFLEN   32
0523 #define GLOCONT_BUFLEN  64
0524 #define INDAT49W_BUFLEN 512
0525 #define IN_BUFLEN   64
0526 #define OUT_BUFLEN  64
0527 #define INACK_BUFLEN    1
0528 #define OUTCONT_BUFLEN  64
0529
0530     /* Per device and per port private data */
0531 struct keyspan_serial_private {
0532     const struct keyspan_device_details *device_details;
0533
0534     struct urb  *instat_urb;
0535     char        *instat_buf;
0536
0537     /* added to support 49wg, where data from all 4 ports comes in
0538        on 1 EP and high-speed supported */
0539     struct urb  *indat_urb;
0540     char        *indat_buf;
0541
0542     /* XXX this one probably will need a lock */
0543     struct urb  *glocont_urb;
0544     char        *glocont_buf;
0545     char        *ctrl_buf;  /* for EP0 control message */
0546 };
0547
0548 struct keyspan_port_private {
0549     /* Keep track of which input & output endpoints to use */
0550     int     in_flip;
0551     int     out_flip;
0552
0553     /* Keep duplicate of device details in each port
0554        structure as well - simplifies some of the
0555        callback functions etc. */
0556     const struct keyspan_device_details *device_details;
0557
0558     /* Input endpoints and buffer for this port */
0559     struct urb  *in_urbs[2];
0560     char        *in_buffer[2];
0561     /* Output endpoints and buffer for this port */
0562     struct urb  *out_urbs[2];
0563     char        *out_buffer[2];
0564
0565     /* Input ack endpoint */
0566     struct urb  *inack_urb;
0567     char        *inack_buffer;
0568
0569     /* Output control endpoint */
0570     struct urb  *outcont_urb;
0571     char        *outcont_buffer;
0572
0573     /* Settings for the port */
0574     int     baud;
0575     int     old_baud;
0576     unsigned int    cflag;
0577     unsigned int    old_cflag;
0578     enum        {flow_none, flow_cts, flow_xon} flow_control;
0579     int     rts_state;  /* Handshaking pins (outputs) */
0580     int     dtr_state;
0581     int     cts_state;  /* Handshaking pins (inputs) */
0582     int     dsr_state;
0583     int     dcd_state;
0584     int     ri_state;
0585     int     break_on;
0586
0587     unsigned long   tx_start_time[2];
0588     int     resend_cont;    /* need to resend control packet */
0589 };
0590
0591 /* Include Keyspan message headers.  All current Keyspan Adapters
0592    make use of one of five message formats which are referred
0593    to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
0594    within this driver. */
0595 #include "keyspan_usa26msg.h"
0596 #include "keyspan_usa28msg.h"
0597 #include "keyspan_usa49msg.h"
0598 #include "keyspan_usa90msg.h"
0599 #include "keyspan_usa67msg.h"
0600
0601
0602 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
0603 {
0604     struct usb_serial_port *port = tty->driver_data;
0605     struct keyspan_port_private     *p_priv;
0606
0607     p_priv = usb_get_serial_port_data(port);
0608
0609     if (break_state == -1)
0610         p_priv->break_on = 1;
0611     else
0612         p_priv->break_on = 0;
0613
0614     keyspan_send_setup(port, 0);
0615 }
0616
0617
0618 static void keyspan_set_termios(struct tty_struct *tty,
0619         struct usb_serial_port *port, struct ktermios *old_termios)
0620 {
0621     int             baud_rate, device_port;
0622     struct keyspan_port_private     *p_priv;
0623     const struct keyspan_device_details *d_details;
0624     unsigned int            cflag;
0625
0626     p_priv = usb_get_serial_port_data(port);
0627     d_details = p_priv->device_details;
0628     cflag = tty->termios.c_cflag;
0629     device_port = port->port_number;
0630
0631     /* Baud rate calculation takes baud rate as an integer
0632        so other rates can be generated if desired. */
0633     baud_rate = tty_get_baud_rate(tty);
0634     /* If no match or invalid, don't change */
0635     if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
0636                 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
0637         /* FIXME - more to do here to ensure rate changes cleanly */
0638         /* FIXME - calculate exact rate from divisor ? */
0639         p_priv->baud = baud_rate;
0640     } else
0641         baud_rate = tty_termios_baud_rate(old_termios);
0642
0643     tty_encode_baud_rate(tty, baud_rate, baud_rate);
0644     /* set CTS/RTS handshake etc. */
0645     p_priv->cflag = cflag;
0646     p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
0647
0648     /* Mark/Space not supported */
0649     tty->termios.c_cflag &= ~CMSPAR;
0650
0651     keyspan_send_setup(port, 0);
0652 }
0653
0654 static int keyspan_tiocmget(struct tty_struct *tty)
0655 {
0656     struct usb_serial_port *port = tty->driver_data;
0657     struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
0658     unsigned int            value;
0659
0660     value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
0661         ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
0662         ((p_priv->cts_state) ? TIOCM_CTS : 0) |
0663         ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
0664         ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
0665         ((p_priv->ri_state) ? TIOCM_RNG : 0);
0666
0667     return value;
0668 }
0669
0670 static int keyspan_tiocmset(struct tty_struct *tty,
0671                 unsigned int set, unsigned int clear)
0672 {
0673     struct usb_serial_port *port = tty->driver_data;
0674     struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
0675
0676     if (set & TIOCM_RTS)
0677         p_priv->rts_state = 1;
0678     if (set & TIOCM_DTR)
0679         p_priv->dtr_state = 1;
0680     if (clear & TIOCM_RTS)
0681         p_priv->rts_state = 0;
0682     if (clear & TIOCM_DTR)
0683         p_priv->dtr_state = 0;
0684     keyspan_send_setup(port, 0);
0685     return 0;
0686 }
0687
0688 /* Write function is similar for the four protocols used
0689    with only a minor change for usa90 (usa19hs) required */
0690 static int keyspan_write(struct tty_struct *tty,
0691     struct usb_serial_port *port, const unsigned char *buf, int count)
0692 {
0693     struct keyspan_port_private     *p_priv;
0694     const struct keyspan_device_details *d_details;
0695     int             flip;
0696     int                 left, todo;
0697     struct urb          *this_urb;
0698     int                 err, maxDataLen, dataOffset;
0699
0700     p_priv = usb_get_serial_port_data(port);
0701     d_details = p_priv->device_details;
0702
0703     if (d_details->msg_format == msg_usa90) {
0704         maxDataLen = 64;
0705         dataOffset = 0;
0706     } else {
0707         maxDataLen = 63;
0708         dataOffset = 1;
0709     }
0710
0711     dev_dbg(&port->dev, "%s - %d chars, flip=%d\n", __func__, count,
0712         p_priv->out_flip);
0713
0714     for (left = count; left > 0; left -= todo) {
0715         todo = left;
0716         if (todo > maxDataLen)
0717             todo = maxDataLen;
0718
0719         flip = p_priv->out_flip;
0720
0721         /* Check we have a valid urb/endpoint before we use it... */
0722         this_urb = p_priv->out_urbs[flip];
0723         if (this_urb == NULL) {
0724             /* no bulk out, so return 0 bytes written */
0725             dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
0726             return count;
0727         }
0728
0729         dev_dbg(&port->dev, "%s - endpoint %x flip %d\n",
0730             __func__, usb_pipeendpoint(this_urb->pipe), flip);
0731
0732         if (this_urb->status == -EINPROGRESS) {
0733             if (time_before(jiffies,
0734                     p_priv->tx_start_time[flip] + 10 * HZ))
0735                 break;
0736             usb_unlink_urb(this_urb);
0737             break;
0738         }
0739
0740         /* First byte in buffer is "last flag" (except for usa19hx)
0741            - unused so for now so set to zero */
0742         ((char *)this_urb->transfer_buffer)[0] = 0;
0743
0744         memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
0745         buf += todo;
0746
0747         /* send the data out the bulk port */
0748         this_urb->transfer_buffer_length = todo + dataOffset;
0749
0750         err = usb_submit_urb(this_urb, GFP_ATOMIC);
0751         if (err != 0)
0752             dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
0753         p_priv->tx_start_time[flip] = jiffies;
0754
0755         /* Flip for next time if usa26 or usa28 interface
0756            (not used on usa49) */
0757         p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
0758     }
0759
0760     return count - left;
0761 }
0762
0763 static void usa26_indat_callback(struct urb *urb)
0764 {
0765     int         i, err;
0766     int         endpoint;
0767     struct usb_serial_port  *port;
0768     unsigned char       *data = urb->transfer_buffer;
0769     int status = urb->status;
0770
0771     endpoint = usb_pipeendpoint(urb->pipe);
0772
0773     if (status) {
0774         dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
0775             __func__, status, endpoint);
0776         return;
0777     }
0778
0779     port =  urb->context;
0780     if (urb->actual_length) {
0781         /* 0x80 bit is error flag */
0782         if ((data[0] & 0x80) == 0) {
0783             /* no errors on individual bytes, only
0784                possible overrun err */
0785             if (data[0] & RXERROR_OVERRUN) {
0786                 tty_insert_flip_char(&port->port, 0,
0787                                 TTY_OVERRUN);
0788             }
0789             for (i = 1; i < urb->actual_length ; ++i)
0790                 tty_insert_flip_char(&port->port, data[i],
0791                                 TTY_NORMAL);
0792         } else {
0793             /* some bytes had errors, every byte has status */
0794             dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
0795             for (i = 0; i + 1 < urb->actual_length; i += 2) {
0796                 int stat = data[i];
0797                 int flag = TTY_NORMAL;
0798
0799                 if (stat & RXERROR_OVERRUN) {
0800                     tty_insert_flip_char(&port->port, 0,
0801                                 TTY_OVERRUN);
0802                 }
0803                 /* XXX should handle break (0x10) */
0804                 if (stat & RXERROR_PARITY)
0805                     flag = TTY_PARITY;
0806                 else if (stat & RXERROR_FRAMING)
0807                     flag = TTY_FRAME;
0808
0809                 tty_insert_flip_char(&port->port, data[i+1],
0810                         flag);
0811             }
0812         }
0813         tty_flip_buffer_push(&port->port);
0814     }
0815
0816     /* Resubmit urb so we continue receiving */
0817     err = usb_submit_urb(urb, GFP_ATOMIC);
0818     if (err != 0)
0819         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
0820 }
0821
0822 /* Outdat handling is common for all devices */
0823 static void usa2x_outdat_callback(struct urb *urb)
0824 {
0825     struct usb_serial_port *port;
0826     struct keyspan_port_private *p_priv;
0827
0828     port =  urb->context;
0829     p_priv = usb_get_serial_port_data(port);
0830     dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
0831
0832     usb_serial_port_softint(port);
0833 }
0834
0835 static void usa26_inack_callback(struct urb *urb)
0836 {
0837 }
0838
0839 static void usa26_outcont_callback(struct urb *urb)
0840 {
0841     struct usb_serial_port *port;
0842     struct keyspan_port_private *p_priv;
0843
0844     port =  urb->context;
0845     p_priv = usb_get_serial_port_data(port);
0846
0847     if (p_priv->resend_cont) {
0848         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
0849         keyspan_usa26_send_setup(port->serial, port,
0850                         p_priv->resend_cont - 1);
0851     }
0852 }
0853
0854 static void usa26_instat_callback(struct urb *urb)
0855 {
0856     unsigned char               *data = urb->transfer_buffer;
0857     struct keyspan_usa26_portStatusMessage  *msg;
0858     struct usb_serial           *serial;
0859     struct usb_serial_port          *port;
0860     struct keyspan_port_private     *p_priv;
0861     int old_dcd_state, err;
0862     int status = urb->status;
0863
0864     serial =  urb->context;
0865
0866     if (status) {
0867         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
0868                 __func__, status);
0869         return;
0870     }
0871     if (urb->actual_length != 9) {
0872         dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
0873         goto exit;
0874     }
0875
0876     msg = (struct keyspan_usa26_portStatusMessage *)data;
0877
0878     /* Check port number from message and retrieve private data */
0879     if (msg->port >= serial->num_ports) {
0880         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
0881         goto exit;
0882     }
0883     port = serial->port[msg->port];
0884     p_priv = usb_get_serial_port_data(port);
0885     if (!p_priv)
0886         goto resubmit;
0887
0888     /* Update handshaking pin state information */
0889     old_dcd_state = p_priv->dcd_state;
0890     p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
0891     p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
0892     p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
0893     p_priv->ri_state = ((msg->ri) ? 1 : 0);
0894
0895     if (old_dcd_state != p_priv->dcd_state)
0896         tty_port_tty_hangup(&port->port, true);
0897 resubmit:
0898     /* Resubmit urb so we continue receiving */
0899     err = usb_submit_urb(urb, GFP_ATOMIC);
0900     if (err != 0)
0901         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
0902 exit: ;
0903 }
0904
0905 static void usa26_glocont_callback(struct urb *urb)
0906 {
0907 }
0908
0909
0910 static void usa28_indat_callback(struct urb *urb)
0911 {
0912     int                     err;
0913     struct usb_serial_port  *port;
0914     unsigned char           *data;
0915     struct keyspan_port_private             *p_priv;
0916     int status = urb->status;
0917
0918     port =  urb->context;
0919     p_priv = usb_get_serial_port_data(port);
0920     data = urb->transfer_buffer;
0921
0922     if (urb != p_priv->in_urbs[p_priv->in_flip])
0923         return;
0924
0925     do {
0926         if (status) {
0927             dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
0928                 __func__, status, usb_pipeendpoint(urb->pipe));
0929             return;
0930         }
0931
0932         port =  urb->context;
0933         p_priv = usb_get_serial_port_data(port);
0934         data = urb->transfer_buffer;
0935
0936         if (urb->actual_length) {
0937             tty_insert_flip_string(&port->port, data,
0938                     urb->actual_length);
0939             tty_flip_buffer_push(&port->port);
0940         }
0941
0942         /* Resubmit urb so we continue receiving */
0943         err = usb_submit_urb(urb, GFP_ATOMIC);
0944         if (err != 0)
0945             dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
0946                             __func__, err);
0947         p_priv->in_flip ^= 1;
0948
0949         urb = p_priv->in_urbs[p_priv->in_flip];
0950     } while (urb->status != -EINPROGRESS);
0951 }
0952
0953 static void usa28_inack_callback(struct urb *urb)
0954 {
0955 }
0956
0957 static void usa28_outcont_callback(struct urb *urb)
0958 {
0959     struct usb_serial_port *port;
0960     struct keyspan_port_private *p_priv;
0961
0962     port =  urb->context;
0963     p_priv = usb_get_serial_port_data(port);
0964
0965     if (p_priv->resend_cont) {
0966         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
0967         keyspan_usa28_send_setup(port->serial, port,
0968                         p_priv->resend_cont - 1);
0969     }
0970 }
0971
0972 static void usa28_instat_callback(struct urb *urb)
0973 {
0974     int                 err;
0975     unsigned char               *data = urb->transfer_buffer;
0976     struct keyspan_usa28_portStatusMessage  *msg;
0977     struct usb_serial           *serial;
0978     struct usb_serial_port          *port;
0979     struct keyspan_port_private     *p_priv;
0980     int old_dcd_state;
0981     int status = urb->status;
0982
0983     serial =  urb->context;
0984
0985     if (status) {
0986         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
0987                 __func__, status);
0988         return;
0989     }
0990
0991     if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
0992         dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
0993         goto exit;
0994     }
0995
0996     msg = (struct keyspan_usa28_portStatusMessage *)data;
0997
0998     /* Check port number from message and retrieve private data */
0999     if (msg->port >= serial->num_ports) {
1000         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1001         goto exit;
1002     }
1003     port = serial->port[msg->port];
1004     p_priv = usb_get_serial_port_data(port);
1005     if (!p_priv)
1006         goto resubmit;
1007
1008     /* Update handshaking pin state information */
1009     old_dcd_state = p_priv->dcd_state;
1010     p_priv->cts_state = ((msg->cts) ? 1 : 0);
1011     p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1012     p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1013     p_priv->ri_state = ((msg->ri) ? 1 : 0);
1014
1015     if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1016         tty_port_tty_hangup(&port->port, true);
1017 resubmit:
1018         /* Resubmit urb so we continue receiving */
1019     err = usb_submit_urb(urb, GFP_ATOMIC);
1020     if (err != 0)
1021         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1022 exit: ;
1023 }
1024
1025 static void usa28_glocont_callback(struct urb *urb)
1026 {
1027 }
1028
1029
1030 static void usa49_glocont_callback(struct urb *urb)
1031 {
1032     struct usb_serial *serial;
1033     struct usb_serial_port *port;
1034     struct keyspan_port_private *p_priv;
1035     int i;
1036
1037     serial =  urb->context;
1038     for (i = 0; i < serial->num_ports; ++i) {
1039         port = serial->port[i];
1040         p_priv = usb_get_serial_port_data(port);
1041         if (!p_priv)
1042             continue;
1043
1044         if (p_priv->resend_cont) {
1045             dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1046             keyspan_usa49_send_setup(serial, port,
1047                         p_priv->resend_cont - 1);
1048             break;
1049         }
1050     }
1051 }
1052
1053     /* This is actually called glostat in the Keyspan
1054        doco */
1055 static void usa49_instat_callback(struct urb *urb)
1056 {
1057     int                 err;
1058     unsigned char               *data = urb->transfer_buffer;
1059     struct keyspan_usa49_portStatusMessage  *msg;
1060     struct usb_serial           *serial;
1061     struct usb_serial_port          *port;
1062     struct keyspan_port_private     *p_priv;
1063     int old_dcd_state;
1064     int status = urb->status;
1065
1066     serial =  urb->context;
1067
1068     if (status) {
1069         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1070                 __func__, status);
1071         return;
1072     }
1073
1074     if (urb->actual_length !=
1075             sizeof(struct keyspan_usa49_portStatusMessage)) {
1076         dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1077         goto exit;
1078     }
1079
1080     msg = (struct keyspan_usa49_portStatusMessage *)data;
1081
1082     /* Check port number from message and retrieve private data */
1083     if (msg->portNumber >= serial->num_ports) {
1084         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1085             __func__, msg->portNumber);
1086         goto exit;
1087     }
1088     port = serial->port[msg->portNumber];
1089     p_priv = usb_get_serial_port_data(port);
1090     if (!p_priv)
1091         goto resubmit;
1092
1093     /* Update handshaking pin state information */
1094     old_dcd_state = p_priv->dcd_state;
1095     p_priv->cts_state = ((msg->cts) ? 1 : 0);
1096     p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1097     p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1098     p_priv->ri_state = ((msg->ri) ? 1 : 0);
1099
1100     if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1101         tty_port_tty_hangup(&port->port, true);
1102 resubmit:
1103     /* Resubmit urb so we continue receiving */
1104     err = usb_submit_urb(urb, GFP_ATOMIC);
1105     if (err != 0)
1106         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1107 exit:   ;
1108 }
1109
1110 static void usa49_inack_callback(struct urb *urb)
1111 {
1112 }
1113
1114 static void usa49_indat_callback(struct urb *urb)
1115 {
1116     int         i, err;
1117     int         endpoint;
1118     struct usb_serial_port  *port;
1119     unsigned char       *data = urb->transfer_buffer;
1120     int status = urb->status;
1121
1122     endpoint = usb_pipeendpoint(urb->pipe);
1123
1124     if (status) {
1125         dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1126             __func__, status, endpoint);
1127         return;
1128     }
1129
1130     port =  urb->context;
1131     if (urb->actual_length) {
1132         /* 0x80 bit is error flag */
1133         if ((data[0] & 0x80) == 0) {
1134             /* no error on any byte */
1135             tty_insert_flip_string(&port->port, data + 1,
1136                         urb->actual_length - 1);
1137         } else {
1138             /* some bytes had errors, every byte has status */
1139             for (i = 0; i + 1 < urb->actual_length; i += 2) {
1140                 int stat = data[i];
1141                 int flag = TTY_NORMAL;
1142
1143                 if (stat & RXERROR_OVERRUN) {
1144                     tty_insert_flip_char(&port->port, 0,
1145                                 TTY_OVERRUN);
1146                 }
1147                 /* XXX should handle break (0x10) */
1148                 if (stat & RXERROR_PARITY)
1149                     flag = TTY_PARITY;
1150                 else if (stat & RXERROR_FRAMING)
1151                     flag = TTY_FRAME;
1152
1153                 tty_insert_flip_char(&port->port, data[i+1],
1154                         flag);
1155             }
1156         }
1157         tty_flip_buffer_push(&port->port);
1158     }
1159
1160     /* Resubmit urb so we continue receiving */
1161     err = usb_submit_urb(urb, GFP_ATOMIC);
1162     if (err != 0)
1163         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1164 }
1165
1166 static void usa49wg_indat_callback(struct urb *urb)
1167 {
1168     int         i, len, x, err;
1169     struct usb_serial   *serial;
1170     struct usb_serial_port  *port;
1171     unsigned char       *data = urb->transfer_buffer;
1172     int status = urb->status;
1173
1174     serial = urb->context;
1175
1176     if (status) {
1177         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1178                 __func__, status);
1179         return;
1180     }
1181
1182     /* inbound data is in the form P#, len, status, data */
1183     i = 0;
1184     len = 0;
1185
1186     while (i < urb->actual_length) {
1187
1188         /* Check port number from message */
1189         if (data[i] >= serial->num_ports) {
1190             dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1191                 __func__, data[i]);
1192             return;
1193         }
1194         port = serial->port[data[i++]];
1195         len = data[i++];
1196
1197         /* 0x80 bit is error flag */
1198         if ((data[i] & 0x80) == 0) {
1199             /* no error on any byte */
1200             i++;
1201             for (x = 1; x < len && i < urb->actual_length; ++x)
1202                 tty_insert_flip_char(&port->port,
1203                         data[i++], 0);
1204         } else {
1205             /*
1206              * some bytes had errors, every byte has status
1207              */
1208             for (x = 0; x + 1 < len &&
1209                     i + 1 < urb->actual_length; x += 2) {
1210                 int stat = data[i];
1211                 int flag = TTY_NORMAL;
1212
1213                 if (stat & RXERROR_OVERRUN) {
1214                     tty_insert_flip_char(&port->port, 0,
1215                                 TTY_OVERRUN);
1216                 }
1217                 /* XXX should handle break (0x10) */
1218                 if (stat & RXERROR_PARITY)
1219                     flag = TTY_PARITY;
1220                 else if (stat & RXERROR_FRAMING)
1221                     flag = TTY_FRAME;
1222
1223                 tty_insert_flip_char(&port->port, data[i+1],
1224                              flag);
1225                 i += 2;
1226             }
1227         }
1228         tty_flip_buffer_push(&port->port);
1229     }
1230
1231     /* Resubmit urb so we continue receiving */
1232     err = usb_submit_urb(urb, GFP_ATOMIC);
1233     if (err != 0)
1234         dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1235 }
1236
1237 /* not used, usa-49 doesn't have per-port control endpoints */
1238 static void usa49_outcont_callback(struct urb *urb)
1239 {
1240 }
1241
1242 static void usa90_indat_callback(struct urb *urb)
1243 {
1244     int         i, err;
1245     int         endpoint;
1246     struct usb_serial_port  *port;
1247     struct keyspan_port_private     *p_priv;
1248     unsigned char       *data = urb->transfer_buffer;
1249     int status = urb->status;
1250
1251     endpoint = usb_pipeendpoint(urb->pipe);
1252
1253     if (status) {
1254         dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1255             __func__, status, endpoint);
1256         return;
1257     }
1258
1259     port =  urb->context;
1260     p_priv = usb_get_serial_port_data(port);
1261
1262     if (urb->actual_length) {
1263         /* if current mode is DMA, looks like usa28 format
1264            otherwise looks like usa26 data format */
1265
1266         if (p_priv->baud > 57600)
1267             tty_insert_flip_string(&port->port, data,
1268                     urb->actual_length);
1269         else {
1270             /* 0x80 bit is error flag */
1271             if ((data[0] & 0x80) == 0) {
1272                 /* no errors on individual bytes, only
1273                    possible overrun err*/
1274                 if (data[0] & RXERROR_OVERRUN) {
1275                     tty_insert_flip_char(&port->port, 0,
1276                                 TTY_OVERRUN);
1277                 }
1278                 for (i = 1; i < urb->actual_length ; ++i)
1279                     tty_insert_flip_char(&port->port,
1280                             data[i], TTY_NORMAL);
1281             }  else {
1282             /* some bytes had errors, every byte has status */
1283                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
1284                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1285                     int stat = data[i];
1286                     int flag = TTY_NORMAL;
1287
1288                     if (stat & RXERROR_OVERRUN) {
1289                         tty_insert_flip_char(
1290                                 &port->port, 0,
1291                                 TTY_OVERRUN);
1292                     }
1293                     /* XXX should handle break (0x10) */
1294                     if (stat & RXERROR_PARITY)
1295                         flag = TTY_PARITY;
1296                     else if (stat & RXERROR_FRAMING)
1297                         flag = TTY_FRAME;
1298
1299                     tty_insert_flip_char(&port->port,
1300                             data[i+1], flag);
1301                 }
1302             }
1303         }
1304         tty_flip_buffer_push(&port->port);
1305     }
1306
1307     /* Resubmit urb so we continue receiving */
1308     err = usb_submit_urb(urb, GFP_ATOMIC);
1309     if (err != 0)
1310         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1311 }
1312
1313
1314 static void usa90_instat_callback(struct urb *urb)
1315 {
1316     unsigned char               *data = urb->transfer_buffer;
1317     struct keyspan_usa90_portStatusMessage  *msg;
1318     struct usb_serial           *serial;
1319     struct usb_serial_port          *port;
1320     struct keyspan_port_private     *p_priv;
1321     int old_dcd_state, err;
1322     int status = urb->status;
1323
1324     serial =  urb->context;
1325
1326     if (status) {
1327         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1328                 __func__, status);
1329         return;
1330     }
1331     if (urb->actual_length < 14) {
1332         dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
1333         goto exit;
1334     }
1335
1336     msg = (struct keyspan_usa90_portStatusMessage *)data;
1337
1338     /* Now do something useful with the data */
1339
1340     port = serial->port[0];
1341     p_priv = usb_get_serial_port_data(port);
1342     if (!p_priv)
1343         goto resubmit;
1344
1345     /* Update handshaking pin state information */
1346     old_dcd_state = p_priv->dcd_state;
1347     p_priv->cts_state = ((msg->cts) ? 1 : 0);
1348     p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1349     p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1350     p_priv->ri_state = ((msg->ri) ? 1 : 0);
1351
1352     if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1353         tty_port_tty_hangup(&port->port, true);
1354 resubmit:
1355     /* Resubmit urb so we continue receiving */
1356     err = usb_submit_urb(urb, GFP_ATOMIC);
1357     if (err != 0)
1358         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1359 exit:
1360     ;
1361 }
1362
1363 static void usa90_outcont_callback(struct urb *urb)
1364 {
1365     struct usb_serial_port *port;
1366     struct keyspan_port_private *p_priv;
1367
1368     port =  urb->context;
1369     p_priv = usb_get_serial_port_data(port);
1370
1371     if (p_priv->resend_cont) {
1372         dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
1373         keyspan_usa90_send_setup(port->serial, port,
1374                         p_priv->resend_cont - 1);
1375     }
1376 }
1377
1378 /* Status messages from the 28xg */
1379 static void usa67_instat_callback(struct urb *urb)
1380 {
1381     int                 err;
1382     unsigned char               *data = urb->transfer_buffer;
1383     struct keyspan_usa67_portStatusMessage  *msg;
1384     struct usb_serial           *serial;
1385     struct usb_serial_port          *port;
1386     struct keyspan_port_private     *p_priv;
1387     int old_dcd_state;
1388     int status = urb->status;
1389
1390     serial = urb->context;
1391
1392     if (status) {
1393         dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1394                 __func__, status);
1395         return;
1396     }
1397
1398     if (urb->actual_length !=
1399             sizeof(struct keyspan_usa67_portStatusMessage)) {
1400         dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1401         return;
1402     }
1403
1404
1405     /* Now do something useful with the data */
1406     msg = (struct keyspan_usa67_portStatusMessage *)data;
1407
1408     /* Check port number from message and retrieve private data */
1409     if (msg->port >= serial->num_ports) {
1410         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1411         return;
1412     }
1413
1414     port = serial->port[msg->port];
1415     p_priv = usb_get_serial_port_data(port);
1416     if (!p_priv)
1417         goto resubmit;
1418
1419     /* Update handshaking pin state information */
1420     old_dcd_state = p_priv->dcd_state;
1421     p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
1422     p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
1423
1424     if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1425         tty_port_tty_hangup(&port->port, true);
1426 resubmit:
1427     /* Resubmit urb so we continue receiving */
1428     err = usb_submit_urb(urb, GFP_ATOMIC);
1429     if (err != 0)
1430         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1431 }
1432
1433 static void usa67_glocont_callback(struct urb *urb)
1434 {
1435     struct usb_serial *serial;
1436     struct usb_serial_port *port;
1437     struct keyspan_port_private *p_priv;
1438     int i;
1439
1440     serial = urb->context;
1441     for (i = 0; i < serial->num_ports; ++i) {
1442         port = serial->port[i];
1443         p_priv = usb_get_serial_port_data(port);
1444         if (!p_priv)
1445             continue;
1446
1447         if (p_priv->resend_cont) {
1448             dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1449             keyspan_usa67_send_setup(serial, port,
1450                         p_priv->resend_cont - 1);
1451             break;
1452         }
1453     }
1454 }
1455
1456 static unsigned int keyspan_write_room(struct tty_struct *tty)
1457 {
1458     struct usb_serial_port *port = tty->driver_data;
1459     struct keyspan_port_private *p_priv;
1460     const struct keyspan_device_details *d_details;
1461     int             flip;
1462     unsigned int            data_len;
1463     struct urb          *this_urb;
1464
1465     p_priv = usb_get_serial_port_data(port);
1466     d_details = p_priv->device_details;
1467
1468     /* FIXME: locking */
1469     if (d_details->msg_format == msg_usa90)
1470         data_len = 64;
1471     else
1472         data_len = 63;
1473
1474     flip = p_priv->out_flip;
1475
1476     /* Check both endpoints to see if any are available. */
1477     this_urb = p_priv->out_urbs[flip];
1478     if (this_urb != NULL) {
1479         if (this_urb->status != -EINPROGRESS)
1480             return data_len;
1481         flip = (flip + 1) & d_details->outdat_endp_flip;
1482         this_urb = p_priv->out_urbs[flip];
1483         if (this_urb != NULL) {
1484             if (this_urb->status != -EINPROGRESS)
1485                 return data_len;
1486         }
1487     }
1488     return 0;
1489 }
1490
1491
1492 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1493 {
1494     struct keyspan_port_private     *p_priv;
1495     const struct keyspan_device_details *d_details;
1496     int             i, err;
1497     int             baud_rate, device_port;
1498     struct urb          *urb;
1499     unsigned int            cflag = 0;
1500
1501     p_priv = usb_get_serial_port_data(port);
1502     d_details = p_priv->device_details;
1503
1504     /* Set some sane defaults */
1505     p_priv->rts_state = 1;
1506     p_priv->dtr_state = 1;
1507     p_priv->baud = 9600;
1508
1509     /* force baud and lcr to be set on open */
1510     p_priv->old_baud = 0;
1511     p_priv->old_cflag = 0;
1512
1513     p_priv->out_flip = 0;
1514     p_priv->in_flip = 0;
1515
1516     /* Reset low level data toggle and start reading from endpoints */
1517     for (i = 0; i < 2; i++) {
1518         urb = p_priv->in_urbs[i];
1519         if (urb == NULL)
1520             continue;
1521
1522         /* make sure endpoint data toggle is synchronized
1523            with the device */
1524         usb_clear_halt(urb->dev, urb->pipe);
1525         err = usb_submit_urb(urb, GFP_KERNEL);
1526         if (err != 0)
1527             dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1528     }
1529
1530     /* Reset low level data toggle on out endpoints */
1531     for (i = 0; i < 2; i++) {
1532         urb = p_priv->out_urbs[i];
1533         if (urb == NULL)
1534             continue;
1535         /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1536                         usb_pipeout(urb->pipe), 0); */
1537     }
1538
1539     /* get the terminal config for the setup message now so we don't
1540      * need to send 2 of them */
1541
1542     device_port = port->port_number;
1543     if (tty) {
1544         cflag = tty->termios.c_cflag;
1545         /* Baud rate calculation takes baud rate as an integer
1546            so other rates can be generated if desired. */
1547         baud_rate = tty_get_baud_rate(tty);
1548         /* If no match or invalid, leave as default */
1549         if (baud_rate >= 0
1550             && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1551                     NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1552             p_priv->baud = baud_rate;
1553         }
1554     }
1555     /* set CTS/RTS handshake etc. */
1556     p_priv->cflag = cflag;
1557     p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1558
1559     keyspan_send_setup(port, 1);
1560     /* mdelay(100); */
1561     /* keyspan_set_termios(port, NULL); */
1562
1563     return 0;
1564 }
1565
1566 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1567 {
1568     struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1569
1570     p_priv->rts_state = on;
1571     p_priv->dtr_state = on;
1572     keyspan_send_setup(port, 0);
1573 }
1574
1575 static void keyspan_close(struct usb_serial_port *port)
1576 {
1577     int         i;
1578     struct keyspan_port_private     *p_priv;
1579
1580     p_priv = usb_get_serial_port_data(port);
1581
1582     p_priv->rts_state = 0;
1583     p_priv->dtr_state = 0;
1584
1585     keyspan_send_setup(port, 2);
1586     /* pilot-xfer seems to work best with this delay */
1587     mdelay(100);
1588
1589     p_priv->out_flip = 0;
1590     p_priv->in_flip = 0;
1591
1592     usb_kill_urb(p_priv->inack_urb);
1593     for (i = 0; i < 2; i++) {
1594         usb_kill_urb(p_priv->in_urbs[i]);
1595         usb_kill_urb(p_priv->out_urbs[i]);
1596     }
1597 }
1598
1599 /* download the firmware to a pre-renumeration device */
1600 static int keyspan_fake_startup(struct usb_serial *serial)
1601 {
1602     char    *fw_name;
1603
1604     dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1605         le16_to_cpu(serial->dev->descriptor.bcdDevice),
1606         le16_to_cpu(serial->dev->descriptor.idProduct));
1607
1608     if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1609                                 != 0x8000) {
1610         dev_dbg(&serial->dev->dev, "Firmware already loaded.  Quitting.\n");
1611         return 1;
1612     }
1613
1614         /* Select firmware image on the basis of idProduct */
1615     switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1616     case keyspan_usa28_pre_product_id:
1617         fw_name = "keyspan/usa28.fw";
1618         break;
1619
1620     case keyspan_usa28x_pre_product_id:
1621         fw_name = "keyspan/usa28x.fw";
1622         break;
1623
1624     case keyspan_usa28xa_pre_product_id:
1625         fw_name = "keyspan/usa28xa.fw";
1626         break;
1627
1628     case keyspan_usa28xb_pre_product_id:
1629         fw_name = "keyspan/usa28xb.fw";
1630         break;
1631
1632     case keyspan_usa19_pre_product_id:
1633         fw_name = "keyspan/usa19.fw";
1634         break;
1635
1636     case keyspan_usa19qi_pre_product_id:
1637         fw_name = "keyspan/usa19qi.fw";
1638         break;
1639
1640     case keyspan_mpr_pre_product_id:
1641         fw_name = "keyspan/mpr.fw";
1642         break;
1643
1644     case keyspan_usa19qw_pre_product_id:
1645         fw_name = "keyspan/usa19qw.fw";
1646         break;
1647
1648     case keyspan_usa18x_pre_product_id:
1649         fw_name = "keyspan/usa18x.fw";
1650         break;
1651
1652     case keyspan_usa19w_pre_product_id:
1653         fw_name = "keyspan/usa19w.fw";
1654         break;
1655
1656     case keyspan_usa49w_pre_product_id:
1657         fw_name = "keyspan/usa49w.fw";
1658         break;
1659
1660     case keyspan_usa49wlc_pre_product_id:
1661         fw_name = "keyspan/usa49wlc.fw";
1662         break;
1663
1664     default:
1665         dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1666             le16_to_cpu(serial->dev->descriptor.idProduct));
1667         return 1;
1668     }
1669
1670     dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1671
1672     if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1673         dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1674             fw_name);
1675         return -ENOENT;
1676     }
1677
1678     /* after downloading firmware Renumeration will occur in a
1679       moment and the new device will bind to the real driver */
1680
1681     /* we don't want this device to have a driver assigned to it. */
1682     return 1;
1683 }
1684
1685 /* Helper functions used by keyspan_setup_urbs */
1686 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1687                              int endpoint)
1688 {
1689     struct usb_host_interface *iface_desc;
1690     struct usb_endpoint_descriptor *ep;
1691     int i;
1692
1693     iface_desc = serial->interface->cur_altsetting;
1694     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1695         ep = &iface_desc->endpoint[i].desc;
1696         if (ep->bEndpointAddress == endpoint)
1697             return ep;
1698     }
1699     dev_warn(&serial->interface->dev, "found no endpoint descriptor for endpoint %x\n",
1700             endpoint);
1701     return NULL;
1702 }
1703
1704 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1705                       int dir, void *ctx, char *buf, int len,
1706                       void (*callback)(struct urb *))
1707 {
1708     struct urb *urb;
1709     struct usb_endpoint_descriptor const *ep_desc;
1710     char const *ep_type_name;
1711
1712     if (endpoint == -1)
1713         return NULL;        /* endpoint not needed */
1714
1715     dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %x\n",
1716             __func__, endpoint);
1717     urb = usb_alloc_urb(0, GFP_KERNEL);     /* No ISO */
1718     if (!urb)
1719         return NULL;
1720
1721     if (endpoint == 0) {
1722         /* control EP filled in when used */
1723         return urb;
1724     }
1725
1726     ep_desc = find_ep(serial, endpoint);
1727     if (!ep_desc) {
1728         usb_free_urb(urb);
1729         return NULL;
1730     }
1731     if (usb_endpoint_xfer_int(ep_desc)) {
1732         ep_type_name = "INT";
1733         usb_fill_int_urb(urb, serial->dev,
1734                  usb_sndintpipe(serial->dev, endpoint) | dir,
1735                  buf, len, callback, ctx,
1736                  ep_desc->bInterval);
1737     } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1738         ep_type_name = "BULK";
1739         usb_fill_bulk_urb(urb, serial->dev,
1740                   usb_sndbulkpipe(serial->dev, endpoint) | dir,
1741                   buf, len, callback, ctx);
1742     } else {
1743         dev_warn(&serial->interface->dev,
1744              "unsupported endpoint type %x\n",
1745              usb_endpoint_type(ep_desc));
1746         usb_free_urb(urb);
1747         return NULL;
1748     }
1749
1750     dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1751         __func__, urb, ep_type_name, endpoint);
1752     return urb;
1753 }
1754
1755 static struct callbacks {
1756     void    (*instat_callback)(struct urb *);
1757     void    (*glocont_callback)(struct urb *);
1758     void    (*indat_callback)(struct urb *);
1759     void    (*outdat_callback)(struct urb *);
1760     void    (*inack_callback)(struct urb *);
1761     void    (*outcont_callback)(struct urb *);
1762 } keyspan_callbacks[] = {
1763     {
1764         /* msg_usa26 callbacks */
1765         .instat_callback =  usa26_instat_callback,
1766         .glocont_callback = usa26_glocont_callback,
1767         .indat_callback =   usa26_indat_callback,
1768         .outdat_callback =  usa2x_outdat_callback,
1769         .inack_callback =   usa26_inack_callback,
1770         .outcont_callback = usa26_outcont_callback,
1771     }, {
1772         /* msg_usa28 callbacks */
1773         .instat_callback =  usa28_instat_callback,
1774         .glocont_callback = usa28_glocont_callback,
1775         .indat_callback =   usa28_indat_callback,
1776         .outdat_callback =  usa2x_outdat_callback,
1777         .inack_callback =   usa28_inack_callback,
1778         .outcont_callback = usa28_outcont_callback,
1779     }, {
1780         /* msg_usa49 callbacks */
1781         .instat_callback =  usa49_instat_callback,
1782         .glocont_callback = usa49_glocont_callback,
1783         .indat_callback =   usa49_indat_callback,
1784         .outdat_callback =  usa2x_outdat_callback,
1785         .inack_callback =   usa49_inack_callback,
1786         .outcont_callback = usa49_outcont_callback,
1787     }, {
1788         /* msg_usa90 callbacks */
1789         .instat_callback =  usa90_instat_callback,
1790         .glocont_callback = usa28_glocont_callback,
1791         .indat_callback =   usa90_indat_callback,
1792         .outdat_callback =  usa2x_outdat_callback,
1793         .inack_callback =   usa28_inack_callback,
1794         .outcont_callback = usa90_outcont_callback,
1795     }, {
1796         /* msg_usa67 callbacks */
1797         .instat_callback =  usa67_instat_callback,
1798         .glocont_callback = usa67_glocont_callback,
1799         .indat_callback =   usa26_indat_callback,
1800         .outdat_callback =  usa2x_outdat_callback,
1801         .inack_callback =   usa26_inack_callback,
1802         .outcont_callback = usa26_outcont_callback,
1803     }
1804 };
1805
1806     /* Generic setup urbs function that uses
1807        data in device_details */
1808 static void keyspan_setup_urbs(struct usb_serial *serial)
1809 {
1810     struct keyspan_serial_private   *s_priv;
1811     const struct keyspan_device_details *d_details;
1812     struct callbacks        *cback;
1813
1814     s_priv = usb_get_serial_data(serial);
1815     d_details = s_priv->device_details;
1816
1817     /* Setup values for the various callback routines */
1818     cback = &keyspan_callbacks[d_details->msg_format];
1819
1820     /* Allocate and set up urbs for each one that is in use,
1821        starting with instat endpoints */
1822     s_priv->instat_urb = keyspan_setup_urb
1823         (serial, d_details->instat_endpoint, USB_DIR_IN,
1824          serial, s_priv->instat_buf, INSTAT_BUFLEN,
1825          cback->instat_callback);
1826
1827     s_priv->indat_urb = keyspan_setup_urb
1828         (serial, d_details->indat_endpoint, USB_DIR_IN,
1829          serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1830          usa49wg_indat_callback);
1831
1832     s_priv->glocont_urb = keyspan_setup_urb
1833         (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1834          serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1835          cback->glocont_callback);
1836 }
1837
1838 /* usa19 function doesn't require prescaler */
1839 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1840                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1841                    u8 *rate_low, u8 *prescaler, int portnum)
1842 {
1843     u32     b16,    /* baud rate times 16 (actual rate used internally) */
1844         div,    /* divisor */
1845         cnt;    /* inverse of divisor (programmed into 8051) */
1846
1847     dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1848
1849     /* prevent divide by zero...  */
1850     b16 = baud_rate * 16L;
1851     if (b16 == 0)
1852         return KEYSPAN_INVALID_BAUD_RATE;
1853     /* Any "standard" rate over 57k6 is marginal on the USA-19
1854        as we run out of divisor resolution. */
1855     if (baud_rate > 57600)
1856         return KEYSPAN_INVALID_BAUD_RATE;
1857
1858     /* calculate the divisor and the counter (its inverse) */
1859     div = baudclk / b16;
1860     if (div == 0)
1861         return KEYSPAN_INVALID_BAUD_RATE;
1862     else
1863         cnt = 0 - div;
1864
1865     if (div > 0xffff)
1866         return KEYSPAN_INVALID_BAUD_RATE;
1867
1868     /* return the counter values if non-null */
1869     if (rate_low)
1870         *rate_low = (u8) (cnt & 0xff);
1871     if (rate_hi)
1872         *rate_hi = (u8) ((cnt >> 8) & 0xff);
1873     if (rate_low && rate_hi)
1874         dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1875                 __func__, baud_rate, *rate_hi, *rate_low);
1876     return KEYSPAN_BAUD_RATE_OK;
1877 }
1878
1879 /* usa19hs function doesn't require prescaler */
1880 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1881                      u32 baud_rate, u32 baudclk, u8 *rate_hi,
1882                      u8 *rate_low, u8 *prescaler, int portnum)
1883 {
1884     u32     b16,    /* baud rate times 16 (actual rate used internally) */
1885             div;    /* divisor */
1886
1887     dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1888
1889     /* prevent divide by zero...  */
1890     b16 = baud_rate * 16L;
1891     if (b16 == 0)
1892         return KEYSPAN_INVALID_BAUD_RATE;
1893
1894     /* calculate the divisor */
1895     div = baudclk / b16;
1896     if (div == 0)
1897         return KEYSPAN_INVALID_BAUD_RATE;
1898
1899     if (div > 0xffff)
1900         return KEYSPAN_INVALID_BAUD_RATE;
1901
1902     /* return the counter values if non-null */
1903     if (rate_low)
1904         *rate_low = (u8) (div & 0xff);
1905
1906     if (rate_hi)
1907         *rate_hi = (u8) ((div >> 8) & 0xff);
1908
1909     if (rate_low && rate_hi)
1910         dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1911             __func__, baud_rate, *rate_hi, *rate_low);
1912
1913     return KEYSPAN_BAUD_RATE_OK;
1914 }
1915
1916 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1917                     u32 baud_rate, u32 baudclk, u8 *rate_hi,
1918                     u8 *rate_low, u8 *prescaler, int portnum)
1919 {
1920     u32     b16,    /* baud rate times 16 (actual rate used internally) */
1921         clk,    /* clock with 13/8 prescaler */
1922         div,    /* divisor using 13/8 prescaler */
1923         res,    /* resulting baud rate using 13/8 prescaler */
1924         diff,   /* error using 13/8 prescaler */
1925         smallest_diff;
1926     u8  best_prescaler;
1927     int i;
1928
1929     dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1930
1931     /* prevent divide by zero */
1932     b16 = baud_rate * 16L;
1933     if (b16 == 0)
1934         return KEYSPAN_INVALID_BAUD_RATE;
1935
1936     /* Calculate prescaler by trying them all and looking
1937        for best fit */
1938
1939     /* start with largest possible difference */
1940     smallest_diff = 0xffffffff;
1941
1942         /* 0 is an invalid prescaler, used as a flag */
1943     best_prescaler = 0;
1944
1945     for (i = 8; i <= 0xff; ++i) {
1946         clk = (baudclk * 8) / (u32) i;
1947
1948         div = clk / b16;
1949         if (div == 0)
1950             continue;
1951
1952         res = clk / div;
1953         diff = (res > b16) ? (res-b16) : (b16-res);
1954
1955         if (diff < smallest_diff) {
1956             best_prescaler = i;
1957             smallest_diff = diff;
1958         }
1959     }
1960
1961     if (best_prescaler == 0)
1962         return KEYSPAN_INVALID_BAUD_RATE;
1963
1964     clk = (baudclk * 8) / (u32) best_prescaler;
1965     div = clk / b16;
1966
1967     /* return the divisor and prescaler if non-null */
1968     if (rate_low)
1969         *rate_low = (u8) (div & 0xff);
1970     if (rate_hi)
1971         *rate_hi = (u8) ((div >> 8) & 0xff);
1972     if (prescaler) {
1973         *prescaler = best_prescaler;
1974         /*  dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1975     }
1976     return KEYSPAN_BAUD_RATE_OK;
1977 }
1978
1979     /* USA-28 supports different maximum baud rates on each port */
1980 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1981                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1982                    u8 *rate_low, u8 *prescaler, int portnum)
1983 {
1984     u32     b16,    /* baud rate times 16 (actual rate used internally) */
1985         div,    /* divisor */
1986         cnt;    /* inverse of divisor (programmed into 8051) */
1987
1988     dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1989
1990         /* prevent divide by zero */
1991     b16 = baud_rate * 16L;
1992     if (b16 == 0)
1993         return KEYSPAN_INVALID_BAUD_RATE;
1994
1995     /* calculate the divisor and the counter (its inverse) */
1996     div = KEYSPAN_USA28_BAUDCLK / b16;
1997     if (div == 0)
1998         return KEYSPAN_INVALID_BAUD_RATE;
1999     else
2000         cnt = 0 - div;
2001
2002     /* check for out of range, based on portnum,
2003        and return result */
2004     if (portnum == 0) {
2005         if (div > 0xffff)
2006             return KEYSPAN_INVALID_BAUD_RATE;
2007     } else {
2008         if (portnum == 1) {
2009             if (div > 0xff)
2010                 return KEYSPAN_INVALID_BAUD_RATE;
2011         } else
2012             return KEYSPAN_INVALID_BAUD_RATE;
2013     }
2014
2015         /* return the counter values if not NULL
2016            (port 1 will ignore retHi) */
2017     if (rate_low)
2018         *rate_low = (u8) (cnt & 0xff);
2019     if (rate_hi)
2020         *rate_hi = (u8) ((cnt >> 8) & 0xff);
2021     dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
2022     return KEYSPAN_BAUD_RATE_OK;
2023 }
2024
2025 static int keyspan_usa26_send_setup(struct usb_serial *serial,
2026                     struct usb_serial_port *port,
2027                     int reset_port)
2028 {
2029     struct keyspan_usa26_portControlMessage msg;
2030     struct keyspan_serial_private       *s_priv;
2031     struct keyspan_port_private         *p_priv;
2032     const struct keyspan_device_details *d_details;
2033     struct urb              *this_urb;
2034     int                     device_port, err;
2035
2036     dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
2037
2038     s_priv = usb_get_serial_data(serial);
2039     p_priv = usb_get_serial_port_data(port);
2040     d_details = s_priv->device_details;
2041     device_port = port->port_number;
2042
2043     this_urb = p_priv->outcont_urb;
2044
2045         /* Make sure we have an urb then send the message */
2046     if (this_urb == NULL) {
2047         dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2048         return -1;
2049     }
2050
2051     dev_dbg(&port->dev, "%s - endpoint %x\n",
2052             __func__, usb_pipeendpoint(this_urb->pipe));
2053
2054     /* Save reset port val for resend.
2055        Don't overwrite resend for open/close condition. */
2056     if ((reset_port + 1) > p_priv->resend_cont)
2057         p_priv->resend_cont = reset_port + 1;
2058     if (this_urb->status == -EINPROGRESS) {
2059         /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2060         mdelay(5);
2061         return -1;
2062     }
2063
2064     memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
2065
2066     /* Only set baud rate if it's changed */
2067     if (p_priv->old_baud != p_priv->baud) {
2068         p_priv->old_baud = p_priv->baud;
2069         msg.setClocking = 0xff;
2070         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2071                            &msg.baudHi, &msg.baudLo, &msg.prescaler,
2072                            device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2073             dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2074                 __func__, p_priv->baud);
2075             msg.baudLo = 0;
2076             msg.baudHi = 125;   /* Values for 9600 baud */
2077             msg.prescaler = 10;
2078         }
2079         msg.setPrescaler = 0xff;
2080     }
2081
2082     msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2083     switch (p_priv->cflag & CSIZE) {
2084     case CS5:
2085         msg.lcr |= USA_DATABITS_5;
2086         break;
2087     case CS6:
2088         msg.lcr |= USA_DATABITS_6;
2089         break;
2090     case CS7:
2091         msg.lcr |= USA_DATABITS_7;
2092         break;
2093     case CS8:
2094         msg.lcr |= USA_DATABITS_8;
2095         break;
2096     }
2097     if (p_priv->cflag & PARENB) {
2098         /* note USA_PARITY_NONE == 0 */
2099         msg.lcr |= (p_priv->cflag & PARODD) ?
2100             USA_PARITY_ODD : USA_PARITY_EVEN;
2101     }
2102     msg.setLcr = 0xff;
2103
2104     msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2105     msg.xonFlowControl = 0;
2106     msg.setFlowControl = 0xff;
2107     msg.forwardingLength = 16;
2108     msg.xonChar = 17;
2109     msg.xoffChar = 19;
2110
2111     /* Opening port */
2112     if (reset_port == 1) {
2113         msg._txOn = 1;
2114         msg._txOff = 0;
2115         msg.txFlush = 0;
2116         msg.txBreak = 0;
2117         msg.rxOn = 1;
2118         msg.rxOff = 0;
2119         msg.rxFlush = 1;
2120         msg.rxForward = 0;
2121         msg.returnStatus = 0;
2122         msg.resetDataToggle = 0xff;
2123     }
2124
2125     /* Closing port */
2126     else if (reset_port == 2) {
2127         msg._txOn = 0;
2128         msg._txOff = 1;
2129         msg.txFlush = 0;
2130         msg.txBreak = 0;
2131         msg.rxOn = 0;
2132         msg.rxOff = 1;
2133         msg.rxFlush = 1;
2134         msg.rxForward = 0;
2135         msg.returnStatus = 0;
2136         msg.resetDataToggle = 0;
2137     }
2138
2139     /* Sending intermediate configs */
2140     else {
2141         msg._txOn = (!p_priv->break_on);
2142         msg._txOff = 0;
2143         msg.txFlush = 0;
2144         msg.txBreak = (p_priv->break_on);
2145         msg.rxOn = 0;
2146         msg.rxOff = 0;
2147         msg.rxFlush = 0;
2148         msg.rxForward = 0;
2149         msg.returnStatus = 0;
2150         msg.resetDataToggle = 0x0;
2151     }
2152
2153     /* Do handshaking outputs */
2154     msg.setTxTriState_setRts = 0xff;
2155     msg.txTriState_rts = p_priv->rts_state;
2156
2157     msg.setHskoa_setDtr = 0xff;
2158     msg.hskoa_dtr = p_priv->dtr_state;
2159
2160     p_priv->resend_cont = 0;
2161     memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2162
2163     /* send the data out the device on control endpoint */
2164     this_urb->transfer_buffer_length = sizeof(msg);
2165
2166     err = usb_submit_urb(this_urb, GFP_ATOMIC);
2167     if (err != 0)
2168         dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2169     return 0;
2170 }
2171
2172 static int keyspan_usa28_send_setup(struct usb_serial *serial,
2173                     struct usb_serial_port *port,
2174                     int reset_port)
2175 {
2176     struct keyspan_usa28_portControlMessage msg;
2177     struct keyspan_serial_private       *s_priv;
2178     struct keyspan_port_private         *p_priv;
2179     const struct keyspan_device_details *d_details;
2180     struct urb              *this_urb;
2181     int                     device_port, err;
2182
2183     s_priv = usb_get_serial_data(serial);
2184     p_priv = usb_get_serial_port_data(port);
2185     d_details = s_priv->device_details;
2186     device_port = port->port_number;
2187
2188     /* only do something if we have a bulk out endpoint */
2189     this_urb = p_priv->outcont_urb;
2190     if (this_urb == NULL) {
2191         dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2192         return -1;
2193     }
2194
2195     /* Save reset port val for resend.
2196        Don't overwrite resend for open/close condition. */
2197     if ((reset_port + 1) > p_priv->resend_cont)
2198         p_priv->resend_cont = reset_port + 1;
2199     if (this_urb->status == -EINPROGRESS) {
2200         dev_dbg(&port->dev, "%s already writing\n", __func__);
2201         mdelay(5);
2202         return -1;
2203     }
2204
2205     memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
2206
2207     msg.setBaudRate = 1;
2208     if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2209                        &msg.baudHi, &msg.baudLo, NULL,
2210                        device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2211         dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
2212                         __func__, p_priv->baud);
2213         msg.baudLo = 0xff;
2214         msg.baudHi = 0xb2;  /* Values for 9600 baud */
2215     }
2216
2217     /* If parity is enabled, we must calculate it ourselves. */
2218     msg.parity = 0;     /* XXX for now */
2219
2220     msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2221     msg.xonFlowControl = 0;
2222
2223     /* Do handshaking outputs, DTR is inverted relative to RTS */
2224     msg.rts = p_priv->rts_state;
2225     msg.dtr = p_priv->dtr_state;
2226
2227     msg.forwardingLength = 16;
2228     msg.forwardMs = 10;
2229     msg.breakThreshold = 45;
2230     msg.xonChar = 17;
2231     msg.xoffChar = 19;
2232
2233     /*msg.returnStatus = 1;
2234     msg.resetDataToggle = 0xff;*/
2235     /* Opening port */
2236     if (reset_port == 1) {
2237         msg._txOn = 1;
2238         msg._txOff = 0;
2239         msg.txFlush = 0;
2240         msg.txForceXoff = 0;
2241         msg.txBreak = 0;
2242         msg.rxOn = 1;
2243         msg.rxOff = 0;
2244         msg.rxFlush = 1;
2245         msg.rxForward = 0;
2246         msg.returnStatus = 0;
2247         msg.resetDataToggle = 0xff;
2248     }
2249     /* Closing port */
2250     else if (reset_port == 2) {
2251         msg._txOn = 0;
2252         msg._txOff = 1;
2253         msg.txFlush = 0;
2254         msg.txForceXoff = 0;
2255         msg.txBreak = 0;
2256         msg.rxOn = 0;
2257         msg.rxOff = 1;
2258         msg.rxFlush = 1;
2259         msg.rxForward = 0;
2260         msg.returnStatus = 0;
2261         msg.resetDataToggle = 0;
2262     }
2263     /* Sending intermediate configs */
2264     else {
2265         msg._txOn = (!p_priv->break_on);
2266         msg._txOff = 0;
2267         msg.txFlush = 0;
2268         msg.txForceXoff = 0;
2269         msg.txBreak = (p_priv->break_on);
2270         msg.rxOn = 0;
2271         msg.rxOff = 0;
2272         msg.rxFlush = 0;
2273         msg.rxForward = 0;
2274         msg.returnStatus = 0;
2275         msg.resetDataToggle = 0x0;
2276     }
2277
2278     p_priv->resend_cont = 0;
2279     memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2280
2281     /* send the data out the device on control endpoint */
2282     this_urb->transfer_buffer_length = sizeof(msg);
2283
2284     err = usb_submit_urb(this_urb, GFP_ATOMIC);
2285     if (err != 0)
2286         dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
2287
2288     return 0;
2289 }
2290
2291 static int keyspan_usa49_send_setup(struct usb_serial *serial,
2292                     struct usb_serial_port *port,
2293                     int reset_port)
2294 {
2295     struct keyspan_usa49_portControlMessage msg;
2296     struct usb_ctrlrequest          *dr = NULL;
2297     struct keyspan_serial_private       *s_priv;
2298     struct keyspan_port_private         *p_priv;
2299     const struct keyspan_device_details *d_details;
2300     struct urb              *this_urb;
2301     int                     err, device_port;
2302
2303     s_priv = usb_get_serial_data(serial);
2304     p_priv = usb_get_serial_port_data(port);
2305     d_details = s_priv->device_details;
2306
2307     this_urb = s_priv->glocont_urb;
2308
2309     /* Work out which port within the device is being setup */
2310     device_port = port->port_number;
2311
2312     /* Make sure we have an urb then send the message */
2313     if (this_urb == NULL) {
2314         dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2315         return -1;
2316     }
2317
2318     dev_dbg(&port->dev, "%s - endpoint %x (%d)\n",
2319         __func__, usb_pipeendpoint(this_urb->pipe), device_port);
2320
2321     /* Save reset port val for resend.
2322        Don't overwrite resend for open/close condition. */
2323     if ((reset_port + 1) > p_priv->resend_cont)
2324         p_priv->resend_cont = reset_port + 1;
2325
2326     if (this_urb->status == -EINPROGRESS) {
2327         /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2328         mdelay(5);
2329         return -1;
2330     }
2331
2332     memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
2333
2334     msg.portNumber = device_port;
2335
2336     /* Only set baud rate if it's changed */
2337     if (p_priv->old_baud != p_priv->baud) {
2338         p_priv->old_baud = p_priv->baud;
2339         msg.setClocking = 0xff;
2340         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2341                            &msg.baudHi, &msg.baudLo, &msg.prescaler,
2342                            device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2343             dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2344                 __func__, p_priv->baud);
2345             msg.baudLo = 0;
2346             msg.baudHi = 125;   /* Values for 9600 baud */
2347             msg.prescaler = 10;
2348         }
2349         /* msg.setPrescaler = 0xff; */
2350     }
2351
2352     msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2353     switch (p_priv->cflag & CSIZE) {
2354     case CS5:
2355         msg.lcr |= USA_DATABITS_5;
2356         break;
2357     case CS6:
2358         msg.lcr |= USA_DATABITS_6;
2359         break;
2360     case CS7:
2361         msg.lcr |= USA_DATABITS_7;
2362         break;
2363     case CS8:
2364         msg.lcr |= USA_DATABITS_8;
2365         break;
2366     }
2367     if (p_priv->cflag & PARENB) {
2368         /* note USA_PARITY_NONE == 0 */
2369         msg.lcr |= (p_priv->cflag & PARODD) ?
2370             USA_PARITY_ODD : USA_PARITY_EVEN;
2371     }
2372     msg.setLcr = 0xff;
2373
2374     msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2375     msg.xonFlowControl = 0;
2376     msg.setFlowControl = 0xff;
2377
2378     msg.forwardingLength = 16;
2379     msg.xonChar = 17;
2380     msg.xoffChar = 19;
2381
2382     /* Opening port */
2383     if (reset_port == 1) {
2384         msg._txOn = 1;
2385         msg._txOff = 0;
2386         msg.txFlush = 0;
2387         msg.txBreak = 0;
2388         msg.rxOn = 1;
2389         msg.rxOff = 0;
2390         msg.rxFlush = 1;
2391         msg.rxForward = 0;
2392         msg.returnStatus = 0;
2393         msg.resetDataToggle = 0xff;
2394         msg.enablePort = 1;
2395         msg.disablePort = 0;
2396     }
2397     /* Closing port */
2398     else if (reset_port == 2) {
2399         msg._txOn = 0;
2400         msg._txOff = 1;
2401         msg.txFlush = 0;
2402         msg.txBreak = 0;
2403         msg.rxOn = 0;
2404         msg.rxOff = 1;
2405         msg.rxFlush = 1;
2406         msg.rxForward = 0;
2407         msg.returnStatus = 0;
2408         msg.resetDataToggle = 0;
2409         msg.enablePort = 0;
2410         msg.disablePort = 1;
2411     }
2412     /* Sending intermediate configs */
2413     else {
2414         msg._txOn = (!p_priv->break_on);
2415         msg._txOff = 0;
2416         msg.txFlush = 0;
2417         msg.txBreak = (p_priv->break_on);
2418         msg.rxOn = 0;
2419         msg.rxOff = 0;
2420         msg.rxFlush = 0;
2421         msg.rxForward = 0;
2422         msg.returnStatus = 0;
2423         msg.resetDataToggle = 0x0;
2424         msg.enablePort = 0;
2425         msg.disablePort = 0;
2426     }
2427
2428     /* Do handshaking outputs */
2429     msg.setRts = 0xff;
2430     msg.rts = p_priv->rts_state;
2431
2432     msg.setDtr = 0xff;
2433     msg.dtr = p_priv->dtr_state;
2434
2435     p_priv->resend_cont = 0;
2436
2437     /* if the device is a 49wg, we send control message on usb
2438        control EP 0 */
2439
2440     if (d_details->product_id == keyspan_usa49wg_product_id) {
2441         dr = (void *)(s_priv->ctrl_buf);
2442         dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2443         dr->bRequest = 0xB0;    /* 49wg control message */
2444         dr->wValue = 0;
2445         dr->wIndex = 0;
2446         dr->wLength = cpu_to_le16(sizeof(msg));
2447
2448         memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2449
2450         usb_fill_control_urb(this_urb, serial->dev,
2451                 usb_sndctrlpipe(serial->dev, 0),
2452                 (unsigned char *)dr, s_priv->glocont_buf,
2453                 sizeof(msg), usa49_glocont_callback, serial);
2454
2455     } else {
2456         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2457
2458         /* send the data out the device on control endpoint */
2459         this_urb->transfer_buffer_length = sizeof(msg);
2460     }
2461     err = usb_submit_urb(this_urb, GFP_ATOMIC);
2462     if (err != 0)
2463         dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2464
2465     return 0;
2466 }
2467
2468 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2469                     struct usb_serial_port *port,
2470                     int reset_port)
2471 {
2472     struct keyspan_usa90_portControlMessage msg;
2473     struct keyspan_serial_private       *s_priv;
2474     struct keyspan_port_private         *p_priv;
2475     const struct keyspan_device_details *d_details;
2476     struct urb              *this_urb;
2477     int                     err;
2478     u8                      prescaler;
2479
2480     s_priv = usb_get_serial_data(serial);
2481     p_priv = usb_get_serial_port_data(port);
2482     d_details = s_priv->device_details;
2483
2484     /* only do something if we have a bulk out endpoint */
2485     this_urb = p_priv->outcont_urb;
2486     if (this_urb == NULL) {
2487         dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2488         return -1;
2489     }
2490
2491     /* Save reset port val for resend.
2492        Don't overwrite resend for open/close condition. */
2493     if ((reset_port + 1) > p_priv->resend_cont)
2494         p_priv->resend_cont = reset_port + 1;
2495     if (this_urb->status == -EINPROGRESS) {
2496         dev_dbg(&port->dev, "%s already writing\n", __func__);
2497         mdelay(5);
2498         return -1;
2499     }
2500
2501     memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2502
2503     /* Only set baud rate if it's changed */
2504     if (p_priv->old_baud != p_priv->baud) {
2505         p_priv->old_baud = p_priv->baud;
2506         msg.setClocking = 0x01;
2507         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2508                            &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2509             dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2510                 __func__, p_priv->baud);
2511             p_priv->baud = 9600;
2512             d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2513                 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2514         }
2515         msg.setRxMode = 1;
2516         msg.setTxMode = 1;
2517     }
2518
2519     /* modes must always be correctly specified */
2520     if (p_priv->baud > 57600) {
2521         msg.rxMode = RXMODE_DMA;
2522         msg.txMode = TXMODE_DMA;
2523     } else {
2524         msg.rxMode = RXMODE_BYHAND;
2525         msg.txMode = TXMODE_BYHAND;
2526     }
2527
2528     msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2529     switch (p_priv->cflag & CSIZE) {
2530     case CS5:
2531         msg.lcr |= USA_DATABITS_5;
2532         break;
2533     case CS6:
2534         msg.lcr |= USA_DATABITS_6;
2535         break;
2536     case CS7:
2537         msg.lcr |= USA_DATABITS_7;
2538         break;
2539     case CS8:
2540         msg.lcr |= USA_DATABITS_8;
2541         break;
2542     }
2543     if (p_priv->cflag & PARENB) {
2544         /* note USA_PARITY_NONE == 0 */
2545         msg.lcr |= (p_priv->cflag & PARODD) ?
2546             USA_PARITY_ODD : USA_PARITY_EVEN;
2547     }
2548     if (p_priv->old_cflag != p_priv->cflag) {
2549         p_priv->old_cflag = p_priv->cflag;
2550         msg.setLcr = 0x01;
2551     }
2552
2553     if (p_priv->flow_control == flow_cts)
2554         msg.txFlowControl = TXFLOW_CTS;
2555     msg.setTxFlowControl = 0x01;
2556     msg.setRxFlowControl = 0x01;
2557
2558     msg.rxForwardingLength = 16;
2559     msg.rxForwardingTimeout = 16;
2560     msg.txAckSetting = 0;
2561     msg.xonChar = 17;
2562     msg.xoffChar = 19;
2563
2564     /* Opening port */
2565     if (reset_port == 1) {
2566         msg.portEnabled = 1;
2567         msg.rxFlush = 1;
2568         msg.txBreak = (p_priv->break_on);
2569     }
2570     /* Closing port */
2571     else if (reset_port == 2)
2572         msg.portEnabled = 0;
2573     /* Sending intermediate configs */
2574     else {
2575         msg.portEnabled = 1;
2576         msg.txBreak = (p_priv->break_on);
2577     }
2578
2579     /* Do handshaking outputs */
2580     msg.setRts = 0x01;
2581     msg.rts = p_priv->rts_state;
2582
2583     msg.setDtr = 0x01;
2584     msg.dtr = p_priv->dtr_state;
2585
2586     p_priv->resend_cont = 0;
2587     memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2588
2589     /* send the data out the device on control endpoint */
2590     this_urb->transfer_buffer_length = sizeof(msg);
2591
2592     err = usb_submit_urb(this_urb, GFP_ATOMIC);
2593     if (err != 0)
2594         dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2595     return 0;
2596 }
2597
2598 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2599                     struct usb_serial_port *port,
2600                     int reset_port)
2601 {
2602     struct keyspan_usa67_portControlMessage msg;
2603     struct keyspan_serial_private       *s_priv;
2604     struct keyspan_port_private         *p_priv;
2605     const struct keyspan_device_details *d_details;
2606     struct urb              *this_urb;
2607     int                     err, device_port;
2608
2609     s_priv = usb_get_serial_data(serial);
2610     p_priv = usb_get_serial_port_data(port);
2611     d_details = s_priv->device_details;
2612
2613     this_urb = s_priv->glocont_urb;
2614
2615     /* Work out which port within the device is being setup */
2616     device_port = port->port_number;
2617
2618     /* Make sure we have an urb then send the message */
2619     if (this_urb == NULL) {
2620         dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2621         return -1;
2622     }
2623
2624     /* Save reset port val for resend.
2625        Don't overwrite resend for open/close condition. */
2626     if ((reset_port + 1) > p_priv->resend_cont)
2627         p_priv->resend_cont = reset_port + 1;
2628     if (this_urb->status == -EINPROGRESS) {
2629         /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2630         mdelay(5);
2631         return -1;
2632     }
2633
2634     memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2635
2636     msg.port = device_port;
2637
2638     /* Only set baud rate if it's changed */
2639     if (p_priv->old_baud != p_priv->baud) {
2640         p_priv->old_baud = p_priv->baud;
2641         msg.setClocking = 0xff;
2642         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2643                            &msg.baudHi, &msg.baudLo, &msg.prescaler,
2644                            device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2645             dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2646                 __func__, p_priv->baud);
2647             msg.baudLo = 0;
2648             msg.baudHi = 125;   /* Values for 9600 baud */
2649             msg.prescaler = 10;
2650         }
2651         msg.setPrescaler = 0xff;
2652     }
2653
2654     msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2655     switch (p_priv->cflag & CSIZE) {
2656     case CS5:
2657         msg.lcr |= USA_DATABITS_5;
2658         break;
2659     case CS6:
2660         msg.lcr |= USA_DATABITS_6;
2661         break;
2662     case CS7:
2663         msg.lcr |= USA_DATABITS_7;
2664         break;
2665     case CS8:
2666         msg.lcr |= USA_DATABITS_8;
2667         break;
2668     }
2669     if (p_priv->cflag & PARENB) {
2670         /* note USA_PARITY_NONE == 0 */
2671         msg.lcr |= (p_priv->cflag & PARODD) ?
2672                     USA_PARITY_ODD : USA_PARITY_EVEN;
2673     }
2674     msg.setLcr = 0xff;
2675
2676     msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2677     msg.xonFlowControl = 0;
2678     msg.setFlowControl = 0xff;
2679     msg.forwardingLength = 16;
2680     msg.xonChar = 17;
2681     msg.xoffChar = 19;
2682
2683     if (reset_port == 1) {
2684         /* Opening port */
2685         msg._txOn = 1;
2686         msg._txOff = 0;
2687         msg.txFlush = 0;
2688         msg.txBreak = 0;
2689         msg.rxOn = 1;
2690         msg.rxOff = 0;
2691         msg.rxFlush = 1;
2692         msg.rxForward = 0;
2693         msg.returnStatus = 0;
2694         msg.resetDataToggle = 0xff;
2695     } else if (reset_port == 2) {
2696         /* Closing port */
2697         msg._txOn = 0;
2698         msg._txOff = 1;
2699         msg.txFlush = 0;
2700         msg.txBreak = 0;
2701         msg.rxOn = 0;
2702         msg.rxOff = 1;
2703         msg.rxFlush = 1;
2704         msg.rxForward = 0;
2705         msg.returnStatus = 0;
2706         msg.resetDataToggle = 0;
2707     } else {
2708         /* Sending intermediate configs */
2709         msg._txOn = (!p_priv->break_on);
2710         msg._txOff = 0;
2711         msg.txFlush = 0;
2712         msg.txBreak = (p_priv->break_on);
2713         msg.rxOn = 0;
2714         msg.rxOff = 0;
2715         msg.rxFlush = 0;
2716         msg.rxForward = 0;
2717         msg.returnStatus = 0;
2718         msg.resetDataToggle = 0x0;
2719     }
2720
2721     /* Do handshaking outputs */
2722     msg.setTxTriState_setRts = 0xff;
2723     msg.txTriState_rts = p_priv->rts_state;
2724
2725     msg.setHskoa_setDtr = 0xff;
2726     msg.hskoa_dtr = p_priv->dtr_state;
2727
2728     p_priv->resend_cont = 0;
2729
2730     memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2731
2732     /* send the data out the device on control endpoint */
2733     this_urb->transfer_buffer_length = sizeof(msg);
2734
2735     err = usb_submit_urb(this_urb, GFP_ATOMIC);
2736     if (err != 0)
2737         dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2738     return 0;
2739 }
2740
2741 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2742 {
2743     struct usb_serial *serial = port->serial;
2744     struct keyspan_serial_private *s_priv;
2745     const struct keyspan_device_details *d_details;
2746
2747     s_priv = usb_get_serial_data(serial);
2748     d_details = s_priv->device_details;
2749
2750     switch (d_details->msg_format) {
2751     case msg_usa26:
2752         keyspan_usa26_send_setup(serial, port, reset_port);
2753         break;
2754     case msg_usa28:
2755         keyspan_usa28_send_setup(serial, port, reset_port);
2756         break;
2757     case msg_usa49:
2758         keyspan_usa49_send_setup(serial, port, reset_port);
2759         break;
2760     case msg_usa90:
2761         keyspan_usa90_send_setup(serial, port, reset_port);
2762         break;
2763     case msg_usa67:
2764         keyspan_usa67_send_setup(serial, port, reset_port);
2765         break;
2766     }
2767 }
2768
2769
2770 /* Gets called by the "real" driver (ie once firmware is loaded
2771    and renumeration has taken place. */
2772 static int keyspan_startup(struct usb_serial *serial)
2773 {
2774     int             i, err;
2775     struct keyspan_serial_private   *s_priv;
2776     const struct keyspan_device_details *d_details;
2777
2778     for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2779         if (d_details->product_id ==
2780                 le16_to_cpu(serial->dev->descriptor.idProduct))
2781             break;
2782     if (d_details == NULL) {
2783         dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2784             __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2785         return -ENODEV;
2786     }
2787
2788     /* Setup private data for serial driver */
2789     s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2790     if (!s_priv)
2791         return -ENOMEM;
2792
2793     s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL);
2794     if (!s_priv->instat_buf)
2795         goto err_instat_buf;
2796
2797     s_priv->indat_buf = kzalloc(INDAT49W_BUFLEN, GFP_KERNEL);
2798     if (!s_priv->indat_buf)
2799         goto err_indat_buf;
2800
2801     s_priv->glocont_buf = kzalloc(GLOCONT_BUFLEN, GFP_KERNEL);
2802     if (!s_priv->glocont_buf)
2803         goto err_glocont_buf;
2804
2805     s_priv->ctrl_buf = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
2806     if (!s_priv->ctrl_buf)
2807         goto err_ctrl_buf;
2808
2809     s_priv->device_details = d_details;
2810     usb_set_serial_data(serial, s_priv);
2811
2812     keyspan_setup_urbs(serial);
2813
2814     if (s_priv->instat_urb != NULL) {
2815         err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2816         if (err != 0)
2817             dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2818     }
2819     if (s_priv->indat_urb != NULL) {
2820         err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2821         if (err != 0)
2822             dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2823     }
2824
2825     return 0;
2826
2827 err_ctrl_buf:
2828     kfree(s_priv->glocont_buf);
2829 err_glocont_buf:
2830     kfree(s_priv->indat_buf);
2831 err_indat_buf:
2832     kfree(s_priv->instat_buf);
2833 err_instat_buf:
2834     kfree(s_priv);
2835
2836     return -ENOMEM;
2837 }
2838
2839 static void keyspan_disconnect(struct usb_serial *serial)
2840 {
2841     struct keyspan_serial_private *s_priv;
2842
2843     s_priv = usb_get_serial_data(serial);
2844
2845     usb_kill_urb(s_priv->instat_urb);
2846     usb_kill_urb(s_priv->glocont_urb);
2847     usb_kill_urb(s_priv->indat_urb);
2848 }
2849
2850 static void keyspan_release(struct usb_serial *serial)
2851 {
2852     struct keyspan_serial_private *s_priv;
2853
2854     s_priv = usb_get_serial_data(serial);
2855
2856     /* Make sure to unlink the URBs submitted in attach. */
2857     usb_kill_urb(s_priv->instat_urb);
2858     usb_kill_urb(s_priv->indat_urb);
2859
2860     usb_free_urb(s_priv->instat_urb);
2861     usb_free_urb(s_priv->indat_urb);
2862     usb_free_urb(s_priv->glocont_urb);
2863
2864     kfree(s_priv->ctrl_buf);
2865     kfree(s_priv->glocont_buf);
2866     kfree(s_priv->indat_buf);
2867     kfree(s_priv->instat_buf);
2868
2869     kfree(s_priv);
2870 }
2871
2872 static int keyspan_port_probe(struct usb_serial_port *port)
2873 {
2874     struct usb_serial *serial = port->serial;
2875     struct keyspan_serial_private *s_priv;
2876     struct keyspan_port_private *p_priv;
2877     const struct keyspan_device_details *d_details;
2878     struct callbacks *cback;
2879     int endp;
2880     int port_num;
2881     int i;
2882
2883     s_priv = usb_get_serial_data(serial);
2884     d_details = s_priv->device_details;
2885
2886     p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2887     if (!p_priv)
2888         return -ENOMEM;
2889
2890     for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) {
2891         p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL);
2892         if (!p_priv->in_buffer[i])
2893             goto err_free_in_buffer;
2894     }
2895
2896     for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) {
2897         p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL);
2898         if (!p_priv->out_buffer[i])
2899             goto err_free_out_buffer;
2900     }
2901
2902     p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
2903     if (!p_priv->inack_buffer)
2904         goto err_free_out_buffer;
2905
2906     p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
2907     if (!p_priv->outcont_buffer)
2908         goto err_free_inack_buffer;
2909
2910     p_priv->device_details = d_details;
2911
2912     /* Setup values for the various callback routines */
2913     cback = &keyspan_callbacks[d_details->msg_format];
2914
2915     port_num = port->port_number;
2916
2917     /* Do indat endpoints first, once for each flip */
2918     endp = d_details->indat_endpoints[port_num];
2919     for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2920         p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2921                         USB_DIR_IN, port,
2922                         p_priv->in_buffer[i],
2923                         IN_BUFLEN,
2924                         cback->indat_callback);
2925     }
2926     /* outdat endpoints also have flip */
2927     endp = d_details->outdat_endpoints[port_num];
2928     for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2929         p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2930                         USB_DIR_OUT, port,
2931                         p_priv->out_buffer[i],
2932                         OUT_BUFLEN,
2933                         cback->outdat_callback);
2934     }
2935     /* inack endpoint */
2936     p_priv->inack_urb = keyspan_setup_urb(serial,
2937                     d_details->inack_endpoints[port_num],
2938                     USB_DIR_IN, port,
2939                     p_priv->inack_buffer,
2940                     INACK_BUFLEN,
2941                     cback->inack_callback);
2942     /* outcont endpoint */
2943     p_priv->outcont_urb = keyspan_setup_urb(serial,
2944                     d_details->outcont_endpoints[port_num],
2945                     USB_DIR_OUT, port,
2946                     p_priv->outcont_buffer,
2947                     OUTCONT_BUFLEN,
2948                      cback->outcont_callback);
2949
2950     usb_set_serial_port_data(port, p_priv);
2951
2952     return 0;
2953
2954 err_free_inack_buffer:
2955     kfree(p_priv->inack_buffer);
2956 err_free_out_buffer:
2957     for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2958         kfree(p_priv->out_buffer[i]);
2959 err_free_in_buffer:
2960     for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2961         kfree(p_priv->in_buffer[i]);
2962     kfree(p_priv);
2963
2964     return -ENOMEM;
2965 }
2966
2967 static void keyspan_port_remove(struct usb_serial_port *port)
2968 {
2969     struct keyspan_port_private *p_priv;
2970     int i;
2971
2972     p_priv = usb_get_serial_port_data(port);
2973
2974     usb_kill_urb(p_priv->inack_urb);
2975     usb_kill_urb(p_priv->outcont_urb);
2976     for (i = 0; i < 2; i++) {
2977         usb_kill_urb(p_priv->in_urbs[i]);
2978         usb_kill_urb(p_priv->out_urbs[i]);
2979     }
2980
2981     usb_free_urb(p_priv->inack_urb);
2982     usb_free_urb(p_priv->outcont_urb);
2983     for (i = 0; i < 2; i++) {
2984         usb_free_urb(p_priv->in_urbs[i]);
2985         usb_free_urb(p_priv->out_urbs[i]);
2986     }
2987
2988     kfree(p_priv->outcont_buffer);
2989     kfree(p_priv->inack_buffer);
2990     for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2991         kfree(p_priv->out_buffer[i]);
2992     for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2993         kfree(p_priv->in_buffer[i]);
2994
2995     kfree(p_priv);
2996 }
2997
2998 /* Structs for the devices, pre and post renumeration. */
2999 static struct usb_serial_driver keyspan_pre_device = {
3000     .driver = {
3001         .owner      = THIS_MODULE,
3002         .name       = "keyspan_no_firm",
3003     },
3004     .description        = "Keyspan - (without firmware)",
3005     .id_table       = keyspan_pre_ids,
3006     .num_ports      = 1,
3007     .attach         = keyspan_fake_startup,
3008 };
3009
3010 static struct usb_serial_driver keyspan_1port_device = {
3011     .driver = {
3012         .owner      = THIS_MODULE,
3013         .name       = "keyspan_1",
3014     },
3015     .description        = "Keyspan 1 port adapter",
3016     .id_table       = keyspan_1port_ids,
3017     .num_ports      = 1,
3018     .open           = keyspan_open,
3019     .close          = keyspan_close,
3020     .dtr_rts        = keyspan_dtr_rts,
3021     .write          = keyspan_write,
3022     .write_room     = keyspan_write_room,
3023     .set_termios        = keyspan_set_termios,
3024     .break_ctl      = keyspan_break_ctl,
3025     .tiocmget       = keyspan_tiocmget,
3026     .tiocmset       = keyspan_tiocmset,
3027     .attach         = keyspan_startup,
3028     .disconnect     = keyspan_disconnect,
3029     .release        = keyspan_release,
3030     .port_probe     = keyspan_port_probe,
3031     .port_remove        = keyspan_port_remove,
3032 };
3033
3034 static struct usb_serial_driver keyspan_2port_device = {
3035     .driver = {
3036         .owner      = THIS_MODULE,
3037         .name       = "keyspan_2",
3038     },
3039     .description        = "Keyspan 2 port adapter",
3040     .id_table       = keyspan_2port_ids,
3041     .num_ports      = 2,
3042     .open           = keyspan_open,
3043     .close          = keyspan_close,
3044     .dtr_rts        = keyspan_dtr_rts,
3045     .write          = keyspan_write,
3046     .write_room     = keyspan_write_room,
3047     .set_termios        = keyspan_set_termios,
3048     .break_ctl      = keyspan_break_ctl,
3049     .tiocmget       = keyspan_tiocmget,
3050     .tiocmset       = keyspan_tiocmset,
3051     .attach         = keyspan_startup,
3052     .disconnect     = keyspan_disconnect,
3053     .release        = keyspan_release,
3054     .port_probe     = keyspan_port_probe,
3055     .port_remove        = keyspan_port_remove,
3056 };
3057
3058 static struct usb_serial_driver keyspan_4port_device = {
3059     .driver = {
3060         .owner      = THIS_MODULE,
3061         .name       = "keyspan_4",
3062     },
3063     .description        = "Keyspan 4 port adapter",
3064     .id_table       = keyspan_4port_ids,
3065     .num_ports      = 4,
3066     .open           = keyspan_open,
3067     .close          = keyspan_close,
3068     .dtr_rts        = keyspan_dtr_rts,
3069     .write          = keyspan_write,
3070     .write_room     = keyspan_write_room,
3071     .set_termios        = keyspan_set_termios,
3072     .break_ctl      = keyspan_break_ctl,
3073     .tiocmget       = keyspan_tiocmget,
3074     .tiocmset       = keyspan_tiocmset,
3075     .attach         = keyspan_startup,
3076     .disconnect     = keyspan_disconnect,
3077     .release        = keyspan_release,
3078     .port_probe     = keyspan_port_probe,
3079     .port_remove        = keyspan_port_remove,
3080 };
3081
3082 static struct usb_serial_driver * const serial_drivers[] = {
3083     &keyspan_pre_device, &keyspan_1port_device,
3084     &keyspan_2port_device, &keyspan_4port_device, NULL
3085 };
3086
3087 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
3088
3089 MODULE_AUTHOR(DRIVER_AUTHOR);
3090 MODULE_DESCRIPTION(DRIVER_DESC);
3091 MODULE_LICENSE("GPL");
3092
3093 MODULE_FIRMWARE("keyspan/usa28.fw");
3094 MODULE_FIRMWARE("keyspan/usa28x.fw");
3095 MODULE_FIRMWARE("keyspan/usa28xa.fw");
3096 MODULE_FIRMWARE("keyspan/usa28xb.fw");
3097 MODULE_FIRMWARE("keyspan/usa19.fw");
3098 MODULE_FIRMWARE("keyspan/usa19qi.fw");
3099 MODULE_FIRMWARE("keyspan/mpr.fw");
3100 MODULE_FIRMWARE("keyspan/usa19qw.fw");
3101 MODULE_FIRMWARE("keyspan/usa18x.fw");
3102 MODULE_FIRMWARE("keyspan/usa19w.fw");
3103 MODULE_FIRMWARE("keyspan/usa49w.fw");
3104 MODULE_FIRMWARE("keyspan/usa49wlc.fw");