| #include <linux/types.h> |
| #include <linux/init.h> |
| #include <linux/delay.h> |
| #include <linux/slab.h> |
| #include <linux/console.h> |
| #include <asm/hvsi.h> |
| |
| #include "hvc_console.h" |
| |
| static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet) |
| { |
| packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno)); |
| |
| /* Assumes that always succeeds, works in practice */ |
| return pv->put_chars(pv->termno, (char *)packet, packet->len); |
| } |
| |
| static void hvsi_start_handshake(struct hvsi_priv *pv) |
| { |
| struct hvsi_query q; |
| |
| /* Reset state */ |
| pv->established = 0; |
| atomic_set(&pv->seqno, 0); |
| |
| pr_devel("HVSI@%x: Handshaking started\n", pv->termno); |
| |
| /* Send version query */ |
| q.hdr.type = VS_QUERY_PACKET_HEADER; |
| q.hdr.len = sizeof(struct hvsi_query); |
| q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); |
| hvsi_send_packet(pv, &q.hdr); |
| } |
| |
| static int hvsi_send_close(struct hvsi_priv *pv) |
| { |
| struct hvsi_control ctrl; |
| |
| pv->established = 0; |
| |
| ctrl.hdr.type = VS_CONTROL_PACKET_HEADER; |
| ctrl.hdr.len = sizeof(struct hvsi_control); |
| ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL); |
| return hvsi_send_packet(pv, &ctrl.hdr); |
| } |
| |
| static void hvsi_cd_change(struct hvsi_priv *pv, int cd) |
| { |
| if (cd) |
| pv->mctrl |= TIOCM_CD; |
| else { |
| pv->mctrl &= ~TIOCM_CD; |
| |
| /* We copy the existing hvsi driver semantics |
| * here which are to trigger a hangup when |
| * we get a carrier loss. |
| * Closing our connection to the server will |
| * do just that. |
| */ |
| if (!pv->is_console && pv->opened) { |
| pr_devel("HVSI@%x Carrier lost, hanging up !\n", |
| pv->termno); |
| hvsi_send_close(pv); |
| } |
| } |
| } |
| |
| static void hvsi_got_control(struct hvsi_priv *pv) |
| { |
| struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf; |
| |
| switch (be16_to_cpu(pkt->verb)) { |
| case VSV_CLOSE_PROTOCOL: |
| /* We restart the handshaking */ |
| hvsi_start_handshake(pv); |
| break; |
| case VSV_MODEM_CTL_UPDATE: |
| /* Transition of carrier detect */ |
| hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD); |
| break; |
| } |
| } |
| |
| static void hvsi_got_query(struct hvsi_priv *pv) |
| { |
| struct hvsi_query *pkt = (struct hvsi_query *)pv->inbuf; |
| struct hvsi_query_response r; |
| |
| /* We only handle version queries */ |
| if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER) |
| return; |
| |
| pr_devel("HVSI@%x: Got version query, sending response...\n", |
| pv->termno); |
| |
| /* Send version response */ |
| r.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER; |
| r.hdr.len = sizeof(struct hvsi_query_response); |
| r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); |
| r.u.version = HVSI_VERSION; |
| r.query_seqno = pkt->hdr.seqno; |
| hvsi_send_packet(pv, &r.hdr); |
| |
| /* Assume protocol is open now */ |
| pv->established = 1; |
| } |
| |
| static void hvsi_got_response(struct hvsi_priv *pv) |
| { |
| struct hvsi_query_response *r = |
| (struct hvsi_query_response *)pv->inbuf; |
| |
| switch(r->verb) { |
| case VSV_SEND_MODEM_CTL_STATUS: |
| hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD); |
| pv->mctrl_update = 1; |
| break; |
| } |
| } |
| |
| static int hvsi_check_packet(struct hvsi_priv *pv) |
| { |
| u8 len, type; |
| |
| /* Check header validity. If it's invalid, we ditch |
| * the whole buffer and hope we eventually resync |
| */ |
| if (pv->inbuf[0] < 0xfc) { |
| pv->inbuf_len = pv->inbuf_pktlen = 0; |
| return 0; |
| } |
| type = pv->inbuf[0]; |
| len = pv->inbuf[1]; |
| |
| /* Packet incomplete ? */ |
| if (pv->inbuf_len < len) |
| return 0; |
| |
| pr_devel("HVSI@%x: Got packet type %x len %d bytes:\n", |
| pv->termno, type, len); |
| |
| /* We have a packet, yay ! Handle it */ |
| switch(type) { |
| case VS_DATA_PACKET_HEADER: |
| pv->inbuf_pktlen = len - 4; |
| pv->inbuf_cur = 4; |
| return 1; |
| case VS_CONTROL_PACKET_HEADER: |
| hvsi_got_control(pv); |
| break; |
| case VS_QUERY_PACKET_HEADER: |
| hvsi_got_query(pv); |
| break; |
| case VS_QUERY_RESPONSE_PACKET_HEADER: |
| hvsi_got_response(pv); |
| break; |
| } |
| |
| /* Swallow packet and retry */ |
| pv->inbuf_len -= len; |
| memmove(pv->inbuf, &pv->inbuf[len], pv->inbuf_len); |
| return 1; |
| } |
| |
| static int hvsi_get_packet(struct hvsi_priv *pv) |
| { |
| /* If we have room in the buffer, ask HV for more */ |
| if (pv->inbuf_len < HVSI_INBUF_SIZE) |
| pv->inbuf_len += pv->get_chars(pv->termno, |
| &pv->inbuf[pv->inbuf_len], |
| HVSI_INBUF_SIZE - pv->inbuf_len); |
| /* |
| * If we have at least 4 bytes in the buffer, check for |
| * a full packet and retry |
| */ |
| if (pv->inbuf_len >= 4) |
| return hvsi_check_packet(pv); |
| return 0; |
| } |
| |
| int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count) |
| { |
| unsigned int tries, read = 0; |
| |
| if (WARN_ON(!pv)) |
| return -ENXIO; |
| |
| /* If we aren't open, don't do anything in order to avoid races |
| * with connection establishment. The hvc core will call this |
| * before we have returned from notifier_add(), and we need to |
| * avoid multiple users playing with the receive buffer |
| */ |
| if (!pv->opened) |
| return 0; |
| |
| /* We try twice, once with what data we have and once more |
| * after we try to fetch some more from the hypervisor |
| */ |
| for (tries = 1; count && tries < 2; tries++) { |
| /* Consume existing data packet */ |
| if (pv->inbuf_pktlen) { |
| unsigned int l = min(count, (int)pv->inbuf_pktlen); |
| memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l); |
| pv->inbuf_cur += l; |
| pv->inbuf_pktlen -= l; |
| count -= l; |
| read += l; |
| } |
| if (count == 0) |
| break; |
| |
| /* Data packet fully consumed, move down remaning data */ |
| if (pv->inbuf_cur) { |
| pv->inbuf_len -= pv->inbuf_cur; |
| memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur], |
| pv->inbuf_len); |
| pv->inbuf_cur = 0; |
| } |
| |
| /* Try to get another packet */ |
| if (hvsi_get_packet(pv)) |
| tries--; |
| } |
| if (!pv->established) { |
| pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno); |
| return -EPIPE; |
| } |
| return read; |
| } |
| |
| int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count) |
| { |
| struct hvsi_data dp; |
| int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA); |
| |
| if (WARN_ON(!pv)) |
| return -ENODEV; |
| |
| dp.hdr.type = VS_DATA_PACKET_HEADER; |
| dp.hdr.len = adjcount + sizeof(struct hvsi_header); |
| memcpy(dp.data, buf, adjcount); |
| rc = hvsi_send_packet(pv, &dp.hdr); |
| if (rc <= 0) |
| return rc; |
| return adjcount; |
| } |
| |
| static void maybe_msleep(unsigned long ms) |
| { |
| /* During early boot, IRQs are disabled, use mdelay */ |
| if (irqs_disabled()) |
| mdelay(ms); |
| else |
| msleep(ms); |
| } |
| |
| int hvsilib_read_mctrl(struct hvsi_priv *pv) |
| { |
| struct hvsi_query q; |
| int rc, timeout; |
| |
| pr_devel("HVSI@%x: Querying modem control status...\n", |
| pv->termno); |
| |
| pv->mctrl_update = 0; |
| q.hdr.type = VS_QUERY_PACKET_HEADER; |
| q.hdr.len = sizeof(struct hvsi_query); |
| q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS); |
| rc = hvsi_send_packet(pv, &q.hdr); |
| if (rc <= 0) { |
| pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc); |
| return rc; |
| } |
| |
| /* Try for up to 200ms */ |
| for (timeout = 0; timeout < 20; timeout++) { |
| if (!pv->established) |
| return -ENXIO; |
| if (pv->mctrl_update) |
| return 0; |
| if (!hvsi_get_packet(pv)) |
| maybe_msleep(10); |
| } |
| return -EIO; |
| } |
| |
| int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr) |
| { |
| struct hvsi_control ctrl; |
| unsigned short mctrl; |
| |
| mctrl = pv->mctrl; |
| if (dtr) |
| mctrl |= TIOCM_DTR; |
| else |
| mctrl &= ~TIOCM_DTR; |
| if (mctrl == pv->mctrl) |
| return 0; |
| pv->mctrl = mctrl; |
| |
| pr_devel("HVSI@%x: %s DTR...\n", pv->termno, |
| dtr ? "Setting" : "Clearing"); |
| |
| ctrl.hdr.type = VS_CONTROL_PACKET_HEADER, |
| ctrl.hdr.len = sizeof(struct hvsi_control); |
| ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL); |
| ctrl.mask = cpu_to_be32(HVSI_TSDTR); |
| ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0); |
| return hvsi_send_packet(pv, &ctrl.hdr); |
| } |
| |
| void hvsilib_establish(struct hvsi_priv *pv) |
| { |
| int timeout; |
| |
| pr_devel("HVSI@%x: Establishing...\n", pv->termno); |
| |
| /* Try for up to 200ms, there can be a packet to |
| * start the process waiting for us... |
| */ |
| for (timeout = 0; timeout < 20; timeout++) { |
| if (pv->established) |
| goto established; |
| if (!hvsi_get_packet(pv)) |
| maybe_msleep(10); |
| } |
| |
| /* Failed, send a close connection packet just |
| * in case |
| */ |
| pr_devel("HVSI@%x: ... sending close\n", pv->termno); |
| |
| hvsi_send_close(pv); |
| |
| /* Then restart handshake */ |
| |
| pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno); |
| |
| hvsi_start_handshake(pv); |
| |
| pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno); |
| |
| /* Try for up to 400ms */ |
| for (timeout = 0; timeout < 40; timeout++) { |
| if (pv->established) |
| goto established; |
| if (!hvsi_get_packet(pv)) |
| maybe_msleep(10); |
| } |
| |
| if (!pv->established) { |
| pr_devel("HVSI@%x: Timeout handshaking, giving up !\n", |
| pv->termno); |
| return; |
| } |
| established: |
| /* Query modem control lines */ |
| |
| pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno); |
| |
| hvsilib_read_mctrl(pv); |
| |
| /* Set our own DTR */ |
| |
| pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno); |
| |
| hvsilib_write_mctrl(pv, 1); |
| |
| /* Set the opened flag so reads are allowed */ |
| wmb(); |
| pv->opened = 1; |
| } |
| |
| int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp) |
| { |
| pr_devel("HVSI@%x: open !\n", pv->termno); |
| |
| /* Keep track of the tty data structure */ |
| pv->tty = tty_port_tty_get(&hp->port); |
| |
| hvsilib_establish(pv); |
| |
| return 0; |
| } |
| |
| void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp) |
| { |
| unsigned long flags; |
| |
| pr_devel("HVSI@%x: close !\n", pv->termno); |
| |
| if (!pv->is_console) { |
| pr_devel("HVSI@%x: Not a console, tearing down\n", |
| pv->termno); |
| |
| /* Clear opened, synchronize with khvcd */ |
| spin_lock_irqsave(&hp->lock, flags); |
| pv->opened = 0; |
| spin_unlock_irqrestore(&hp->lock, flags); |
| |
| /* Clear our own DTR */ |
| if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL)) |
| hvsilib_write_mctrl(pv, 0); |
| |
| /* Tear down the connection */ |
| hvsi_send_close(pv); |
| } |
| |
| if (pv->tty) |
| tty_kref_put(pv->tty); |
| pv->tty = NULL; |
| } |
| |
| void hvsilib_init(struct hvsi_priv *pv, |
| int (*get_chars)(uint32_t termno, char *buf, int count), |
| int (*put_chars)(uint32_t termno, const char *buf, |
| int count), |
| int termno, int is_console) |
| { |
| memset(pv, 0, sizeof(*pv)); |
| pv->get_chars = get_chars; |
| pv->put_chars = put_chars; |
| pv->termno = termno; |
| pv->is_console = is_console; |
| } |