OvmfPkg/Library/BhyveFwCtlLib/BhyveFwCtlLib.c

/** @file

  Copyright (c) 2020, Rebecca Cran <rebecca@bsdio.com>
  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
  Copyright (C) 2013, Red Hat, Inc.
  Copyright (c) 2015, Nahanni Systems.

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "Uefi.h"
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/BhyveFwCtlLib.h>
#include <Library/DebugLib.h>
#include <Library/IoLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>

#define FW_PORT   0x510
#define FW_IPORT  0x511

/* Transport protocol basic operations */
#define OP_NULL     1
#define OP_ECHO     2
#define OP_GET      3
#define OP_GET_LEN  4
#define OP_SET      5

/* Transport protocol error returns */
#define T_ESUCCESS  0
#define T_ENOENT    2
#define T_E2BIG     7
#define T_EMSGSIZE  40

#define ROUNDUP(x, y)  ((((x)+((y)-1))/(y))*(y))

STATIC CONST CHAR8  mBhyveSig[4] = { 'B', 'H', 'Y', 'V' };

STATIC BOOLEAN  mBhyveFwCtlSupported = FALSE;

STATIC INT32  mBhyveFwCtlTxid = 0xa5;

/* XXX Maybe a better inbuilt version of this ? */
typedef struct {
  VOID      *Base;
  UINT32    Len;
} BIO_VEC;

typedef struct {
  UINT32    Sz;
  UINT32    Op;
  UINT32    TxId;
  UINT32    Err;
} MSG_RX_HDR;

STATIC
RETURN_STATUS
EFIAPI
BhyveFwCtl_CvtErr (
  IN UINT32  errno
  )
{
  RETURN_STATUS  Status;

  switch (errno) {
    case T_ESUCCESS:
      Status = RETURN_SUCCESS;
      break;
    case T_ENOENT:
      Status = RETURN_NOT_FOUND;
      break;
    case T_E2BIG:
      Status = RETURN_INVALID_PARAMETER;
      break;
    case T_EMSGSIZE:
      Status = RETURN_BUFFER_TOO_SMALL;
      break;
    default:
      Status = RETURN_PROTOCOL_ERROR;
      break;
  }

  return Status;
}

STATIC
UINT32
EFIAPI
BIov_WLen (
  IN BIO_VEC  b[]
  )
{
  UINT32  i;
  UINT32  tLen;

  tLen = 0;

  if (b != NULL) {
    for (i = 0; b[i].Base != NULL; i++) {
      tLen += ROUNDUP (b[i].Len, sizeof (UINT32));
    }
  }

  return tLen;
}

/**
   Utility to send 1-3 bytes of input as a 4-byte value
   with trailing zeroes.
 **/
STATIC
UINT32
BIov_Send_Rem (
  IN UINT32  *Data,
  IN UINT32  Len
  )
{
  union {
    UINT8     c[4];
    UINT32    w;
  } u;
  UINT8   *cdata;
  UINT32  i;

  cdata = (UINT8 *)Data;
  u.w   = 0;

  for (i = 0; i < Len; i++) {
    u.c[i] = *cdata++;
  }

  return u.w;
}

/**
   Send a block of data out the i/o port as 4-byte quantities,
   appending trailing zeroes on the last if required.
 **/
STATIC
VOID
BIov_Send (
  IN char    *Data,
  IN UINT32  Len
  )
{
  UINT32  *LData;

  LData = (UINT32 *)Data;

  while (Len > sizeof (UINT32)) {
    IoWrite32 (FW_PORT, *LData++);
    Len -= sizeof (UINT32);
  }

  if (Len > 0) {
    IoWrite32 (FW_PORT, BIov_Send_Rem (LData, Len));
  }
}

/**
   Send data described by an array of iovecs out the i/o port.
 **/
STATIC
VOID
BIov_SendAll (
  IN BIO_VEC  b[]
  )
{
  INT32  i;

  if (b != NULL) {
    for (i = 0; b[i].Base; i++) {
      BIov_Send (b[i].Base, b[i].Len);
    }
  }
}

/**
   Prepend the transport header to a block of data and send.
 **/
STATIC
VOID
EFIAPI
BhyveFwCtl_MsgSend (
  IN  UINT32   OpCode,
  IN  BIO_VEC  Data[]
  )
{
  BIO_VEC  hIov[4];
  UINT32   Hdr[3];
  UINT32   i;

  /* Set up header as an iovec */
  for (i = 0; i < 3; i++) {
    hIov[i].Base = &Hdr[i];
    hIov[i].Len  = sizeof (Hdr[0]);
  }

  hIov[i].Base = NULL;
  hIov[i].Len  = 0;

  /* Initialize header */
  Hdr[0] = BIov_WLen (hIov) + BIov_WLen (Data);
  Hdr[1] = (UINT32)OpCode;
  Hdr[2] = mBhyveFwCtlTxid;

  /* Send header and data */
  BIov_SendAll (hIov);
  BIov_SendAll (Data);
}

/**
   Read a transport response and optional data from the i/o port.
 **/
