[deliverable/linux.git] / drivers / tty / hvc / hvsi_lib.c

#include <linux/types.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/console.h>
#include <asm/hvsi.h>

#include "hvc_console.h"

static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet)
{
	packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno));

	/* Assumes that always succeeds, works in practice */
	return pv->put_chars(pv->termno, (char *)packet, packet->len);
}

static void hvsi_start_handshake(struct hvsi_priv *pv)
{
	struct hvsi_query q;

	/* Reset state */
	pv->established = 0;
	atomic_set(&pv->seqno, 0);

	pr_devel("HVSI@%x: Handshaking started\n", pv->termno);

	/* Send version query */
	q.hdr.type = VS_QUERY_PACKET_HEADER;
	q.hdr.len = sizeof(struct hvsi_query);
	q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
	hvsi_send_packet(pv, &q.hdr);
}

static int hvsi_send_close(struct hvsi_priv *pv)
{
	struct hvsi_control ctrl;

	pv->established = 0;

	ctrl.hdr.type = VS_CONTROL_PACKET_HEADER;
	ctrl.hdr.len = sizeof(struct hvsi_control);
	ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL);
	return hvsi_send_packet(pv, &ctrl.hdr);
}

static void hvsi_cd_change(struct hvsi_priv *pv, int cd)
{
	if (cd)
		pv->mctrl |= TIOCM_CD;
	else {
		pv->mctrl &= ~TIOCM_CD;

		/* We copy the existing hvsi driver semantics
		 * here which are to trigger a hangup when
		 * we get a carrier loss.
		 * Closing our connection to the server will
		 * do just that.
		 */
		if (!pv->is_console && pv->opened) {
			pr_devel("HVSI@%x Carrier lost, hanging up !\n",
				 pv->termno);
			hvsi_send_close(pv);
		}
	}
}

static void hvsi_got_control(struct hvsi_priv *pv)
{
	struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf;

	switch (be16_to_cpu(pkt->verb)) {
	case VSV_CLOSE_PROTOCOL:
		/* We restart the handshaking */
		hvsi_start_handshake(pv);
		break;
	case VSV_MODEM_CTL_UPDATE:
		/* Transition of carrier detect */
		hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD);
		break;
	}
}

static void hvsi_got_query(struct hvsi_priv *pv)
{
	struct hvsi_query *pkt = (struct hvsi_query *)pv->inbuf;
	struct hvsi_query_response r;

	/* We only handle version queries */
	if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER)
		return;

	pr_devel("HVSI@%x: Got version query, sending response...\n",
		 pv->termno);

	/* Send version response */
	r.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER;
	r.hdr.len = sizeof(struct hvsi_query_response);
	r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
	r.u.version = HVSI_VERSION;
	r.query_seqno = pkt->hdr.seqno;
	hvsi_send_packet(pv, &r.hdr);

	/* Assume protocol is open now */
	pv->established = 1;
}

static void hvsi_got_response(struct hvsi_priv *pv)
{
	struct hvsi_query_response *r =
		(struct hvsi_query_response *)pv->inbuf;

	switch(r->verb) {
	case VSV_SEND_MODEM_CTL_STATUS:
		hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD);
		pv->mctrl_update = 1;
		break;
	}
}

static int hvsi_check_packet(struct hvsi_priv *pv)
{
	u8 len, type;

	/* Check header validity. If it's invalid, we ditch
	 * the whole buffer and hope we eventually resync
	 */
	if (pv->inbuf[0] < 0xfc) {
		pv->inbuf_len = pv->inbuf_pktlen = 0;
		return 0;
	}
	type = pv->inbuf[0];
	len = pv->inbuf[1];

	/* Packet incomplete ? */
	if (pv->inbuf_len < len)
		return 0;

	pr_devel("HVSI@%x: Got packet type %x len %d bytes:\n",
		 pv->termno, type, len);

	/* We have a packet, yay ! Handle it */
	switch(type) {
	case VS_DATA_PACKET_HEADER:
		pv->inbuf_pktlen = len - 4;
		pv->inbuf_cur = 4;
		return 1;
	case VS_CONTROL_PACKET_HEADER:
		hvsi_got_control(pv);
		break;
	case VS_QUERY_PACKET_HEADER:
		hvsi_got_query(pv);
		break;
	case VS_QUERY_RESPONSE_PACKET_HEADER:
		hvsi_got_response(pv);
		break;
	}

	/* Swallow packet and retry */
	pv->inbuf_len -= len;
	memmove(pv->inbuf, &pv->inbuf[len], pv->inbuf_len);
	return 1;
}

