MnpMain.c

Go to the documentation of this file.

 
#include "MnpImpl.h"
 
EFI_STATUS
EFIAPI
MnpGetModeData (
  IN     EFI_MANAGED_NETWORK_PROTOCOL  *This,
  OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData OPTIONAL,
  OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData OPTIONAL
  )
{
  MNP_INSTANCE_DATA            *Instance;
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  EFI_TPL                      OldTpl;
  EFI_STATUS                   Status;
  UINT32                       InterruptStatus;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (MnpConfigData != NULL) {
    //
    // Copy the instance configuration data.
    //
    CopyMem (MnpConfigData, &Instance->ConfigData, sizeof (*MnpConfigData));
  }
 
  if (SnpModeData != NULL) {
    //
    // Copy the underlayer Snp mode data.
    //
    Snp = Instance->MnpServiceData->MnpDeviceData->Snp;
 
    //
    // Upon successful return of GetStatus(), the Snp->Mode->MediaPresent
    // will be updated to reflect any change of media status
    //
    Snp->GetStatus (Snp, &InterruptStatus, NULL);
    CopyMem (SnpModeData, Snp->Mode, sizeof (*SnpModeData));
  }
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
  } else {
    Status = EFI_SUCCESS;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpConfigure (
  IN EFI_MANAGED_NETWORK_PROTOCOL     *This,
  IN EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData OPTIONAL
  )
{
  MNP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
  EFI_STATUS         Status;
 
  if ((This == NULL) ||
      ((MnpConfigData != NULL) &&
       (MnpConfigData->ProtocolTypeFilter > 0) &&
       (MnpConfigData->ProtocolTypeFilter <= 1500))
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if ((MnpConfigData == NULL) && (!Instance->Configured)) {
    //
    // If the instance is not configured and a reset is requested, just return.
    //
    Status = EFI_SUCCESS;
    goto ON_EXIT;
  }
 
  //
  // Configure the instance.
  //
  Status = MnpConfigureInstance (Instance, MnpConfigData);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpMcastIpToMac (
  IN     EFI_MANAGED_NETWORK_PROTOCOL  *This,
  IN     BOOLEAN                       Ipv6Flag,
  IN     EFI_IP_ADDRESS                *IpAddress,
  OUT EFI_MAC_ADDRESS                  *MacAddress
  )
{
  EFI_STATUS                   Status;
  MNP_INSTANCE_DATA            *Instance;
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  EFI_TPL                      OldTpl;
  EFI_IPv6_ADDRESS             *Ip6Address;
 
  if ((This == NULL) || (IpAddress == NULL) || (MacAddress == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Ip6Address = &IpAddress->v6;
 
  if ((Ipv6Flag && !IP6_IS_MULTICAST (Ip6Address)) ||
      (!Ipv6Flag && !IP4_IS_MULTICAST (EFI_NTOHL (*IpAddress)))
      )
  {
    //
    // The IP address passed in is not a multicast address.
    //
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  Snp = Instance->MnpServiceData->MnpDeviceData->Snp;
  ASSERT (Snp != NULL);
 
  ZeroMem (MacAddress, sizeof (EFI_MAC_ADDRESS));
 
  if (Snp->Mode->IfType == NET_IFTYPE_ETHERNET) {
    if (!Ipv6Flag) {
      //
      // Translate the IPv4 address into a multicast MAC address if the NIC is an
      // ethernet NIC according to RFC1112..
      //
      MacAddress->Addr[0] = 0x01;
      MacAddress->Addr[1] = 0x00;
      MacAddress->Addr[2] = 0x5E;
      MacAddress->Addr[3] = (UINT8)(IpAddress->v4.Addr[1] & 0x7F);
      MacAddress->Addr[4] = IpAddress->v4.Addr[2];
      MacAddress->Addr[5] = IpAddress->v4.Addr[3];
    } else {
      //
      // Translate the IPv6 address into a multicast MAC address if the NIC is an
      // ethernet NIC according to RFC2464.
      //
 
      MacAddress->Addr[0] = 0x33;
      MacAddress->Addr[1] = 0x33;
      MacAddress->Addr[2] = Ip6Address->Addr[12];
      MacAddress->Addr[3] = Ip6Address->Addr[13];
      MacAddress->Addr[4] = Ip6Address->Addr[14];
      MacAddress->Addr[5] = Ip6Address->Addr[15];
    }
 
    Status = EFI_SUCCESS;
  } else {
    //
    // Invoke Snp to translate the multicast IP address.
    //
    Status = Snp->MCastIpToMac (
                    Snp,
                    Ipv6Flag,
                    IpAddress,
                    MacAddress
                    );
  }
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpGroups (
  IN EFI_MANAGED_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                       JoinFlag,
  IN EFI_MAC_ADDRESS               *MacAddress OPTIONAL
  )
{
  MNP_INSTANCE_DATA        *Instance;
  EFI_SIMPLE_NETWORK_MODE  *SnpMode;
  MNP_GROUP_CONTROL_BLOCK  *GroupCtrlBlk;
  MNP_GROUP_ADDRESS        *GroupAddress;
  LIST_ENTRY               *ListEntry;
  BOOLEAN                  AddressExist;
  EFI_TPL                  OldTpl;
  EFI_STATUS               Status;
 
  if ((This == NULL) || (JoinFlag && (MacAddress == NULL))) {
    //
    // This is NULL, or it's a join operation but MacAddress is NULL.
    //
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
  SnpMode  = Instance->MnpServiceData->MnpDeviceData->Snp->Mode;
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  if ((!Instance->ConfigData.EnableMulticastReceive) ||
      ((MacAddress != NULL) && !NET_MAC_IS_MULTICAST (MacAddress, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize)))
  {
    //
    // The instance isn't configured to do multicast receive. OR
    // the passed in MacAddress is not a multicast mac address.
    //
    Status = EFI_INVALID_PARAMETER;
    goto ON_EXIT;
  }
 
  Status       = EFI_SUCCESS;
  AddressExist = FALSE;
  GroupCtrlBlk = NULL;
 
  if (MacAddress != NULL) {
    //
    // Search the instance's GroupCtrlBlkList to find the specific address.
    //
    NET_LIST_FOR_EACH (ListEntry, &Instance->GroupCtrlBlkList) {
      GroupCtrlBlk = NET_LIST_USER_STRUCT (
                       ListEntry,
                       MNP_GROUP_CONTROL_BLOCK,
                       CtrlBlkEntry
                       );
      GroupAddress = GroupCtrlBlk->GroupAddress;
      if (0 == CompareMem (
                 MacAddress,
                 &GroupAddress->Address,
                 SnpMode->HwAddressSize
                 ))
      {
        //
        // There is already the same multicast mac address configured.
        //
        AddressExist = TRUE;
        break;
      }
    }
 
    if (JoinFlag && AddressExist) {
      //
      // The multicast mac address to join already exists.
      //
      Status = EFI_ALREADY_STARTED;
    }
 
    if (!JoinFlag && !AddressExist) {
      //
      // The multicast mac address to leave doesn't exist in this instance.
      //
      Status = EFI_NOT_FOUND;
    }
 
    if (EFI_ERROR (Status)) {
      goto ON_EXIT;
    }
  } else if (IsListEmpty (&Instance->GroupCtrlBlkList)) {
    //
    // The MacAddress is NULL and there is no configured multicast mac address,
    // just return.
    //
    goto ON_EXIT;
  }
 
  //
  // OK, it is time to take action.
  //
  Status = MnpGroupOp (Instance, JoinFlag, MacAddress, GroupCtrlBlk);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpTransmit (
  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token
  )
{
  EFI_STATUS         Status;
  MNP_INSTANCE_DATA  *Instance;
  MNP_SERVICE_DATA   *MnpServiceData;
  UINT8              *PktBuf;
  UINT32             PktLen;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) || (Token == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  if (!MnpIsValidTxToken (Instance, Token)) {
    //
    // The Token is invalid.
    //
    Status = EFI_INVALID_PARAMETER;
    goto ON_EXIT;
  }
 
  MnpServiceData = Instance->MnpServiceData;
  NET_CHECK_SIGNATURE (MnpServiceData, MNP_SERVICE_DATA_SIGNATURE);
 
  //
  // Build the tx packet
  //
  Status = MnpBuildTxPacket (MnpServiceData, Token->Packet.TxData, &PktBuf, &PktLen);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  //  OK, send the packet synchronously.
  //
  Status = MnpSyncSendPacket (MnpServiceData, PktBuf, PktLen, Token);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpReceive (
  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token
  )
{
  EFI_STATUS         Status;
  MNP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) || (Token == NULL) || (Token->Event == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  //
  // Check whether this token(event) is already in the rx token queue.
  //
  Status = NetMapIterate (&Instance->RxTokenMap, MnpTokenExist, (VOID *)Token);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  // Insert the Token into the RxTokenMap.
  //
  Status = NetMapInsertTail (&Instance->RxTokenMap, (VOID *)Token, NULL);
  if (!EFI_ERROR (Status)) {
    //
    // Try to deliver any buffered packets.
    //
    Status = MnpInstanceDeliverPacket (Instance);
 
    //
    // Dispatch the DPC queued by the NotifyFunction of Token->Event.
    //
    DispatchDpc ();
  }
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpCancel (
  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token OPTIONAL
  )
{
  EFI_STATUS         Status;
  MNP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  //
  // Iterate the RxTokenMap to cancel the specified Token.
  //
  Status = NetMapIterate (&Instance->RxTokenMap, MnpCancelTokens, (VOID *)Token);
  if (Token != NULL) {
    Status = (Status == EFI_ABORTED) ? EFI_SUCCESS : EFI_NOT_FOUND;
  }
 
  //
  // Dispatch the DPC queued by the NotifyFunction of the canceled token's events.
  //
  DispatchDpc ();
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpPoll (
  IN EFI_MANAGED_NETWORK_PROTOCOL  *This
  )
{
  EFI_STATUS         Status;
  MNP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (!Instance->Configured) {
    Status = EFI_NOT_STARTED;
    goto ON_EXIT;
  }
 
  //
  // Try to receive packets.
  //
  Status = MnpReceivePacket (Instance->MnpServiceData->MnpDeviceData);
 
  //
  // Dispatch the DPC queued by the NotifyFunction of rx token's events.
  //
  DispatchDpc ();
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}