[mirror_edk2.git] / MdeModulePkg / Universal / Network / MnpDxe / MnpConfig.c

/** @file\r
  Implementation of Managed Network Protocol private services.\r
\r
Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "MnpImpl.h"\r
#include "MnpVlan.h"\r
\r
EFI_SERVICE_BINDING_PROTOCOL    mMnpServiceBindingProtocol = {\r
  MnpServiceBindingCreateChild,\r
  MnpServiceBindingDestroyChild\r
};\r
\r
EFI_MANAGED_NETWORK_PROTOCOL    mMnpProtocolTemplate = {\r
  MnpGetModeData,\r
  MnpConfigure,\r
  MnpMcastIpToMac,\r
  MnpGroups,\r
  MnpTransmit,\r
  MnpReceive,\r
  MnpCancel,\r
  MnpPoll\r
};\r
\r
EFI_MANAGED_NETWORK_CONFIG_DATA mMnpDefaultConfigData = {\r
  10000000,\r
  10000000,\r
  0,\r
  FALSE,\r
  FALSE,\r
  FALSE,\r
  FALSE,\r
  FALSE,\r
  FALSE,\r
  FALSE\r
};\r
\r
/**\r
  Add Count of net buffers to MnpDeviceData->FreeNbufQue. The length of the net\r
  buffer is specified by MnpDeviceData->BufferLength.\r
\r
  @param[in, out]  MnpDeviceData         Pointer to the MNP_DEVICE_DATA.\r
  @param[in]       Count                 Number of NET_BUFFERs to add.\r
\r
  @retval EFI_SUCCESS           The specified amount of NET_BUFs are allocated\r
                                and added to MnpDeviceData->FreeNbufQue.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate a NET_BUF structure.\r
\r
**/\r
EFI_STATUS\r
MnpAddFreeNbuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN     UINTN             Count\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Index;\r
  NET_BUF     *Nbuf;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
  ASSERT ((Count > 0) && (MnpDeviceData->BufferLength > 0));\r
\r
  Status = EFI_SUCCESS;\r
  for (Index = 0; Index < Count; Index++) {\r
    Nbuf = NetbufAlloc (MnpDeviceData->BufferLength + MnpDeviceData->PaddingSize);\r
    if (Nbuf == NULL) {\r
      DEBUG ((EFI_D_ERROR, "MnpAddFreeNbuf: NetBufAlloc failed.\n"));\r
\r
      Status = EFI_OUT_OF_RESOURCES;\r
      break;\r
    }\r
\r
    if (MnpDeviceData->PaddingSize > 0) {\r
      //\r
      // Pad padding bytes before the media header\r
      //\r
      NetbufAllocSpace (Nbuf, MnpDeviceData->PaddingSize, NET_BUF_TAIL);\r
      NetbufTrim (Nbuf, MnpDeviceData->PaddingSize, NET_BUF_HEAD);\r
    }\r
\r
    NetbufQueAppend (&MnpDeviceData->FreeNbufQue, Nbuf);\r
  }\r
\r
  MnpDeviceData->NbufCnt += Index;\r
  return Status;\r
}\r
\r
\r
/**\r
  Allocate a free NET_BUF from MnpDeviceData->FreeNbufQue. If there is none\r
  in the queue, first try to allocate some and add them into the queue, then\r
  fetch the NET_BUF from the updated FreeNbufQue.\r
\r
  @param[in, out]  MnpDeviceData        Pointer to the MNP_DEVICE_DATA.\r
\r
  @return     Pointer to the allocated free NET_BUF structure, if NULL the\r
              operation is failed.\r
\r
**/\r
NET_BUF *\r
MnpAllocNbuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData\r
  )\r
{\r
  EFI_STATUS    Status;\r
  NET_BUF_QUEUE *FreeNbufQue;\r
  NET_BUF       *Nbuf;\r
  EFI_TPL       OldTpl;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  FreeNbufQue = &MnpDeviceData->FreeNbufQue;\r
  OldTpl      = gBS->RaiseTPL (TPL_NOTIFY);\r
\r
  //\r
  // Check whether there are available buffers, or else try to add some.\r
  //\r
  if (FreeNbufQue->BufNum == 0) {\r
    if ((MnpDeviceData->NbufCnt + MNP_NET_BUFFER_INCREASEMENT) > MNP_MAX_NET_BUFFER_NUM) {\r
      DEBUG (\r
        (EFI_D_ERROR,\r
        "MnpAllocNbuf: The maximum NET_BUF size is reached for MNP driver instance %p.\n",\r
        MnpDeviceData)\r
        );\r
\r
      Nbuf = NULL;\r
      goto ON_EXIT;\r
    }\r
\r
    Status = MnpAddFreeNbuf (MnpDeviceData, MNP_NET_BUFFER_INCREASEMENT);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG (\r
        (EFI_D_ERROR,\r
        "MnpAllocNbuf: Failed to add NET_BUFs into the FreeNbufQue, %r.\n",\r
        Status)\r
        );\r
\r
      //\r
      // Don't return NULL, perhaps MnpAddFreeNbuf does add some NET_BUFs but\r
      // the amount is less than MNP_NET_BUFFER_INCREASEMENT.\r
      //\r
    }\r
  }\r
\r
  Nbuf = NetbufQueRemove (FreeNbufQue);\r
\r
  //\r
  // Increase the RefCnt.\r
  //\r
  if (Nbuf != NULL) {\r
    NET_GET_REF (Nbuf);\r
  }\r
