]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
17bdc6c0 | 2 | #include <linux/types.h> |
17bdc6c0 BH |
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 | ||
10 | static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet) | |
11 | { | |
99fc1d91 | 12 | packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno)); |
17bdc6c0 BH |
13 | |
14 | /* Assumes that always succeeds, works in practice */ | |
15 | return pv->put_chars(pv->termno, (char *)packet, packet->len); | |
16 | } | |
17 | ||
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); | |
99fc1d91 | 31 | q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); |
17bdc6c0 BH |
32 | hvsi_send_packet(pv, &q.hdr); |
33 | } | |
34 | ||
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); | |
99fc1d91 | 43 | ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL); |
17bdc6c0 BH |
44 | return hvsi_send_packet(pv, &ctrl.hdr); |
45 | } | |
46 | ||
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 | ||
68 | static void hvsi_got_control(struct hvsi_priv *pv) | |
69 | { | |
70 | struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf; | |
71 | ||
99fc1d91 | 72 | switch (be16_to_cpu(pkt->verb)) { |
17bdc6c0 BH |
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 */ | |
99fc1d91 | 79 | hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD); |
17bdc6c0 BH |
80 | break; |
81 | } | |
82 | } | |
83 | ||
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 */ | |
99fc1d91 | 90 | if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER) |
17bdc6c0 BH |
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); | |
99fc1d91 | 99 | r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); |
17bdc6c0 BH |
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 | ||
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: | |
99fc1d91 | 115 | hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD); |
17bdc6c0 BH |
116 | pv->mctrl_update = 1; |
117 | break; | |
118 | } | |
119 | } | |
120 | ||
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 | ||
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 | ||
87fa35dd | 181 | int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count) |
17bdc6c0 BH |
182 | { |
183 | unsigned int tries, read = 0; | |
184 | ||
185 | if (WARN_ON(!pv)) | |
daea1175 | 186 | return -ENXIO; |
17bdc6c0 BH |
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 | ||
87fa35dd | 231 | int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count) |
17bdc6c0 BH |
232 | { |
233 | struct hvsi_data dp; | |
234 | int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA); | |
235 | ||
236 | if (WARN_ON(!pv)) | |
daea1175 | 237 | return -ENODEV; |
17bdc6c0 BH |
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 | ||
248 | static 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 | ||
87fa35dd | 257 | int hvsilib_read_mctrl(struct hvsi_priv *pv) |
17bdc6c0 BH |
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); | |
99fc1d91 | 268 | q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS); |
17bdc6c0 BH |
269 | rc = hvsi_send_packet(pv, &q.hdr); |
270 | if (rc <= 0) { | |
271 | pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc); | |
272 | return rc; | |
273 | } | |
274 | ||
275 | /* Try for up to 200ms */ | |
276 | for (timeout = 0; timeout < 20; timeout++) { | |
277 | if (!pv->established) | |
278 | return -ENXIO; | |
279 | if (pv->mctrl_update) | |
280 | return 0; | |
281 | if (!hvsi_get_packet(pv)) | |
282 | maybe_msleep(10); | |
283 | } | |
284 | return -EIO; | |
285 | } | |
286 | ||
87fa35dd | 287 | int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr) |
17bdc6c0 BH |
288 | { |
289 | struct hvsi_control ctrl; | |
290 | unsigned short mctrl; | |
291 | ||
292 | mctrl = pv->mctrl; | |
293 | if (dtr) | |
294 | mctrl |= TIOCM_DTR; | |
295 | else | |
296 | mctrl &= ~TIOCM_DTR; | |
297 | if (mctrl == pv->mctrl) | |
298 | return 0; | |
299 | pv->mctrl = mctrl; | |
300 | ||
301 | pr_devel("HVSI@%x: %s DTR...\n", pv->termno, | |
302 | dtr ? "Setting" : "Clearing"); | |
303 | ||
304 | ctrl.hdr.type = VS_CONTROL_PACKET_HEADER, | |
305 | ctrl.hdr.len = sizeof(struct hvsi_control); | |
99fc1d91 BH |
306 | ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL); |
307 | ctrl.mask = cpu_to_be32(HVSI_TSDTR); | |
308 | ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0); | |
17bdc6c0 BH |
309 | return hvsi_send_packet(pv, &ctrl.hdr); |
310 | } | |
311 | ||
87fa35dd | 312 | void hvsilib_establish(struct hvsi_priv *pv) |
17bdc6c0 BH |
313 | { |
314 | int timeout; | |
315 | ||
316 | pr_devel("HVSI@%x: Establishing...\n", pv->termno); | |
317 | ||
318 | /* Try for up to 200ms, there can be a packet to | |
319 | * start the process waiting for us... | |
320 | */ | |
321 | for (timeout = 0; timeout < 20; timeout++) { | |
322 | if (pv->established) | |
323 | goto established; | |
324 | if (!hvsi_get_packet(pv)) | |
325 | maybe_msleep(10); | |
326 | } | |
327 | ||
328 | /* Failed, send a close connection packet just | |
329 | * in case | |
330 | */ | |
331 | pr_devel("HVSI@%x: ... sending close\n", pv->termno); | |
332 | ||
333 | hvsi_send_close(pv); | |
334 | ||
335 | /* Then restart handshake */ | |
336 | ||
337 | pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno); | |
338 | ||
339 | hvsi_start_handshake(pv); | |
340 | ||
341 | pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno); | |
342 | ||
d220980b ES |
343 | /* Try for up to 400ms */ |
344 | for (timeout = 0; timeout < 40; timeout++) { | |
17bdc6c0 BH |
345 | if (pv->established) |
346 | goto established; | |
347 | if (!hvsi_get_packet(pv)) | |
348 | maybe_msleep(10); | |
349 | } | |
350 | ||
351 | if (!pv->established) { | |
352 | pr_devel("HVSI@%x: Timeout handshaking, giving up !\n", | |
353 | pv->termno); | |
354 | return; | |
355 | } | |
356 | established: | |
357 | /* Query modem control lines */ | |
358 | ||
359 | pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno); | |
360 | ||
87fa35dd | 361 | hvsilib_read_mctrl(pv); |
17bdc6c0 BH |
362 | |
363 | /* Set our own DTR */ | |
364 | ||
365 | pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno); | |
366 | ||
87fa35dd | 367 | hvsilib_write_mctrl(pv, 1); |
17bdc6c0 BH |
368 | |
369 | /* Set the opened flag so reads are allowed */ | |
370 | wmb(); | |
371 | pv->opened = 1; | |
372 | } | |
373 | ||
87fa35dd | 374 | int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp) |
17bdc6c0 BH |
375 | { |
376 | pr_devel("HVSI@%x: open !\n", pv->termno); | |
377 | ||
378 | /* Keep track of the tty data structure */ | |
85bbc003 | 379 | pv->tty = tty_port_tty_get(&hp->port); |
17bdc6c0 | 380 | |
87fa35dd | 381 | hvsilib_establish(pv); |
17bdc6c0 BH |
382 | |
383 | return 0; | |
384 | } | |
385 | ||
87fa35dd | 386 | void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp) |
17bdc6c0 BH |
387 | { |
388 | unsigned long flags; | |
389 | ||
390 | pr_devel("HVSI@%x: close !\n", pv->termno); | |
391 | ||
392 | if (!pv->is_console) { | |
393 | pr_devel("HVSI@%x: Not a console, tearing down\n", | |
394 | pv->termno); | |
395 | ||
396 | /* Clear opened, synchronize with khvcd */ | |
397 | spin_lock_irqsave(&hp->lock, flags); | |
398 | pv->opened = 0; | |
399 | spin_unlock_irqrestore(&hp->lock, flags); | |
400 | ||
401 | /* Clear our own DTR */ | |
adc8d746 | 402 | if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL)) |
87fa35dd | 403 | hvsilib_write_mctrl(pv, 0); |
17bdc6c0 BH |
404 | |
405 | /* Tear down the connection */ | |
406 | hvsi_send_close(pv); | |
407 | } | |
408 | ||
48f5cde5 | 409 | tty_kref_put(pv->tty); |
17bdc6c0 BH |
410 | pv->tty = NULL; |
411 | } | |
412 | ||
87fa35dd BH |
413 | void hvsilib_init(struct hvsi_priv *pv, |
414 | int (*get_chars)(uint32_t termno, char *buf, int count), | |
415 | int (*put_chars)(uint32_t termno, const char *buf, | |
416 | int count), | |
417 | int termno, int is_console) | |
17bdc6c0 BH |
418 | { |
419 | memset(pv, 0, sizeof(*pv)); | |
420 | pv->get_chars = get_chars; | |
421 | pv->put_chars = put_chars; | |
422 | pv->termno = termno; | |
423 | pv->is_console = is_console; | |
424 | } |