/** @file
Implementation of the SNP.Initialize() function and its private helpers if
any.
Copyright (c) 2021, Oracle and/or its affiliates.
Copyright (c) 2017, AMD Inc, All rights reserved.
Copyright (C) 2013, Red Hat, Inc.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include
#include
#include
#include
#include "E1kNet.h"
/**
Set up static scaffolding for the E1kNetTransmit() and
E1kNetGetStatus() SNP methods.
This function may only be called by E1kNetInitialize().
@param[in,out] Dev The E1K_NET_DEV driver instance about to enter the
EfiSimpleNetworkInitialized state.
@retval EFI_OUT_OF_RESOURCES Failed to allocate the stack to track the heads
of free descriptor chains or failed to init
TxBufCollection.
@return Status codes from VIRTIO_DEVICE_PROTOCOL.
AllocateSharedPages() or
VirtioMapAllBytesInSharedBuffer()
@retval EFI_SUCCESS TX setup successful.
*/
STATIC
EFI_STATUS
EFIAPI
E1kNetInitTx (
IN OUT E1K_NET_DEV *Dev
)
{
UINTN TxRingSize;
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS DeviceAddress;
VOID *TxRingBuffer;
Dev->TxMaxPending = E1K_NET_MAX_PENDING;
Dev->TxCurPending = 0;
Dev->TxBufCollection = OrderedCollectionInit (
E1kNetTxBufMapInfoCompare,
E1kNetTxBufDeviceAddressCompare
);
if (Dev->TxBufCollection == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Exit;
}
//
// Allocate TxRing header and map with BusMasterCommonBuffer so that it
// can be accessed equally by both processor and device.
//
TxRingSize = Dev->TxMaxPending * sizeof (*Dev->TxRing);
Status = Dev->PciIo->AllocateBuffer (
Dev->PciIo,
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES (TxRingSize),
&TxRingBuffer,
EFI_PCI_ATTRIBUTE_MEMORY_CACHED
);
if (EFI_ERROR (Status)) {
goto UninitTxBufCollection;
}
ZeroMem (TxRingBuffer, TxRingSize);
Status = Dev->PciIo->Map (
Dev->PciIo,
EfiPciIoOperationBusMasterCommonBuffer,
TxRingBuffer,
&TxRingSize,
&DeviceAddress,
&Dev->TxRingMap
);
if (EFI_ERROR (Status)) {
goto FreeTxRingBuffer;
}
Dev->TxRing = TxRingBuffer;
Dev->TdhLastSeen = 0;
Dev->TxLastUsed = 0;
// Program the transmit engine.
MemoryFence ();
E1kNetRegWrite32(Dev, E1K_REG_TDBAL, (UINT32)DeviceAddress);
E1kNetRegWrite32(Dev, E1K_REG_TDBAH, (UINT32)(RShiftU64 (DeviceAddress, 32)));
E1kNetRegWrite32(Dev, E1K_REG_TDLEN, (UINT32)TxRingSize);
E1kNetRegWrite32(Dev, E1K_REG_TDH, 0);
E1kNetRegWrite32(Dev, E1K_REG_TDT, 0);
E1kNetRegWrite32(Dev, E1K_REG_TCTL, E1K_REG_TCTL_EN | E1K_REG_TCTL_PSP);
return EFI_SUCCESS;
FreeTxRingBuffer:
Dev->PciIo->FreeBuffer (
Dev->PciIo,
EFI_SIZE_TO_PAGES (TxRingSize),
TxRingBuffer
);
UninitTxBufCollection:
OrderedCollectionUninit (Dev->TxBufCollection);
Exit:
return Status;
}
/**
Set up static scaffolding for the E1kNetReceive() SNP method and enable
live device operation.
This function may only be called as E1kNetInitialize()'s final step.
@param[in,out] Dev The E1K_NET_DEV driver instance about to enter the
EfiSimpleNetworkInitialized state.
@return Status codes from VIRTIO_CFG_WRITE() or
VIRTIO_DEVICE_PROTOCOL.AllocateSharedPages or
VirtioMapAllBytesInSharedBuffer().
@retval EFI_SUCCESS RX setup successful. The device is live and may
already be writing to the receive area.
*/
STATIC
EFI_STATUS
EFIAPI
E1kNetInitRx (
IN OUT E1K_NET_DEV *Dev
)
{
EFI_STATUS Status;
UINTN RxBufSize;
UINTN PktIdx;
UINTN NumBytes;
EFI_PHYSICAL_ADDRESS RxBufDeviceAddress;
VOID *RxBuffer;
//
// For each incoming packet we must supply two buffers:
// - the recipient for the RX descriptor, plus
// - the recipient for the network data (which consists of Ethernet header
// and Ethernet payload) which is a 2KB buffer.
//
RxBufSize = sizeof(*Dev->RxRing) + 2048;
//
// The RxBuf is shared between guest and hypervisor, use
// AllocateSharedPages() to allocate this memory region and map it with
// BusMasterCommonBuffer so that it can be accessed by both guest and
// hypervisor.
//
NumBytes = E1K_NET_MAX_PENDING * RxBufSize;
Dev->RxBufNrPages = EFI_SIZE_TO_PAGES (NumBytes);
Status = Dev->PciIo->AllocateBuffer (
Dev->PciIo,
AllocateAnyPages,
EfiBootServicesData,
Dev->RxBufNrPages,
&RxBuffer,
EFI_PCI_ATTRIBUTE_MEMORY_CACHED
);
if (EFI_ERROR (Status)) {
return Status;
}
ZeroMem (RxBuffer, NumBytes);
Status = Dev->PciIo->Map (
Dev->PciIo,
EfiPciIoOperationBusMasterCommonBuffer,
RxBuffer,
&NumBytes,
&Dev->RxDeviceBase,
&Dev->RxMap
);
if (EFI_ERROR (Status)) {
goto FreeSharedBuffer;
}
Dev->RxRing = RxBuffer;
Dev->RxBuf = (UINT8 *)RxBuffer + sizeof(*Dev->RxRing) * E1K_NET_MAX_PENDING;
Dev->RdhLastSeen = 0;
// Set up the RX descriptors.
Dev->RxBufDeviceBase = Dev->RxDeviceBase + sizeof(*Dev->RxRing) * E1K_NET_MAX_PENDING;
RxBufDeviceAddress = Dev->RxBufDeviceBase;
for (PktIdx = 0; PktIdx < E1K_NET_MAX_PENDING; ++PktIdx) {
Dev->RxRing[PktIdx].AddrBufferLow = (UINT32)RxBufDeviceAddress;
Dev->RxRing[PktIdx].AddrBufferHigh = (UINT32)RShiftU64(RxBufDeviceAddress, 32);
Dev->RxRing[PktIdx].BufferLength = 2048;
RxBufDeviceAddress += Dev->RxRing[PktIdx].BufferLength;
}
// Program the receive engine.
MemoryFence ();
E1kNetRegWrite32(Dev, E1K_REG_RDBAL, (UINT32)Dev->RxDeviceBase);
E1kNetRegWrite32(Dev, E1K_REG_RDBAH, (UINT32)(RShiftU64 (Dev->RxDeviceBase, 32)));
E1kNetRegWrite32(Dev, E1K_REG_RDLEN, sizeof(*Dev->RxRing) * E1K_NET_MAX_PENDING);
E1kNetRegWrite32(Dev, E1K_REG_RDH, 0);
E1kNetRegWrite32(Dev, E1K_REG_RDT, E1K_NET_MAX_PENDING - 1);
E1kNetRegClear32(Dev, E1K_REG_RCTL, E1K_REG_RCTL_BSIZE_MASK);
E1kNetRegSet32(Dev, E1K_REG_RCTL, E1K_REG_RCTL_EN | E1K_REG_RCTL_MPE);
return EFI_SUCCESS;
FreeSharedBuffer:
Dev->PciIo->FreeBuffer (
Dev->PciIo,
Dev->RxBufNrPages,
RxBuffer
);
return Status;
}
/**
Resets a network adapter and allocates the transmit and receive buffers
required by the network interface; optionally, also requests allocation of
additional transmit and receive buffers.
@param This The protocol instance pointer.
@param ExtraRxBufferSize The size, in bytes, of the extra receive buffer
space that the driver should allocate for the
network interface. Some network interfaces will not
be able to use the extra buffer, and the caller
will not know if it is actually being used.
@param ExtraTxBufferSize The size, in bytes, of the extra transmit buffer
space that the driver should allocate for the
network interface. Some network interfaces will not
be able to use the extra buffer, and the caller
will not know if it is actually being used.
@retval EFI_SUCCESS The network interface was initialized.
@retval EFI_NOT_STARTED The network interface has not been started.
@retval EFI_OUT_OF_RESOURCES There was not enough memory for the transmit
and receive buffers.
@retval EFI_INVALID_PARAMETER One or more of the parameters has an
unsupported value.
@retval EFI_DEVICE_ERROR The command could not be sent to the network
interface.
@retval EFI_UNSUPPORTED This function is not supported by the network
interface.
**/
EFI_STATUS
EFIAPI
E1kNetInitialize (
IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN UINTN ExtraRxBufferSize OPTIONAL,
IN UINTN ExtraTxBufferSize OPTIONAL
)
{
E1K_NET_DEV *Dev;
EFI_TPL OldTpl;
EFI_STATUS Status;
DEBUG((DEBUG_INFO, "E1kNetInitialize:\n"));
if (This == NULL) {
return EFI_INVALID_PARAMETER;
}
if (ExtraRxBufferSize > 0 || ExtraTxBufferSize > 0) {
return EFI_UNSUPPORTED;
}
Dev = E1K_NET_FROM_SNP (This);
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
if (Dev->Snm.State != EfiSimpleNetworkStarted) {
Status = EFI_NOT_STARTED;
goto InitFailed;
}
// Program the first Receive Address Low/High register.
E1kNetRegSet32(Dev, E1K_REG_CTRL, E1K_REG_CTRL_ASDE | E1K_REG_CTRL_SLU);
E1kNetRegWrite32(Dev, E1K_REG_RAL, *(UINT32 *)&Dev->Snm.CurrentAddress.Addr[0]);
E1kNetRegWrite32(Dev, E1K_REG_RAH, (*(UINT32 *)&Dev->Snm.CurrentAddress.Addr[4]) | E1K_REG_RAH_AV);
Status = E1kNetInitTx (Dev);
if (EFI_ERROR (Status)) {
goto AbortDevice;
}
//
// start receiving
//
Status = E1kNetInitRx (Dev);
if (EFI_ERROR (Status)) {
goto ReleaseTxAux;
}
Dev->Snm.State = EfiSimpleNetworkInitialized;
gBS->RestoreTPL (OldTpl);
return EFI_SUCCESS;
ReleaseTxAux:
E1kNetShutdownTx (Dev);
AbortDevice:
E1kNetDevReset(Dev);
InitFailed:
gBS->RestoreTPL (OldTpl);
return Status;
}