static int hvsi_get_packet(struct hvsi_priv *pv)
{
	/* If we have room in the buffer, ask HV for more */
	if (pv->inbuf_len < HVSI_INBUF_SIZE)
		pv->inbuf_len += pv->get_chars(pv->termno,
					     &pv->inbuf[pv->inbuf_len],
					     HVSI_INBUF_SIZE - pv->inbuf_len);
	/*
	 * If we have at least 4 bytes in the buffer, check for
	 * a full packet and retry
	 */
	if (pv->inbuf_len >= 4)
		return hvsi_check_packet(pv);
	return 0;
}

int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count)
{
	unsigned int tries, read = 0;

	if (WARN_ON(!pv))
		return -ENXIO;

	/* If we aren't open, don't do anything in order to avoid races
	 * with connection establishment. The hvc core will call this
	 * before we have returned from notifier_add(), and we need to
	 * avoid multiple users playing with the receive buffer
	 */
	if (!pv->opened)
		return 0;

	/* We try twice, once with what data we have and once more
	 * after we try to fetch some more from the hypervisor
	 */
	for (tries = 1; count && tries < 2; tries++) {
		/* Consume existing data packet */
		if (pv->inbuf_pktlen) {
			unsigned int l = min(count, (int)pv->inbuf_pktlen);
			memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l);
			pv->inbuf_cur += l;
			pv->inbuf_pktlen -= l;
			count -= l;
			read += l;
		}
		if (count == 0)
			break;

		/* Data packet fully consumed, move down remaning data */
		if (pv->inbuf_cur) {
			pv->inbuf_len -= pv->inbuf_cur;
			memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur],
				pv->inbuf_len);
			pv->inbuf_cur = 0;
		}

		/* Try to get another packet */
		if (hvsi_get_packet(pv))
			tries--;
	}
	if (!pv->established) {
		pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno);
		return -EPIPE;
	}
	return read;
}

int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count)
{
	struct hvsi_data dp;
	int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA);

	if (WARN_ON(!pv))
		return -ENODEV;

	dp.hdr.type = VS_DATA_PACKET_HEADER;
	dp.hdr.len = adjcount + sizeof(struct hvsi_header);
	memcpy(dp.data, buf, adjcount);
	rc = hvsi_send_packet(pv, &dp.hdr);
	if (rc <= 0)
		return rc;
	return adjcount;
}

static void maybe_msleep(unsigned long ms)
{
	/* During early boot, IRQs are disabled, use mdelay */
	if (irqs_disabled())
		mdelay(ms);
	else
		msleep(ms);
}

int hvsilib_read_mctrl(struct hvsi_priv *pv)
{
	struct hvsi_query q;
	int rc, timeout;

	pr_devel("HVSI@%x: Querying modem control status...\n",
		 pv->termno);

	pv->mctrl_update = 0;
	q.hdr.type = VS_QUERY_PACKET_HEADER;
	q.hdr.len = sizeof(struct hvsi_query);
	q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS);
	rc = hvsi_send_packet(pv, &q.hdr);
	if (rc <= 0) {
		pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc);
		return rc;
	}

	/* Try for up to 200ms */
	for (timeout = 0; timeout < 20; timeout++) {
		if (!pv->established)
			return -ENXIO;
		if (pv->mctrl_update)
			return 0;
		if (!hvsi_get_packet(pv))
			maybe_msleep(10);
	}
	return -EIO;
}

