Staging: quatech_usb2: vendor implementation of break_ctl

#define QT2_HW_FLOW_CONTROL_MASK		0xc5

#define QT2_SW_FLOW_CONTROL_MASK		0xc6

#define QT2_SW_FLOW_CONTROL_DISABLE		0xc7

/*#define QT_BREAK_CONTROL 		0xc8

#define QT_STOP_RECEIVE			0xe0*/

#define QT2_BREAK_CONTROL 			0xc8

#define QT2_STOP_RECEIVE			0xe0

#define QT2_FLUSH_DEVICE			0xc4

#define QT_GET_SET_QMCR			0xe1

#define QT2_GET_SET_QMCR			0xe1

/* sorts of flush we can do on */

#define QT2_FLUSH_RX			0x00

	.no_dynamic_id = 1,

};

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

/**

 * 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).

 * @param shadowLSR Last received state of the line status register, holds the

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

 * @shadowMSR: Last received state of the modem status register, holds

 * the value of the modem status received from the port

 * @param rcv_flush Flag indicating that a receive flush has occured on

 * @rcv_flush: Flag indicating that a receive flush has occured on

 * the hardware.

 * @param xmit_flush Flag indicating that a transmit flush has been processed by

 * @xmit_flush: Flag indicating that a transmit flush has been processed by

 * the hardware.

 * @param fifo_empty_flag

 * - Starts off true when port opened

 * - set false when a write is submitted to the driver

 * - as far as I can see not true again until device is re-opened.

 * - read in a number of places.

 * @param tx_fifo_room

 * - set to FIFO_DEPTH when port opened

 * - decremented by tc_pending_bytes when a new write is submitted.

 * - set to FIFO_DEPTH when "xmit_empty" is received from the device,

 * regardless of how many bytes were reported to have been sent (?)

 *

 * @param tx_pending_bytes Number of bytes waiting to be sent. This total

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

 * each time a write urb is dispatched.

 * - is decremented each time a "transmit empty" message is received

 * by the driver in the data stream.

 * @sem: Semaphore 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	close_pending;

	__u8	shadowLSR;

	__u8	shadowMSR;

	/*int	xmit_fifo_room_bytes;*/

	bool	rcv_flush;

	bool	xmit_flush;

/*	bool	fifo_empty_flag;

	int	tx_fifo_room;*/

	int	tx_pending_bytes;

	struct semaphore	sem;

	int	open_count;

	char	active;		/* someone has this device open */

	unsigned char		*xfer_to_tty_buffer;

	wait_queue_head_t	wait;

	int	open_count;	/* number of times this	port has been opened */

	struct semaphore	sem;	/* locks this structure */

	__u8	shadowLCR;	/* last LCR value received */

	__u8	shadowMCR;	/* last MCR value received */

	char	RxHolding;

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)

			    __func__, i);

			return -ENOMEM;

		}

		/* initialise stuff in the structure */

		qt2_port->open_count = 0;	/* port is not open */

		spin_lock_init(&qt2_port->lock);

		qt2_set_port_private(port, qt2_port);

	}

			port->bulk_out_size,

			qt2_write_bulk_callback,

			port);

	/*port_extra->fifo_empty_flag = true;

	port_extra->tx_fifo_room = FIFO_DEPTH;*/

	port_extra->tx_pending_bytes = 0;

	if (dev_extra->open_ports == 0) {

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

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

	/* Round to nearest divisor */

	if (((remainder * 2) >= baud) && (baud != 110))

		divisor++;

	dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = 0x%x",

	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,

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

	down(&port_extra->sem);

	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:

	up(&port_extra->sem);

	dbg("%s(): exit port %d", __func__, port->number);

}

/**

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

	dbg("%s(): port %d", __func__, port->number);

	port_extra = qt2_get_port_private(port);

	if (!serial) {

		dbg("%s(): enter port %d no serial object", __func__,

		      port->number);

		return;

	}

	down(&port_extra->sem);	/* 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 implmented, 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:

	up(&port_extra->sem);

	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;

	}

	dbg("%s(): enter port %d", __func__, port->number);

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

	down(&port_extra->sem);

	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:

	up(&port_extra->sem);

	dbg("%s(): exit port %d", __func__, port->number);

	return;

}

/* internal, private helper functions for the driver */

/* Power up the FPGA in the box to get it working */

}

/*

 * qt2_boxsetQMCR Issue a QT_GET_SET_QMCR vendor-spcific request on the

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

 */

			Uart_Number, PortSettings);

	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),

				QT_GET_SET_QMCR, 0x40, PortSettings,

				QT2_GET_SET_QMCR, 0x40, PortSettings,

				(__u16)Uart_Number, NULL, 0, 5000);

	return result;

}

					}

					/* Port change. If port open push

					 * current data up to tty layer */

					if (dev_extra->open_ports > 0)

					if (active_extra->open_count > 0)

						tty_flip_buffer_push(tty_st);

					dbg("Port Change: new port = %d",

			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.

	.write = qt2_write,

	.write_room = qt2_write_room,

	.chars_in_buffer = qt2_chars_in_buffer,

	/*.throttle = qt_throttle,

	.unthrottle = qt_unthrottle,*/

	.throttle = qt2_throttle,

	.unthrottle = qt2_unthrottle,

	.calc_num_ports = qt2_calc_num_ports,

	.ioctl = qt2_ioctl,

	.set_termios = qt2_set_termios,

	/*.break_ctl = qt_break,*/

	.break_ctl = qt2_break,

	.tiocmget = qt2_tiocmget,

	.tiocmset = qt2_tiocmset,

	.attach = qt2_attach,