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