\r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Nbuf;\r
}\r
\r
\r
/**\r
  Try to reclaim the Nbuf into the buffer pool.\r
\r
  @param[in, out]  MnpDeviceData         Pointer to the mnp device context data.\r
  @param[in, out]  Nbuf                  Pointer to the NET_BUF to free.\r
\r
**/\r
VOID\r
MnpFreeNbuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN OUT NET_BUF           *Nbuf\r
  )\r
{\r
  EFI_TPL  OldTpl;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
  ASSERT (Nbuf->RefCnt > 1);\r
\r
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
\r
  NET_PUT_REF (Nbuf);\r
\r
  if (Nbuf->RefCnt == 1) {\r
    //\r
    // Trim all buffer contained in the Nbuf, then append it to the NbufQue.\r
    //\r
    NetbufTrim (Nbuf, Nbuf->TotalSize, NET_BUF_TAIL);\r
\r
    if (NetbufAllocSpace (Nbuf, NET_VLAN_TAG_LEN, NET_BUF_HEAD) != NULL) {\r
      //\r
      // There is space reserved for vlan tag in the head, reclaim it\r
      //\r
      NetbufTrim (Nbuf, NET_VLAN_TAG_LEN, NET_BUF_TAIL);\r
    }\r
\r
    NetbufQueAppend (&MnpDeviceData->FreeNbufQue, Nbuf);\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
}\r
\r
/**\r
  Add Count of TX buffers to MnpDeviceData->AllTxBufList and MnpDeviceData->FreeTxBufList.\r
  The length of the buffer is specified by MnpDeviceData->BufferLength.\r
\r
  @param[in, out]  MnpDeviceData         Pointer to the MNP_DEVICE_DATA.\r
  @param[in]       Count                 Number of TX buffers to add.\r
\r
  @retval EFI_SUCCESS           The specified amount of TX buffers are allocated.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate a TX buffer.\r
\r
**/\r
EFI_STATUS\r
MnpAddFreeTxBuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN     UINTN             Count\r
  )\r
{\r
  EFI_STATUS        Status;\r
  UINT32            Index;\r
  MNP_TX_BUF_WRAP   *TxBufWrap;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
  ASSERT ((Count > 0) && (MnpDeviceData->BufferLength > 0));\r
\r
  Status = EFI_SUCCESS;\r
  for (Index = 0; Index < Count; Index++) {\r
    TxBufWrap = (MNP_TX_BUF_WRAP*) AllocatePool (OFFSET_OF (MNP_TX_BUF_WRAP, TxBuf) + MnpDeviceData->BufferLength );\r
    if (TxBufWrap == NULL) {\r
      DEBUG ((EFI_D_ERROR, "MnpAddFreeTxBuf: TxBuf Alloc failed.\n"));\r
\r
      Status = EFI_OUT_OF_RESOURCES;\r
      break;\r
    }\r
    DEBUG ((EFI_D_INFO, "MnpAddFreeTxBuf: Add TxBufWrap %p, TxBuf %p\n", TxBufWrap, TxBufWrap->TxBuf));\r
    TxBufWrap->Signature = MNP_TX_BUF_WRAP_SIGNATURE;\r
    TxBufWrap->InUse     = FALSE;\r
    InsertTailList (&MnpDeviceData->FreeTxBufList, &TxBufWrap->WrapEntry);\r
    InsertTailList (&MnpDeviceData->AllTxBufList, &TxBufWrap->AllEntry);\r
  }\r
\r
  MnpDeviceData->TxBufCount += Index;\r
  return Status;\r
}\r
\r
/**\r
  Allocate a free TX buffer from MnpDeviceData->FreeTxBufList. If there is none\r
  in the queue, first try to recycle some from SNP, then try to allocate some and add\r
  them into the queue, then fetch the NET_BUF from the updated FreeTxBufList.\r
\r
  @param[in, out]  MnpDeviceData        Pointer to the MNP_DEVICE_DATA.\r
\r
  @return     Pointer to the allocated free NET_BUF structure, if NULL the\r
              operation is failed.\r
\r
**/\r
UINT8 *\r
MnpAllocTxBuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData\r
  )\r
{\r
  EFI_TPL           OldTpl;\r
  UINT8             *TxBuf;\r
  EFI_STATUS        Status;\r
  LIST_ENTRY        *Entry;\r
  MNP_TX_BUF_WRAP   *TxBufWrap;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  if (IsListEmpty (&MnpDeviceData->FreeTxBufList)) {\r
    //\r
    // First try to recycle some TX buffer from SNP\r
    //\r
    Status = MnpRecycleTxBuf (MnpDeviceData);\r
    if (EFI_ERROR (Status)) {\r
      TxBuf = NULL;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // If still no free TX buffer, allocate more.\r
    //\r
    if (IsListEmpty (&MnpDeviceData->FreeTxBufList)) {\r
      if ((MnpDeviceData->TxBufCount + MNP_TX_BUFFER_INCREASEMENT) > MNP_MAX_TX_BUFFER_NUM) {\r
        DEBUG (\r
          (EFI_D_ERROR,\r
          "MnpAllocTxBuf: The maximum TxBuf size is reached for MNP driver instance %p.\n",\r
          MnpDeviceData)\r
          );\r
\r
        TxBuf = NULL;\r
        goto ON_EXIT;\r
      }\r
\r
      Status = MnpAddFreeTxBuf (MnpDeviceData, MNP_TX_BUFFER_INCREASEMENT);\r
      if (IsListEmpty (&MnpDeviceData->FreeTxBufList)) {\r
        DEBUG (\r
          (EFI_D_ERROR,\r
          "MnpAllocNbuf: Failed to add TxBuf into the FreeTxBufList, %r.\n",\r
          Status)\r
          );\r
\r
        TxBuf = NULL;\r
        goto ON_EXIT;\r
      }\r
    }\r
  }\r
\r
  ASSERT (!IsListEmpty (&MnpDeviceData->FreeTxBufList));\r
  Entry = MnpDeviceData->FreeTxBufList.ForwardLink;\r
  RemoveEntryList (MnpDeviceData->FreeTxBufList.ForwardLink);\r
  TxBufWrap = NET_LIST_USER_STRUCT_S (Entry, MNP_TX_BUF_WRAP, WrapEntry, MNP_TX_BUF_WRAP_SIGNATURE);\r
  TxBufWrap->InUse = TRUE;\r
  TxBuf = TxBufWrap->TxBuf;\r
\r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return TxBuf;\r
}\r
\r
/**\r
  Try to reclaim the TX buffer into the buffer pool.\r
\r
  @param[in, out]  MnpDeviceData         Pointer to the mnp device context data.\r
  @param[in, out]  TxBuf                 Pointer to the TX buffer to free.\r
\r
**/\r
VOID\r
MnpFreeTxBuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN OUT UINT8             *TxBuf\r
  )\r
{\r
  MNP_TX_BUF_WRAP   *TxBufWrap;\r
  EFI_TPL           OldTpl;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  if (TxBuf == NULL) {\r
    return;\r
  }\r
\r
  TxBufWrap = NET_LIST_USER_STRUCT (TxBuf, MNP_TX_BUF_WRAP, TxBuf);\r
  if (TxBufWrap->Signature != MNP_TX_BUF_WRAP_SIGNATURE) {\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "MnpFreeTxBuf: Signature check failed in MnpFreeTxBuf.\n")\r
      );\r
    return;\r
  }\r
\r
  if (!TxBufWrap->InUse) {\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "MnpFreeTxBuf: Duplicated recycle report from SNP.\n")\r
      );\r
    return;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
  InsertTailList (&MnpDeviceData->FreeTxBufList, &TxBufWrap->WrapEntry);\r
  TxBufWrap->InUse = FALSE;\r
  gBS->RestoreTPL (OldTpl);\r
}\r
\r
/**\r
  Try to recycle all the transmitted buffer address from SNP.\r
\r
  @param[in, out]  MnpDeviceData     Pointer to the mnp device context data.\r
\r
  @retval EFI_SUCCESS             Successed to recyclethe transmitted buffer address.\r
  @retval Others                  Failed to recyclethe transmitted buffer address.\r
\r
**/\r
EFI_STATUS\r
MnpRecycleTxBuf (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData\r
  )\r
{\r
  UINT8                         *TxBuf;\r
  EFI_SIMPLE_NETWORK_PROTOCOL   *Snp;\r
  EFI_STATUS                    Status;\r
\r
  Snp = MnpDeviceData->Snp;\r
  ASSERT (Snp != NULL);\r
\r
  do {\r
    TxBuf = NULL;\r
    Status = Snp->GetStatus (Snp, NULL, (VOID **) &TxBuf);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (TxBuf != NULL) {\r
      MnpFreeTxBuf (MnpDeviceData, TxBuf);\r
    }\r
  } while (TxBuf != NULL);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize the mnp device context data.\r
\r
  @param[in, out]  MnpDeviceData      Pointer to the mnp device context data.\r
  @param[in]       ImageHandle        The driver image handle.\r
  @param[in]       ControllerHandle   Handle of device to bind driver to.\r
\r
  @retval EFI_SUCCESS           The mnp service context is initialized.\r
  @retval EFI_UNSUPPORTED       ControllerHandle does not support Simple Network Protocol.\r
  @retval Others                Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpInitializeDeviceData (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN     EFI_HANDLE        ImageHandle,\r
  IN     EFI_HANDLE        ControllerHandle\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_SIMPLE_NETWORK_PROTOCOL *Snp;\r
  EFI_SIMPLE_NETWORK_MODE     *SnpMode;\r
\r
  MnpDeviceData->Signature        = MNP_DEVICE_DATA_SIGNATURE;\r
  MnpDeviceData->ImageHandle      = ImageHandle;\r
  MnpDeviceData->ControllerHandle = ControllerHandle;\r
\r
  //\r
  // Copy the MNP Protocol interfaces from the template.\r
  //\r
  CopyMem (&MnpDeviceData->VlanConfig, &mVlanConfigProtocolTemplate, sizeof (EFI_VLAN_CONFIG_PROTOCOL));\r
\r
  //\r
  // Open the Simple Network protocol.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiSimpleNetworkProtocolGuid,\r
                  (VOID **) &Snp,\r
                  ImageHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Get MTU from Snp.\r
  //\r
  SnpMode            = Snp->Mode;\r
  MnpDeviceData->Snp = Snp;\r
\r
  //\r
  // Initialize the lists.\r
  //\r
  InitializeListHead (&MnpDeviceData->ServiceList);\r
  InitializeListHead (&MnpDeviceData->GroupAddressList);\r
\r
  //\r
  // Get the buffer length used to allocate NET_BUF to hold data received\r
  // from SNP. Do this before fill the FreeNetBufQue.\r
  //\r
  //\r
  MnpDeviceData->BufferLength = SnpMode->MediaHeaderSize + NET_VLAN_TAG_LEN + SnpMode->MaxPacketSize + NET_ETHER_FCS_SIZE;\r
\r
  //\r
  // Make sure the protocol headers immediately following the media header\r
  // 4-byte aligned, and also preserve additional space for VLAN tag\r
  //\r
  MnpDeviceData->PaddingSize = ((4 - SnpMode->MediaHeaderSize) & 0x3) + NET_VLAN_TAG_LEN;\r
\r
  //\r
  // Initialize MAC string which will be used as VLAN configuration variable name\r
  //\r
  Status = NetLibGetMacString (ControllerHandle, ImageHandle, &MnpDeviceData->MacString);\r
  if (EFI_ERROR (Status)) {\r
    goto ERROR;\r
  }\r
\r
  //\r
  // Initialize the FreeNetBufQue and pre-allocate some NET_BUFs.\r
  //\r
  NetbufQueInit (&MnpDeviceData->FreeNbufQue);\r
  Status = MnpAddFreeNbuf (MnpDeviceData, MNP_INIT_NET_BUFFER_NUM);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "MnpInitializeDeviceData: MnpAddFreeNbuf failed, %r.\n", Status));\r
