Staging: quatech_usb2: implement open functionality

#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;

	/* 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 0x%x",

				endpoint->bEndpointAddress);

		}

		if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&

				    ((endpoint->bmAttributes & 3) == 0x02))

		{

			/* we found a bulk out endpoint */

			dbg("found bulk out at 0x%x",

				endpoint->bEndpointAddress);

	/* 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;

	}

	}	/* end printing endpoint addresses */

	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 */

			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);

	}

	/* 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 0x%x",

				endpoint->bEndpointAddress);

		}

		if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&

			((endpoint->bmAttributes & 3) == 0x02)) {

			/* we found a bulk out endpoint */

			dbg("found bulk out at 0x%x",

				endpoint->bEndpointAddress);

		}

	}	/* end printing endpoint addresses */

	/* 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;

}

	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;