drivers/tty/hvc/hvsi_lib.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/types.h>
   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 {
  12         packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno));
  13
  14         /* Assumes that always succeeds, works in practice */
  15         return pv->put_chars(pv->termno, (u8 *)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);
  31         q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
  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);
  43         ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL);
  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
  72         switch (be16_to_cpu(pkt->verb)) {
  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 */
  79                 hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD);
  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 */
  90         if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER)
  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);
  99         r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER);
 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:
 115                 hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD);
 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
 181 ssize_t hvsilib_get_chars(struct hvsi_priv *pv, u8 *buf, size_t count)
 182 {
 183         unsigned int tries;
 184         size_t read = 0;
 185
 186         if (WARN_ON(!pv))
 187                 return -ENXIO;
 188
 189         /* If we aren't open, don't do anything in order to avoid races
 190          * with connection establishment. The hvc core will call this
 191          * before we have returned from notifier_add(), and we need to
 192          * avoid multiple users playing with the receive buffer
 193          */
 194         if (!pv->opened)
 195                 return 0;
 196
 197         /* We try twice, once with what data we have and once more
 198          * after we try to fetch some more from the hypervisor
 199          */
 200         for (tries = 1; count && tries < 2; tries++) {
 201                 /* Consume existing data packet */
 202                 if (pv->inbuf_pktlen) {
 203                         size_t l = min(count, pv->inbuf_pktlen);
 204                         memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l);
 205                         pv->inbuf_cur += l;
 206                         pv->inbuf_pktlen -= l;
 207                         count -= l;
 208                         read += l;
 209                 }
 210                 if (count == 0)
 211                         break;
 212
 213                 /* Data packet fully consumed, move down remaning data */
 214                 if (pv->inbuf_cur) {
 215                         pv->inbuf_len -= pv->inbuf_cur;
 216                         memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur],
 217                                 pv->inbuf_len);
 218                         pv->inbuf_cur = 0;
 219                 }
 220
 221                 /* Try to get another packet */
 222                 if (hvsi_get_packet(pv))
 223                         tries--;
 224         }
 225         if (!pv->established) {
 226                 pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno);
 227                 return -EPIPE;
 228         }
 229         return read;
 230 }
 231
 232 ssize_t hvsilib_put_chars(struct hvsi_priv *pv, const u8 *buf, size_t count)
 233 {
 234         struct hvsi_data dp;
 235         size_t adjcount = min_t(size_t, count, HVSI_MAX_OUTGOING_DATA);
 236         int rc;
 237
 238         if (WARN_ON(!pv))
 239                 return -ENODEV;
 240
 241         dp.hdr.type = VS_DATA_PACKET_HEADER;
 242         dp.hdr.len = adjcount + sizeof(struct hvsi_header);
 243         memcpy(dp.data, buf, adjcount);
 244         rc = hvsi_send_packet(pv, &dp.hdr);
 245         if (rc <= 0)
 246                 return rc;
 247         return adjcount;
 248 }
 249
 250 static void maybe_msleep(unsigned long ms)
 251 {
 252         /* During early boot, IRQs are disabled, use mdelay */
 253         if (irqs_disabled())
 254                 mdelay(ms);
 255         else
 256                 msleep(ms);
 257 }
 258
 259 int hvsilib_read_mctrl(struct hvsi_priv *pv)
 260 {
 261         struct hvsi_query q;
 262         int rc, timeout;
 263
 264         pr_devel("HVSI@%x: Querying modem control status...\n",
 265                  pv->termno);
 266
 267         pv->mctrl_update = 0;
 268         q.hdr.type = VS_QUERY_PACKET_HEADER;
 269         q.hdr.len = sizeof(struct hvsi_query);
 270         q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS);
 271         rc = hvsi_send_packet(pv, &q.hdr);
 272         if (rc <= 0) {
 273                 pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc);
 274                 return rc;
 275         }
 276
 277         /* Try for up to 200ms */
 278         for (timeout = 0; timeout < 20; timeout++) {
 279                 if (!pv->established)
 280                         return -ENXIO;
 281                 if (pv->mctrl_update)
 282                         return 0;
 283                 if (!hvsi_get_packet(pv))
 284                         maybe_msleep(10);
 285         }
 286         return -EIO;
 287 }
 288
 289 int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr)
 290 {
 291         struct hvsi_control ctrl;
 292         unsigned short mctrl;
 293
 294         mctrl = pv->mctrl;
 295         if (dtr)
 296                 mctrl |= TIOCM_DTR;
 297         else
 298                 mctrl &= ~TIOCM_DTR;
 299         if (mctrl == pv->mctrl)
 300                 return 0;
 301         pv->mctrl = mctrl;
 302
 303         pr_devel("HVSI@%x: %s DTR...\n", pv->termno,
 304                  dtr ? "Setting" : "Clearing");
 305
 306         ctrl.hdr.type = VS_CONTROL_PACKET_HEADER,
 307         ctrl.hdr.len = sizeof(struct hvsi_control);
 308         ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL);
 309         ctrl.mask = cpu_to_be32(HVSI_TSDTR);
 310         ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0);
 311         return hvsi_send_packet(pv, &ctrl.hdr);
 312 }
 313
 314 void hvsilib_establish(struct hvsi_priv *pv)
 315 {
 316         int timeout;
 317
 318         pr_devel("HVSI@%x: Establishing...\n", pv->termno);
 319
 320         /* Try for up to 200ms, there can be a packet to
 321          * start the process waiting for us...
 322          */
 323         for (timeout = 0; timeout < 20; timeout++) {
 324                 if (pv->established)
 325                         goto established;
 326                 if (!hvsi_get_packet(pv))
 327                         maybe_msleep(10);
 328         }
 329
 330         /* Failed, send a close connection packet just
 331          * in case
 332          */
 333         pr_devel("HVSI@%x:   ... sending close\n", pv->termno);
 334
 335         hvsi_send_close(pv);
 336
 337         /* Then restart handshake */
 338
 339         pr_devel("HVSI@%x:   ... restarting handshake\n", pv->termno);
 340
 341         hvsi_start_handshake(pv);
 342
 343         pr_devel("HVSI@%x:   ... waiting handshake\n", pv->termno);
 344
 345         /* Try for up to 400ms */
 346         for (timeout = 0; timeout < 40; timeout++) {
 347                 if (pv->established)
 348                         goto established;
 349                 if (!hvsi_get_packet(pv))
 350                         maybe_msleep(10);
 351         }
 352
 353         if (!pv->established) {
 354                 pr_devel("HVSI@%x: Timeout handshaking, giving up !\n",
 355                          pv->termno);
 356                 return;
 357         }
 358  established:
 359         /* Query modem control lines */
 360
 361         pr_devel("HVSI@%x:   ... established, reading mctrl\n", pv->termno);
 362
 363         hvsilib_read_mctrl(pv);
 364
 365         /* Set our own DTR */
 366
 367         pr_devel("HVSI@%x:   ... setting mctrl\n", pv->termno);
 368
 369         hvsilib_write_mctrl(pv, 1);
 370
 371         /* Set the opened flag so reads are allowed */
 372         wmb();
 373         pv->opened = 1;
 374 }
 375
 376 int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp)
 377 {
 378         pr_devel("HVSI@%x: open !\n", pv->termno);
 379
 380         /* Keep track of the tty data structure */
 381         pv->tty = tty_port_tty_get(&hp->port);
 382
 383         hvsilib_establish(pv);
 384
 385         return 0;
 386 }
 387
 388 void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp)
 389 {
 390         unsigned long flags;
 391
 392         pr_devel("HVSI@%x: close !\n", pv->termno);
 393
 394         if (!pv->is_console) {
 395                 pr_devel("HVSI@%x: Not a console, tearing down\n",
 396                          pv->termno);
 397
 398                 /* Clear opened, synchronize with khvcd */
 399                 spin_lock_irqsave(&hp->lock, flags);
 400                 pv->opened = 0;
 401                 spin_unlock_irqrestore(&hp->lock, flags);
 402
 403                 /* Clear our own DTR */
 404                 if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL))
 405                         hvsilib_write_mctrl(pv, 0);
 406
 407                 /* Tear down the connection */
 408                 hvsi_send_close(pv);
 409         }
 410
 411         tty_kref_put(pv->tty);
 412         pv->tty = NULL;
 413 }
 414
 415 void hvsilib_init(struct hvsi_priv *pv,
 416                   ssize_t (*get_chars)(uint32_t termno, u8 *buf, size_t count),
 417                   ssize_t (*put_chars)(uint32_t termno, const u8 *buf,
 418                                        size_t count),
 419                   int termno, int is_console)
 420 {
 421         memset(pv, 0, sizeof(*pv));
 422         pv->get_chars = get_chars;
 423         pv->put_chars = put_chars;
 424         pv->termno = termno;
 425         pv->is_console = is_console;
 426 }