![Alan Cox](/assets/img/avatar_default.png)
This will let us sort out a whole pile of tty related races. The alternative would be to keep points and refcount the termios objects. However 1. They are tiny anyway 2. Many devices don't use the stored copies 3. We can remove a pty special case Signed-off-by: Alan Cox <alan@linux.intel.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
427 lines
9.5 KiB
C
427 lines
9.5 KiB
C
#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 = 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 = 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 = 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 (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, 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 (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 = 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, 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.hdr.seqno = atomic_inc_return(&pv->seqno);
|
|
q.verb = 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 = VSV_SET_MODEM_CTL;
|
|
ctrl.mask = HVSI_TSDTR;
|
|
ctrl.word = 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 200s */
|
|
for (timeout = 0; timeout < 20; 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;
|
|
}
|