int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr)
{
	struct hvsi_control ctrl;
	unsigned short mctrl;

	mctrl = pv->mctrl;
	if (dtr)
		mctrl |= TIOCM_DTR;
	else
		mctrl &= ~TIOCM_DTR;
	if (mctrl == pv->mctrl)
		return 0;
	pv->mctrl = mctrl;

	pr_devel("HVSI@%x: %s DTR...\n", pv->termno,
		 dtr ? "Setting" : "Clearing");

	ctrl.hdr.type = VS_CONTROL_PACKET_HEADER,
	ctrl.hdr.len = sizeof(struct hvsi_control);
	ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL);
	ctrl.mask = cpu_to_be32(HVSI_TSDTR);
	ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0);
	return hvsi_send_packet(pv, &ctrl.hdr);
}

void hvsilib_establish(struct hvsi_priv *pv)
{
	int timeout;

	pr_devel("HVSI@%x: Establishing...\n", pv->termno);

	/* Try for up to 200ms, there can be a packet to
	 * start the process waiting for us...
	 */
	for (timeout = 0; timeout < 20; timeout++) {
		if (pv->established)
			goto established;
		if (!hvsi_get_packet(pv))
			maybe_msleep(10);
	}

	/* Failed, send a close connection packet just
	 * in case
	 */
	pr_devel("HVSI@%x:   ... sending close\n", pv->termno);

	hvsi_send_close(pv);

	/* Then restart handshake */

	pr_devel("HVSI@%x:   ... restarting handshake\n", pv->termno);

	hvsi_start_handshake(pv);

	pr_devel("HVSI@%x:   ... waiting handshake\n", pv->termno);

	/* Try for up to 400ms */
	for (timeout = 0; timeout < 40; timeout++) {
		if (pv->established)
			goto established;
		if (!hvsi_get_packet(pv))
			maybe_msleep(10);
	}

	if (!pv->established) {
		pr_devel("HVSI@%x: Timeout handshaking, giving up !\n",
			 pv->termno);
		return;
	}
 established:
	/* Query modem control lines */

	pr_devel("HVSI@%x:   ... established, reading mctrl\n", pv->termno);

	hvsilib_read_mctrl(pv);

	/* Set our own DTR */

	pr_devel("HVSI@%x:   ... setting mctrl\n", pv->termno);

	hvsilib_write_mctrl(pv, 1);

	/* Set the opened flag so reads are allowed */
	wmb();
	pv->opened = 1;
}

int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp)
{
	pr_devel("HVSI@%x: open !\n", pv->termno);

	/* Keep track of the tty data structure */
	pv->tty = tty_port_tty_get(&hp->port);

	hvsilib_establish(pv);

	return 0;
}

void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp)
{
	unsigned long flags;

	pr_devel("HVSI@%x: close !\n", pv->termno);

	if (!pv->is_console) {
		pr_devel("HVSI@%x: Not a console, tearing down\n",
			 pv->termno);

		/* Clear opened, synchronize with khvcd */
		spin_lock_irqsave(&hp->lock, flags);
		pv->opened = 0;
		spin_unlock_irqrestore(&hp->lock, flags);

		/* Clear our own DTR */
		if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL))
			hvsilib_write_mctrl(pv, 0);

		/* Tear down the connection */
		hvsi_send_close(pv);
	}

	tty_kref_put(pv->tty);
	pv->tty = NULL;
}

