SnpTransmit.c

Go to the documentation of this file.

 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
 
#include "VirtioNet.h"
 
EFI_STATUS
EFIAPI
VirtioNetTransmit (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINTN                        HeaderSize,
  IN UINTN                        BufferSize,
  IN /* +OUT! */ VOID             *Buffer,
  IN EFI_MAC_ADDRESS              *SrcAddr  OPTIONAL,
  IN EFI_MAC_ADDRESS              *DestAddr OPTIONAL,
  IN UINT16                       *Protocol OPTIONAL
  )
{
  VNET_DEV              *Dev;
  EFI_TPL               OldTpl;
  EFI_STATUS            Status;
  UINT16                DescIdx;
  UINT16                AvailIdx;
  EFI_PHYSICAL_ADDRESS  DeviceAddress;
 
  if ((This == NULL) || (BufferSize == 0) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Dev    = VIRTIO_NET_FROM_SNP (This);
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  switch (Dev->Snm.State) {
    case EfiSimpleNetworkStopped:
      Status = EFI_NOT_STARTED;
      goto Exit;
    case EfiSimpleNetworkStarted:
      Status = EFI_DEVICE_ERROR;
      goto Exit;
    default:
      break;
  }
 
  if (BufferSize < Dev->Snm.MediaHeaderSize) {
    Status = EFI_BUFFER_TOO_SMALL;
    goto Exit;
  }
 
  if (BufferSize > Dev->Snm.MediaHeaderSize + Dev->Snm.MaxPacketSize) {
    Status = EFI_INVALID_PARAMETER;
    goto Exit;
  }
 
  //
  // check if we have room for transmission
  //
  ASSERT (Dev->TxCurPending <= Dev->TxMaxPending);
  if (Dev->TxCurPending == Dev->TxMaxPending) {
    Status = EFI_NOT_READY;
    goto Exit;
  }
 
  //
  // the caller may want us to fill in the media header:
  // dst MAC, src MAC, Ethertype
  //
  if (HeaderSize != 0) {
    UINT8  *Ptr;
 
    if ((HeaderSize != Dev->Snm.MediaHeaderSize) ||
        (DestAddr == NULL) || (Protocol == NULL))
    {
      Status = EFI_INVALID_PARAMETER;
      goto Exit;
    }
 
    Ptr = Buffer;
    ASSERT (SIZE_OF_VNET (Mac) <= sizeof (EFI_MAC_ADDRESS));
 
    CopyMem (Ptr, DestAddr, SIZE_OF_VNET (Mac));
    Ptr += SIZE_OF_VNET (Mac);
 
    CopyMem (
      Ptr,
      (SrcAddr == NULL) ? &Dev->Snm.CurrentAddress : SrcAddr,
      SIZE_OF_VNET (Mac)
      );
    Ptr += SIZE_OF_VNET (Mac);
 
    *Ptr++ = (UINT8)(*Protocol >> 8);
    *Ptr++ = (UINT8)*Protocol;
 
    ASSERT ((UINTN)(Ptr - (UINT8 *)Buffer) == Dev->Snm.MediaHeaderSize);
  }
 
  //
  // Map the transmit buffer system physical address to device address.
  //
  Status = VirtioNetMapTxBuf (
             Dev,
             Buffer,
             BufferSize,
             &DeviceAddress
             );
  if (EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    goto Exit;
  }
 
  //
  // virtio-0.9.5, 2.4.1 Supplying Buffers to The Device
  //
  DescIdx                            = Dev->TxFreeStack[Dev->TxCurPending++];
  Dev->TxRing.Desc[DescIdx + 1].Addr = DeviceAddress;
  Dev->TxRing.Desc[DescIdx + 1].Len  = (UINT32)BufferSize;
 
  //
  // the available index is never written by the host, we can read it back
  // without a barrier
  //
  AvailIdx                                                   = *Dev->TxRing.Avail.Idx;
  Dev->TxRing.Avail.Ring[AvailIdx++ % Dev->TxRing.QueueSize] = DescIdx;
 
  MemoryFence ();
  *Dev->TxRing.Avail.Idx = AvailIdx;
 
  MemoryFence ();
  Status = Dev->VirtIo->SetQueueNotify (Dev->VirtIo, VIRTIO_NET_Q_TX);
 
Exit:
  gBS->RestoreTPL (OldTpl);
  return Status;
}