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