#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
#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)},
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,
.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;
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;
*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)
{
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 */
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 */
}
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");
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;
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 */
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;
}
}
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)
{
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.
git://ftp.safe.ca / safe / jmp / linux-2.6 / blobdiff