\r
    goto ERROR;\r
  }\r
\r
  //\r
  // Get one NET_BUF from the FreeNbufQue for rx cache.\r
  //\r
  MnpDeviceData->RxNbufCache = MnpAllocNbuf (MnpDeviceData);\r
  NetbufAllocSpace (\r
    MnpDeviceData->RxNbufCache,\r
    MnpDeviceData->BufferLength,\r
    NET_BUF_TAIL\r
    );\r
\r
  //\r
  // Allocate buffer pool for tx.\r
  //\r
  InitializeListHead (&MnpDeviceData->FreeTxBufList);\r
  InitializeListHead (&MnpDeviceData->AllTxBufList);\r
  MnpDeviceData->TxBufCount = 0;\r
\r
  //\r
  // Create the system poll timer.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL | EVT_TIMER,\r
                  TPL_CALLBACK,\r
                  MnpSystemPoll,\r
                  MnpDeviceData,\r
                  &MnpDeviceData->PollTimer\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "MnpInitializeDeviceData: CreateEvent for poll timer failed.\n"));\r
\r
    goto ERROR;\r
  }\r
\r
  //\r
  // Create the timer for packet timeout check.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL | EVT_TIMER,\r
                  TPL_CALLBACK,\r
                  MnpCheckPacketTimeout,\r
                  MnpDeviceData,\r
                  &MnpDeviceData->TimeoutCheckTimer\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "MnpInitializeDeviceData: CreateEvent for packet timeout check failed.\n"));\r
\r
    goto ERROR;\r
  }\r
\r
  //\r
  // Create the timer for media detection.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL | EVT_TIMER,\r
                  TPL_CALLBACK,\r
                  MnpCheckMediaStatus,\r
                  MnpDeviceData,\r
                  &MnpDeviceData->MediaDetectTimer\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "MnpInitializeDeviceData: CreateEvent for media detection failed.\n"));\r
\r
    goto ERROR;\r
  }\r
\r
ERROR:\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Free the dynamic allocated resources if necessary.\r
    //\r
    if (MnpDeviceData->MacString != NULL) {\r
      FreePool (MnpDeviceData->MacString);\r
    }\r
\r
    if (MnpDeviceData->TimeoutCheckTimer != NULL) {\r
      gBS->CloseEvent (MnpDeviceData->TimeoutCheckTimer);\r
    }\r
\r
    if (MnpDeviceData->MediaDetectTimer != NULL) {\r
      gBS->CloseEvent (MnpDeviceData->MediaDetectTimer);\r
    }\r
\r
    if (MnpDeviceData->PollTimer != NULL) {\r
      gBS->CloseEvent (MnpDeviceData->PollTimer);\r
    }\r
\r
    if (MnpDeviceData->RxNbufCache != NULL) {\r
      MnpFreeNbuf (MnpDeviceData, MnpDeviceData->RxNbufCache);\r
    }\r
\r
    if (MnpDeviceData->FreeNbufQue.BufNum != 0) {\r
      NetbufQueFlush (&MnpDeviceData->FreeNbufQue);\r
    }\r
\r
    //\r
    // Close the Simple Network Protocol.\r
    //\r
    gBS->CloseProtocol (\r
          ControllerHandle,\r
          &gEfiSimpleNetworkProtocolGuid,\r
          ImageHandle,\r
          ControllerHandle\r
          );\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Destroy the MNP device context data.\r
\r
  @param[in, out]  MnpDeviceData      Pointer to the mnp device context data.\r
  @param[in]       ImageHandle        The driver image handle.\r
\r
**/\r
VOID\r
MnpDestroyDeviceData (\r
  IN OUT MNP_DEVICE_DATA   *MnpDeviceData,\r
  IN     EFI_HANDLE        ImageHandle\r
  )\r
{\r
  LIST_ENTRY         *Entry;\r
  LIST_ENTRY         *NextEntry;\r
  MNP_TX_BUF_WRAP    *TxBufWrap;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  //\r
  // Free Vlan Config variable name string\r
  //\r
  if (MnpDeviceData->MacString != NULL) {\r
    FreePool (MnpDeviceData->MacString);\r
  }\r
\r
  //\r
  // The GroupAddressList must be empty.\r
  //\r
  ASSERT (IsListEmpty (&MnpDeviceData->GroupAddressList));\r
\r
  //\r
  // Close the event.\r
  //\r
  gBS->CloseEvent (MnpDeviceData->TimeoutCheckTimer);\r
  gBS->CloseEvent (MnpDeviceData->MediaDetectTimer);\r
  gBS->CloseEvent (MnpDeviceData->PollTimer);\r
\r
  //\r
  // Free the Tx buffer pool.\r
  //\r
  NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, &MnpDeviceData->AllTxBufList) {\r
    TxBufWrap = NET_LIST_USER_STRUCT (Entry, MNP_TX_BUF_WRAP, AllEntry);\r
    RemoveEntryList (Entry);\r
    FreePool (TxBufWrap);\r
    MnpDeviceData->TxBufCount--;\r
  }\r
  ASSERT (IsListEmpty (&MnpDeviceData->AllTxBufList));\r
  ASSERT (MnpDeviceData->TxBufCount == 0);\r
\r
  //\r
  // Free the RxNbufCache.\r
  //\r
  MnpFreeNbuf (MnpDeviceData, MnpDeviceData->RxNbufCache);\r
\r
  //\r
  // Flush the FreeNbufQue.\r
  //\r
  MnpDeviceData->NbufCnt -= MnpDeviceData->FreeNbufQue.BufNum;\r
  NetbufQueFlush (&MnpDeviceData->FreeNbufQue);\r