void hvsilib_init(struct hvsi_priv *pv,
		  int (*get_chars)(uint32_t termno, char *buf, int count),
		  int (*put_chars)(uint32_t termno, const char *buf,
				   int count),
		  int termno, int is_console)
{
	memset(pv, 0, sizeof(*pv));
	pv->get_chars = get_chars;
	pv->put_chars = put_chars;
	pv->termno = termno;
	pv->is_console = is_console;
}
Commit	Line	Data
17bdc6c0	1	#include <linux/types.h>
17bdc6c0 BH	2	#include <linux/delay.h>
	3	#include <linux/slab.h>
	4	#include <linux/console.h>
	5	#include <asm/hvsi.h>
	6
	7	#include "hvc_console.h"
	8
	9	static int hvsi_send_packet(struct hvsi_priv pv, struct hvsi_header packet)
	10	{
99fc1d91	11	packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno));
17bdc6c0 BH	12
	13	/* Assumes that always succeeds, works in practice */
	14	return pv->put_chars(pv->termno, (char *)packet, packet->len);
	15	}
	16
	17	static void hvsi_start_handshake(struct hvsi_priv *pv)
	18	{
	19	struct hvsi_query q;
	20
	21	/* Reset state */
	22	pv->established = 0;
	23	atomic_set(&pv->seqno, 0);
	24
	25	pr_devel("HVSI@%x: Handshaking started\n", pv->termno);
	26
	27	/* Send version query */
	28	q.hdr.type = VS_QUERY_PACKET_HEADER;
	29	q.hdr.len = sizeof(struct hvsi_query);
99fc1d91	30	q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
17bdc6c0 BH	31	hvsi_send_packet(pv, &q.hdr);
	32	}
	33
	34	static int hvsi_send_close(struct hvsi_priv *pv)
	35	{
	36	struct hvsi_control ctrl;
	37
	38	pv->established = 0;
	39
	40	ctrl.hdr.type = VS_CONTROL_PACKET_HEADER;
	41	ctrl.hdr.len = sizeof(struct hvsi_control);
99fc1d91	42	ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL);
17bdc6c0 BH	43	return hvsi_send_packet(pv, &ctrl.hdr);
	44	}
	45
	46	static void hvsi_cd_change(struct hvsi_priv *pv, int cd)
	47	{
	48	if (cd)
	49	pv->mctrl \|= TIOCM_CD;
	50	else {
	51	pv->mctrl &= ~TIOCM_CD;
	52
	53	/* We copy the existing hvsi driver semantics
	54	* here which are to trigger a hangup when
	55	* we get a carrier loss.
	56	* Closing our connection to the server will
	57	* do just that.
	58	*/
	59	if (!pv->is_console && pv->opened) {
	60	pr_devel("HVSI@%x Carrier lost, hanging up !\n",
	61	pv->termno);
	62	hvsi_send_close(pv);
	63	}
	64	}
	65	}
	66
	67	static void hvsi_got_control(struct hvsi_priv *pv)
	68	{
	69	struct hvsi_control pkt = (struct hvsi_control )pv->inbuf;
	70
99fc1d91	71	switch (be16_to_cpu(pkt->verb)) {
17bdc6c0 BH	72	case VSV_CLOSE_PROTOCOL:
	73	/* We restart the handshaking */
	74	hvsi_start_handshake(pv);
	75	break;
	76	case VSV_MODEM_CTL_UPDATE:
	77	/* Transition of carrier detect */
99fc1d91	78	hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD);
17bdc6c0 BH	79	break;
	80	}
	81	}
	82
	83	static void hvsi_got_query(struct hvsi_priv *pv)
	84	{
	85	struct hvsi_query pkt = (struct hvsi_query )pv->inbuf;
	86	struct hvsi_query_response r;
	87
	88	/* We only handle version queries */
99fc1d91	89	if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER)
17bdc6c0 BH	90	return;
	91
	92	pr_devel("HVSI@%x: Got version query, sending response...\n",
	93	pv->termno);
	94
	95	/* Send version response */
	96	r.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER;
	97	r.hdr.len = sizeof(struct hvsi_query_response);
