XenConsoleSerialPortLib.c

Go to the documentation of this file.

 
#include <Base.h>
 
#include <Library/BaseLib.h>
#include <Library/SerialPortLib.h>
#include <Library/XenHypercallLib.h>
 
#include <IndustryStandard/Xen/io/console.h>
#include <IndustryStandard/Xen/hvm/params.h>
#include <IndustryStandard/Xen/event_channel.h>
 
//
// We can't use DebugLib due to a constructor dependency cycle between DebugLib
// and ourselves.
//
#define ASSERT(Expression)      \
  do {                          \
    if (!(Expression)) {        \
      CpuDeadLoop ();           \
    }                           \
  } while (FALSE)
 
//
// The code below expects these global variables to be mutable, even in the case
// that we have been incorporated into SEC or PEIM phase modules (which is
// allowed by our INF description). While this is a dangerous assumption to make
// in general, it is actually fine for the Xen domU (guest) environment that
// this module is intended for, as UEFI always executes from DRAM in that case.
//
STATIC evtchn_send_t             mXenConsoleEventChain;
STATIC struct xencons_interface  *mXenConsoleInterface;
 
RETURN_STATUS
EFIAPI
SerialPortInitialize (
  VOID
  )
{
  if (!XenHypercallIsAvailable ()) {
    return RETURN_DEVICE_ERROR;
  }
 
  if (!mXenConsoleInterface) {
    mXenConsoleEventChain.port = (UINT32)XenHypercallHvmGetParam (HVM_PARAM_CONSOLE_EVTCHN);
    mXenConsoleInterface       = (struct xencons_interface *)(UINTN)
                                 (XenHypercallHvmGetParam (HVM_PARAM_CONSOLE_PFN) << EFI_PAGE_SHIFT);
 
    //
    // No point in ASSERT'ing here as we won't be seeing the output
    //
  }
 
  return RETURN_SUCCESS;
}
 
UINTN
EFIAPI
SerialPortWrite (
  IN UINT8  *Buffer,
  IN UINTN  NumberOfBytes
  )
{
  XENCONS_RING_IDX  Consumer, Producer;
  UINTN             Sent;
 
  ASSERT (Buffer != NULL);
 
  if (NumberOfBytes == 0) {
    return 0;
  }
 
  if (!mXenConsoleInterface) {
    return 0;
  }
 
  Sent = 0;
  do {
    Consumer = mXenConsoleInterface->out_cons;
    Producer = mXenConsoleInterface->out_prod;
 
    MemoryFence ();
 
    while (Sent < NumberOfBytes && ((Producer - Consumer) < sizeof (mXenConsoleInterface->out))) {
      mXenConsoleInterface->out[MASK_XENCONS_IDX (Producer++, mXenConsoleInterface->out)] = Buffer[Sent++];
    }
 
    MemoryFence ();
 
    mXenConsoleInterface->out_prod = Producer;
 
    XenHypercallEventChannelOp (EVTCHNOP_send, &mXenConsoleEventChain);
  } while (Sent < NumberOfBytes);
 
  return Sent;
}
 
UINTN
EFIAPI
SerialPortRead (
  OUT UINT8  *Buffer,
  IN  UINTN  NumberOfBytes
  )
{
  XENCONS_RING_IDX  Consumer, Producer;
  UINTN             Received;
 
  ASSERT (Buffer != NULL);
 
  if (NumberOfBytes == 0) {
    return 0;
  }
 
  if (!mXenConsoleInterface) {
    return 0;
  }
 
  Consumer = mXenConsoleInterface->in_cons;
  Producer = mXenConsoleInterface->in_prod;
 
  MemoryFence ();
 
  Received = 0;
  while (Received < NumberOfBytes && Consumer < Producer) {
    Buffer[Received++] = mXenConsoleInterface->in[MASK_XENCONS_IDX (Consumer++, mXenConsoleInterface->in)];
  }
 
  MemoryFence ();
 
  mXenConsoleInterface->in_cons = Consumer;
 
  XenHypercallEventChannelOp (EVTCHNOP_send, &mXenConsoleEventChain);
 
  return Received;
}
 
BOOLEAN
EFIAPI
SerialPortPoll (
  VOID
  )
{
  return mXenConsoleInterface &&
         mXenConsoleInterface->in_cons != mXenConsoleInterface->in_prod;
}
 
RETURN_STATUS
EFIAPI
SerialPortSetControl (
  IN UINT32  Control
  )
{
  return RETURN_UNSUPPORTED;
}
 
RETURN_STATUS
EFIAPI
SerialPortGetControl (
  OUT UINT32  *Control
  )
{
  if (!mXenConsoleInterface) {
    return RETURN_UNSUPPORTED;
  }
 
  *Control = 0;
  if (!SerialPortPoll ()) {
    *Control = EFI_SERIAL_INPUT_BUFFER_EMPTY;
  }
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
SerialPortSetAttributes (
  IN OUT UINT64              *BaudRate,
  IN OUT UINT32              *ReceiveFifoDepth,
  IN OUT UINT32              *Timeout,
  IN OUT EFI_PARITY_TYPE     *Parity,
  IN OUT UINT8               *DataBits,
  IN OUT EFI_STOP_BITS_TYPE  *StopBits
  )
{
  return RETURN_UNSUPPORTED;
}