\r
  //\r
  // Close the Simple Network Protocol.\r
  //\r
  gBS->CloseProtocol (\r
         MnpDeviceData->ControllerHandle,\r
         &gEfiSimpleNetworkProtocolGuid,\r
         ImageHandle,\r
         MnpDeviceData->ControllerHandle\r
         );\r
}\r
\r
\r
/**\r
  Create mnp service context data.\r
\r
  @param[in]       MnpDeviceData      Pointer to the mnp device context data.\r
  @param[in]       VlanId             The VLAN ID.\r
  @param[in]       Priority           The VLAN priority. If VlanId is 0,\r
                                      Priority is ignored.\r
\r
  @return A pointer to MNP_SERVICE_DATA or NULL if failed to create MNP service context.\r
\r
**/\r
MNP_SERVICE_DATA *\r
MnpCreateServiceData (\r
  IN MNP_DEVICE_DATA     *MnpDeviceData,\r
  IN UINT16              VlanId,\r
  IN UINT8                Priority OPTIONAL\r
  )\r
{\r
  EFI_HANDLE                MnpServiceHandle;\r
  MNP_SERVICE_DATA          *MnpServiceData;\r
  EFI_STATUS                Status;\r
  EFI_SIMPLE_NETWORK_MODE   *SnpMode;\r
  EFI_VLAN_CONFIG_PROTOCOL  *VlanConfig;\r
\r
  //\r
  // Initialize the Mnp Service Data.\r
  //\r
  MnpServiceData = AllocateZeroPool (sizeof (MNP_SERVICE_DATA));\r
  if (MnpServiceData == NULL) {\r
    DEBUG ((EFI_D_ERROR, "MnpCreateServiceData: Faild to allocate memory for the new Mnp Service Data.\n"));\r
\r
    return NULL;\r
  }\r
\r
  //\r
  // Add to MNP service list\r
  //\r
  InsertTailList (&MnpDeviceData->ServiceList, &MnpServiceData->Link);\r
\r
  MnpServiceData->Signature     = MNP_SERVICE_DATA_SIGNATURE;\r
  MnpServiceData->MnpDeviceData = MnpDeviceData;\r
\r
  //\r
  // Copy the ServiceBinding structure.\r
  //\r
  CopyMem (&MnpServiceData->ServiceBinding, &mMnpServiceBindingProtocol, sizeof (EFI_SERVICE_BINDING_PROTOCOL));\r
\r
  //\r
  // Initialize the lists.\r
  //\r
  InitializeListHead (&MnpServiceData->ChildrenList);\r
\r
  SnpMode = MnpDeviceData->Snp->Mode;\r
  if (VlanId != 0) {\r
    //\r
    // Create VLAN child handle\r
    //\r
    MnpServiceHandle = MnpCreateVlanChild (\r
                         MnpDeviceData->ImageHandle,\r
                         MnpDeviceData->ControllerHandle,\r
                         VlanId,\r
                         &MnpServiceData->DevicePath\r
                         );\r
    if (MnpServiceHandle == NULL) {\r
      DEBUG ((EFI_D_ERROR, "MnpCreateServiceData: Faild to create child handle.\n"));\r
\r
      return NULL;\r
    }\r
\r
    //\r
    // Open VLAN Config Protocol by child\r
    //\r
    Status = gBS->OpenProtocol (\r
                    MnpDeviceData->ControllerHandle,\r
                    &gEfiVlanConfigProtocolGuid,\r
                    (VOID **) &VlanConfig,\r
                    MnpDeviceData->ImageHandle,\r
                    MnpServiceHandle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto Exit;\r
    }\r
\r
    //\r
    // Reduce MTU for VLAN device\r
    //\r
    MnpServiceData->Mtu = SnpMode->MaxPacketSize - NET_VLAN_TAG_LEN;\r
  } else {\r
    //\r
    // VlanId set to 0 means rx/tx untagged frame\r
    //\r
    MnpServiceHandle    = MnpDeviceData->ControllerHandle;\r
    MnpServiceData->Mtu = SnpMode->MaxPacketSize;\r
  }\r
\r
  MnpServiceData->ServiceHandle = MnpServiceHandle;\r
  MnpServiceData->VlanId        = VlanId;\r
  MnpServiceData->Priority      = Priority;\r
\r
  //\r
  // Install the MNP Service Binding Protocol\r
  //\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &MnpServiceHandle,\r
                  &gEfiManagedNetworkServiceBindingProtocolGuid,\r
                  &MnpServiceData->ServiceBinding,\r
                  NULL\r
                  );\r
\r
Exit:\r
  if (EFI_ERROR (Status)) {\r
    MnpDestroyServiceData (MnpServiceData);\r
    MnpServiceData = NULL;\r
  }\r