99fc1d91	98	r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
17bdc6c0 BH	99	r.u.version = HVSI_VERSION;
	100	r.query_seqno = pkt->hdr.seqno;
	101	hvsi_send_packet(pv, &r.hdr);
	102
	103	/* Assume protocol is open now */
	104	pv->established = 1;
	105	}
	106
	107	static void hvsi_got_response(struct hvsi_priv *pv)
	108	{
	109	struct hvsi_query_response *r =
	110	(struct hvsi_query_response *)pv->inbuf;
	111
	112	switch(r->verb) {
	113	case VSV_SEND_MODEM_CTL_STATUS:
99fc1d91	114	hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD);
17bdc6c0 BH	115	pv->mctrl_update = 1;
	116	break;
	117	}
	118	}
	119
	120	static int hvsi_check_packet(struct hvsi_priv *pv)
	121	{
	122	u8 len, type;
	123
	124	/* Check header validity. If it's invalid, we ditch
	125	* the whole buffer and hope we eventually resync
	126	*/
	127	if (pv->inbuf[0] < 0xfc) {
	128	pv->inbuf_len = pv->inbuf_pktlen = 0;
	129	return 0;
	130	}
	131	type = pv->inbuf[0];
	132	len = pv->inbuf[1];
	133
	134	/* Packet incomplete ? */
	135	if (pv->inbuf_len < len)
	136	return 0;
	137
	138	pr_devel("HVSI@%x: Got packet type %x len %d bytes:\n",
	139	pv->termno, type, len);
	140
	141	/* We have a packet, yay ! Handle it */
	142	switch(type) {
	143	case VS_DATA_PACKET_HEADER:
	144	pv->inbuf_pktlen = len - 4;
	145	pv->inbuf_cur = 4;
	146	return 1;
	147	case VS_CONTROL_PACKET_HEADER:
	148	hvsi_got_control(pv);
	149	break;
	150	case VS_QUERY_PACKET_HEADER:
	151	hvsi_got_query(pv);
	152	break;
	153	case VS_QUERY_RESPONSE_PACKET_HEADER:
	154	hvsi_got_response(pv);
	155	break;
	156	}
	157
	158	/* Swallow packet and retry */
	159	pv->inbuf_len -= len;
	160	memmove(pv->inbuf, &pv->inbuf[len], pv->inbuf_len);
	161	return 1;
	162	}
	163
	164	static int hvsi_get_packet(struct hvsi_priv *pv)
	165	{
	166	/* If we have room in the buffer, ask HV for more */
	167	if (pv->inbuf_len < HVSI_INBUF_SIZE)
	168	pv->inbuf_len += pv->get_chars(pv->termno,
	169	&pv->inbuf[pv->inbuf_len],
	170	HVSI_INBUF_SIZE - pv->inbuf_len);
	171	/*
	172	* If we have at least 4 bytes in the buffer, check for
	173	* a full packet and retry
	174	*/
	175	if (pv->inbuf_len >= 4)
	176	return hvsi_check_packet(pv);
	177	return 0;
	178	}
179
87fa35dd	180	int hvsilib_get_chars(struct hvsi_priv pv, char buf, int count)
17bdc6c0 BH	181	{
	182	unsigned int tries, read = 0;
	183
	184	if (WARN_ON(!pv))
daea1175	185	return -ENXIO;
17bdc6c0 BH	186
	187	/* If we aren't open, don't do anything in order to avoid races
	188	* with connection establishment. The hvc core will call this
	189	* before we have returned from notifier_add(), and we need to
	190	* avoid multiple users playing with the receive buffer
	191	*/
	192	if (!pv->opened)
	193	return 0;
	194
	195	/* We try twice, once with what data we have and once more
	196	* after we try to fetch some more from the hypervisor
	197	*/
	198	for (tries = 1; count && tries < 2; tries++) {
	199	/* Consume existing data packet */
	200	if (pv->inbuf_pktlen) {
	201	unsigned int l = min(count, (int)pv->inbuf_pktlen);
	202	memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l);
	203	pv->inbuf_cur += l;
	204	pv->inbuf_pktlen -= l;
	205	count -= l;
	206	read += l;
	207	}
	208	if (count == 0)
	209	break;
	210
	211	/* Data packet fully consumed, move down remaning data */
	212	if (pv->inbuf_cur) {
	213	pv->inbuf_len -= pv->inbuf_cur;
	214	memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur],
	215	pv->inbuf_len);
	216	pv->inbuf_cur = 0;
	217	}
	218
	219	/* Try to get another packet */
	220	if (hvsi_get_packet(pv))
	221	tries--;
	222	}
	223	if (!pv->established) {
	224	pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno);
	225	return -EPIPE;
	226	}
	227	return read;
	228	}
	229
