USB: remove staging quatech_usb2 driver
authorGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Thu, 10 May 2012 21:09:16 +0000 (14:09 -0700)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Thu, 10 May 2012 21:09:16 +0000 (14:09 -0700)
Now that we have a "real" driver for the quatech devices, we can remove
the drivers/staging/quatech_usb2/ driver as it is no longer needed.

Thanks to Bill Pemberton for writing the new driver.

Cc: Richard Ash <richard@audacityteam.org>
Cc: Bill Pemberton <wfp5p@virginia.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/staging/Kconfig
drivers/staging/Makefile
drivers/staging/quatech_usb2/Kconfig [deleted file]
drivers/staging/quatech_usb2/Makefile [deleted file]
drivers/staging/quatech_usb2/TODO [deleted file]
drivers/staging/quatech_usb2/quatech_usb2.c [deleted file]

index 97d412d91458b258401af63d701cd0bbbe9ec5cf..f34d3fb70f0a27745b6a06a5c0e2cfac39425e86 100644 (file)
@@ -68,8 +68,6 @@ source "drivers/staging/octeon/Kconfig"
 
 source "drivers/staging/serqt_usb2/Kconfig"
 
-source "drivers/staging/quatech_usb2/Kconfig"
-
 source "drivers/staging/vt6655/Kconfig"
 
 source "drivers/staging/vt6656/Kconfig"
index ffe7d44374e606cf770f87ca46a5ad8f45753592..e4637d1aef34437081b040a5f531637cb550074d 100644 (file)
@@ -25,7 +25,6 @@ obj-$(CONFIG_TRANZPORT)               += frontier/
 obj-$(CONFIG_IDE_PHISON)       += phison/
 obj-$(CONFIG_LINE6_USB)                += line6/
 obj-$(CONFIG_USB_SERIAL_QUATECH2)      += serqt_usb2/
-obj-$(CONFIG_USB_SERIAL_QUATECH_USB2)  += quatech_usb2/
 obj-$(CONFIG_OCTEON_ETHERNET)  += octeon/
 obj-$(CONFIG_VT6655)           += vt6655/
 obj-$(CONFIG_VT6656)           += vt6656/