\r
  return MnpServiceData;\r
}\r
\r
/**\r
  Destroy the MNP service context data.\r
\r
  @param[in, out]  MnpServiceData    Pointer to the mnp service context data.\r
\r
  @retval EFI_SUCCESS           The mnp service context is destroyed.\r
  @retval Others                Errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpDestroyServiceData (\r
  IN OUT MNP_SERVICE_DATA    *MnpServiceData\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Uninstall the MNP Service Binding Protocol\r
  //\r
  Status = gBS->UninstallMultipleProtocolInterfaces (\r
                  MnpServiceData->ServiceHandle,\r
                  &gEfiManagedNetworkServiceBindingProtocolGuid,\r
                  &MnpServiceData->ServiceBinding,\r
                  NULL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (MnpServiceData->VlanId != 0) {\r
    //\r
    // Close VlanConfig Protocol opened by VLAN child handle\r
    //\r
    Status = gBS->CloseProtocol (\r
                    MnpServiceData->MnpDeviceData->ControllerHandle,\r
                    &gEfiVlanConfigProtocolGuid,\r
                    MnpServiceData->MnpDeviceData->ImageHandle,\r
                    MnpServiceData->ServiceHandle\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Uninstall Device Path Protocol to destroy the VLAN child handle\r
    //\r
    Status = gBS->UninstallMultipleProtocolInterfaces (\r
                    MnpServiceData->ServiceHandle,\r
                    &gEfiDevicePathProtocolGuid,\r
                    MnpServiceData->DevicePath,\r
                    NULL\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (MnpServiceData->DevicePath != NULL) {\r
      FreePool (MnpServiceData->DevicePath);\r
    }\r
  }\r
\r
  //\r
  // Remove from MnpDeviceData service list\r
  //\r
  RemoveEntryList (&MnpServiceData->Link);\r
\r
  FreePool (MnpServiceData);\r
\r
  return Status;\r
}\r
\r
/**\r
  Callback function which provided by user to remove one node in NetDestroyLinkList process.\r
\r
  @param[in]    Entry           The entry to be removed.\r
  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.\r
\r
  @retval EFI_SUCCESS           The entry has been removed successfully.\r
  @retval Others                Fail to remove the entry.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MnpDestoryChildEntry (\r
  IN LIST_ENTRY         *Entry,\r
  IN VOID               *Context\r
  )\r
{\r
  MNP_INSTANCE_DATA             *Instance;\r
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;\r
\r
  ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *) Context;\r
  Instance = CR (Entry, MNP_INSTANCE_DATA, InstEntry, MNP_INSTANCE_DATA_SIGNATURE);\r
  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);\r
}\r
\r
/**\r
  Destroy all child of the MNP service data.\r
\r
  @param[in, out]  MnpServiceData    Pointer to the mnp service context data.\r
\r
  @retval EFI_SUCCESS           All child are destroyed.\r
  @retval Others                Failed to destroy all child.\r
\r
**/\r
EFI_STATUS\r
MnpDestroyServiceChild (\r
  IN OUT MNP_SERVICE_DATA    *MnpServiceData\r
  )\r
{\r
  LIST_ENTRY                         *List;\r
  EFI_STATUS                         Status;\r
  UINTN                              ListLength;\r
\r
  List = &MnpServiceData->ChildrenList;\r
\r
  Status = NetDestroyLinkList (\r
             List,\r
             MnpDestoryChildEntry,\r
             &MnpServiceData->ServiceBinding,\r
             &ListLength\r
             );\r
  if (EFI_ERROR (Status) || ListLength != 0) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Find the MNP Service Data for given VLAN ID.\r
\r
  @param[in]  MnpDeviceData      Pointer to the mnp device context data.\r
  @param[in]  VlanId             The VLAN ID.\r
\r
  @return A pointer to MNP_SERVICE_DATA or NULL if not found.\r
\r
**/\r
MNP_SERVICE_DATA *\r
MnpFindServiceData (\r
  IN MNP_DEVICE_DATA     *MnpDeviceData,\r
  IN UINT16              VlanId\r
  )\r
{\r
  LIST_ENTRY        *Entry;\r
  MNP_SERVICE_DATA  *MnpServiceData;\r
\r
  NET_LIST_FOR_EACH (Entry, &MnpDeviceData->ServiceList) {\r
    //\r
    // Check VLAN ID of each Mnp Service Data\r
    //\r
    MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);\r
    if (MnpServiceData->VlanId == VlanId) {\r
      return MnpServiceData;\r
    }\r
  }\r
\r
  return NULL;\r
}\r
\r
/**\r
  Initialize the mnp instance context data.\r
\r
  @param[in]       MnpServiceData   Pointer to the mnp service context data.\r
  @param[in, out]  Instance         Pointer to the mnp instance context data\r
                                    to initialize.\r
\r
**/\r
VOID\r
MnpInitializeInstanceData (\r
  IN     MNP_SERVICE_DATA    *MnpServiceData,\r
  IN OUT MNP_INSTANCE_DATA   *Instance\r
  )\r
{\r
  NET_CHECK_SIGNATURE (MnpServiceData, MNP_SERVICE_DATA_SIGNATURE);\r
  ASSERT (Instance != NULL);\r
\r
  //\r
  // Set the signature.\r
  //\r
  Instance->Signature = MNP_INSTANCE_DATA_SIGNATURE;\r
\r
  //\r
  // Copy the MNP Protocol interfaces from the template.\r
  //\r
  CopyMem (&Instance->ManagedNetwork, &mMnpProtocolTemplate, sizeof (Instance->ManagedNetwork));\r
\r
  //\r
  // Copy the default config data.\r
  //\r
  CopyMem (&Instance->ConfigData, &mMnpDefaultConfigData, sizeof (Instance->ConfigData));\r
\r
  //\r
  // Initialize the lists.\r
  //\r
  InitializeListHead (&Instance->GroupCtrlBlkList);\r
  InitializeListHead (&Instance->RcvdPacketQueue);\r
  InitializeListHead (&Instance->RxDeliveredPacketQueue);\r
\r
  //\r
  // Initialize the RxToken Map.\r
  //\r
  NetMapInit (&Instance->RxTokenMap);\r
\r
  //\r
  // Save the MnpServiceData info.\r
  //\r
  Instance->MnpServiceData = MnpServiceData;\r
}\r
\r
\r
/**\r
  Check whether the token specified by Arg matches the token in Item.\r
\r
  @param[in]  Map               Pointer to the NET_MAP.\r
  @param[in]  Item              Pointer to the NET_MAP_ITEM.\r
  @param[in]  Arg               Pointer to the Arg, it's a pointer to the token to\r
                                check.\r
\r
  @retval EFI_SUCCESS           The token specified by Arg is different from the\r
                                token in Item.\r
  @retval EFI_ACCESS_DENIED     The token specified by Arg is the same as that in\r
                                Item.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MnpTokenExist (\r
  IN NET_MAP         *Map,\r
  IN NET_MAP_ITEM    *Item,\r
  IN VOID            *Arg\r
  )\r
{\r
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token;\r
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *TokenInItem;\r
\r
  Token       = (EFI_MANAGED_NETWORK_COMPLETION_TOKEN *) Arg;\r
  TokenInItem = (EFI_MANAGED_NETWORK_COMPLETION_TOKEN *) Item->Key;\r
\r
  if ((Token == TokenInItem) || (Token->Event == TokenInItem->Event)) {\r
    //\r
    // The token is the same either the two tokens equals or the Events in\r
    // the two tokens are the same.\r
    //\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Cancel the token specified by Arg if it matches the token in Item.\r
\r
  @param[in, out]  Map               Pointer to the NET_MAP.\r
  @param[in, out]  Item              Pointer to the NET_MAP_ITEM.\r
  @param[in]       Arg               Pointer to the Arg, it's a pointer to the\r
                                     token to cancel.\r
\r
  @retval EFI_SUCCESS       The Arg is NULL, and the token in Item is cancelled,\r
                            or the Arg isn't NULL, and the token in Item is\r
                            different from the Arg.\r
  @retval EFI_ABORTED       The Arg isn't NULL, the token in Item mathces the\r
                            Arg, and the token is cancelled.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MnpCancelTokens (\r
  IN OUT NET_MAP         *Map,\r
  IN OUT NET_MAP_ITEM    *Item,\r
  IN     VOID            *Arg\r
  )\r
{\r
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *TokenToCancel;\r
\r
  if ((Arg != NULL) && (Item->Key != Arg)) {\r
    //\r
    // The token in Item is not the token specified by Arg.\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  TokenToCancel = (EFI_MANAGED_NETWORK_COMPLETION_TOKEN *) Item->Key;\r
\r
  //\r
  // Remove the item from the map.\r
  //\r
  NetMapRemoveItem (Map, Item, NULL);\r
\r
  //\r
  // Cancel this token with status set to EFI_ABORTED.\r
  //\r
  TokenToCancel->Status = EFI_ABORTED;\r
  gBS->SignalEvent (TokenToCancel->Event);\r
\r
  if (Arg != NULL) {\r
    //\r
    // Only abort the token specified by Arg if Arg isn't NULL.\r
    //\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Start and initialize the simple network.\r
\r
  @param[in]  Snp               Pointer to the simple network protocol.\r
\r
  @retval EFI_SUCCESS           The simple network protocol is started.\r
  @retval Others                Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpStartSnp (\r
  IN EFI_SIMPLE_NETWORK_PROTOCOL     *Snp\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  ASSERT (Snp != NULL);\r
\r
  //\r
  // Start the simple network.\r
  //\r
  Status = Snp->Start (Snp);\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Initialize the simple network.\r
    //\r
    Status = Snp->Initialize (Snp, 0, 0);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Stop the simple network.\r
\r
  @param[in]  MnpDeviceData     Pointer to the MNP_DEVICE_DATA.\r
\r
  @retval EFI_SUCCESS           The simple network is stopped.\r
  @retval Others                Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpStopSnp (\r
  IN  MNP_DEVICE_DATA   *MnpDeviceData\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;\r
\r
  Snp = MnpDeviceData->Snp;\r
  ASSERT (Snp != NULL);\r
\r
  //\r
  // Recycle all the transmit buffer from SNP.\r
  //\r
  Status = MnpRecycleTxBuf (MnpDeviceData);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Shut down the simple network.\r
  //\r
  Status  = Snp->Shutdown (Snp);\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Stop the simple network.\r
    //\r
    Status = Snp->Stop (Snp);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Start the managed network, this function is called when one instance is configured\r
  or reconfigured.\r
\r
  @param[in, out]  MnpServiceData       Pointer to the mnp service context data.\r
  @param[in]       IsConfigUpdate       The instance is reconfigured or it's the first\r
                                        time the instanced is configured.\r
  @param[in]       EnableSystemPoll     Enable the system polling or not.\r
\r
  @retval EFI_SUCCESS                   The managed network is started and some\r
                                        configuration is updated.\r
  @retval Others                        Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpStart (\r
  IN OUT MNP_SERVICE_DATA    *MnpServiceData,\r
  IN     BOOLEAN             IsConfigUpdate,\r
  IN     BOOLEAN             EnableSystemPoll\r
  )\r
{\r
  EFI_STATUS      Status;\r
  EFI_TIMER_DELAY TimerOpType;\r
  MNP_DEVICE_DATA *MnpDeviceData;\r
\r
  NET_CHECK_SIGNATURE (MnpServiceData, MNP_SERVICE_DATA_SIGNATURE);\r
\r
  Status        = EFI_SUCCESS;\r
  MnpDeviceData = MnpServiceData->MnpDeviceData;\r
\r
  if (!IsConfigUpdate) {\r
    //\r
    // If it's not a configuration update, increase the configured children number.\r
    //\r
    MnpDeviceData->ConfiguredChildrenNumber++;\r
\r
    if (MnpDeviceData->ConfiguredChildrenNumber == 1) {\r
      //\r
      // It's the first configured child, start the simple network.\r
      //\r
      Status = MnpStartSnp (MnpDeviceData->Snp);\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "MnpStart: MnpStartSnp failed, %r.\n", Status));\r
\r
        goto ErrorExit;\r
      }\r
\r
      //\r
      // Start the timeout timer.\r
      //\r
      Status = gBS->SetTimer (\r
                      MnpDeviceData->TimeoutCheckTimer,\r
                      TimerPeriodic,\r
                      MNP_TIMEOUT_CHECK_INTERVAL\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        DEBUG (\r
          (EFI_D_ERROR,\r
          "MnpStart, gBS->SetTimer for TimeoutCheckTimer %r.\n",\r
          Status)\r
          );\r
\r
        goto ErrorExit;\r
      }\r
\r
      //\r
      // Start the media detection timer.\r
      //\r
      Status = gBS->SetTimer (\r
                      MnpDeviceData->MediaDetectTimer,\r
                      TimerPeriodic,\r
                      MNP_MEDIA_DETECT_INTERVAL\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        DEBUG (\r
          (EFI_D_ERROR,\r
          "MnpStart, gBS->SetTimer for MediaDetectTimer %r.\n",\r
          Status)\r
          );\r
\r
        goto ErrorExit;\r
      }\r
    }\r
  }\r
\r
  if (MnpDeviceData->EnableSystemPoll ^ EnableSystemPoll) {\r
    //\r
    // The EnableSystemPoll differs with the current state, disable or enable\r
    // the system poll.\r
    //\r
    TimerOpType = EnableSystemPoll ? TimerPeriodic : TimerCancel;\r
\r
    Status      = gBS->SetTimer (MnpDeviceData->PollTimer, TimerOpType, MNP_SYS_POLL_INTERVAL);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_ERROR, "MnpStart: gBS->SetTimer for PollTimer failed, %r.\n", Status));\r
\r
      goto ErrorExit;\r
    }\r
\r
    MnpDeviceData->EnableSystemPoll = EnableSystemPoll;\r
  }\r
\r
  //\r
  // Change the receive filters if need.\r
  //\r
  Status = MnpConfigReceiveFilters (MnpDeviceData);\r
\r
ErrorExit:\r
  return Status;\r
}\r
\r
\r
/**\r
  Stop the managed network.\r
\r
  @param[in, out]  MnpServiceData    Pointer to the mnp service context data.\r
\r
  @retval EFI_SUCCESS                The managed network is stopped.\r
  @retval Others                     Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpStop (\r
  IN OUT MNP_SERVICE_DATA    *MnpServiceData\r
  )\r
{\r
  EFI_STATUS      Status;\r
  MNP_DEVICE_DATA *MnpDeviceData;\r
\r
  NET_CHECK_SIGNATURE (MnpServiceData, MNP_SERVICE_DATA_SIGNATURE);\r
  MnpDeviceData = MnpServiceData->MnpDeviceData;\r
  ASSERT (MnpDeviceData->ConfiguredChildrenNumber > 0);\r
\r
  //\r
  // Configure the receive filters.\r
  //\r
  MnpConfigReceiveFilters (MnpDeviceData);\r
\r
  //\r
  // Decrease the children number.\r
  //\r
  MnpDeviceData->ConfiguredChildrenNumber--;\r
\r
  if (MnpDeviceData->ConfiguredChildrenNumber > 0) {\r
    //\r
    // If there are other configured chilren, return and keep the timers and\r
    // simple network unchanged.\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // No configured children now.\r
  //\r
  if (MnpDeviceData->EnableSystemPoll) {\r
    //\r
    //  The system poll in on, cancel the poll timer.\r
    //\r
    Status  = gBS->SetTimer (MnpDeviceData->PollTimer, TimerCancel, 0);\r
    MnpDeviceData->EnableSystemPoll = FALSE;\r
  }\r
\r
  //\r
  // Cancel the timeout timer.\r
  //\r
  Status = gBS->SetTimer (MnpDeviceData->TimeoutCheckTimer, TimerCancel, 0);\r
\r
  //\r
  // Cancel the media detect timer.\r
  //\r
  Status = gBS->SetTimer (MnpDeviceData->MediaDetectTimer, TimerCancel, 0);\r
\r
  //\r
  // Stop the simple network.\r
  //\r
  Status = MnpStopSnp (MnpDeviceData);\r
  return Status;\r
}\r
\r
\r
/**\r
  Flush the instance's received data.\r
\r
  @param[in, out]  Instance              Pointer to the mnp instance context data.\r
\r
**/\r
VOID\r
MnpFlushRcvdDataQueue (\r
  IN OUT MNP_INSTANCE_DATA   *Instance\r
  )\r
{\r
  EFI_TPL         OldTpl;\r
  MNP_RXDATA_WRAP *RxDataWrap;\r
\r
  NET_CHECK_SIGNATURE (Instance, MNP_INSTANCE_DATA_SIGNATURE);\r
\r
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
\r
  while (!IsListEmpty (&Instance->RcvdPacketQueue)) {\r
    //\r
    // Remove all the Wraps.\r
    //\r
    RxDataWrap = NET_LIST_HEAD (&Instance->RcvdPacketQueue, MNP_RXDATA_WRAP, WrapEntry);\r
\r
    //\r
    // Recycle the RxDataWrap.\r
    //\r
    MnpRecycleRxData (NULL, (VOID *) RxDataWrap);\r
    Instance->RcvdPacketQueueSize--;\r
  }\r
\r
  ASSERT (Instance->RcvdPacketQueueSize == 0);\r
\r
  gBS->RestoreTPL (OldTpl);\r
}\r
\r
\r
/**\r
  Configure the Instance using ConfigData.\r
\r
  @param[in, out]  Instance     Pointer to the mnp instance context data.\r
  @param[in]       ConfigData   Pointer to the configuration data used to configure\r
                                the isntance.\r
\r
  @retval EFI_SUCCESS           The Instance is configured.\r
  @retval EFI_UNSUPPORTED       EnableReceiveTimestamps is on and the\r
                                implementation doesn't support it.\r
  @retval Others                Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpConfigureInstance (\r
  IN OUT MNP_INSTANCE_DATA                 *Instance,\r
  IN     EFI_MANAGED_NETWORK_CONFIG_DATA   *ConfigData OPTIONAL\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  MNP_SERVICE_DATA                *MnpServiceData;\r
  MNP_DEVICE_DATA                 *MnpDeviceData;\r
  EFI_MANAGED_NETWORK_CONFIG_DATA *OldConfigData;\r
  EFI_MANAGED_NETWORK_CONFIG_DATA *NewConfigData;\r
  BOOLEAN                         IsConfigUpdate;\r
\r
  NET_CHECK_SIGNATURE (Instance, MNP_INSTANCE_DATA_SIGNATURE);\r
\r
  if ((ConfigData != NULL) && ConfigData->EnableReceiveTimestamps) {\r
    //\r
    // Don't support timestamp.\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Status          = EFI_SUCCESS;\r
\r
  MnpServiceData  = Instance->MnpServiceData;\r
  MnpDeviceData   = MnpServiceData->MnpDeviceData;\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  IsConfigUpdate  = (BOOLEAN) ((Instance->Configured) && (ConfigData != NULL));\r
\r
  OldConfigData   = &Instance->ConfigData;\r
  NewConfigData   = ConfigData;\r
  if (NewConfigData == NULL) {\r
    //\r
    // Restore back the default config data if a reset of this instance\r
    // is required.\r
    //\r
    NewConfigData = &mMnpDefaultConfigData;\r
  }\r
\r
  //\r
  // Reset the instance's receive filter.\r
  //\r
  Instance->ReceiveFilter = 0;\r
\r
  //\r
  // Clear the receive counters according to the old ConfigData.\r
  //\r
  if (OldConfigData->EnableUnicastReceive) {\r
    MnpDeviceData->UnicastCount--;\r
  }\r
\r
  if (OldConfigData->EnableMulticastReceive) {\r
    MnpDeviceData->MulticastCount--;\r
  }\r
\r
  if (OldConfigData->EnableBroadcastReceive) {\r
    MnpDeviceData->BroadcastCount--;\r
  }\r
\r
  if (OldConfigData->EnablePromiscuousReceive) {\r
    MnpDeviceData->PromiscuousCount--;\r
  }\r
\r
  //\r
  // Set the receive filter counters and the receive filter of the\r
  // instance according to the new ConfigData.\r
  //\r
  if (NewConfigData->EnableUnicastReceive) {\r
    MnpDeviceData->UnicastCount++;\r
    Instance->ReceiveFilter |= MNP_RECEIVE_UNICAST;\r
  }\r
\r
  if (NewConfigData->EnableMulticastReceive) {\r
    MnpDeviceData->MulticastCount++;\r
  }\r
\r
  if (NewConfigData->EnableBroadcastReceive) {\r
    MnpDeviceData->BroadcastCount++;\r
    Instance->ReceiveFilter |= MNP_RECEIVE_BROADCAST;\r
  }\r
\r
  if (NewConfigData->EnablePromiscuousReceive) {\r
    MnpDeviceData->PromiscuousCount++;\r
  }\r
\r
  if (OldConfigData->FlushQueuesOnReset) {\r
    MnpFlushRcvdDataQueue (Instance);\r
  }\r
\r
  if (ConfigData == NULL) {\r
    Instance->ManagedNetwork.Cancel (&Instance->ManagedNetwork, NULL);\r
  }\r
\r
  if (!NewConfigData->EnableMulticastReceive) {\r
    MnpGroupOp (Instance, FALSE, NULL, NULL);\r
  }\r
\r
  //\r
  // Save the new configuration data.\r
  //\r
  CopyMem (OldConfigData, NewConfigData, sizeof (*OldConfigData));\r
\r
  Instance->Configured = (BOOLEAN) (ConfigData != NULL);\r
  if (Instance->Configured) {\r
    //\r
    // The instance is configured, start the Mnp.\r
    //\r
    Status = MnpStart (\r
              MnpServiceData,\r
              IsConfigUpdate,\r
              (BOOLEAN) !NewConfigData->DisableBackgroundPolling\r
              );\r
  } else {\r
    //\r
    // The instance is changed to the unconfigured state, stop the Mnp.\r
    //\r
    Status = MnpStop (MnpServiceData);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Configure the Snp receive filters according to the instances' receive filter\r
  settings.\r
\r
  @param[in]  MnpDeviceData         Pointer to the mnp device context data.\r
\r
  @retval     EFI_SUCCESS           The receive filters is configured.\r
  @retval     EFI_OUT_OF_RESOURCES  The receive filters can't be configured due\r
                                    to lack of memory resource.\r
\r
**/\r
EFI_STATUS\r
MnpConfigReceiveFilters (\r
  IN MNP_DEVICE_DATA     *MnpDeviceData\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_SIMPLE_NETWORK_PROTOCOL *Snp;\r
  EFI_MAC_ADDRESS             *MCastFilter;\r
  UINT32                      MCastFilterCnt;\r
  UINT32                      EnableFilterBits;\r
  UINT32                      DisableFilterBits;\r
  BOOLEAN                     ResetMCastFilters;\r
  LIST_ENTRY                  *Entry;\r
  UINT32                      Index;\r
  MNP_GROUP_ADDRESS           *GroupAddress;\r
\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  Snp = MnpDeviceData->Snp;\r
\r
  //\r
  // Initialize the enable filter and disable filter.\r
  //\r
  EnableFilterBits  = 0;\r
  DisableFilterBits = Snp->Mode->ReceiveFilterMask;\r
\r
  if (MnpDeviceData->UnicastCount != 0) {\r
    //\r
    // Enable unicast if any instance wants to receive unicast.\r
    //\r
    EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;\r
  }\r
\r
  if (MnpDeviceData->BroadcastCount != 0) {\r
    //\r
    // Enable broadcast if any instance wants to receive broadcast.\r
    //\r
    EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;\r
  }\r
\r
  MCastFilter       = NULL;\r
  MCastFilterCnt    = 0;\r
  ResetMCastFilters = TRUE;\r
\r
  if ((MnpDeviceData->MulticastCount != 0) && (MnpDeviceData->GroupAddressCount != 0)) {\r
    //\r
    // There are instances configured to receive multicast and already some group\r
    // addresses are joined.\r
    //\r
\r
    ResetMCastFilters = FALSE;\r
\r
    if (MnpDeviceData->GroupAddressCount <= Snp->Mode->MaxMCastFilterCount) {\r
      //\r
      // The joind group address is less than simple network's maximum count.\r
      // Just configure the snp to do the multicast filtering.\r
      //\r
\r
      EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST;\r
\r
      //\r
      // Allocate pool for the mulicast addresses.\r
      //\r
      MCastFilterCnt  = MnpDeviceData->GroupAddressCount;\r
      MCastFilter     = AllocatePool (sizeof (EFI_MAC_ADDRESS) * MCastFilterCnt);\r
      if (MCastFilter == NULL) {\r
        DEBUG ((EFI_D_ERROR, "MnpConfigReceiveFilters: Failed to allocate memory resource for MCastFilter.\n"));\r
\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      //\r
      // Fill the multicast HW address buffer.\r
      //\r
      Index = 0;\r
      NET_LIST_FOR_EACH (Entry, &MnpDeviceData->GroupAddressList) {\r
\r
        GroupAddress = NET_LIST_USER_STRUCT (Entry, MNP_GROUP_ADDRESS, AddrEntry);\r
        CopyMem (MCastFilter + Index, &GroupAddress->Address, sizeof (*(MCastFilter + Index)));\r
        Index++;\r
\r
        ASSERT (Index <= MCastFilterCnt);\r
      }\r
    } else {\r
      //\r
      // The maximum multicast is reached, set the filter to be promiscuous\r
      // multicast.\r
      //\r
\r
      if ((Snp->Mode->ReceiveFilterMask & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {\r
        EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;\r
      } else {\r
        //\r
        // Either MULTICAST or PROMISCUOUS_MULTICAST is not supported by Snp,\r
        // set the NIC to be promiscuous although this will tremendously degrade\r
        // the performance.\r
        //\r
        EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;\r
      }\r
    }\r
  }\r
\r
  if (MnpDeviceData->PromiscuousCount != 0) {\r
    //\r
    // Enable promiscuous if any instance wants to receive promiscuous.\r
    //\r
    EnableFilterBits |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;\r
  }\r
\r
  //\r
  // Set the disable filter.\r
  //\r
  DisableFilterBits ^= EnableFilterBits;\r
\r
  //\r
  // Configure the receive filters of SNP.\r
  //\r
  Status = Snp->ReceiveFilters (\r
                  Snp,\r
                  EnableFilterBits,\r
                  DisableFilterBits,\r
                  ResetMCastFilters,\r
                  MCastFilterCnt,\r
                  MCastFilter\r
                  );\r
  DEBUG_CODE (\r
    if (EFI_ERROR (Status)) {\r
      DEBUG (\r
        (EFI_D_ERROR,\r
        "MnpConfigReceiveFilters: Snp->ReceiveFilters failed, %r.\n",\r
        Status)\r
        );\r
    }\r
  );\r
\r
  if (MCastFilter != NULL) {\r
    //\r
    // Free the buffer used to hold the group addresses.\r
    //\r
    FreePool (MCastFilter);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Add a group address control block which controls the MacAddress for\r
  this instance.\r
\r
  @param[in, out]  Instance        Pointer to the mnp instance context data.\r
  @param[in, out]  CtrlBlk         Pointer to the group address control block.\r
  @param[in, out]  GroupAddress    Pointer to the group adress.\r
  @param[in]       MacAddress      Pointer to the mac address.\r
  @param[in]       HwAddressSize   The hardware address size.\r
\r
  @retval EFI_SUCCESS              The group address control block is added.\r
  @retval EFI_OUT_OF_RESOURCES     Failed due to lack of memory resources.\r
\r
**/\r
EFI_STATUS\r
MnpGroupOpAddCtrlBlk (\r
  IN OUT MNP_INSTANCE_DATA         *Instance,\r
  IN OUT MNP_GROUP_CONTROL_BLOCK   *CtrlBlk,\r
  IN OUT MNP_GROUP_ADDRESS         *GroupAddress OPTIONAL,\r
  IN     EFI_MAC_ADDRESS           *MacAddress,\r
  IN     UINT32                    HwAddressSize\r
  )\r
{\r
  MNP_DEVICE_DATA  *MnpDeviceData;\r
\r
  NET_CHECK_SIGNATURE (Instance, MNP_INSTANCE_DATA_SIGNATURE);\r
\r
  MnpDeviceData = Instance->MnpServiceData->MnpDeviceData;\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  if (GroupAddress == NULL) {\r
    ASSERT (MacAddress != NULL);\r
\r
    //\r
    // Allocate a new GroupAddress to be added into MNP's GroupAddressList.\r
    //\r
    GroupAddress = AllocatePool (sizeof (MNP_GROUP_ADDRESS));\r
    if (GroupAddress == NULL) {\r
\r
      DEBUG ((EFI_D_ERROR, "MnpGroupOpFormCtrlBlk: Failed to allocate memory resource.\n"));\r
\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    CopyMem (&GroupAddress->Address, MacAddress, sizeof (GroupAddress->Address));\r
    GroupAddress->RefCnt = 0;\r
    InsertTailList (\r
      &MnpDeviceData->GroupAddressList,\r
      &GroupAddress->AddrEntry\r
      );\r
    MnpDeviceData->GroupAddressCount++;\r
  }\r
\r
  //\r
  // Increase the RefCnt.\r
  //\r
  GroupAddress->RefCnt++;\r
\r
  //\r
  // Add the CtrlBlk into the instance's GroupCtrlBlkList.\r
  //\r
  CtrlBlk->GroupAddress = GroupAddress;\r
  InsertTailList (&Instance->GroupCtrlBlkList, &CtrlBlk->CtrlBlkEntry);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Delete a group control block from the instance. If the controlled group address's\r
  reference count reaches zero, the group address is removed too.\r
\r
  @param[in]  Instance              Pointer to the instance context data.\r
  @param[in]  CtrlBlk               Pointer to the group control block to delete.\r
\r
  @return The group address controlled by the control block is no longer used or not.\r
\r
**/\r
BOOLEAN\r
MnpGroupOpDelCtrlBlk (\r
  IN MNP_INSTANCE_DATA           *Instance,\r
  IN MNP_GROUP_CONTROL_BLOCK     *CtrlBlk\r
  )\r
{\r
  MNP_DEVICE_DATA   *MnpDeviceData;\r
  MNP_GROUP_ADDRESS *GroupAddress;\r
\r
  NET_CHECK_SIGNATURE (Instance, MNP_INSTANCE_DATA_SIGNATURE);\r
\r
  MnpDeviceData = Instance->MnpServiceData->MnpDeviceData;\r
  NET_CHECK_SIGNATURE (MnpDeviceData, MNP_DEVICE_DATA_SIGNATURE);\r
\r
  //\r
  // Remove and free the CtrlBlk.\r
  //\r
  GroupAddress = CtrlBlk->GroupAddress;\r
  RemoveEntryList (&CtrlBlk->CtrlBlkEntry);\r
  FreePool (CtrlBlk);\r
\r
  ASSERT (GroupAddress->RefCnt > 0);\r
\r
  //\r
  // Count down the RefCnt.\r
  //\r
  GroupAddress->RefCnt--;\r
\r
  if (GroupAddress->RefCnt == 0) {\r
    //\r
    // Free this GroupAddress entry if no instance uses it.\r
    //\r
    MnpDeviceData->GroupAddressCount--;\r
    RemoveEntryList (&GroupAddress->AddrEntry);\r
    FreePool (GroupAddress);\r
\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
\r
/**\r
  Do the group operations for this instance.\r
\r
  @param[in, out]  Instance        Pointer to the instance context data.\r
  @param[in]       JoinFlag        Set to TRUE to join a group. Set to TRUE to\r
                                   leave a group/groups.\r
  @param[in]       MacAddress      Pointer to the group address to join or leave.\r
  @param[in]       CtrlBlk         Pointer to the group control block if JoinFlag\r
                                   is FALSE.\r
\r
  @retval EFI_SUCCESS              The group operation finished.\r
  @retval EFI_OUT_OF_RESOURCES     Failed due to lack of memory resources.\r
  @retval Others                   Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
MnpGroupOp (\r
  IN OUT MNP_INSTANCE_DATA         *Instance,\r
  IN     BOOLEAN                   JoinFlag,\r
  IN     EFI_MAC_ADDRESS           *MacAddress OPTIONAL,\r
  IN     MNP_GROUP_CONTROL_BLOCK   *CtrlBlk OPTIONAL\r
  )\r
{\r
  MNP_DEVICE_DATA         *MnpDeviceData;\r
  LIST_ENTRY              *Entry;\r
  LIST_ENTRY              *NextEntry;\r
  MNP_GROUP_ADDRESS       *GroupAddress;\r
  EFI_SIMPLE_NETWORK_MODE *SnpMode;\r
  MNP_GROUP_CONTROL_BLOCK *NewCtrlBlk;\r
  EFI_STATUS              Status;\r
  BOOLEAN                 AddressExist;\r
  BOOLEAN                 NeedUpdate;\r
\r
  NET_CHECK_SIGNATURE (Instance, MNP_INSTANCE_DATA_SIGNATURE);\r
\r
  MnpDeviceData = Instance->MnpServiceData->MnpDeviceData;\r
  SnpMode       = MnpDeviceData->Snp->Mode;\r
\r
  if (JoinFlag) {\r
    //\r
    // A new gropu address is to be added.\r
    //\r
    GroupAddress  = NULL;\r
    AddressExist  = FALSE;\r
\r
    //\r
    // Allocate memory for the control block.\r
    //\r
    NewCtrlBlk = AllocatePool (sizeof (MNP_GROUP_CONTROL_BLOCK));\r
    if (NewCtrlBlk == NULL) {\r
      DEBUG ((EFI_D_ERROR, "MnpGroupOp: Failed to allocate memory resource.\n"));\r
\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    NET_LIST_FOR_EACH (Entry, &MnpDeviceData->GroupAddressList) {\r
      //\r
      // Check whether the MacAddress is already joined by other instances.\r
      //\r
      GroupAddress = NET_LIST_USER_STRUCT (Entry, MNP_GROUP_ADDRESS, AddrEntry);\r
      if (CompareMem (MacAddress, &GroupAddress->Address, SnpMode->HwAddressSize) == 0) {\r
        AddressExist = TRUE;\r
        break;\r
      }\r
    }\r
\r
    if (!AddressExist) {\r
      GroupAddress = NULL;\r
    }\r
\r
    //\r
    // Add the GroupAddress for this instance.\r
    //\r
    Status = MnpGroupOpAddCtrlBlk (\r
              Instance,\r
              NewCtrlBlk,\r
              GroupAddress,\r
              MacAddress,\r
              SnpMode->HwAddressSize\r
              );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    NeedUpdate = TRUE;\r
  } else {\r
    if (MacAddress != NULL) {\r
      ASSERT (CtrlBlk != NULL);\r
\r
      //\r
      // Leave the specific multicast mac address.\r
      //\r
      NeedUpdate = MnpGroupOpDelCtrlBlk (Instance, CtrlBlk);\r
    } else {\r
      //\r
      // Leave all multicast mac addresses.\r
      //\r
      NeedUpdate = FALSE;\r
\r
      NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Instance->GroupCtrlBlkList) {\r
\r
        NewCtrlBlk = NET_LIST_USER_STRUCT (\r
                      Entry,\r
                      MNP_GROUP_CONTROL_BLOCK,\r
                      CtrlBlkEntry\r
                      );\r
        //\r
        // Update is required if the group address left is no longer used\r
        // by other instances.\r
        //\r
        NeedUpdate = MnpGroupOpDelCtrlBlk (Instance, NewCtrlBlk);\r
      }\r
    }\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (NeedUpdate) {\r
    //\r
    // Reconfigure the receive filters if necessary.\r
    //\r
    Status = MnpConfigReceiveFilters (MnpDeviceData);\r
  }\r
\r
  return Status;\r
}\r