87fa35dd	230	int hvsilib_put_chars(struct hvsi_priv pv, const char buf, int count)
17bdc6c0 BH	231	{
	232	struct hvsi_data dp;
	233	int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA);
	234
	235	if (WARN_ON(!pv))
daea1175	236	return -ENODEV;
17bdc6c0 BH	237
	238	dp.hdr.type = VS_DATA_PACKET_HEADER;
	239	dp.hdr.len = adjcount + sizeof(struct hvsi_header);
	240	memcpy(dp.data, buf, adjcount);
	241	rc = hvsi_send_packet(pv, &dp.hdr);
	242	if (rc <= 0)
	243	return rc;
	244	return adjcount;
	245	}
	246
	247	static void maybe_msleep(unsigned long ms)
	248	{
	249	/* During early boot, IRQs are disabled, use mdelay */
	250	if (irqs_disabled())
	251	mdelay(ms);
	252	else
	253	msleep(ms);
	254	}
	255
87fa35dd	256	int hvsilib_read_mctrl(struct hvsi_priv *pv)
17bdc6c0 BH	257	{
	258	struct hvsi_query q;
	259	int rc, timeout;
	260
	261	pr_devel("HVSI@%x: Querying modem control status...\n",
	262	pv->termno);
	263
	264	pv->mctrl_update = 0;
	265	q.hdr.type = VS_QUERY_PACKET_HEADER;
	266	q.hdr.len = sizeof(struct hvsi_query);
99fc1d91	267	q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS);
17bdc6c0 BH	268	rc = hvsi_send_packet(pv, &q.hdr);
	269	if (rc <= 0) {
	270	pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc);
	271	return rc;
	272	}
	273
	274	/* Try for up to 200ms */
	275	for (timeout = 0; timeout < 20; timeout++) {
	276	if (!pv->established)
	277	return -ENXIO;
	278	if (pv->mctrl_update)
	279	return 0;
	280	if (!hvsi_get_packet(pv))
	281	maybe_msleep(10);
	282	}
	283	return -EIO;
	284	}
	285
87fa35dd	286	int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr)
17bdc6c0 BH	287	{
	288	struct hvsi_control ctrl;
	289	unsigned short mctrl;
	290
	291	mctrl = pv->mctrl;
	292	if (dtr)
	293	mctrl \|= TIOCM_DTR;
	294	else
	295	mctrl &= ~TIOCM_DTR;
	296	if (mctrl == pv->mctrl)
	297	return 0;
	298	pv->mctrl = mctrl;
	299
	300	pr_devel("HVSI@%x: %s DTR...\n", pv->termno,
	301	dtr ? "Setting" : "Clearing");
	302
	303	ctrl.hdr.type = VS_CONTROL_PACKET_HEADER,
	304	ctrl.hdr.len = sizeof(struct hvsi_control);
99fc1d91 BH	305	ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL);
	306	ctrl.mask = cpu_to_be32(HVSI_TSDTR);
	307	ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0);
17bdc6c0 BH	308	return hvsi_send_packet(pv, &ctrl.hdr);
	309	}
	310