diff --git a/drivers/staging/quatech_usb2/Kconfig b/drivers/staging/quatech_usb2/Kconfig
deleted file mode 100644 (file)
index 1494f42..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-config USB_SERIAL_QUATECH_USB2
-       tristate "USB Quatech xSU2-[14]00 USB Serial Driver"
-       depends on USB_SERIAL
-       help
-         Say Y here if you want to use a Quatech USB2.0 to serial adaptor. This
-         driver supports the SSU2-100, DSU2-100, DSU2-400, QSU2-100, QSU2-400,
-         ESU2-400 and ESU2-100 USB2.0 to RS232 / 485 / 422 serial adaptors.
-
-         Some hardware has an incorrect product string and announces itself as
-         ESU-100 (which uses the serqt driver) even though it is an ESU2-100.
-         Check the label on the bottom of your device.
-
-         To compile this driver as a module, choose M here: the module will be
-         called quatech_usb2 .
-
diff --git a/drivers/staging/quatech_usb2/Makefile b/drivers/staging/quatech_usb2/Makefile
deleted file mode 100644 (file)
index bcd1f89..0000000
+++ /dev/null
@@ -1 +0,0 @@
-obj-$(CONFIG_USB_SERIAL_QUATECH_USB2)          += quatech_usb2.o
diff --git a/drivers/staging/quatech_usb2/TODO b/drivers/staging/quatech_usb2/TODO
deleted file mode 100644 (file)
index 67f61db..0000000
+++ /dev/null
@@ -1,8 +0,0 @@
-Incomplete list of things that this driver does not yet implement completely or
-at all. some of these may not be possible to implement because the hardware
-support does not exist. Others may be possible, but the magic control codes to
-make them happen are unknown, and some may just need the driver support to
-implement them writing.
-
-* Mark/Space parity is not implemented (reported back correctly)
-* IXANY flow control mode is not implemented (flag ignored completely)
diff --git a/drivers/staging/quatech_usb2/quatech_usb2.c b/drivers/staging/quatech_usb2/quatech_usb2.c
deleted file mode 100644 (file)
index a977aca..0000000
+++ /dev/null
@@ -1,1950 +0,0 @@
-/*
- * Driver for Quatech Inc USB2.0 to serial adaptors. Largely unrelated to the
- * serqt_usb driver, based on a re-write of the vendor supplied serqt_usb2 code,
- * which is unrelated to the serqt_usb2 in the staging kernel
- */
-
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/tty.h>
-#include <linux/tty_driver.h>
-#include <linux/tty_flip.h>
-#include <linux/module.h>
-#include <linux/serial.h>
-#include <linux/usb.h>
-#include <linux/usb/serial.h>
-#include <linux/uaccess.h>
-
-static bool debug;
-
-/* Version Information */
-#define DRIVER_VERSION "v2.00"
-#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
-#define DRIVER_DESC "Quatech USB 2.0 to Serial Driver"
-
-/* vendor and device IDs */
-#define        USB_VENDOR_ID_QUATECH 0x061d    /* Quatech VID */
-#define QUATECH_SSU2_100 0xC120                /* RS232 single port */
-#define QUATECH_DSU2_100 0xC140                /* RS232 dual port */
-#define QUATECH_DSU2_400 0xC150                /* RS232/422/485 dual port */
-#define QUATECH_QSU2_100 0xC160                /* RS232 four port */
-#define QUATECH_QSU2_400 0xC170                /* RS232/422/485 four port */
-#define QUATECH_ESU2_100 0xC1A0                /* RS232 eight port */
-#define QUATECH_ESU2_400 0xC180                /* RS232/422/485 eight port */
-
-/* magic numbers go here, when we find out which ones are needed */
-
-#define QU2BOXPWRON 0x8000             /* magic number to turn FPGA power on */
-#define QU2BOX232 0x40                 /* RS232 mode on MEI devices */
-#define QU2BOXSPD9600 0x60             /* set speed to 9600 baud */
-#define QT2_FIFO_DEPTH 1024                    /* size of hardware fifos */
-#define QT2_TX_HEADER_LENGTH   5
-/* length of the header sent to the box with each write URB */
-
-/* directions for USB transfers */
-#define USBD_TRANSFER_DIRECTION_IN    0xc0
-#define USBD_TRANSFER_DIRECTION_OUT   0x40
-
-/* special Quatech command IDs. These are pushed down the
- USB control pipe to get the box on the end to do things */
-#define QT_SET_GET_DEVICE              0xc2
-#define QT_OPEN_CLOSE_CHANNEL          0xca
-/*#define QT_GET_SET_PREBUF_TRIG_LVL   0xcc
-#define QT_SET_ATF                     0xcd*/
-#define QT2_GET_SET_REGISTER                   0xc0
-#define QT2_GET_SET_UART                       0xc1
-#define QT2_HW_FLOW_CONTROL_MASK               0xc5
-#define QT2_SW_FLOW_CONTROL_MASK               0xc6
-#define QT2_SW_FLOW_CONTROL_DISABLE            0xc7
-#define QT2_BREAK_CONTROL                      0xc8
-#define QT2_STOP_RECEIVE                       0xe0
-#define QT2_FLUSH_DEVICE                       0xc4
-#define QT2_GET_SET_QMCR                       0xe1
-
-/* sorts of flush we can do on */
-#define QT2_FLUSH_RX                   0x00
-#define QT2_FLUSH_TX                   0x01
-
-/* port setting constants, used to set up serial port speeds, flow
- * control and so on */
-#define QT2_SERIAL_MCR_DTR     0x01
-#define QT2_SERIAL_MCR_RTS     0x02
-#define QT2_SERIAL_MCR_LOOP    0x10
-
-#define QT2_SERIAL_MSR_CTS     0x10
-#define QT2_SERIAL_MSR_CD      0x80
-#define QT2_SERIAL_MSR_RI      0x40
-#define QT2_SERIAL_MSR_DSR     0x20
-#define QT2_SERIAL_MSR_MASK    0xf0
-
-#define QT2_SERIAL_8_DATA      0x03
-#define QT2_SERIAL_7_DATA      0x02
-#define QT2_SERIAL_6_DATA      0x01
-#define QT2_SERIAL_5_DATA      0x00
-
-#define QT2_SERIAL_ODD_PARITY  0x08
-#define QT2_SERIAL_EVEN_PARITY 0x18
-#define QT2_SERIAL_TWO_STOPB   0x04
-#define QT2_SERIAL_ONE_STOPB   0x00
-
-#define QT2_MAX_BAUD_RATE      921600
-#define QT2_MAX_BAUD_REMAINDER 4608
-
-#define QT2_SERIAL_LSR_OE      0x02
-#define QT2_SERIAL_LSR_PE      0x04
-#define QT2_SERIAL_LSR_FE      0x08
-#define QT2_SERIAL_LSR_BI      0x10
-
-/* value of Line Status Register when UART has completed
- * emptying data out on the line */
-#define QT2_LSR_TEMT     0x40
-
-/* register numbers on each UART, for use with  qt2_box_[get|set]_register*/
-#define  QT2_XMT_HOLD_REGISTER          0x00
-#define  QT2_XVR_BUFFER_REGISTER        0x00
-#define  QT2_FIFO_CONTROL_REGISTER      0x02
-#define  QT2_LINE_CONTROL_REGISTER      0x03
-#define  QT2_MODEM_CONTROL_REGISTER     0x04
-#define  QT2_LINE_STATUS_REGISTER       0x05
-#define  QT2_MODEM_STATUS_REGISTER      0x06
-
-/* handy macros for doing escape sequence parsing on data reads */
-#define THISCHAR       ((unsigned char *)(urb->transfer_buffer))[i]
-#define NEXTCHAR       ((unsigned char *)(urb->transfer_buffer))[i + 1]
-#define THIRDCHAR      ((unsigned char *)(urb->transfer_buffer))[i + 2]
-#define FOURTHCHAR     ((unsigned char *)(urb->transfer_buffer))[i + 3]
-#define FIFTHCHAR      ((unsigned char *)(urb->transfer_buffer))[i + 4]
-
-static const struct usb_device_id id_table[] = {
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)},
-       {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)},
-       {}      /* Terminating entry */
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-
-/**
- * quatech2_port: Structure in which to keep all the messy stuff that this
- * driver needs alongside the usb_serial_port structure
- * @read_urb_busy: Flag indicating that port->read_urb is in use
- * @close_pending: flag indicating that this port is in the process of
- * being closed (and so no new reads / writes should be started).
- * @shadowLSR: Last received state of the line status register, holds the
- * value of the line status flags from the port
- * @shadowMSR: Last received state of the modem status register, holds
- * the value of the modem status received from the port
- * @rcv_flush: Flag indicating that a receive flush has occurred on
- * the hardware.
- * @xmit_flush: Flag indicating that a transmit flush has been processed by
- * the hardware.
- * @tx_pending_bytes: Number of bytes waiting to be sent. This total
- * includes the size (excluding header) of URBs that have been submitted but
- * have not yet been sent to to the device, and bytes that have been sent out
- * of the port but not yet reported sent by the "xmit_empty" messages (which
- * indicate the number of bytes sent each time they are received, despite the
- * misleading name).
- * - Starts at zero when port is initialised.
- * - is incremented by the size of the data to be written (no headers)
- * each time a write urb is dispatched.
- * - is decremented each time a "transmit empty" message is received
- * by the driver in the data stream.
- * @lock: Mutex to lock access to this structure when we need to ensure that
- * races don't occur to access bits of it.
- * @open_count: The number of uses of the port currently having
- * it open, i.e. the reference count.
- */
-struct quatech2_port {
-       int     magic;
-       bool    read_urb_busy;
-       bool    close_pending;
-       __u8    shadowLSR;
-       __u8    shadowMSR;
-       bool    rcv_flush;
-       bool    xmit_flush;
-       int     tx_pending_bytes;
-       struct mutex modelock;
-       int     open_count;
-
-       char    active;         /* someone has this device open */
-       unsigned char           *xfer_to_tty_buffer;
-       wait_queue_head_t       wait;
-       __u8    shadowLCR;      /* last LCR value received */
-       __u8    shadowMCR;      /* last MCR value received */
-       char    RxHolding;
-       struct semaphore        pend_xmit_sem;  /* locks this structure */
-       spinlock_t lock;
-};
-
-/**
- * Structure to hold device-wide internal status information
- * @param ReadBulkStopped The last bulk read attempt ended in tears
- * @param open_ports The number of serial ports currently in use on the box
- * @param current_port Pointer to the serial port structure of the port which
- * the read stream is currently directed to. Escape sequences in the read
- * stream will change this around as data arrives from different ports on the
- * box
- * @buffer_size: The max size buffer each URB can take, used to set the size of
- * the buffers allocated for writing to each port on the device (we need to
- * store this because it is known only to the endpoint, but used each time a
- * port is opened and a new buffer is allocated.
- */
-struct quatech2_dev {
-       bool    ReadBulkStopped;
-       char    open_ports;
-       struct usb_serial_port *current_port;
-       int     buffer_size;
-};
-
-/* structure which holds line and modem status flags */
-struct qt2_status_data {
-       __u8 line_status;
-       __u8 modem_status;
-};
-
-/* Function prototypes */
-static int qt2_boxpoweron(struct usb_serial *serial);
-static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
-                       __u8 QMCR_Value);
-static int port_paranoia_check(struct usb_serial_port *port,
-                       const char *function);
-static int serial_paranoia_check(struct usb_serial *serial,
-                        const char *function);
-static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
-                       *port);
-static inline void qt2_set_port_private(struct usb_serial_port *port,
-                       struct quatech2_port *data);
-static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial
-                       *serial);
-static inline void qt2_set_dev_private(struct usb_serial *serial,
-                       struct quatech2_dev *data);
-static int qt2_openboxchannel(struct usb_serial *serial, __u16
-                       Uart_Number, struct qt2_status_data *pDeviceData);
-static int qt2_closeboxchannel(struct usb_serial *serial, __u16
-                       Uart_Number);
-static int qt2_conf_uart(struct usb_serial *serial,  unsigned short Uart_Number,
-                        unsigned short divisor, unsigned char LCR);
-static void qt2_read_bulk_callback(struct urb *urb);
-static void qt2_write_bulk_callback(struct urb *urb);
-static void qt2_process_line_status(struct usb_serial_port *port,
-                             unsigned char LineStatus);
-static void qt2_process_modem_status(struct usb_serial_port *port,
-                              unsigned char ModemStatus);
-static void qt2_process_xmit_empty(struct usb_serial_port *port,
-       unsigned char fourth_char, unsigned char fifth_char);
-static void qt2_process_port_change(struct usb_serial_port *port,
-                             unsigned char New_Current_Port);
-static void qt2_process_rcv_flush(struct usb_serial_port *port);
-static void qt2_process_xmit_flush(struct usb_serial_port *port);
-static void qt2_process_rx_char(struct usb_serial_port *port,
-                               unsigned char data);
-static int qt2_box_get_register(struct usb_serial *serial,
-               unsigned char uart_number, unsigned short register_num,
-               __u8 *pValue);
-static int qt2_box_set_register(struct usb_serial *serial,
-               unsigned short Uart_Number, unsigned short Register_Num,
-               unsigned short Value);
-static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
-               unsigned short default_divisor, unsigned char default_LCR);
-static int qt2_boxsethw_flowctl(struct usb_serial *serial,
-               unsigned int UartNumber, bool bSet);
-static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
-               unsigned char stop_char,  unsigned char start_char);
-static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber);
-static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
-                        unsigned short stop);
-
-/* implementation functions, roughly in order of use, are here */
-static int qt2_calc_num_ports(struct usb_serial *serial)
-{
-       int num_ports;
-       int flag_as_400;
-       switch (serial->dev->descriptor.idProduct) {
-       case QUATECH_SSU2_100:
-               num_ports = 1;
-               break;
-
-       case QUATECH_DSU2_400:
-               flag_as_400 = true;
-       case QUATECH_DSU2_100:
-               num_ports = 2;
-       break;
-
-       case QUATECH_QSU2_400:
-               flag_as_400 = true;
-       case QUATECH_QSU2_100:
-               num_ports = 4;
-       break;
-
-       case QUATECH_ESU2_400:
-               flag_as_400 = true;
-       case QUATECH_ESU2_100:
-               num_ports = 8;
-       break;
-       default:
-       num_ports = 1;
-       break;
-       }
-       return num_ports;
-}
-
-static int qt2_attach(struct usb_serial *serial)
-{
-       struct usb_serial_port *port;
-       struct quatech2_port *qt2_port; /* port-specific private data pointer */
-       struct quatech2_dev  *qt2_dev;  /* dev-specific private data pointer */
-       int i;
-       /* stuff for storing endpoint addresses now */
-       struct usb_endpoint_descriptor *endpoint;
-       struct usb_host_interface *iface_desc;
-       struct usb_serial_port *port0;  /* first port structure on device */
-
-       /* check how many endpoints there are on the device, for
-        * sanity's sake */
-       dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in",
-                       __func__, serial->num_bulk_in,
-                       serial->num_bulk_out, serial->num_interrupt_in);
-       if ((serial->num_bulk_in != 1) || (serial->num_bulk_out != 1)) {
-               dbg("Device has wrong number of bulk endpoints!");
-               return -ENODEV;
-       }
-       iface_desc = serial->interface->cur_altsetting;
-
-       /* Set up per-device private data, storing extra data alongside
-        * struct usb_serial */
-       qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL);
-       if (!qt2_dev) {
-               dbg("%s: kmalloc for quatech2_dev failed!",
-                   __func__);
-               return -ENOMEM;
-       }
-       qt2_dev->open_ports = 0;        /* no ports open */
-       qt2_set_dev_private(serial, qt2_dev);   /* store private data */
-
-       /* Now setup per port private data, which replaces all the things
-        * that quatech added to standard kernel structures in their driver */
-       for (i = 0; i < serial->num_ports; i++) {
-               port = serial->port[i];
-               qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL);
-               if (!qt2_port) {
-                       dbg("%s: kmalloc for quatech2_port (%d) failed!.",
-                           __func__, i);
-                       return -ENOMEM;
-               }
-               /* initialise stuff in the structure */
-               qt2_port->open_count = 0;       /* port is not open */
-               spin_lock_init(&qt2_port->lock);
-               mutex_init(&qt2_port->modelock);
-               qt2_set_port_private(port, qt2_port);
-       }
-
-       /* gain access to port[0]'s structure because we want to store
-        * device-level stuff in it */
-       if (serial_paranoia_check(serial, __func__))
-               return -ENODEV;
-       port0 = serial->port[0]; /* get the first port's device structure */
-
-       /* print endpoint addresses so we can check them later
-        * by hand */
-       for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
-               endpoint = &iface_desc->endpoint[i].desc;
-               if ((endpoint->bEndpointAddress & 0x80) &&
-                       ((endpoint->bmAttributes & 3) == 0x02)) {
-                       /* we found a bulk in endpoint */
-                       dbg("found bulk in at %#.2x",
-                               endpoint->bEndpointAddress);
-               }
-
-               if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
-                       ((endpoint->bmAttributes & 3) == 0x02)) {
-                       /* we found a bulk out endpoint */
-                       dbg("found bulk out at %#.2x",
-                               endpoint->bEndpointAddress);
-                       qt2_dev->buffer_size = endpoint->wMaxPacketSize;
-                       /* max size of URB needs recording for the device */
-               }
-       }       /* end printing endpoint addresses */
-
-       /* switch on power to the hardware */
-       if (qt2_boxpoweron(serial) < 0) {
-               dbg("qt2_boxpoweron() failed");
-               goto startup_error;
-       }
-       /* set all ports to RS232 mode */
-       for (i = 0; i < serial->num_ports; ++i) {
-               if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) {
-                       dbg("qt2_boxsetQMCR() on port %d failed",
-                               i);
-                       goto startup_error;
-               }
-       }
-
-       return 0;
-
-startup_error:
-       for (i = 0; i < serial->num_ports; i++) {
-               port = serial->port[i];
-               qt2_port = qt2_get_port_private(port);
-               kfree(qt2_port);
-               qt2_set_port_private(port, NULL);
-       }
-       qt2_dev = qt2_get_dev_private(serial);
-       kfree(qt2_dev);
-       qt2_set_dev_private(serial, NULL);
-
-       dbg("Exit fail %s\n", __func__);
-       return -EIO;
-}
-
-static void qt2_release(struct usb_serial *serial)
-{
-       struct usb_serial_port *port;
-       struct quatech2_port *qt_port;
-       int i;
-
-       for (i = 0; i < serial->num_ports; i++) {
-               port = serial->port[i];
-               if (!port)
-                       continue;
-
-               qt_port = usb_get_serial_port_data(port);
-               kfree(qt_port);
-               usb_set_serial_port_data(port, NULL);
-       }
-}
-/* This function is called once per serial port on the device, when
- * that port is opened by a userspace application.
- * The tty_struct and the usb_serial_port belong to this port,
- * i.e. there are multiple ones for a multi-port device.
- * However the usb_serial_port structure has a back-pointer
- * to the parent usb_serial structure which belongs to the device,
- * so we can access either the device-wide information or
- * any other port's information (because there are also forward
- * pointers) via that pointer.
- * This is most helpful if the device shares resources (e.g. end
- * points) between different ports
- */
-int qt2_open(struct tty_struct *tty, struct usb_serial_port *port)
-{
-       struct usb_serial *serial;      /* device structure */
-       struct usb_serial_port *port0;  /* first port structure on device */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       struct quatech2_port *port0_extra;      /* extra data for first port */
-       struct quatech2_dev *dev_extra;         /* extra data for the device */
-       struct qt2_status_data ChannelData;
-       unsigned short default_divisor = QU2BOXSPD9600;
-       unsigned char  default_LCR = QT2_SERIAL_8_DATA;
-       int status;
-       int result;
-
-       if (port_paranoia_check(port, __func__))
-               return -ENODEV;
-
-       serial = port->serial;  /* get the parent device structure */
-       if (serial_paranoia_check(serial, __func__)) {
-               dbg("usb_serial struct failed sanity check");
-               return -ENODEV;
-       }
-       dev_extra = qt2_get_dev_private(serial);
-       /* get the device private data */
-       if (dev_extra == NULL) {
-               dbg("device extra data pointer is null");
-               return -ENODEV;
-       }
-       port0 = serial->port[0]; /* get the first port's device structure */
-       if (port_paranoia_check(port0, __func__)) {
-               dbg("port0 usb_serial_port struct failed sanity check");
-               return -ENODEV;
-       }
-
-       port_extra = qt2_get_port_private(port);
-       port0_extra = qt2_get_port_private(port0);
-       if (port_extra == NULL || port0_extra == NULL) {
-               dbg("failed to get private data for port or port0");
-               return -ENODEV;
-       }
-
-       /* FIXME: are these needed?  Does it even do anything useful? */
-       /* get the modem and line status values from the UART */
-       status = qt2_openboxchannel(serial, port->number,
-                       &ChannelData);
-       if (status < 0) {
-               dbg("qt2_openboxchannel on channel %d failed",
-                   port->number);
-               return status;
-       }
-       port_extra->shadowLSR = ChannelData.line_status &
-                       (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE |
-                       QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
-       port_extra->shadowMSR = ChannelData.modem_status &
-                       (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR |
-                       QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD);
-
-/*     port_extra->fifo_empty_flag = true;*/
-       dbg("qt2_openboxchannel on channel %d completed.",
-           port->number);
-
-       /* Set Baud rate to default and turn off flow control here */
-       status = qt2_conf_uart(serial, port->number, default_divisor,
-                               default_LCR);
-       if (status < 0) {
-               dbg("qt2_conf_uart() failed on channel %d",
-                   port->number);
-               return status;
-       }
-       dbg("qt2_conf_uart() completed on channel %d",
-               port->number);
-
-       /*
-        * At this point we will need some end points to make further progress.
-        * Handlily, the correct endpoint addresses have been filled out into
-        * the usb_serial_port structure for us by the driver core, so we
-        * already have access to them.
-        * As there is only one bulk in and one bulk out end-point, these are in
-        * port[0]'s structure, and the rest are uninitialised. Handily,
-        * when we do a write to a port, we will use the same endpoint
-        * regardless of the port, with a 5-byte header added on to
-        * tell the box which port it should eventually come out of, so we only
-        * need the one set of endpoints. We will have one URB per port for
-        * writing, so that multiple ports can be writing at once.
-        * Finally we need a bulk in URB to use for background reads from the
-        * device, which will deal with uplink data from the box to host.
-        */
-       dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress);
-       dbg("port0 bulk out endpoint is %#.2x",
-               port0->bulk_out_endpointAddress);
-
-       /* set up write_urb for bulk out transfers on this port. The USB
-        * serial framework will have allocated a blank URB, buffer etc for
-        * port0 when it put the endpoints there, but not for any of the other
-        * ports on the device because there are no more endpoints. Thus we
-        * have to allocate our own URBs for ports 1-7
-        */
-       if (port->write_urb == NULL) {
-               dbg("port->write_urb == NULL, allocating one");
-               port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
-               if (!port->write_urb) {
-                       dev_err(&port->dev, "Allocating write URB failed\n");
-                       return -ENOMEM;
-               }
-               /* buffer same size as port0 */
-               port->bulk_out_size = dev_extra->buffer_size;
-               port->bulk_out_buffer = kmalloc(port->bulk_out_size,
-                                               GFP_KERNEL);
-               if (!port->bulk_out_buffer) {
-                       dev_err(&port->dev, "Couldn't allocate bulk_out_buffer\n");
-                       return -ENOMEM;
-               }
-       }
-       if (serial->dev == NULL)
-               dbg("serial->dev == NULL");
-       dbg("port->bulk_out_size is %d", port->bulk_out_size);
-
-       usb_fill_bulk_urb(port->write_urb, serial->dev,
-                       usb_sndbulkpipe(serial->dev,
-                       port0->bulk_out_endpointAddress),
-                       port->bulk_out_buffer,
-                       port->bulk_out_size,
-                       qt2_write_bulk_callback,
-                       port);
-       port_extra->tx_pending_bytes = 0;
-
-       if (dev_extra->open_ports == 0) {
-               /* this is first port to be opened, so need the read URB
-                * initialised for bulk in transfers (this is shared amongst
-                * all the ports on the device) */
-               usb_fill_bulk_urb(port0->read_urb, serial->dev,
-                       usb_rcvbulkpipe(serial->dev,
-                       port0->bulk_in_endpointAddress),
-                       port0->bulk_in_buffer,
-                       port0->bulk_in_size,
-                       qt2_read_bulk_callback, serial);
-               dbg("port0 bulk in URB initialised");
-
-               /* submit URB, i.e. start reading from device (async) */
-               dev_extra->ReadBulkStopped = false;
-               port_extra->read_urb_busy = true;
-               result = usb_submit_urb(port->read_urb, GFP_KERNEL);
-               if (result) {
-                       dev_err(&port->dev,
-                                "%s(): Error %d submitting bulk in urb",
-                               __func__, result);
-                       port_extra->read_urb_busy = false;
-                       dev_extra->ReadBulkStopped = true;
-               }
-
-               /* When the first port is opened, initialise the value of
-                * current_port in dev_extra to this port, so it is set
-                * to something. Once the box sends data it will send the
-                * relevant escape sequences to get it to the right port anyway
-                */
-               dev_extra->current_port = port;
-       }
-
-       /* initialize our wait queues */
-       init_waitqueue_head(&port_extra->wait);
-       /* increment the count of openings of this port by one */
-       port_extra->open_count++;
-
-       /* remember to store dev_extra, port_extra and port0_extra back again at
-        * end !*/
-       qt2_set_port_private(port, port_extra);
-       qt2_set_port_private(serial->port[0], port0_extra);
-       qt2_set_dev_private(serial, dev_extra);
-
-       dev_extra->open_ports++; /* one more port opened */
-
-       return 0;
-}
-
-/* called when a port is closed by userspace. It won't be called, however,
- * until calls to chars_in_buffer() reveal that the port has completed
- * sending buffered data, and there is nothing else to do. Thus we don't have
- * to rely on forcing data through in this function. */
-/* Setting close_pending should keep new data from being written out,
- * once all the data in the enpoint buffers is moved out we won't get
- * any more. */
-/* BoxStopReceive would keep any more data from coming from a given
- * port, but isn't called by the vendor driver, although their comments
- * mention it. Should it be used here to stop the inbound data
- * flow?
- */
-static void qt2_close(struct usb_serial_port *port)
-{
-       /* time out value for flush loops */
-       unsigned long jift;
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       struct usb_serial *serial;      /* device structure */
-       struct quatech2_dev *dev_extra; /* extra data for the device */
-       __u8  lsr_value = 0;    /* value of Line Status Register */
-       int status;     /* result of last USB comms function */
-
-       serial = port->serial;  /* get the parent device structure */
-       dev_extra = qt2_get_dev_private(serial);
-       /* get the device private data */
-       port_extra = qt2_get_port_private(port); /* port private data */
-
-       /* we can now (and only now) stop reading data */
-       port_extra->close_pending = true;
-       dbg("%s(): port_extra->close_pending = true", __func__);
-       /* although the USB side is now empty, the UART itself may
-        * still be pushing characters out over the line, so we have to
-        * wait testing the actual line status until the lines change
-        * indicating that the data is done transferring. */
-       /* FIXME: slow this polling down so it doesn't run the USB bus flat out
-        * if it actually has to spend any time in this loop (which it normally
-        * doesn't because the buffer is nearly empty) */
-       jift = jiffies + (10 * HZ);     /* 10 sec timeout */
-       do {
-               status = qt2_box_get_register(serial, port->number,
-                       QT2_LINE_STATUS_REGISTER, &lsr_value);
-               if (status < 0) {
-                       dbg("%s(): qt2_box_get_register failed", __func__);
-                       break;
-               }
-               if ((lsr_value & QT2_LSR_TEMT)) {
-                       dbg("UART done sending");
-                       break;
-               }
-               schedule();
-       } while (jiffies <= jift);
-
-       status = qt2_closeboxchannel(serial, port->number);
-       if (status < 0)
-               dbg("%s(): port %d qt2_box_open_close_channel failed",
-                       __func__, port->number);
-       /* to avoid leaking URBs, we should now free the write_urb for this
-        * port and set the pointer to null so that next time the port is opened
-        * a new URB is allocated. This avoids leaking URBs when the device is
-        * removed */
-       usb_free_urb(port->write_urb);
-       kfree(port->bulk_out_buffer);
-       port->bulk_out_buffer = NULL;
-       port->bulk_out_size = 0;
-
-       /* decrement the count of openings of this port by one */
-       port_extra->open_count--;
-       /* one less overall open as well */
-       dev_extra->open_ports--;
-       dbg("%s(): Exit, dev_extra->open_ports  = %d", __func__,
-               dev_extra->open_ports);
-}
-
-/**
- * qt2_write - write bytes from the tty layer out to the USB device.
- * @buf: The data to be written, size at least count.
- * @count: The number of bytes requested for transmission.
- * @return The number of bytes actually accepted for transmission to the device.
- */
-static int qt2_write(struct tty_struct *tty, struct usb_serial_port *port,
-               const unsigned char *buf, int count)
-{
-       struct usb_serial *serial;      /* parent device struct */
-       __u8 header_array[5];   /* header used to direct writes to the correct
-       port on the device */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       int result;
-
-       serial = port->serial; /* get the parent device of the port */
-       port_extra = qt2_get_port_private(port); /* port extra info */
-       if (serial == NULL)
-               return -ENODEV;
-       dbg("%s(): port %d, requested to write %d bytes, %d already pending",
-               __func__, port->number, count, port_extra->tx_pending_bytes);
-
-       if (count <= 0) {
-               dbg("%s(): write request of <= 0 bytes", __func__);
-               return 0;       /* no bytes written */
-       }
-
-       /* check if the write urb is already in use, i.e. data already being
-        * sent to this port */
-       if ((port->write_urb->status == -EINPROGRESS)) {
-               /* Fifo hasn't been emptied since last write to this port */
-               dbg("%s(): already writing, port->write_urb->status == "
-                       "-EINPROGRESS", __func__);
-               /* schedule_work(&port->work); commented in vendor driver */
-               return 0;
-       } else if (port_extra->tx_pending_bytes >= QT2_FIFO_DEPTH) {
-               /* buffer is full (==). > should not occur, but would indicate
-                * that an overflow had occurred */
-               dbg("%s(): port transmit buffer is full!", __func__);
-               /* schedule_work(&port->work); commented in vendor driver */
-               return 0;
-       }
-
-       /* We must fill the first 5 bytes of anything we sent with a transmit
-        * header which directes the data to the correct port. The maximum
-        * size we can send out in one URB is port->bulk_out_size, which caps
-        * the number of bytes of real data we can send in each write. As the
-        * semantics of write allow us to write less than we were give, we cap
-        * the maximum we will ever write to the device as 5 bytes less than
-        * one URB's worth, by reducing the value of the count argument
-        * appropriately*/
-       if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) {
-               count = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
-               dbg("%s(): write request bigger than urb, only accepting "
-                       "%d bytes", __func__, count);
-       }
-       /* we must also ensure that the FIFO at the other end can cope with the
-        * URB we send it, otherwise it will have problems. As above, we can
-        * restrict the write size by just shrinking count.*/
-       if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) {
-               count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes;
-               dbg("%s(): not enough room in buffer, only accepting %d bytes",
-                       __func__, count);
-       }
-       /* now build the header for transmission */
-       header_array[0] = 0x1b;
-       header_array[1] = 0x1b;
-       header_array[2] = (__u8)port->number;
-       header_array[3] = (__u8)count;
-       header_array[4] = (__u8)count >> 8;
-       /* copy header into URB */
-       memcpy(port->write_urb->transfer_buffer, header_array,
-               QT2_TX_HEADER_LENGTH);
-       /* and actual data to write */
-       memcpy(port->write_urb->transfer_buffer + 5, buf, count);
-
-       dbg("%s(): first data byte to send = %#.2x", __func__, *buf);
-
-       /* set up our urb */
-       usb_fill_bulk_urb(port->write_urb, serial->dev,
-                       usb_sndbulkpipe(serial->dev,
-                       port->bulk_out_endpointAddress),
-                       port->write_urb->transfer_buffer, count + 5,
-                       (qt2_write_bulk_callback), port);
-       /* send the data out the bulk port */
-       result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-       if (result) {
-               /* error couldn't submit urb */
-               result = 0;     /* return 0 as nothing got written */
-               dbg("%s(): failed submitting write urb, error %d",
-                       __func__, result);
-       } else {
-               port_extra->tx_pending_bytes += count;
-               result = count; /* return number of bytes written, i.e. count */
-               dbg("%s(): submitted write urb, wrote %d bytes, "
-                       "total pending bytes %d",
-                       __func__, result, port_extra->tx_pending_bytes);
-       }
-       return result;
-}
-
-/* This is used by the next layer up to know how much space is available
- * in the buffer on the device. It is used on a device closure to avoid
- * calling close() until the buffer is reported to be empty.
- * The returned value must never go down by more than the number of bytes
- * written for correct behaviour further up the driver stack, i.e. if I call
- * it, then write 6 bytes, then call again I should get 6 less, or possibly
- * only 5 less if one was written in the meantime, etc. I should never get 7
- * less (or any bigger number) because I only wrote 6 bytes.
- */
-static int qt2_write_room(struct tty_struct *tty)
-{
-       struct usb_serial_port *port = tty->driver_data;
-               /* parent usb_serial_port pointer */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       int room = 0;
-       port_extra = qt2_get_port_private(port);
-
-       if (port_extra->close_pending == true) {
-               dbg("%s(): port_extra->close_pending == true", __func__);
-               return -ENODEV;
-       }
-       /* Q: how many bytes would a write() call actually succeed in writing
-        * if it happened now?
-        * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent
-        * out of the port, unless this is more than the size of the
-        * write_urb output buffer less the header, which is the maximum
-        * size write we can do.
-
-        * Most of the implementation of this is done when writes to the device
-        * are started or terminate. When we send a write to the device, we
-        * reduce the free space count by the size of the dispatched write.
-        * When a "transmit empty" message comes back up the USB read stream,
-        * we decrement the count by the number of bytes reported sent, thus
-        * keeping track of the difference between sent and received bytes.
-        */
-
-       room = (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes);
-       /* space in FIFO */
-       if (room > port->bulk_out_size - QT2_TX_HEADER_LENGTH)
-               room = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
-       /* if more than the URB can hold, then cap to that limit */
-
-       dbg("%s(): port %d: write room is %d", __func__, port->number, room);
-       return room;
-}
-
-static int qt2_chars_in_buffer(struct tty_struct *tty)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       /* parent usb_serial_port pointer */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       port_extra = qt2_get_port_private(port);
-
-       dbg("%s(): port %d: chars_in_buffer = %d", __func__,
-               port->number, port_extra->tx_pending_bytes);
-       return port_extra->tx_pending_bytes;
-}
-
-/* called when userspace does an ioctl() on the device. Note that
- * TIOCMGET and TIOCMSET are filtered off to their own methods before they get
- * here, so we don't have to handle them.
- */
-static int qt2_ioctl(struct tty_struct *tty,
-                    unsigned int cmd, unsigned long arg)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       struct usb_serial *serial = port->serial;
-       __u8 mcr_value; /* Modem Control Register value */
-       __u8 msr_value; /* Modem Status Register value */
-       unsigned short prev_msr_value; /* Previous value of Modem Status
-        * Register used to implement waiting for a line status change to
-        * occur */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       DECLARE_WAITQUEUE(wait, current);
-       /* Declare a wait queue named "wait" */
-
-       unsigned int value;
-       unsigned int UartNumber;
-
-       if (serial == NULL)
-               return -ENODEV;
-       UartNumber = tty->index - serial->minor;
-       port_extra = qt2_get_port_private(port);
-
-       dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__,
-           port->number, UartNumber, tty);
-
-       if (cmd == TIOCMBIS || cmd == TIOCMBIC) {
-               if (qt2_box_get_register(port->serial, UartNumber,
-                       QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0)
-                       return -ESPIPE;
-               if (copy_from_user(&value, (unsigned int *)arg,
-                       sizeof(value)))
-                       return -EFAULT;
-
-               switch (cmd) {
-               case TIOCMBIS:
-                       if (value & TIOCM_RTS)
-                               mcr_value |= QT2_SERIAL_MCR_RTS;
-                       if (value & TIOCM_DTR)
-                               mcr_value |= QT2_SERIAL_MCR_DTR;
-                       if (value & TIOCM_LOOP)
-                               mcr_value |= QT2_SERIAL_MCR_LOOP;
-               break;
-               case TIOCMBIC:
-                       if (value & TIOCM_RTS)
-                               mcr_value &= ~QT2_SERIAL_MCR_RTS;
-                       if (value & TIOCM_DTR)
-                               mcr_value &= ~QT2_SERIAL_MCR_DTR;
-                       if (value & TIOCM_LOOP)
-                               mcr_value &= ~QT2_SERIAL_MCR_LOOP;
-               break;
-               default:
-               break;
-               }       /* end of local switch on cmd */
-               if (qt2_box_set_register(port->serial,  UartNumber,
-                   QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) {
-                       return -ESPIPE;
-               } else {
-                       port_extra->shadowMCR = mcr_value;
-                       return 0;
-               }
-       } else if (cmd == TIOCMIWAIT) {
-               dbg("%s() port %d, cmd == TIOCMIWAIT enter",
-                       __func__, port->number);
-               prev_msr_value = port_extra->shadowMSR  & QT2_SERIAL_MSR_MASK;
-               barrier();
-               __set_current_state(TASK_INTERRUPTIBLE);
-               while (1) {
-                       add_wait_queue(&port_extra->wait, &wait);
-                       schedule();
-                       dbg("%s(): port %d, cmd == TIOCMIWAIT here\n",
-                               __func__, port->number);
-                       remove_wait_queue(&port_extra->wait, &wait);
-                       /* see if a signal woke us up */
-                       if (signal_pending(current))
-                               return -ERESTARTSYS;
-                       set_current_state(TASK_INTERRUPTIBLE);
-                       msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK;
-                       if (msr_value == prev_msr_value) {
-                               __set_current_state(TASK_RUNNING);
-                               return -EIO;  /* no change - error */
-                       }
-                       if ((arg & TIOCM_RNG &&
-                               ((prev_msr_value & QT2_SERIAL_MSR_RI) ==
-                                       (msr_value & QT2_SERIAL_MSR_RI))) ||
-                               (arg & TIOCM_DSR &&
-                               ((prev_msr_value & QT2_SERIAL_MSR_DSR) ==
-                                       (msr_value & QT2_SERIAL_MSR_DSR))) ||
-                               (arg & TIOCM_CD &&
-                               ((prev_msr_value & QT2_SERIAL_MSR_CD) ==
-                                       (msr_value & QT2_SERIAL_MSR_CD))) ||
-                               (arg & TIOCM_CTS &&
-                               ((prev_msr_value & QT2_SERIAL_MSR_CTS) ==
-                                       (msr_value & QT2_SERIAL_MSR_CTS)))) {
-                               __set_current_state(TASK_RUNNING);
-                               return 0;
-                       }
-               } /* end inifinite while */
-               /* FIXME: This while loop needs a way to break out if the device
-                * is disconnected while a process is waiting for the MSR to
-                * change, because once it's disconnected, it isn't going to
-                * change state ... */
-       } else {
-               /* any other ioctls we don't know about come here */
-               dbg("%s(): No ioctl for that one. port = %d", __func__,
-                       port->number);
-               return -ENOIOCTLCMD;
-       }
-}
-
-/* Called when the user wishes to change the port settings using the termios
- * userspace interface */
-static void qt2_set_termios(struct tty_struct *tty,
-       struct usb_serial_port *port, struct ktermios *old_termios)
-{
-       struct usb_serial *serial; /* parent serial device */
-       int baud, divisor, remainder;
-       unsigned char LCR_change_to = 0;
-       int status;
-       __u16 UartNumber;
-
-       serial = port->serial;
-       UartNumber = port->number;
-
-       if (old_termios && !tty_termios_hw_change(old_termios, tty->termios))
-               return;
-
-       switch (tty->termios->c_cflag) {
-       case CS5:
-               LCR_change_to |= QT2_SERIAL_5_DATA;
-               break;
-       case CS6:
-               LCR_change_to |= QT2_SERIAL_6_DATA;
-               break;
-       case CS7:
-               LCR_change_to |= QT2_SERIAL_7_DATA;
-               break;
-       default:
-       case CS8:
-               LCR_change_to |= QT2_SERIAL_8_DATA;
-               break;
-       }
-
-       /* Parity stuff */
-       if (tty->termios->c_cflag & PARENB) {
-               if (tty->termios->c_cflag & PARODD)
-                       LCR_change_to |= QT2_SERIAL_ODD_PARITY;
-               else
-                       LCR_change_to |= QT2_SERIAL_EVEN_PARITY;
-       }
-       /* Because LCR_change_to is initialised to zero, we don't have to worry
-        * about the case where PARENB is not set or clearing bits, because by
-        * default all of them are cleared, turning parity off.
-        * as we don't support mark/space parity, we should clear the
-        * mark/space parity bit in c_cflag, so the caller can tell we have
-        * ignored the request */
-       tty->termios->c_cflag &= ~CMSPAR;
-
-       if (tty->termios->c_cflag & CSTOPB)
-               LCR_change_to |= QT2_SERIAL_TWO_STOPB;
-       else
-               LCR_change_to |= QT2_SERIAL_ONE_STOPB;
-
-       /* Thats the LCR stuff, next we need to work out the divisor as the
-        * LCR and the divisor are set together */
-       baud = tty_get_baud_rate(tty);
-       if (!baud) {
-               /* pick a default, any default... */
-               baud = 9600;
-       }
-       dbg("%s(): got baud = %d", __func__, baud);
-
-       divisor = QT2_MAX_BAUD_RATE / baud;
-       remainder = QT2_MAX_BAUD_RATE % baud;
-       /* Round to nearest divisor */
-       if (((remainder * 2) >= baud) && (baud != 110))
-               divisor++;
-       dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x",
-             __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to);
-
-       status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor,
-                           LCR_change_to);
-       if (status < 0) {
-               dbg("qt2_boxsetuart() failed");
-               return;
-       } else {
-               /* now encode the baud rate we actually set, which may be
-                * different to the request */
-               baud = QT2_MAX_BAUD_RATE / divisor;
-               tty_encode_baud_rate(tty, baud, baud);
-       }
-
-       /* Now determine flow control */
-       if (tty->termios->c_cflag & CRTSCTS) {
-               dbg("%s(): Enabling HW flow control port %d", __func__,
-                     port->number);
-               /* Enable  RTS/CTS flow control */
-               status = qt2_boxsethw_flowctl(serial, UartNumber, true);
-               if (status < 0) {
-                       dbg("qt2_boxsethw_flowctl() failed");
-                       return;
-               }
-       } else {
-               /* Disable RTS/CTS flow control */
-               dbg("%s(): disabling HW flow control port %d", __func__,
-                       port->number);
-               status = qt2_boxsethw_flowctl(serial, UartNumber, false);
-               if (status < 0) {
-                       dbg("qt2_boxsethw_flowctl failed");
-                       return;
-               }
-       }
-       /* if we are implementing XON/XOFF, set the start and stop character
-        * in the device */
-       if (I_IXOFF(tty) || I_IXON(tty)) {
-               unsigned char stop_char  = STOP_CHAR(tty);
-               unsigned char start_char = START_CHAR(tty);
-               status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char,
-                               start_char);
-               if (status < 0)
-                       dbg("qt2_boxsetsw_flowctl (enabled) failed");
-       } else {
-               /* disable SW flow control */
-               status = qt2_boxunsetsw_flowctl(serial, UartNumber);
-               if (status < 0)
-                       dbg("qt2_boxunsetsw_flowctl (disabling) failed");
-       }
-}
-
-static int qt2_tiocmget(struct tty_struct *tty)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       struct usb_serial *serial = port->serial;
-
-       __u8 mcr_value; /* Modem Control Register value */
-       __u8 msr_value; /* Modem Status Register value */
-       unsigned int result = 0;
-       int status;
-       unsigned int UartNumber;
-
-       if (serial == NULL)
-               return -ENODEV;
-
-       UartNumber = tty->index - serial->minor;
-
-       status = qt2_box_get_register(port->serial, UartNumber,
-                       QT2_MODEM_CONTROL_REGISTER,     &mcr_value);
-       if (status >= 0) {
-               status = qt2_box_get_register(port->serial,  UartNumber,
-                               QT2_MODEM_STATUS_REGISTER, &msr_value);
-       }
-       if (status >= 0) {
-               result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
-                               /*DTR set */
-                       | ((mcr_value & QT2_SERIAL_MCR_RTS)  ? TIOCM_RTS : 0)
-                               /*RTS set */
-                       | ((msr_value & QT2_SERIAL_MSR_CTS)  ? TIOCM_CTS : 0)
-                               /* CTS set */
-                       | ((msr_value & QT2_SERIAL_MSR_CD)  ? TIOCM_CAR : 0)
-                               /*Carrier detect set */
-                       | ((msr_value & QT2_SERIAL_MSR_RI)  ? TIOCM_RI : 0)
-                               /* Ring indicator set */
-                       | ((msr_value & QT2_SERIAL_MSR_DSR)  ? TIOCM_DSR : 0);
-                               /* DSR set */
-               return result;
-       } else {
-               return -ESPIPE;
-       }
-}
-
-static int qt2_tiocmset(struct tty_struct *tty,
-                      unsigned int set, unsigned int clear)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       struct usb_serial *serial = port->serial;
-       __u8 mcr_value; /* Modem Control Register value */
-       int status;
-       unsigned int UartNumber;
-
-       if (serial == NULL)
-               return -ENODEV;
-
-       UartNumber = tty->index - serial->minor;
-
-       status = qt2_box_get_register(port->serial, UartNumber,
-                       QT2_MODEM_CONTROL_REGISTER, &mcr_value);
-       if (status < 0)
-               return -ESPIPE;
-
-       /* Turn off RTS, DTR and loopback, then only turn on what was asked
-        * for */
-       mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR |
-                       QT2_SERIAL_MCR_LOOP);
-       if (set & TIOCM_RTS)
-               mcr_value |= QT2_SERIAL_MCR_RTS;
-       if (set & TIOCM_DTR)
-               mcr_value |= QT2_SERIAL_MCR_DTR;
-       if (set & TIOCM_LOOP)
-               mcr_value |= QT2_SERIAL_MCR_LOOP;
-
-       status = qt2_box_set_register(port->serial, UartNumber,
-                       QT2_MODEM_CONTROL_REGISTER, mcr_value);
-       if (status < 0)
-               return -ESPIPE;
-       else
-               return 0;
-}
-
-/** qt2_break - Turn BREAK on and off on the UARTs
- */
-static void qt2_break(struct tty_struct *tty, int break_state)
-{
-       struct usb_serial_port *port = tty->driver_data; /* parent port */
-       struct usb_serial *serial = port->serial;       /* parent device */
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       __u16 break_value;
-       unsigned int result;
-
-       port_extra = qt2_get_port_private(port);
-       if (!serial) {
-               dbg("%s(): port %d: no serial object", __func__, port->number);
-               return;
-       }
-
-       if (break_state == -1)
-               break_value = 1;
-       else
-               break_value = 0;
-       dbg("%s(): port %d, break_value %d", __func__, port->number,
-               break_value);
-
-       mutex_lock(&port_extra->modelock);
-       if (!port_extra->open_count) {
-               dbg("%s(): port not open", __func__);
-               goto exit;
-       }
-
-       result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                               QT2_BREAK_CONTROL, 0x40, break_value,
-                               port->number, NULL, 0, 300);
-exit:
-       mutex_unlock(&port_extra->modelock);
-
-}
-/**
- * qt2_throttle: - stop reading new data from the port
- */
-static void qt2_throttle(struct tty_struct *tty)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       struct usb_serial *serial = port->serial;
-       struct quatech2_port *port_extra;       /* extra data for this port */
-
-       port_extra = qt2_get_port_private(port);
-       if (!serial) {
-               dbg("%s(): enter port %d no serial object", __func__,
-                     port->number);
-               return;
-       }
-
-       mutex_lock(&port_extra->modelock);      /* lock structure */
-       if (!port_extra->open_count) {
-               dbg("%s(): port not open", __func__);
-               goto exit;
-       }
-       /* Send command to box to stop receiving stuff. This will stop this
-        * particular UART from filling the endpoint - in the multiport case the
-        * FPGA UART will handle any flow control implemented, but for the single
-        * port it's handed differently and we just quit submitting urbs
-        */
-       if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100)
-               qt2_boxstoprx(serial, port->number, 1);
-
-       port->throttled = 1;
-exit:
-       mutex_unlock(&port_extra->modelock);
-       dbg("%s(): port %d: setting port->throttled", __func__, port->number);
-       return;
-}
-
-/**
- * qt2_unthrottle: - start receiving data through the port again after being
- * throttled
- */
-static void qt2_unthrottle(struct tty_struct *tty)
-{
-       struct usb_serial_port *port = tty->driver_data;
-       struct usb_serial *serial = port->serial;
-       struct quatech2_port *port_extra;       /* extra data for this port */
-       struct usb_serial_port *port0;  /* first port structure on device */
-       struct quatech2_dev *dev_extra;         /* extra data for the device */
-
-       if (!serial) {
-               dbg("%s() enter port %d no serial object!", __func__,
-                       port->number);
-               return;
-       }
-       dev_extra = qt2_get_dev_private(serial);
-       port_extra = qt2_get_port_private(port);
-       port0 = serial->port[0]; /* get the first port's device structure */
-
-       mutex_lock(&port_extra->modelock);
-       if (!port_extra->open_count) {
-               dbg("%s(): port %d not open", __func__, port->number);
-               goto exit;
-       }
-
-       if (port->throttled != 0) {
-               dbg("%s(): port %d: unsetting port->throttled", __func__,
-                   port->number);
-               port->throttled = 0;
-               /* Send command to box to start receiving stuff */
-               if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) {
-                       qt2_boxstoprx(serial,  port->number, 0);
-               } else if (dev_extra->ReadBulkStopped == true) {
-                       usb_fill_bulk_urb(port0->read_urb, serial->dev,
-                               usb_rcvbulkpipe(serial->dev,
-                               port0->bulk_in_endpointAddress),
-                               port0->bulk_in_buffer,
-                               port0->bulk_in_size,
-                               qt2_read_bulk_callback,
-                               serial);
-               }
-       }
-exit:
-       mutex_unlock(&port_extra->modelock);
-       return;
-}
-
-/* internal, private helper functions for the driver */
-
-/* Power up the FPGA in the box to get it working */
-static int qt2_boxpoweron(struct usb_serial *serial)
-{
-       int result;
-       __u8  Direcion;
-       unsigned int pipe;
-       Direcion = USBD_TRANSFER_DIRECTION_OUT;
-       pipe = usb_rcvctrlpipe(serial->dev, 0);
-       result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE,
-                               Direcion, QU2BOXPWRON, 0x00, NULL, 0x00,
-                               5000);
-       return result;
-}
-
-/*
- * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the
- * default control pipe. If successful return the number of bytes written,
- * otherwise return a negative error number of the problem.
- */
-static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
-                         __u8 QMCR_Value)
-{
-       int result;
-       __u16 PortSettings;
-
-       PortSettings = (__u16)(QMCR_Value);
-
-       dbg("%s(): Port = %d, PortSettings = 0x%x", __func__,
-                       Uart_Number, PortSettings);
-
-       result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                               QT2_GET_SET_QMCR, 0x40, PortSettings,
-                               (__u16)Uart_Number, NULL, 0, 5000);
-       return result;
-}
-
-static int port_paranoia_check(struct usb_serial_port *port,
-                              const char *function)
-{
-       if (!port) {
-               dbg("%s - port == NULL", function);
-               return -1;
-       }
-       if (!port->serial) {
-               dbg("%s - port->serial == NULL\n", function);
-               return -1;
-       }
-       return 0;
-}
-
-static int serial_paranoia_check(struct usb_serial *serial,
-                                const char *function)
-{
-       if (!serial) {
-               dbg("%s - serial == NULL\n", function);
-               return -1;
-       }
-
-       if (!serial->type) {
-               dbg("%s - serial->type == NULL!", function);
-               return -1;
-       }
-
-       return 0;
-}
-
-static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
-               *port)
-{
-       return (struct quatech2_port *)usb_get_serial_port_data(port);
-}
-
-static inline void qt2_set_port_private(struct usb_serial_port *port,
-               struct quatech2_port *data)
-{
-       usb_set_serial_port_data(port, (void *)data);
-}
-
-static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial
-               *serial)
-{
-       return (struct quatech2_dev *)usb_get_serial_data(serial);
-}
-static inline void qt2_set_dev_private(struct usb_serial *serial,
-               struct quatech2_dev *data)
-{
-       usb_set_serial_data(serial, (void *)data);
-}
-
-static int qt2_openboxchannel(struct usb_serial *serial, __u16
-               Uart_Number, struct qt2_status_data *status)
-{
-       int result;
-       __u16 length;
-       __u8  Direcion;
-       unsigned int pipe;
-       length = sizeof(struct qt2_status_data);
-       Direcion = USBD_TRANSFER_DIRECTION_IN;
-       pipe = usb_rcvctrlpipe(serial->dev, 0);
-       result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
-                       Direcion, 0x00, Uart_Number, status, length, 5000);
-       return result;
-}
-static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number)
-{
-       int result;
-       __u8  direcion;
-       unsigned int pipe;
-       direcion = USBD_TRANSFER_DIRECTION_OUT;
-       pipe = usb_sndctrlpipe(serial->dev, 0);
-       result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
-                 direcion, 0, Uart_Number, NULL, 0, 5000);
-       return result;
-}
-
-/* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default
- * control pipe. If successful sets baud rate divisor and LCR value
- */
-static int qt2_conf_uart(struct usb_serial *serial,  unsigned short Uart_Number,
-                     unsigned short divisor, unsigned char LCR)
-{
-       int result;
-       unsigned short UartNumandLCR;
-
-       UartNumandLCR = (LCR << 8) + Uart_Number;
-
-       result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                               QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR,
-                               NULL, 0, 300);
-       return result;
-}
-
-/** @brief Callback for asynchronous submission of read URBs on bulk in
- * endpoints
- *
- * Registered in qt2_open_port(), used to deal with incomming data
- * from the box.
- */
-static void qt2_read_bulk_callback(struct urb *urb)
-{
-       /* Get the device pointer (struct usb_serial) back out of the URB */
-       struct usb_serial *serial = urb->context;
-       /* get the extra struct for the device */
-       struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
-       /* Get first port structure from the device */
-       struct usb_serial_port *port0 = serial->port[0];
-       /* Get the currently active port structure from serial struct */
-       struct usb_serial_port *active = dev_extra->current_port;
-       /* get the extra struct for port 0 */
-       struct quatech2_port *port0_extra = qt2_get_port_private(port0);
-       /* and for the currently active port */
-       struct quatech2_port *active_extra = qt2_get_port_private(active);
-       /* When we finally get to doing some tty stuff, we will need this */
-       struct tty_struct *tty_st;
-       unsigned int RxCount;   /* the length of the data to process */
-       unsigned int i; /* loop counter over the data to process */
-       int result;     /* return value cache variable */
-       bool escapeflag;        /* flag set to true if this loop iteration is
-                                * parsing an escape sequence, rather than
-                                * ordinary data */
-       dbg("%s(): callback running, active port is %d", __func__,
-               active->number);
-
-       if (urb->status) {
-               /* read didn't go well */
-               dev_extra->ReadBulkStopped = true;
-               dbg("%s(): nonzero bulk read status received: %d",
-                       __func__, urb->status);
-               return;
-       }
-
-       /* inline port_sofrint() here */
-       if (port_paranoia_check(port0, __func__) != 0) {
-               dbg("%s - port_paranoia_check on port0 failed, exiting\n",
-__func__);
-               return;
-       }
-       if (port_paranoia_check(active, __func__) != 0) {
-               dbg("%s - port_paranoia_check on current_port "
-                       "failed, exiting", __func__);
-               return;
-       }
-
-/* This single callback function has to do for all the ports on
- * the device. Data being read up the USB can contain certain
- * escape sequences which are used to communicate out-of-band
- * information from the serial port in-band over the USB.
- * These escapes include sending modem and flow control line
- * status, and switching the port. The concept of a "Current Port"
- * is used, which is where data is going until a port change
- * escape seqence is received. This Current Port is kept between
- * callbacks so that when this function enters we know which the
- * currently active port is and can get to work right away without
- * the box having to send repeat escape sequences (anyway, how
- * would it know to do so?).
- */
-
-       if (active_extra->close_pending == true) {
-               /* We are closing , stop reading */
-               dbg("%s - (active->close_pending == true", __func__);
-               if (dev_extra->open_ports <= 0) {
-                       /* If this is the only port left open - stop the
-                        * bulk read */
-                       dev_extra->ReadBulkStopped = true;
-                       dbg("%s - (ReadBulkStopped == true;", __func__);
-                       return;
-               }
-       }
-
-       /*
-        * RxHolding is asserted by throttle, if we assert it, we're not
-        * receiving any more characters and let the box handle the flow
-        * control
-        */
-       if ((port0_extra->RxHolding == true) &&
-                   (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) {
-               /* single port device, input is already stopped, so we don't
-                * need any more input data */
-               dev_extra->ReadBulkStopped = true;
-               return;
-       }
-       /* finally, we are in a situation where we might consider the data
-        * that is contained within the URB, and what to do about it.
-        * This is likely to involved communicating up to the TTY layer, so
-        * we will need to get hold of the tty for the port we are currently
-        * dealing with */
-
-       /* active is a usb_serial_port. It has a member port which is a
-        * tty_port. From this we get a tty_struct pointer which is what we
-        * actually wanted, and keep it on tty_st */
-       tty_st = tty_port_tty_get(&active->port);
-       if (!tty_st) {
-               dbg("%s - bad tty pointer - exiting", __func__);
-               return;
-       }
-       RxCount = urb->actual_length;   /* grab length of data handy */
-
-       if (RxCount) {
-               /* skip all this if no data to process */
-               for (i = 0; i < RxCount ; ++i) {
-                       /* Look ahead code here -works on several bytes at onc*/
-                       if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
-                               && (NEXTCHAR == 0x1b)) {
-                               /* we are in an escape sequence, type
-                                * determined by the 3rd char */
-                               escapeflag = false;
-                               switch (THIRDCHAR) {
-                               case 0x00:
-                                       /* Line status change 4th byte must
-                                        * follow */
-                                       if (i > (RxCount - 4)) {
-                                               dbg("Illegal escape sequences "
-                                               "in received data");
-                                               break;
-                                       }
-                                       qt2_process_line_status(active,
-                                               FOURTHCHAR);
-                                       i += 3;
-                                       escapeflag = true;
-                                       break;
-                               case 0x01:
-                                       /* Modem status status change 4th byte
-                                        * must follow */
-                                       if (i > (RxCount - 4)) {
-                                               dbg("Illegal escape sequences "
-                                               "in received data");
-                                               break;
-                                       }
-                                       qt2_process_modem_status(active,
-                                               FOURTHCHAR);
-                                       i += 3;
-                                       escapeflag = true;
-                                       break;
-                               case 0x02:
-                                       /* xmit hold empty 4th byte
-                                        * must follow */
-                                       if (i > (RxCount - 4)) {
-                                               dbg("Illegal escape sequences "
-                                               "in received data");
-                                               break;
-                                       }
-                                       qt2_process_xmit_empty(active,
-                                               FOURTHCHAR, FIFTHCHAR);
-                                       i += 4;
-                                       escapeflag = true;
-                                       break;
-                               case 0x03:
-                                       /* Port number change 4th byte
-                                        * must follow */
-                                       if (i > (RxCount - 4)) {
-                                               dbg("Illegal escape sequences "
-                                               "in received data");
-                                               break;
-                                       }
-                                       /* Port change. If port open push
-                                        * current data up to tty layer */
-                                       if (active_extra->open_count > 0)
-                                               tty_flip_buffer_push(tty_st);
-
-                                       dbg("Port Change: new port = %d",
-                                               FOURTHCHAR);
-                                       qt2_process_port_change(active,
-                                               FOURTHCHAR);
-                                       i += 3;
-                                       escapeflag = true;
-                                       /* having changed port, the pointers for
-                                        * the currently active port are all out
-                                        * of date and need updating */
-                                       active = dev_extra->current_port;
-                                       active_extra =
-                                               qt2_get_port_private(active);
-                                       tty_st = tty_port_tty_get(
-                                               &active->port);
-                                       break;
-                               case 0x04:
-                                       /* Recv flush 3rd byte must
-                                        * follow */
-                                       if (i > (RxCount - 3)) {
-                                               dbg("Illegal escape sequences "
-                                                       "in received data");
-                                               break;
-                                       }
-                                       qt2_process_rcv_flush(active);
-                                       i += 2;
-                                       escapeflag = true;
-                                       break;
-                               case 0x05:
-                                       /* xmit flush 3rd byte must follow */
-                                       if (i > (RxCount - 3)) {
-                                               dbg("Illegal escape sequences "
-                                               "in received data");
-                                               break;
-                                       }
-                                       qt2_process_xmit_flush(active);
-                                       i += 2;
-                                       escapeflag = true;
-                                       break;
-                               case 0xff:
-                                       dbg("No status sequence");
-                                       qt2_process_rx_char(active, THISCHAR);
-                                       qt2_process_rx_char(active, NEXTCHAR);
-                                       i += 2;
-                                       break;
-                               default:
-                                       qt2_process_rx_char(active, THISCHAR);
-                                       i += 1;
-                                       break;
-                               } /*end switch*/
-                               if (escapeflag == true)
-                                       continue;
-                               /* if we did an escape char, we don't need
-                                * to mess around pushing data through the
-                                * tty layer, and can go round again */
-                       } /*endif*/
-                       if (tty_st && urb->actual_length) {
-                               tty_buffer_request_room(tty_st, 1);
-                               tty_insert_flip_string(tty_st, &(
-                                               (unsigned char *)
-                                               (urb->transfer_buffer)
-                                       )[i], 1);
-                       }
-               } /*endfor*/
-               tty_flip_buffer_push(tty_st);
-       } /*endif*/
-
-       /* at this point we have complete dealing with the data for this
-        * callback. All we have to do now is to start the async read process
-        * back off again. */
-
-       usb_fill_bulk_urb(port0->read_urb, serial->dev,
-               usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress),
-               port0->bulk_in_buffer, port0->bulk_in_size,
-               qt2_read_bulk_callback, serial);
-       result = usb_submit_urb(port0->read_urb, GFP_ATOMIC);
-       if (result) {
-               dbg("%s(): failed resubmitting read urb, error %d",
-                       __func__, result);
-       } else {
-               dbg("%s() successfully resubmitted read urb", __func__);
-               if (tty_st && RxCount) {
-                       /* if some inbound data was processed, then
-                        * we need to push that through the tty layer
-                        */
-                       tty_flip_buffer_push(tty_st);
-                       tty_schedule_flip(tty_st);
-               }
-       }
-
-       /* cribbed from serqt_usb2 driver, but not sure which work needs
-        * scheduling - port0 or currently active port? */
-       /* schedule_work(&port->work); */
-       return;
-}
-
-/** @brief Callback for asynchronous submission of write URBs on bulk in
- * endpoints
- *
- * Registered in qt2_write(), used to deal with outgoing data
- * to the box.
- */
-static void qt2_write_bulk_callback(struct urb *urb)
-{
-       struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
-       struct usb_serial *serial = port->serial;
-
-       if (!serial) {
-               dbg("%s(): bad serial pointer, exiting", __func__);
-               return;
-       }
-       if (urb->status) {
-               dbg("%s(): nonzero write bulk status received: %d",
-                       __func__, urb->status);
-               return;
-       }
-       /* FIXME What is supposed to be going on here?
-        * does this actually do anything useful, and should it?
-        */
-       /*port_softint((void *) serial); commented in vendor driver */
-       schedule_work(&port->work);
-       return;
-}
-
-static void qt2_process_line_status(struct usb_serial_port *port,
-       unsigned char LineStatus)
-{
-       /* obtain the private structure for the port */
-       struct quatech2_port *port_extra = qt2_get_port_private(port);
-       port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE |
-               QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
-}
-static void qt2_process_modem_status(struct usb_serial_port *port,
-       unsigned char ModemStatus)
-{
-       /* obtain the private structure for the port */
-       struct quatech2_port *port_extra = qt2_get_port_private(port);
-       port_extra->shadowMSR = ModemStatus;
-       wake_up_interruptible(&port_extra->wait);
-       /* this wakes up the otherwise indefinitely waiting code for
-        * the TIOCMIWAIT ioctl, so that it can notice that
-        * port_extra->shadowMSR has changed and the ioctl needs to return.
-        */
-}
-
-static void qt2_process_xmit_empty(struct usb_serial_port *port,
-       unsigned char fourth_char, unsigned char fifth_char)
-{
-       int byte_count;
-       /* obtain the private structure for the port */
-       struct quatech2_port *port_extra = qt2_get_port_private(port);
-
-       byte_count = (int)(fifth_char * 16);
-       byte_count +=  (int)fourth_char;
-       /* byte_count indicates how many bytes the device has written out. This
-        * message appears to occur regularly, and is used in the vendor driver
-        * to keep track of the fill state of the port transmit buffer */
-       port_extra->tx_pending_bytes -= byte_count;
-       /* reduce the stored data queue length by the known number of bytes
-        * sent */
-       dbg("port %d: %d bytes reported sent, %d still pending", port->number,
-                       byte_count, port_extra->tx_pending_bytes);
-
-       /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/
-}
-
-static void qt2_process_port_change(struct usb_serial_port *port,
-       unsigned char New_Current_Port)
-{
-       /* obtain the parent usb serial device structure */
-       struct usb_serial *serial = port->serial;
-       /* obtain the private structure for the device */
-       struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
-       dev_extra->current_port = serial->port[New_Current_Port];
-       /* what should I do with this? commented out in upstream
-        * driver */
-       /*schedule_work(&port->work);*/
-}
-
-static void qt2_process_rcv_flush(struct usb_serial_port *port)
-{
-       /* obtain the private structure for the port */
-       struct quatech2_port *port_extra = qt2_get_port_private(port);
-       port_extra->rcv_flush = true;
-}
-static void qt2_process_xmit_flush(struct usb_serial_port *port)
-{
-       /* obtain the private structure for the port */
-       struct quatech2_port *port_extra = qt2_get_port_private(port);
-       port_extra->xmit_flush = true;
-}
-
-static void qt2_process_rx_char(struct usb_serial_port *port,
-       unsigned char data)
-{
-       /* get the tty_struct for this port */
-       struct tty_struct *tty = tty_port_tty_get(&(port->port));
-       /* get the URB with the data in to push */
-       struct urb *urb = port->serial->port[0]->read_urb;
-
-       if (tty && urb->actual_length) {
-               tty_buffer_request_room(tty, 1);
-               tty_insert_flip_string(tty, &data, 1);
-               /* should this be commented out here? */
-               /*tty_flip_buffer_push(tty);*/
-       }
-}
-
-/** @brief Retrieve the value of a register from the device
- *
- * Issues a GET_REGISTER vendor-spcific request over the USB control
- * pipe to obtain a value back from a specific register on a specific
- * UART
- * @param serial Serial device handle to access the device through
- * @param uart_number Which UART the value is wanted from
- * @param register_num Which register to read the value from
- * @param pValue Pointer to somewhere to put the retrieved value
- */
-static int qt2_box_get_register(struct usb_serial *serial,
-               unsigned char uart_number, unsigned short register_num,
-               __u8 *pValue)
-{
-       int result;
-       result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
-                       QT2_GET_SET_REGISTER, 0xC0, register_num,
-                       uart_number, (void *)pValue, sizeof(*pValue), 300);
-       return result;
-}
-
-/** qt2_box_set_register
- * Issue a SET_REGISTER vendor-specific request on the default control pipe
- */
-static int qt2_box_set_register(struct usb_serial *serial,
-               unsigned short Uart_Number, unsigned short Register_Num,
-               unsigned short Value)
-{
-       int result;
-       unsigned short reg_and_byte;
-
-       reg_and_byte = Value;
-       reg_and_byte = reg_and_byte << 8;
-       reg_and_byte = reg_and_byte + Register_Num;
-
-       result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                       QT2_GET_SET_REGISTER, 0x40, reg_and_byte,
-                       Uart_Number, NULL, 0, 300);
-       return result;
-}
-
-/** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default
- * control pipe. If successful sets baud rate divisor and LCR value.
- */
-static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
-               unsigned short default_divisor, unsigned char default_LCR)
-{
-       unsigned short UartNumandLCR;
-
-       UartNumandLCR = (default_LCR << 8) + Uart_Number;
-
-       return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                       QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR,
-                       NULL, 0, 300);
-}
-
-/** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for
- * a hardware UART.
- */
-static int qt2_boxsethw_flowctl(struct usb_serial *serial,
-               unsigned int UartNumber, bool bSet)
-{
-       __u8 MCR_Value = 0;
-       __u8 MSR_Value = 0;
-       __u16 MOUT_Value = 0;
-
-       if (bSet == true) {
-               MCR_Value =  QT2_SERIAL_MCR_RTS;
-               /* flow control, box will clear RTS line to prevent remote
-                * device from transmitting more chars */
-       } else {
-               /* no flow control to remote device */
-               MCR_Value =  0;
-       }
-       MOUT_Value = MCR_Value << 8;
-
-       if (bSet == true) {
-               MSR_Value = QT2_SERIAL_MSR_CTS;
-               /* flow control on, box will inhibit tx data if CTS line is
-                * asserted */
-       } else {
-               /* Box will not inhibit tx data due to CTS line */
-               MSR_Value = 0;
-       }
-       MOUT_Value |= MSR_Value;
-       return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                       QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber,
-                       NULL, 0, 300);
-}
-
-/** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for
- * a hardware UART, and set the XON and XOFF characters.
- */
-static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
-                       unsigned char stop_char,  unsigned char start_char)
-{
-       __u16 nSWflowout;
-
-       nSWflowout = start_char << 8;
-       nSWflowout = (unsigned short)stop_char;
-       return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                       QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber,
-                       NULL, 0, 300);
-}
-
-/** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for
- * a hardware UART.
- */
-static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber)
-{
-       return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                       QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL,
-                       0, 300);
-}
-
-/**
- * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in
- * response to requests from the tty layer
- * @serial: pointer to the usb_serial structure for the parent device
- * @uart_number: which UART on the device we are addressing
- * @stop: Whether to start or stop data reception. Set to 1 to stop data being
- * received, and to 0 to start it being received.
- */
-static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
-               unsigned short stop)
-{
-       return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-               QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300);
-}
-
-
-/*
- * last things in file: stuff to register this driver into the generic
- * USB serial framework.
- */
-
-static struct usb_serial_driver quatech2_device = {
-       .driver = {
-               .owner = THIS_MODULE,
-               .name = "quatech_usb2",
-       },
-       .description = DRIVER_DESC,
-       .id_table = id_table,
-       .num_ports = 8,
-       .open = qt2_open,
-       .close = qt2_close,
-       .write = qt2_write,
-       .write_room = qt2_write_room,
-       .chars_in_buffer = qt2_chars_in_buffer,
-       .throttle = qt2_throttle,
-       .unthrottle = qt2_unthrottle,
-       .calc_num_ports = qt2_calc_num_ports,
-       .ioctl = qt2_ioctl,
-       .set_termios = qt2_set_termios,
-       .break_ctl = qt2_break,
-       .tiocmget = qt2_tiocmget,
-       .tiocmset = qt2_tiocmset,
-       .attach = qt2_attach,
-       .release = qt2_release,
-       .read_bulk_callback = qt2_read_bulk_callback,
-       .write_bulk_callback = qt2_write_bulk_callback,
-};
-
-static struct usb_serial_driver * const serial_drivers[] = {
-       &quatech2_device, NULL
-};
-
-module_usb_serial_driver(serial_drivers, id_table);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");