VirtioLib.c

Go to the documentation of this file.

 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
 
#include <Library/VirtioLib.h>
 
EFI_STATUS
EFIAPI
VirtioRingInit (
  IN  VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN  UINT16                  QueueSize,
  OUT VRING                   *Ring
  )
{
  EFI_STATUS      Status;
  UINTN           RingSize;
  volatile UINT8  *RingPagesPtr;
 
  RingSize = ALIGN_VALUE (
               sizeof *Ring->Desc            * QueueSize +
               sizeof *Ring->Avail.Flags                 +
               sizeof *Ring->Avail.Idx                   +
               sizeof *Ring->Avail.Ring      * QueueSize +
               sizeof *Ring->Avail.UsedEvent,
               EFI_PAGE_SIZE
               );
 
  RingSize += ALIGN_VALUE (
                sizeof *Ring->Used.Flags                  +
                sizeof *Ring->Used.Idx                    +
                sizeof *Ring->Used.UsedElem   * QueueSize +
                sizeof *Ring->Used.AvailEvent,
                EFI_PAGE_SIZE
                );
 
  //
  // Allocate a shared ring buffer
  //
  Ring->NumPages = EFI_SIZE_TO_PAGES (RingSize);
  Status         = VirtIo->AllocateSharedPages (
                             VirtIo,
                             Ring->NumPages,
                             &Ring->Base
                             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  SetMem (Ring->Base, RingSize, 0x00);
  RingPagesPtr = Ring->Base;
 
  Ring->Desc    = (volatile VOID *)RingPagesPtr;
  RingPagesPtr += sizeof *Ring->Desc * QueueSize;
 
  Ring->Avail.Flags = (volatile VOID *)RingPagesPtr;
  RingPagesPtr     += sizeof *Ring->Avail.Flags;
 
  Ring->Avail.Idx = (volatile VOID *)RingPagesPtr;
  RingPagesPtr   += sizeof *Ring->Avail.Idx;
 
  Ring->Avail.Ring = (volatile VOID *)RingPagesPtr;
  RingPagesPtr    += sizeof *Ring->Avail.Ring * QueueSize;
 
  Ring->Avail.UsedEvent = (volatile VOID *)RingPagesPtr;
  RingPagesPtr         += sizeof *Ring->Avail.UsedEvent;
 
  RingPagesPtr = (volatile UINT8 *)Ring->Base +
                 ALIGN_VALUE (
                   RingPagesPtr - (volatile UINT8 *)Ring->Base,
                   EFI_PAGE_SIZE
                   );
 
  Ring->Used.Flags = (volatile VOID *)RingPagesPtr;
  RingPagesPtr    += sizeof *Ring->Used.Flags;
 
  Ring->Used.Idx = (volatile VOID *)RingPagesPtr;
  RingPagesPtr  += sizeof *Ring->Used.Idx;
 
  Ring->Used.UsedElem = (volatile VOID *)RingPagesPtr;
  RingPagesPtr       += sizeof *Ring->Used.UsedElem * QueueSize;
 
  Ring->Used.AvailEvent = (volatile VOID *)RingPagesPtr;
  RingPagesPtr         += sizeof *Ring->Used.AvailEvent;
 
  Ring->QueueSize = QueueSize;
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
VirtioRingUninit (
  IN     VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN OUT VRING                   *Ring
  )
{
  VirtIo->FreeSharedPages (VirtIo, Ring->NumPages, Ring->Base);
  SetMem (Ring, sizeof *Ring, 0x00);
}
 
VOID
EFIAPI
VirtioPrepare (
  IN OUT VRING         *Ring,
  OUT    DESC_INDICES  *Indices
  )
{
  //
  // Prepare for virtio-0.9.5, 2.4.2 Receiving Used Buffers From the Device.
  // We're going to poll the answer, the host should not send an interrupt.
  //
  *Ring->Avail.Flags = (UINT16)VRING_AVAIL_F_NO_INTERRUPT;
 
  //
  // Prepare for virtio-0.9.5, 2.4.1 Supplying Buffers to the Device.
  //
  // Since we support only one in-flight descriptor chain, we can always build
  // that chain starting at entry #0 of the descriptor table.
  //
  Indices->HeadDescIdx = 0;
  Indices->NextDescIdx = Indices->HeadDescIdx;
}
 
VOID
EFIAPI
VirtioAppendDesc (
  IN OUT VRING         *Ring,
  IN     UINT64        BufferDeviceAddress,
  IN     UINT32        BufferSize,
  IN     UINT16        Flags,
  IN OUT DESC_INDICES  *Indices
  )
{
  volatile VRING_DESC  *Desc;
 
  Desc        = &Ring->Desc[Indices->NextDescIdx++ % Ring->QueueSize];
  Desc->Addr  = BufferDeviceAddress;
  Desc->Len   = BufferSize;
  Desc->Flags = Flags;
  Desc->Next  = Indices->NextDescIdx % Ring->QueueSize;
}
 
EFI_STATUS
EFIAPI
VirtioFlush (
  IN     VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN     UINT16                  VirtQueueId,
  IN OUT VRING                   *Ring,
  IN     DESC_INDICES            *Indices,
  OUT    UINT32                  *UsedLen    OPTIONAL
  )
{
  UINT16      NextAvailIdx;
  UINT16      LastUsedIdx;
  EFI_STATUS  Status;
  UINTN       PollPeriodUsecs;
 
  //
  // virtio-0.9.5, 2.4.1.2 Updating the Available Ring
  //
  // It is not exactly clear from the wording of the virtio-0.9.5
  // specification, but each entry in the Available Ring references only the
  // head descriptor of any given descriptor chain.
  //
  NextAvailIdx = *Ring->Avail.Idx;
  //
  // (Due to our lock-step progress, this is where the host will produce the
  // used element with the head descriptor's index in it.)
  //
  LastUsedIdx                                        = NextAvailIdx;
  Ring->Avail.Ring[NextAvailIdx++ % Ring->QueueSize] =
    Indices->HeadDescIdx % Ring->QueueSize;
 
  //
  // virtio-0.9.5, 2.4.1.3 Updating the Index Field
  //
  MemoryFence ();
  *Ring->Avail.Idx = NextAvailIdx;
 
  //
  // virtio-0.9.5, 2.4.1.4 Notifying the Device -- gratuitous notifications are
  // OK.
  //
  MemoryFence ();
  Status = VirtIo->SetQueueNotify (VirtIo, VirtQueueId);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // virtio-0.9.5, 2.4.2 Receiving Used Buffers From the Device
  // Wait until the host processes and acknowledges our descriptor chain. The
  // condition we use for polling is greatly simplified and relies on the
  // synchronous, lock-step progress.
  //
  // Keep slowing down until we reach a poll period of slightly above 1 ms.
  //
  PollPeriodUsecs = 1;
  MemoryFence ();
  while (*Ring->Used.Idx != NextAvailIdx) {
    gBS->Stall (PollPeriodUsecs); // calls AcpiTimerLib::MicroSecondDelay
 
    if (PollPeriodUsecs < 1024) {
      PollPeriodUsecs *= 2;
    }
 
    MemoryFence ();
  }
 
  MemoryFence ();
 
  if (UsedLen != NULL) {
    volatile CONST VRING_USED_ELEM  *UsedElem;
 
    UsedElem = &Ring->Used.UsedElem[LastUsedIdx % Ring->QueueSize];
    ASSERT (UsedElem->Id == Indices->HeadDescIdx);
    *UsedLen = UsedElem->Len;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Virtio10WriteFeatures (
  IN     VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN     UINT64                  Features,
  IN OUT UINT8                   *DeviceStatus
  )
{
  EFI_STATUS  Status;
 
  if (VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) {
    return EFI_UNSUPPORTED;
  }
 
  Status = VirtIo->SetGuestFeatures (VirtIo, Features);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *DeviceStatus |= VSTAT_FEATURES_OK;
  Status         = VirtIo->SetDeviceStatus (VirtIo, *DeviceStatus);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = VirtIo->GetDeviceStatus (VirtIo, DeviceStatus);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if ((*DeviceStatus & VSTAT_FEATURES_OK) == 0) {
    Status = EFI_UNSUPPORTED;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
VirtioMapAllBytesInSharedBuffer (
  IN  VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN  VIRTIO_MAP_OPERATION    Operation,
  IN  VOID                    *HostAddress,
  IN  UINTN                   NumberOfBytes,
  OUT EFI_PHYSICAL_ADDRESS    *DeviceAddress,
  OUT VOID                    **Mapping
  )
{
  EFI_STATUS            Status;
  VOID                  *MapInfo;
  UINTN                 Size;
  EFI_PHYSICAL_ADDRESS  PhysicalAddress;
 
  Size   = NumberOfBytes;
  Status = VirtIo->MapSharedBuffer (
                     VirtIo,
                     Operation,
                     HostAddress,
                     &Size,
                     &PhysicalAddress,
                     &MapInfo
                     );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Size < NumberOfBytes) {
    goto Failed;
  }
 
  *Mapping       = MapInfo;
  *DeviceAddress = PhysicalAddress;
 
  return EFI_SUCCESS;
 
Failed:
  VirtIo->UnmapSharedBuffer (VirtIo, MapInfo);
  return EFI_OUT_OF_RESOURCES;
}
 
EFI_STATUS
EFIAPI
VirtioRingMap (
  IN  VIRTIO_DEVICE_PROTOCOL  *VirtIo,
  IN  VRING                   *Ring,
  OUT UINT64                  *RingBaseShift,
  OUT VOID                    **Mapping
  )
{
  EFI_STATUS            Status;
  EFI_PHYSICAL_ADDRESS  DeviceAddress;
 
  Status = VirtioMapAllBytesInSharedBuffer (
             VirtIo,
             VirtioOperationBusMasterCommonBuffer,
             Ring->Base,
             EFI_PAGES_TO_SIZE (Ring->NumPages),
             &DeviceAddress,
             Mapping
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *RingBaseShift = DeviceAddress - (UINT64)(UINTN)Ring->Base;
  return EFI_SUCCESS;
}