Staging: quatech_usb2: implement open functionality
authorRichard Ash <richard@audacityteam.org>
Wed, 29 Jul 2009 16:12:18 +0000 (17:12 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 15 Sep 2009 19:01:35 +0000 (12:01 -0700)
Part two of the driver implementation has finally got done. It
implements the rest of open and the callback for reads from the box. I
seem to have finally found a structure that can be made to work, with a
single set of URBs for bulk read and write for the whole device, which
are used by all the ports. I've rationalised a few things, but there
will still be a lot of clean-up needed.

This one definitely can panic the kernel when a port is opened for
reading, but I'm off on holiday so I thought I'd post where I have got
to so far. I haven't tried to debug why it panics with a null pointer
dereference yet.

Signed-off-by: Richard Ash <richard@audacityteam.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/quatech_usb2/quatech_usb2.c

index 3544e7005404e0fa420a5de3dc2b90245f26e066..0eaea2e7ce8a8c4b528aa2f0fa7ae865a1c5bf3b 100644 (file)
@@ -38,6 +38,7 @@ static int debug;
 #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 FIFO_DEPTH 1024                        /* size of hardware fifos */
 /* directions for USB transfers */
 #define USBD_TRANSFER_DIRECTION_IN    0xc0
 #define USBD_TRANSFER_DIRECTION_OUT   0x40
@@ -84,6 +85,12 @@ static int debug;
 #define SERIAL_LSR_FE       0x08
 #define SERIAL_LSR_BI       0x10
 
+/* 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 struct usb_device_id quausb2_id_table[] = {
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)},
@@ -99,8 +106,6 @@ static struct usb_device_id quausb2_id_table[] = {
 MODULE_DEVICE_TABLE(usb, quausb2_id_table);
 
 /* custom structures we need go here */
-
-
 static struct usb_driver quausb2_usb_driver = {
        .name = "quatech-usb2-serial",
        .probe = usb_serial_probe,
@@ -109,10 +114,35 @@ static struct usb_driver quausb2_usb_driver = {
        .no_dynamic_id = 1,
 };
 
-/* structure in which to keep all the messy stuff that this driver needs
- * alongside the usb_serial_port structure */
+/** structure in which to keep all the messy stuff that this driver needs
+ * alongside the usb_serial_port structure
+ * @param read_urb_busy Flag indicating that port->read_urb is in use
+ * @param close_pending flag indicating that this port is in the process of
+ * being closed.
+ * @param shadowLSR Last received state of the line status register, holds the
+ * value of the line status flags from the port
+ * @param shadowMSR Last received state of the modem status register, holds
+ * the value of the modem status received from the port
+ * @param xmit_pending_bytes Number of bytes waiting to be sent out of
+ * the serial port
+ * @param xmit_fifo_room_bytes free space available in the transmit fifo
+ * for this port on the box
+ * @param rcv_flush Flag indicating that a receive flush has been requested by
+ * the hardware.
+ * @param xmit_flush Flag indicating that a transmit flush has been requested by
+ * the hardware.
+ */
 struct quatech2_port {
        int     magic;
+       bool    read_urb_busy;
+       bool    close_pending;
+       __u8    shadowLSR;
+       __u8    shadowMSR;
+       int     xmit_pending_bytes;
+       int     xmit_fifo_room_bytes;
+       char    rcv_flush;
+       char    xmit_flush;
+
        char    active;         /* someone has this device open */
        unsigned char           *xfer_to_tty_buffer;
        wait_queue_head_t       wait;
@@ -120,20 +150,27 @@ struct quatech2_port {
        struct semaphore        sem;    /* locks this structure */
        __u8    shadowLCR;      /* last LCR value received */
        __u8    shadowMCR;      /* last MCR value received */
-       __u8    shadowMSR;      /* last MSR value received */
-       __u8    shadowLSR;      /* last LSR value received */
-       char    open_ports;     /* ports open on whole device */
        char    RxHolding;
-       char    Rcv_Flush;
-       char    Xmit_Flush;
-       char    closePending;
        char    fifo_empty_flag;
-       int     xmit_pending_bytes;
-       int     xmit_fifo_room_bytes;
        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
+ */
+struct quatech2_dev {
+       bool    ReadBulkStopped;
+       char    open_ports;
+       struct usb_serial_port *current_port;
+};
+
 /* structure which holds line and modem status flags */
 struct qt2_status_data {
        __u8 line_status;
@@ -152,12 +189,30 @@ 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_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);
+
 /* implementation functions, roughly in order of use, are here */
 static int qt2_calc_num_ports(struct usb_serial *serial)
 {
@@ -195,12 +250,13 @@ static int qt2_calc_num_ports(struct usb_serial *serial)
 static int qt2_attach(struct usb_serial *serial)
 {
        struct usb_serial_port *port;
-       struct quatech2_port *qt2_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 printing endpoint addresses, not needed for
-        * production */
+       /* 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 */
@@ -212,12 +268,42 @@ static int qt2_attach(struct usb_serial *serial)
                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;
+               }
+               spin_lock_init(&qt2_port->lock);
+               usb_set_serial_port_data(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)
-       {
+       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 */
@@ -226,33 +312,13 @@ static int qt2_attach(struct usb_serial *serial)
                }
 
                if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
-                                   ((endpoint->bmAttributes & 3) == 0x02))
-               {
+                       ((endpoint->bmAttributes & 3) == 0x02)) {
                        /* we found a bulk out endpoint */
                        dbg("found bulk out at 0x%x",
                                endpoint->bEndpointAddress);
                }
        }       /* end printing endpoint addresses */
 
-       /* 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;
-               }
-               spin_lock_init(&qt2_port->lock);
-               if (i == 0)
-                       qt2_port->open_ports = 0; /* no ports */
-               else
-                       qt2_port->open_ports = -1; /* unused */
-
-               usb_set_serial_port_data(port, qt2_port);
-
-       }
        /* switch on power to the hardware */
        if (qt2_boxpoweron(serial) < 0) {
                dbg("qt2_boxpoweron() failed");
@@ -274,8 +340,11 @@ startup_error:
                port = serial->port[i];
                qt2_port = qt2_get_port_private(port);
                kfree(qt2_port);
-               usb_set_serial_port_data(port, NULL);
+               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;
@@ -317,30 +386,40 @@ int qt2_open(struct tty_struct *tty,
        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 = SERIAL_8_DATA;
        int status;
+       int result;
 
        if (port_paranoia_check(port, __func__))
                return -ENODEV;
 
-       dbg("%s - port %d\n", __func__, port->number);
+       dbg("%s(): port %d", __func__, port->number);
 
        serial = port->serial;  /* get the parent device structure */
-       if (serial_paranoia_check(serial, __func__))
+       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 */
        port0 = serial->port[0]; /* get the first port's device structure */
-
+       if (port_paranoia_check(port, __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)
+       if (port_extra == NULL || port0_extra == NULL) {
+               dbg("failed to get private data for port and port0");
                return -ENODEV;
+       }
 
        usb_clear_halt(serial->dev, port->write_urb->pipe);
        usb_clear_halt(serial->dev, port->read_urb->pipe);
-       port0_extra->open_ports++;
 
        /* FIXME: are these needed?  Does it even do anything useful? */
        /* get the modem and line status values from the UART */
@@ -374,39 +453,58 @@ int qt2_open(struct tty_struct *tty,
        dbg("qt2_conf_uart() completed on channel %d",
                port->number);
 
-       dbg("port number is %d", port->number);
-       dbg("serial number is %d", port->serial->minor);
-
-       /* We need to set up endpoints here. We only
-        * have one pair of endpoints per device, so in fact
-        * we only need to set up endpoints on the first time
-        * round, not subsequent ones.
-        * When we do a write to a port, we will use the same endpoint
+       /*
+        * 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 the same endpoint information needs to be visible to
-        * write calls regardless of which port is being written.
-        * To this end we actually keep the relevant endpoints
-        * in port 0's structure, because that's always there
-        * and avoids providing our own duplicate members in some
-        * user data structure for the same purpose.
-        * URBs will be allocated and freed dynamically as the are
-        * used, so are not touched here.
+        * tell the box which port it should eventually come out of, so we only
+        * need the one set of endpoints.
+        * 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.
         */
-       if (port0_extra->open_ports == 1) {
-               /* this is first port to be opened */
+       dbg("port number is %d", port->number);
+       dbg("serial number is %d", port->serial->minor);
+       dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress);
+       dbg("port0 bulk out endpoint is %#.2x",
+               port0->bulk_out_endpointAddress);
+
+       if (dev_extra->open_ports == 0) {
+               /* this is first port to be opened, so need some URBs */
+               /* initialise read_urb for bulk in transfers */
+               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 intialised");
+
+               /* 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\n",
+                               __func__, result);
+                       port_extra->read_urb_busy = false;
+               }
        }
 
-       dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress);
-       dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress);
-       dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress);
-
        /* initialize our wait queues */
        init_waitqueue_head(&port_extra->wait);
 
        /* remember to store port_extra and port0 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;
 }
@@ -486,11 +584,22 @@ static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
 }
 
 static inline void qt2_set_port_private(struct usb_serial_port *port,
-                                      struct quatech2_port *data)
+               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)
 {
@@ -534,6 +643,343 @@ static int qt2_conf_uart(struct usb_serial *serial,  unsigned short Uart_Number,
        return result;
 }
 
+/** @brief Callback for asynchronous submission of 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", __func__);
+
+       if (urb->status) {
+               /* read didn't go well */
+               dev_extra->ReadBulkStopped = true;
+               dbg("%s(): nonzero write bulk 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;
+       }
+       dbg("%s(): active port %d, tty_st =0x%p\n", __func__, active->number,
+               tty_st);
+       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 (dev_extra->open_ports > 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 {
+               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;
+}
+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 & (SERIAL_LSR_OE | SERIAL_LSR_PE |
+               SERIAL_LSR_FE | 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);
+}
+
+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;
+       port_extra->xmit_pending_bytes -= (int)byte_count;
+       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);*/
+       }
+}
 /*
  * last things in file: stuff to register this driver into the generic
  * USB serial framework.