1 #include <linux/types.h> 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 { 11 packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno)); 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); 30 q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); 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); 42 ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL); 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 71 switch (be16_to_cpu(pkt->verb)) { 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 */ 78 hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD); 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 */ 89 if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER) 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); 98 r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); 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: 114 hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD); 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 180 int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count) 181 { 182 unsigned int tries, read = 0; 183 184 if (WARN_ON(!pv)) 185 return -ENXIO; 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 230 int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count) 231 { 232 struct hvsi_data dp; 233 int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA); 234 235 if (WARN_ON(!pv)) 236 return -ENODEV; 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 256 int hvsilib_read_mctrl(struct hvsi_priv *pv) 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); 267 q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS); 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 286 int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr) 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); 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); 308 return hvsi_send_packet(pv, &ctrl.hdr); 309 } 310 311 void hvsilib_establish(struct hvsi_priv *pv) 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 342 /* Try for up to 400ms */ 343 for (timeout = 0; timeout < 40; timeout++) { 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 360 hvsilib_read_mctrl(pv); 361 362 /* Set our own DTR */ 363 364 pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno); 365 366 hvsilib_write_mctrl(pv, 1); 367 368 /* Set the opened flag so reads are allowed */ 369 wmb(); 370 pv->opened = 1; 371 } 372 373 int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp) 374 { 375 pr_devel("HVSI@%x: open !\n", pv->termno); 376 377 /* Keep track of the tty data structure */ 378 pv->tty = tty_port_tty_get(&hp->port); 379 380 hvsilib_establish(pv); 381 382 return 0; 383 } 384 385 void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp) 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 */ 401 if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL)) 402 hvsilib_write_mctrl(pv, 0); 403 404 /* Tear down the connection */ 405 hvsi_send_close(pv); 406 } 407 408 tty_kref_put(pv->tty); 409 pv->tty = NULL; 410 } 411 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) 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 } 424