STATIC
RETURN_STATUS
EFIAPI
BhyveFwCtl_MsgRecv (
  OUT  MSG_RX_HDR  *Rhdr,
  OUT  BIO_VEC     Data[]
  )
{
  RETURN_STATUS  Status;
  UINT32         *Dp;
  UINT32         Rd;
  UINT32         remLen;
  INT32          oLen;
  INT32          xLen;

  Rd = IoRead32 (FW_PORT);
  if (Rd < sizeof (MSG_RX_HDR)) {
  }

  /* Read in header and setup initial error */
  Rhdr->Sz   = Rd;
  Rhdr->Op   = IoRead32 (FW_PORT);
  Rhdr->TxId = IoRead32 (FW_PORT);
  Rhdr->Err  = IoRead32 (FW_PORT);

  /* Convert transport errno into UEFI error status */
  Status = BhyveFwCtl_CvtErr (Rhdr->Err);

  remLen = Rd - sizeof (MSG_RX_HDR);
  xLen   = 0;

  /*
   * A few cases to handle:
   *  - the user didn't supply a read buffer
   *  - the buffer is too small for the response
   *  - the response is zero-length
   */
  if (Data != NULL) {
    Dp   = (UINT32 *)Data[0].Base;
    oLen = remLen;
    if (remLen > Data[0].Len) {
      Status = RETURN_BUFFER_TOO_SMALL;
      xLen   = remLen - Data[0].Len;
      oLen   = remLen = Data[0].Len;
    }

    while (remLen > 0) {
      *Dp++   = IoRead32 (FW_PORT);
      remLen -= sizeof (UINT32);
    }

    Data[0].Len = oLen;
  } else {
    /* No user data, but data returned - drop */
    if (remLen > 0) {
      Status = RETURN_BUFFER_TOO_SMALL;
      xLen   = remLen;
    }
  }

  /* Drop additional data */
  while (xLen > 0) {
    (void)IoRead32 (FW_PORT);
    xLen -= sizeof (UINT32);
  }

  return Status;
}

STATIC
RETURN_STATUS
EFIAPI
BhyveFwCtl_Msg (
  IN   UINT32   OpCode,
  IN   BIO_VEC  Sdata[],
  OUT  BIO_VEC  Rdata[]
  )
{
  MSG_RX_HDR     Rh;
  RETURN_STATUS  Status;

  Status = RETURN_SUCCESS;

  BhyveFwCtl_MsgSend (OpCode, Sdata);
  Status = BhyveFwCtl_MsgRecv (&Rh, Rdata);

  mBhyveFwCtlTxid++;

  return Status;
}

STATIC
RETURN_STATUS
EFIAPI
BhyveFwCtlGetLen (
  IN CONST CHAR8   *Name,
  IN OUT   UINT32  *Size
  )
{
  BIO_VEC        Req[2], Resp[2];
  RETURN_STATUS  Status;

  Req[0].Base = (VOID *)Name;
  Req[0].Len  = (UINT32)AsciiStrLen (Name) + 1;
  Req[1].Base = NULL;

  Resp[0].Base = Size;
  Resp[0].Len  = sizeof (UINT32);
  Resp[1].Base = NULL;

  Status = BhyveFwCtl_Msg (OP_GET_LEN, Req, Resp);

  return Status;
}

#define FMAXSZ  1024
STATIC struct {
  UINT64    fSize;
  UINT32    fData[FMAXSZ];
} FwGetvalBuf;

STATIC
RETURN_STATUS
EFIAPI
BhyveFwCtlGetVal (
  IN CONST CHAR8   *Name,
  OUT      VOID    *Item,
  IN OUT   UINT32  *Size
  )
{
  BIO_VEC        Req[2];
  BIO_VEC        Resp[2];
  RETURN_STATUS  Status;

  /* Make sure temp buffer is larger than passed-in size */
  if (*Size > sizeof (FwGetvalBuf.fData)) {
    return RETURN_INVALID_PARAMETER;
  }

  Req[0].Base = (VOID *)Name;
  Req[0].Len  = (UINT32)AsciiStrLen (Name) + 1;
  Req[1].Base = NULL;

  Resp[0].Base = &FwGetvalBuf;
  Resp[0].Len  = sizeof (UINT64) + *Size;
  Resp[1].Base = NULL;

  Status = BhyveFwCtl_Msg (OP_GET, Req, Resp);

  /*
   * Copy out data on success (or on a truncated message).
   * XXX This step can be eliminted with Msg() supporting
   *     multiple iovecs.
   */
  if ((Status == RETURN_SUCCESS) || (Status == RETURN_BUFFER_TOO_SMALL)) {
    *Size = (UINT32)FwGetvalBuf.fSize;
    CopyMem (Item, FwGetvalBuf.fData, *Size);
  }

  return Status;
}

/**
   Front end to the internal GET_LEN and GET protocols
 **/
RETURN_STATUS
EFIAPI
BhyveFwCtlGet (
  IN   CONST CHAR8  *Name,
  OUT  VOID         *Item,
  IN OUT  UINTN     *Size
  )
{
  RETURN_STATUS  Status;

  if (mBhyveFwCtlSupported == FALSE) {
    return RETURN_UNSUPPORTED;
  }

  if (Item == NULL) {
    Status = BhyveFwCtlGetLen (Name, (UINT32 *)Size);
  } else {
    Status = BhyveFwCtlGetVal (Name, Item, (UINT32 *)Size);
  }

  return Status;
}

/**
   Library initialization. Probe the host to see if the f/w ctl
   interface is supported.
 **/
RETURN_STATUS
EFIAPI
BhyveFwCtlInitialize (
  VOID
  )
{
  UINT32  i;
  UINT8   ch;

  DEBUG ((DEBUG_INFO, "FwCtlInitialize\n"));

  IoWrite16 (FW_PORT, 0x0000);
  for (i = 0; i < 4; i++) {
    ch = IoRead8 (FW_IPORT);
    if (ch != mBhyveSig[i]) {
      DEBUG ((DEBUG_INFO, "Host f/w sig mismatch %c/%c\n", ch, mBhyveSig[i]));
      return RETURN_SUCCESS;
    }
  }

  mBhyveFwCtlSupported = TRUE;

  return RETURN_SUCCESS;
}