[mirror_edk2.git] / OvmfPkg / VirtioNetDxe / SnpInitialize.c

/** @file\r
\r
  Implementation of the SNP.Initialize() function and its private helpers if\r
  any.\r
\r
  Copyright (C) 2013, Red Hat, Inc.\r
  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
  Copyright (c) 2017, AMD Inc, All rights reserved.<BR>\r
\r
  This program and the accompanying materials are licensed and made available\r
  under the terms and conditions of the BSD License which accompanies this\r
  distribution. The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
\r
#include "VirtioNet.h"\r
\r
/**\r
  Initialize a virtio ring for a specific transfer direction of the virtio-net\r
  device.\r
\r
  This function may only be called by VirtioNetInitialize().\r
\r
  @param[in,out] Dev       The VNET_DEV driver instance about to enter the\r
                           EfiSimpleNetworkInitialized state.\r
  @param[in]     Selector  Identifies the transfer direction (virtio queue) of\r
                           the network device.\r
  @param[out]    Ring      The virtio-ring inside the VNET_DEV structure,\r
                           corresponding to Selector.\r
  @param[out]    Mapping   A resulting token to pass to VirtioNetUninitRing()\r
\r
  @retval EFI_UNSUPPORTED  The queue size reported by the virtio-net device is\r
                           too small.\r
  @return                  Status codes from VIRTIO_CFG_WRITE(),\r
                           VIRTIO_CFG_READ(), VirtioRingInit() and\r
                           VirtioRingMap().\r
  @retval EFI_SUCCESS      Ring initialized.\r
*/\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
VirtioNetInitRing (\r
  IN OUT VNET_DEV *Dev,\r
  IN     UINT16   Selector,\r
  OUT    VRING    *Ring,\r
  OUT    VOID     **Mapping\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINT16     QueueSize;\r
  UINT64     RingBaseShift;\r
  VOID       *MapInfo;\r
\r
  //\r
  // step 4b -- allocate selected queue\r
  //\r
  Status = Dev->VirtIo->SetQueueSel (Dev->VirtIo, Selector);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  Status = Dev->VirtIo->GetQueueNumMax (Dev->VirtIo, &QueueSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // For each packet (RX and TX alike), we need two descriptors:\r
  // one for the virtio-net request header, and another one for the data\r
  //\r
  if (QueueSize < 2) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  Status = VirtioRingInit (Dev->VirtIo, QueueSize, Ring);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // If anything fails from here on, we must release the ring resources.\r
  //\r
  Status = VirtioRingMap (Dev->VirtIo, Ring, &RingBaseShift, &MapInfo);\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseQueue;\r
  }\r
\r
  //\r
  // Additional steps for MMIO: align the queue appropriately, and set the\r
  // size. If anything fails from here on, we must unmap the ring resources.\r
  //\r
  Status = Dev->VirtIo->SetQueueNum (Dev->VirtIo, QueueSize);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  Status = Dev->VirtIo->SetQueueAlign (Dev->VirtIo, EFI_PAGE_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  //\r
  // step 4c -- report GPFN (guest-physical frame number) of queue\r
  //\r
  Status = Dev->VirtIo->SetQueueAddress (Dev->VirtIo, Ring, RingBaseShift);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  *Mapping = MapInfo;\r
\r
  return EFI_SUCCESS;\r
\r
UnmapQueue:\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, MapInfo);\r
\r
ReleaseQueue:\r
  VirtioRingUninit (Dev->VirtIo, Ring);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Set up static scaffolding for the VirtioNetTransmit() and\r
  VirtioNetGetStatus() SNP methods.\r
\r
  This function may only be called by VirtioNetInitialize().\r
\r
  The structures laid out and resources configured include:\r
  - fully populate the TX queue with a static pattern of virtio descriptor\r
    chains,\r
  - tracking of heads of free descriptor chains from the above,\r
  - one common virtio-net request header (never modified by the host) for all\r
    pending TX packets,\r
  - select polling over TX interrupt.\r
\r
  @param[in,out] Dev       The VNET_DEV driver instance about to enter the\r
                           EfiSimpleNetworkInitialized state.\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate the stack to track the heads\r
                                of free descriptor chains.\r
  @return                       Status codes from VIRTIO_DEVICE_PROTOCOL.\r
                                AllocateSharedPages() or\r
                                VirtioMapAllBytesInSharedBuffer()\r
  @retval EFI_SUCCESS           TX setup successful.\r
*/\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
VirtioNetInitTx (\r
  IN OUT VNET_DEV *Dev\r
  )\r
{\r
  UINTN                 TxSharedReqSize;\r
  UINTN                 PktIdx;\r
  EFI_STATUS            Status;\r
  EFI_PHYSICAL_ADDRESS  DeviceAddress;\r
  VOID                  *TxSharedReqBuffer;\r
\r
  Dev->TxMaxPending = (UINT16) MIN (Dev->TxRing.QueueSize / 2,\r
                                 VNET_MAX_PENDING);\r
  Dev->TxCurPending = 0;\r
  Dev->TxFreeStack  = AllocatePool (Dev->TxMaxPending *\r
                        sizeof *Dev->TxFreeStack);\r
  if (Dev->TxFreeStack == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Allocate TxSharedReq header and map with BusMasterCommonBuffer so that it\r
  // can be accessed equally by both processor and device.\r
  //\r
  Status = Dev->VirtIo->AllocateSharedPages (\r
                          Dev->VirtIo,\r
                          EFI_SIZE_TO_PAGES (sizeof *Dev->TxSharedReq),\r
                          &TxSharedReqBuffer\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeTxFreeStack;\r
  }\r
\r
  ZeroMem (TxSharedReqBuffer, sizeof *Dev->TxSharedReq);\r
\r
  Status = VirtioMapAllBytesInSharedBuffer (\r
             Dev->VirtIo,\r
             VirtioOperationBusMasterCommonBuffer,\r
             TxSharedReqBuffer,\r
             sizeof *(Dev->TxSharedReq),\r
             &DeviceAddress,\r
             &Dev->TxSharedReqMap\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeTxSharedReqBuffer;\r
  }\r
\r
  Dev->TxSharedReq = TxSharedReqBuffer;\r
\r
\r
  //\r
  // In VirtIo 1.0, the NumBuffers field is mandatory. In 0.9.5, it depends on\r
  // VIRTIO_NET_F_MRG_RXBUF, which we never negotiate.\r
  //\r
  TxSharedReqSize = (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) ?\r
                    sizeof (Dev->TxSharedReq->V0_9_5) :\r
                    sizeof *Dev->TxSharedReq;\r
\r
  for (PktIdx = 0; PktIdx < Dev->TxMaxPending; ++PktIdx) {\r
    UINT16 DescIdx;\r
\r
    DescIdx = (UINT16) (2 * PktIdx);\r
    Dev->TxFreeStack[PktIdx] = DescIdx;\r
\r
    //\r
    // For each possibly pending packet, lay out the descriptor for the common\r
    // (unmodified by the host) virtio-net request header.\r
    //\r
    Dev->TxRing.Desc[DescIdx].Addr  = DeviceAddress;\r
    Dev->TxRing.Desc[DescIdx].Len   = (UINT32) TxSharedReqSize;\r
    Dev->TxRing.Desc[DescIdx].Flags = VRING_DESC_F_NEXT;\r
    Dev->TxRing.Desc[DescIdx].Next  = (UINT16) (DescIdx + 1);\r
\r
    //\r
    // The second descriptor of each pending TX packet is updated on the fly,\r
    // but it always terminates the descriptor chain of the packet.\r
    //\r
    Dev->TxRing.Desc[DescIdx + 1].Flags = 0;\r
  }\r
\r
  //\r
  // virtio-0.9.5, Appendix C, Packet Transmission\r
  //\r
  Dev->TxSharedReq->V0_9_5.Flags   = 0;\r
  Dev->TxSharedReq->V0_9_5.GsoType = VIRTIO_NET_HDR_GSO_NONE;\r
\r
  //\r
  // For VirtIo 1.0 only -- the field exists, but it is unused\r
  //\r
  Dev->TxSharedReq->NumBuffers = 0;\r
\r
  //\r
  // virtio-0.9.5, 2.4.2 Receiving Used Buffers From the Device\r
  //\r
  MemoryFence ();\r
  Dev->TxLastUsed = *Dev->TxRing.Used.Idx;\r
  ASSERT (Dev->TxLastUsed == 0);\r
\r
  //\r
  // want no interrupt when a transmit completes\r
  //\r
  *Dev->TxRing.Avail.Flags = (UINT16) VRING_AVAIL_F_NO_INTERRUPT;\r
\r
  return EFI_SUCCESS;\r
\r
FreeTxSharedReqBuffer:\r
  Dev->VirtIo->FreeSharedPages (\r
                 Dev->VirtIo,\r
                 EFI_SIZE_TO_PAGES (sizeof *(Dev->TxSharedReq)),\r
                 TxSharedReqBuffer\r
                 );\r
FreeTxFreeStack:\r
  FreePool (Dev->TxFreeStack);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Set up static scaffolding for the VirtioNetReceive() SNP method and enable\r
  live device operation.\r
\r
  This function may only be called as VirtioNetInitialize()'s final step.\r
\r
  The structures laid out and resources configured include:\r
  - destination area for the host to write virtio-net request headers and\r
    packet data into,\r
  - select polling over RX interrupt,\r
  - fully populate the RX queue with a static pattern of virtio descriptor\r
    chains.\r
\r
  @param[in,out] Dev       The VNET_DEV driver instance about to enter the\r
                           EfiSimpleNetworkInitialized state.\r
\r
  @return                       Status codes from VIRTIO_CFG_WRITE() or\r
                                VIRTIO_DEVICE_PROTOCOL.AllocateSharedPages or\r
                                VirtioMapAllBytesInSharedBuffer().\r
  @retval EFI_SUCCESS           RX setup successful. The device is live and may\r
                                already be writing to the receive area.\r
*/\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
VirtioNetInitRx (\r
  IN OUT VNET_DEV *Dev\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINTN                 VirtioNetReqSize;\r
  UINTN                 RxBufSize;\r
  UINT16                RxAlwaysPending;\r
  UINTN                 PktIdx;\r
  UINT16                DescIdx;\r
  UINTN                 NumBytes;\r
  EFI_PHYSICAL_ADDRESS  RxBufDeviceAddress;\r
  VOID                  *RxBuffer;\r
\r
  //\r
  // In VirtIo 1.0, the NumBuffers field is mandatory. In 0.9.5, it depends on\r
  // VIRTIO_NET_F_MRG_RXBUF, which we never negotiate.\r
  //\r
  VirtioNetReqSize = (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) ?\r
                     sizeof (VIRTIO_NET_REQ) :\r
                     sizeof (VIRTIO_1_0_NET_REQ);\r
\r
  //\r
  // For each incoming packet we must supply two descriptors:\r
  // - the recipient for the virtio-net request header, plus\r
  // - the recipient for the network data (which consists of Ethernet header\r
  //   and Ethernet payload).\r
  //\r
  RxBufSize = VirtioNetReqSize +\r
              (Dev->Snm.MediaHeaderSize + Dev->Snm.MaxPacketSize);\r
\r
  //\r
  // Limit the number of pending RX packets if the queue is big. The division\r
  // by two is due to the above "two descriptors per packet" trait.\r
  //\r
  RxAlwaysPending = (UINT16) MIN (Dev->RxRing.QueueSize / 2, VNET_MAX_PENDING);\r
\r
  //\r
  // The RxBuf is shared between guest and hypervisor, use\r
  // AllocateSharedPages() to allocate this memory region and map it with\r
  // BusMasterCommonBuffer so that it can be accessed by both guest and\r
  // hypervisor.\r
  //\r
  NumBytes = RxAlwaysPending * RxBufSize;\r
  Dev->RxBufNrPages = EFI_SIZE_TO_PAGES (NumBytes);\r
  Status = Dev->VirtIo->AllocateSharedPages (\r
                          Dev->VirtIo,\r
                          Dev->RxBufNrPages,\r
                          &RxBuffer\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  ZeroMem (RxBuffer, NumBytes);\r
\r
  Status = VirtioMapAllBytesInSharedBuffer (\r
             Dev->VirtIo,\r
             VirtioOperationBusMasterCommonBuffer,\r
             RxBuffer,\r
             NumBytes,\r
             &Dev->RxBufDeviceBase,\r
             &Dev->RxBufMap\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeSharedBuffer;\r
  }\r
\r
  Dev->RxBuf = RxBuffer;\r
\r
  //\r
  // virtio-0.9.5, 2.4.2 Receiving Used Buffers From the Device\r
  //\r
  MemoryFence ();\r
  Dev->RxLastUsed = *Dev->RxRing.Used.Idx;\r
  ASSERT (Dev->RxLastUsed == 0);\r
\r
  //\r
  // virtio-0.9.5, 2.4.2 Receiving Used Buffers From the Device:\r
  // the host should not send interrupts, we'll poll in VirtioNetReceive()\r
  // and VirtioNetIsPacketAvailable().\r
  //\r
  *Dev->RxRing.Avail.Flags = (UINT16) VRING_AVAIL_F_NO_INTERRUPT;\r
\r
  //\r
  // now set up a separate, two-part descriptor chain for each RX packet, and\r
  // link each chain into (from) the available ring as well\r
  //\r
  DescIdx = 0;\r
  RxBufDeviceAddress = Dev->RxBufDeviceBase;\r
  for (PktIdx = 0; PktIdx < RxAlwaysPending; ++PktIdx) {\r
    //\r
    // virtio-0.9.5, 2.4.1.2 Updating the Available Ring\r
    // invisible to the host until we update the Index Field\r
    //\r
    Dev->RxRing.Avail.Ring[PktIdx] = DescIdx;\r
\r
    //\r
    // virtio-0.9.5, 2.4.1.1 Placing Buffers into the Descriptor Table\r
    //\r
    Dev->RxRing.Desc[DescIdx].Addr  = RxBufDeviceAddress;\r
    Dev->RxRing.Desc[DescIdx].Len   = (UINT32) VirtioNetReqSize;\r
    Dev->RxRing.Desc[DescIdx].Flags = VRING_DESC_F_WRITE | VRING_DESC_F_NEXT;\r
    Dev->RxRing.Desc[DescIdx].Next  = (UINT16) (DescIdx + 1);\r
    RxBufDeviceAddress += Dev->RxRing.Desc[DescIdx++].Len;\r
\r
    Dev->RxRing.Desc[DescIdx].Addr  = RxBufDeviceAddress;\r
    Dev->RxRing.Desc[DescIdx].Len   = (UINT32) (RxBufSize - VirtioNetReqSize);\r
    Dev->RxRing.Desc[DescIdx].Flags = VRING_DESC_F_WRITE;\r
    RxBufDeviceAddress += Dev->RxRing.Desc[DescIdx++].Len;\r
  }\r
\r
  //\r
  // virtio-0.9.5, 2.4.1.3 Updating the Index Field\r
  //\r
  MemoryFence ();\r
  *Dev->RxRing.Avail.Idx = RxAlwaysPending;\r
\r
  //\r
  // At this point reception may already be running. In order to make it sure,\r
  // kick the hypervisor. If we fail to kick it, we must first abort reception\r
  // before tearing down anything, because reception may have been already\r
  // running even without the kick.\r
  //\r
  // virtio-0.9.5, 2.4.1.4 Notifying the Device\r
  //\r
  MemoryFence ();\r
  Status = Dev->VirtIo->SetQueueNotify (Dev->VirtIo, VIRTIO_NET_Q_RX);\r
  if (EFI_ERROR (Status)) {\r
    Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);\r
    goto UnmapSharedBuffer;\r
  }\r
\r
  return Status;\r
\r
UnmapSharedBuffer:\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RxBufMap);\r
\r
FreeSharedBuffer:\r
  Dev->VirtIo->FreeSharedPages (\r
                 Dev->VirtIo,\r
                 Dev->RxBufNrPages,\r
                 RxBuffer\r
                 );\r
  return Status;\r
}\r
\r
\r
/**\r
  Resets a network adapter and allocates the transmit and receive buffers\r
  required by the network interface; optionally, also requests allocation  of\r
  additional transmit and receive buffers.\r
\r
  @param  This              The protocol instance pointer.\r
  @param  ExtraRxBufferSize The size, in bytes, of the extra receive buffer\r
                            space that the driver should allocate for the\r
                            network interface. Some network interfaces will not\r
                            be able to use the extra buffer, and the caller\r
                            will not know if it is actually being used.\r
  @param  ExtraTxBufferSize The size, in bytes, of the extra transmit buffer\r
                            space that the driver should allocate for the\r
                            network interface. Some network interfaces will not\r
                            be able to use the extra buffer, and the caller\r
                            will not know if it is actually being used.\r
\r
  @retval EFI_SUCCESS           The network interface was initialized.\r
  @retval EFI_NOT_STARTED       The network interface has not been started.\r
  @retval EFI_OUT_OF_RESOURCES  There was not enough memory for the transmit\r
                                and receive buffers.\r
  @retval EFI_INVALID_PARAMETER One or more of the parameters has an\r
                                unsupported value.\r
  @retval EFI_DEVICE_ERROR      The command could not be sent to the network\r
                                interface.\r
  @retval EFI_UNSUPPORTED       This function is not supported by the network\r
                                interface.\r
\r
**/\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioNetInitialize (\r
  IN EFI_SIMPLE_NETWORK_PROTOCOL *This,\r
  IN UINTN                       ExtraRxBufferSize  OPTIONAL,\r
  IN UINTN                       ExtraTxBufferSize  OPTIONAL\r
  )\r
{\r
  VNET_DEV   *Dev;\r
  EFI_TPL    OldTpl;\r
  EFI_STATUS Status;\r
  UINT8      NextDevStat;\r
  UINT64     Features;\r
\r
  if (This == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if (ExtraRxBufferSize > 0 || ExtraTxBufferSize > 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Dev = VIRTIO_NET_FROM_SNP (This);\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
  if (Dev->Snm.State != EfiSimpleNetworkStarted) {\r
    Status = EFI_NOT_STARTED;\r
    goto InitFailed;\r
  }\r
\r
  //\r
  // In the EfiSimpleNetworkStarted state the virtio-net device has status\r
  // value 0 (= reset) -- see the state diagram, the full call chain to\r
  // the end of VirtioNetGetFeatures() (considering we're here now),\r
  // the DeviceFailed label below, and VirtioNetShutdown().\r
  //\r
  // Accordingly, the below is a subsequence of the steps found in the\r
  // virtio-0.9.5 spec, 2.2.1 Device Initialization Sequence.\r
  //\r
  NextDevStat = VSTAT_ACK;    // step 2 -- acknowledge device presence\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto InitFailed;\r
  }\r
\r
  NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto DeviceFailed;\r
  }\r
\r
  //\r
  // Set Page Size - MMIO VirtIo Specific\r
  //\r
  Status = Dev->VirtIo->SetPageSize (Dev->VirtIo, EFI_PAGE_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto DeviceFailed;\r
  }\r
\r
  //\r
  // step 4a -- retrieve features. Note that we're past validating required\r
  // features in VirtioNetGetFeatures().\r
  //\r
  Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features);\r
  if (EFI_ERROR (Status)) {\r
    goto DeviceFailed;\r
  }\r
\r
  ASSERT (Features & VIRTIO_NET_F_MAC);\r
  ASSERT (Dev->Snm.MediaPresentSupported ==\r
    !!(Features & VIRTIO_NET_F_STATUS));\r
\r
  Features &= VIRTIO_NET_F_MAC | VIRTIO_NET_F_STATUS | VIRTIO_F_VERSION_1;\r
\r
  //\r
  // In virtio-1.0, feature negotiation is expected to complete before queue\r
  // discovery, and the device can also reject the selected set of features.\r
  //\r
  if (Dev->VirtIo->Revision >= VIRTIO_SPEC_REVISION (1, 0, 0)) {\r
    Status = Virtio10WriteFeatures (Dev->VirtIo, Features, &NextDevStat);\r
    if (EFI_ERROR (Status)) {\r
      goto DeviceFailed;\r
    }\r
  }\r
\r
  //\r
  // step 4b, 4c -- allocate and report virtqueues\r
  //\r
  Status = VirtioNetInitRing (\r
             Dev,\r
             VIRTIO_NET_Q_RX,\r
             &Dev->RxRing,\r
             &Dev->RxRingMap\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto DeviceFailed;\r
  }\r
\r
  Status = VirtioNetInitRing (\r
             Dev,\r
             VIRTIO_NET_Q_TX,\r
             &Dev->TxRing,\r
             &Dev->TxRingMap\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseRxRing;\r
  }\r
\r
  //\r
  // step 5 -- keep only the features we want\r
  //\r
  if (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) {\r
    Features &= ~(UINT64)VIRTIO_F_VERSION_1;\r
    Status = Dev->VirtIo->SetGuestFeatures (Dev->VirtIo, Features);\r
    if (EFI_ERROR (Status)) {\r
      goto ReleaseTxRing;\r
    }\r
  }\r
\r
  //\r
  // step 6 -- virtio-net initialization complete\r
  //\r
  NextDevStat |= VSTAT_DRIVER_OK;\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseTxRing;\r
  }\r
\r
  Status = VirtioNetInitTx (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto AbortDevice;\r
  }\r
\r
  //\r
  // start receiving\r
  //\r
  Status = VirtioNetInitRx (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseTxAux;\r
  }\r
\r
  Dev->Snm.State = EfiSimpleNetworkInitialized;\r
  gBS->RestoreTPL (OldTpl);\r
  return EFI_SUCCESS;\r
\r
ReleaseTxAux:\r
  VirtioNetShutdownTx (Dev);\r
\r
AbortDevice:\r
  Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);\r
\r
ReleaseTxRing:\r
  VirtioNetUninitRing (Dev, &Dev->TxRing, Dev->TxRingMap);\r
\r
ReleaseRxRing:\r
  VirtioNetUninitRing (Dev, &Dev->RxRing, Dev->RxRingMap);\r
\r
DeviceFailed:\r
  //\r
  // restore device status invariant for the EfiSimpleNetworkStarted state\r
  //\r
  Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);\r
\r
InitFailed:\r
  gBS->RestoreTPL (OldTpl);\r
  return Status;\r
}\r