87fa35dd	311	void hvsilib_establish(struct hvsi_priv *pv)
17bdc6c0 BH	312	{
	313	int timeout;
	314
	315	pr_devel("HVSI@%x: Establishing...\n", pv->termno);
	316
	317	/* Try for up to 200ms, there can be a packet to
	318	* start the process waiting for us...
	319	*/
	320	for (timeout = 0; timeout < 20; timeout++) {
	321	if (pv->established)
	322	goto established;
	323	if (!hvsi_get_packet(pv))
	324	maybe_msleep(10);
	325	}
	326
	327	/* Failed, send a close connection packet just
	328	* in case
	329	*/
	330	pr_devel("HVSI@%x: ... sending close\n", pv->termno);
	331
	332	hvsi_send_close(pv);
	333
	334	/* Then restart handshake */
	335
	336	pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno);
	337
	338	hvsi_start_handshake(pv);
	339
	340	pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno);
	341
d220980b ES	342	/* Try for up to 400ms */
d220980b ES	343	for (timeout = 0; timeout < 40; timeout++) {
17bdc6c0 BH	344	if (pv->established)
	345	goto established;
	346	if (!hvsi_get_packet(pv))
	347	maybe_msleep(10);
	348	}
	349
	350	if (!pv->established) {
	351	pr_devel("HVSI@%x: Timeout handshaking, giving up !\n",
	352	pv->termno);
	353	return;
	354	}
	355	established:
	356	/* Query modem control lines */
	357
	358	pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno);
	359
87fa35dd	360	hvsilib_read_mctrl(pv);
17bdc6c0 BH	361
	362	/* Set our own DTR */
	363
	364	pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno);
	365
87fa35dd	366	hvsilib_write_mctrl(pv, 1);
17bdc6c0 BH	367
	368	/* Set the opened flag so reads are allowed */
	369	wmb();
	370	pv->opened = 1;
	371	}
	372
87fa35dd	373	int hvsilib_open(struct hvsi_priv pv, struct hvc_struct hp)
17bdc6c0 BH	374	{
	375	pr_devel("HVSI@%x: open !\n", pv->termno);
	376
	377	/* Keep track of the tty data structure */
85bbc003	378	pv->tty = tty_port_tty_get(&hp->port);
17bdc6c0	379
87fa35dd	380	hvsilib_establish(pv);
17bdc6c0 BH	381
	382	return 0;
	383	}
	384
87fa35dd	385	void hvsilib_close(struct hvsi_priv pv, struct hvc_struct hp)
17bdc6c0 BH	386	{
	387	unsigned long flags;
	388
	389	pr_devel("HVSI@%x: close !\n", pv->termno);
	390
	391	if (!pv->is_console) {
	392	pr_devel("HVSI@%x: Not a console, tearing down\n",
	393	pv->termno);
	394
	395	/* Clear opened, synchronize with khvcd */
	396	spin_lock_irqsave(&hp->lock, flags);
	397	pv->opened = 0;
	398	spin_unlock_irqrestore(&hp->lock, flags);
	399
	400	/* Clear our own DTR */
adc8d746	401	if (!pv->tty \|\| (pv->tty->termios.c_cflag & HUPCL))
87fa35dd	402	hvsilib_write_mctrl(pv, 0);
17bdc6c0 BH	403
	404	/* Tear down the connection */
	405	hvsi_send_close(pv);
	406	}
	407
48f5cde5	408	tty_kref_put(pv->tty);
17bdc6c0 BH	409	pv->tty = NULL;
	410	}
	411
87fa35dd BH	412	void hvsilib_init(struct hvsi_priv *pv,
	413	int (get_chars)(uint32_t termno, char buf, int count),
	414	int (put_chars)(uint32_t termno, const char buf,
	415	int count),
	416	int termno, int is_console)
17bdc6c0 BH	417	{
	418	memset(pv, 0, sizeof(*pv));
	419	pv->get_chars = get_chars;
	420	pv->put_chars = put_chars;
	421	pv->termno = termno;
	422	pv->is_console = is_console;
	423	}