1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/types.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
hvsi_send_packet(struct hvsi_priv * pv,struct hvsi_header * packet)10 static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet)
11 {
12 packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno));
13
14 /* Assumes that always succeeds, works in practice */
15 return pv->put_chars(pv->termno, (u8 *)packet, packet->len);
16 }
17
hvsi_start_handshake(struct hvsi_priv * pv)18 static 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 = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
32 hvsi_send_packet(pv, &q.hdr);
33 }
34
hvsi_send_close(struct hvsi_priv * pv)35 static 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 = cpu_to_be16(VSV_CLOSE_PROTOCOL);
44 return hvsi_send_packet(pv, &ctrl.hdr);
45 }
46
hvsi_cd_change(struct hvsi_priv * pv,int cd)47 static 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
hvsi_got_control(struct hvsi_priv * pv)68 static void hvsi_got_control(struct hvsi_priv *pv)
69 {
70 struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf;
71
72 switch (be16_to_cpu(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, be32_to_cpu(pkt->word) & HVSI_TSCD);
80 break;
81 }
82 }
83
hvsi_got_query(struct hvsi_priv * pv)84 static 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 (be16_to_cpu(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 = cpu_to_be16(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
hvsi_got_response(struct hvsi_priv * pv)108 static 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, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD);
116 pv->mctrl_update = 1;
117 break;
118 }
119 }
120
hvsi_check_packet(struct hvsi_priv * pv)121 static 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
hvsi_get_packet(struct hvsi_priv * pv)165 static 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
hvsilib_get_chars(struct hvsi_priv * pv,u8 * buf,size_t count)181 ssize_t hvsilib_get_chars(struct hvsi_priv *pv, u8 *buf, size_t count)
182 {
183 unsigned int tries;
184 size_t read = 0;
185
186 if (WARN_ON(!pv))
187 return -ENXIO;
188
189 /* If we aren't open, don't do anything in order to avoid races
190 * with connection establishment. The hvc core will call this
191 * before we have returned from notifier_add(), and we need to
192 * avoid multiple users playing with the receive buffer
193 */
194 if (!pv->opened)
195 return 0;
196
197 /* We try twice, once with what data we have and once more
198 * after we try to fetch some more from the hypervisor
199 */
200 for (tries = 1; count && tries < 2; tries++) {
201 /* Consume existing data packet */
202 if (pv->inbuf_pktlen) {
203 size_t l = min(count, pv->inbuf_pktlen);
204 memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l);
205 pv->inbuf_cur += l;
206 pv->inbuf_pktlen -= l;
207 count -= l;
208 read += l;
209 }
210 if (count == 0)
211 break;
212
213 /* Data packet fully consumed, move down remaning data */
214 if (pv->inbuf_cur) {
215 pv->inbuf_len -= pv->inbuf_cur;
216 memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur],
217 pv->inbuf_len);
218 pv->inbuf_cur = 0;
219 }
220
221 /* Try to get another packet */
222 if (hvsi_get_packet(pv))
223 tries--;
224 }
225 if (!pv->established) {
226 pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno);
227 return -EPIPE;
228 }
229 return read;
230 }
231
hvsilib_put_chars(struct hvsi_priv * pv,const u8 * buf,size_t count)232 ssize_t hvsilib_put_chars(struct hvsi_priv *pv, const u8 *buf, size_t count)
233 {
234 struct hvsi_data dp;
235 size_t adjcount = min_t(size_t, count, HVSI_MAX_OUTGOING_DATA);
236 int rc;
237
238 if (WARN_ON(!pv))
239 return -ENODEV;
240
241 dp.hdr.type = VS_DATA_PACKET_HEADER;
242 dp.hdr.len = adjcount + sizeof(struct hvsi_header);
243 memcpy(dp.data, buf, adjcount);
244 rc = hvsi_send_packet(pv, &dp.hdr);
245 if (rc <= 0)
246 return rc;
247 return adjcount;
248 }
249
maybe_msleep(unsigned long ms)250 static void maybe_msleep(unsigned long ms)
251 {
252 /* During early boot, IRQs are disabled, use mdelay */
253 if (irqs_disabled())
254 mdelay(ms);
255 else
256 msleep(ms);
257 }
258
hvsilib_read_mctrl(struct hvsi_priv * pv)259 int hvsilib_read_mctrl(struct hvsi_priv *pv)
260 {
261 struct hvsi_query q;
262 int rc, timeout;
263
264 pr_devel("HVSI@%x: Querying modem control status...\n",
265 pv->termno);
266
267 pv->mctrl_update = 0;
268 q.hdr.type = VS_QUERY_PACKET_HEADER;
269 q.hdr.len = sizeof(struct hvsi_query);
270 q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS);
271 rc = hvsi_send_packet(pv, &q.hdr);
272 if (rc <= 0) {
273 pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc);
274 return rc;
275 }
276
277 /* Try for up to 200ms */
278 for (timeout = 0; timeout < 20; timeout++) {
279 if (!pv->established)
280 return -ENXIO;
281 if (pv->mctrl_update)
282 return 0;
283 if (!hvsi_get_packet(pv))
284 maybe_msleep(10);
285 }
286 return -EIO;
287 }
288
hvsilib_write_mctrl(struct hvsi_priv * pv,int dtr)289 int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr)
290 {
291 struct hvsi_control ctrl;
292 unsigned short mctrl;
293
294 mctrl = pv->mctrl;
295 if (dtr)
296 mctrl |= TIOCM_DTR;
297 else
298 mctrl &= ~TIOCM_DTR;
299 if (mctrl == pv->mctrl)
300 return 0;
301 pv->mctrl = mctrl;
302
303 pr_devel("HVSI@%x: %s DTR...\n", pv->termno,
304 dtr ? "Setting" : "Clearing");
305
306 ctrl.hdr.type = VS_CONTROL_PACKET_HEADER;
307 ctrl.hdr.len = sizeof(struct hvsi_control);
308 ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL);
309 ctrl.mask = cpu_to_be32(HVSI_TSDTR);
310 ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0);
311 return hvsi_send_packet(pv, &ctrl.hdr);
312 }
313
hvsilib_establish(struct hvsi_priv * pv)314 void hvsilib_establish(struct hvsi_priv *pv)
315 {
316 int timeout;
317
318 pr_devel("HVSI@%x: Establishing...\n", pv->termno);
319
320 /* Try for up to 200ms, there can be a packet to
321 * start the process waiting for us...
322 */
323 for (timeout = 0; timeout < 20; timeout++) {
324 if (pv->established)
325 goto established;
326 if (!hvsi_get_packet(pv))
327 maybe_msleep(10);
328 }
329
330 /* Failed, send a close connection packet just
331 * in case
332 */
333 pr_devel("HVSI@%x: ... sending close\n", pv->termno);
334
335 hvsi_send_close(pv);
336
337 /* Then restart handshake */
338
339 pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno);
340
341 hvsi_start_handshake(pv);
342
343 pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno);
344
345 /* Try for up to 400ms */
346 for (timeout = 0; timeout < 40; timeout++) {
347 if (pv->established)
348 goto established;
349 if (!hvsi_get_packet(pv))
350 maybe_msleep(10);
351 }
352
353 if (!pv->established) {
354 pr_devel("HVSI@%x: Timeout handshaking, giving up !\n",
355 pv->termno);
356 return;
357 }
358 established:
359 /* Query modem control lines */
360
361 pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno);
362
363 hvsilib_read_mctrl(pv);
364
365 /* Set our own DTR */
366
367 pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno);
368
369 hvsilib_write_mctrl(pv, 1);
370
371 /* Set the opened flag so reads are allowed */
372 wmb();
373 pv->opened = 1;
374 }
375
hvsilib_open(struct hvsi_priv * pv,struct hvc_struct * hp)376 int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp)
377 {
378 pr_devel("HVSI@%x: open !\n", pv->termno);
379
380 /* Keep track of the tty data structure */
381 pv->tty = tty_port_tty_get(&hp->port);
382
383 hvsilib_establish(pv);
384
385 return 0;
386 }
387
hvsilib_close(struct hvsi_priv * pv,struct hvc_struct * hp)388 void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp)
389 {
390 unsigned long flags;
391
392 pr_devel("HVSI@%x: close !\n", pv->termno);
393
394 if (!pv->is_console) {
395 pr_devel("HVSI@%x: Not a console, tearing down\n",
396 pv->termno);
397
398 /* Clear opened, synchronize with khvcd */
399 spin_lock_irqsave(&hp->lock, flags);
400 pv->opened = 0;
401 spin_unlock_irqrestore(&hp->lock, flags);
402
403 /* Clear our own DTR */
404 if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL))
405 hvsilib_write_mctrl(pv, 0);
406
407 /* Tear down the connection */
408 hvsi_send_close(pv);
409 }
410
411 tty_kref_put(pv->tty);
412 pv->tty = NULL;
413 }
414
hvsilib_init(struct hvsi_priv * pv,ssize_t (* get_chars)(uint32_t termno,u8 * buf,size_t count),ssize_t (* put_chars)(uint32_t termno,const u8 * buf,size_t count),int termno,int is_console)415 void hvsilib_init(struct hvsi_priv *pv,
416 ssize_t (*get_chars)(uint32_t termno, u8 *buf, size_t count),
417 ssize_t (*put_chars)(uint32_t termno, const u8 *buf,
418 size_t 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