EmuSnpDxe.c

Go to the documentation of this file.

 
#include "EmuSnpDxe.h"
 
EFI_SIMPLE_NETWORK_PROTOCOL  gEmuSnpTemplate = {
  EFI_SIMPLE_NETWORK_PROTOCOL_REVISION,
  EmuSnpStart,
  EmuSnpStop,
  EmuSnpInitialize,
  EmuSnpReset,
  EmuSnpShutdown,
  EmuSnpReceiveFilters,
  EmuSnpStationAddress,
  EmuSnpStatistics,
  EmuSnpMcastIptoMac,
  EmuSnpNvdata,
  EmuSnpGetStatus,
  EmuSnpTransmit,
  EmuSnpReceive,
  NULL,                     // WaitForPacket
  NULL                      // Mode
};
 
EFI_SIMPLE_NETWORK_MODE  gEmuSnpModeTemplate = {
  EfiSimpleNetworkStopped,      //  State
  NET_ETHER_ADDR_LEN,           //  HwAddressSize
  NET_ETHER_HEADER_SIZE,        //  MediaHeaderSize
  1500,                         //  MaxPacketSize
  0,                            //  NvRamSize
  0,                            //  NvRamAccessSize
  0,                            //  ReceiveFilterMask
  0,                            //  ReceiveFilterSetting
  MAX_MCAST_FILTER_CNT,         //  MaxMCastFilterCount
  0,                            //  MCastFilterCount
  {
    {
      { 0 }
    }
  },                            //  MCastFilter
  {
    { 0 }
  },                            //  CurrentAddress
  {
    { 0 }
  },                            //  BroadcastAddress
  {
    { 0 }
  },                            //  PermanentAddress
  NET_IFTYPE_ETHERNET,          //  IfType
  FALSE,                        //  MacAddressChangeable
  FALSE,                        //  MultipleTxSupported
  FALSE,                        //  MediaPresentSupported
  TRUE                          //  MediaPresent
};
 
EFI_STATUS
EFIAPI
EmuSnpStart (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Start (Private->Io);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpStop (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Stop (Private->Io);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpInitialize (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINTN                        ExtraRxBufferSize OPTIONAL,
  IN UINTN                        ExtraTxBufferSize OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Initialize (Private->Io, ExtraRxBufferSize, ExtraTxBufferSize);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpReset (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      ExtendedVerification
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Reset (Private->Io, ExtendedVerification);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpShutdown (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Shutdown (Private->Io);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpReceiveFilters (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINT32                       EnableBits,
  IN UINT32                       DisableBits,
  IN BOOLEAN                      ResetMcastFilter,
  IN UINTN                        McastFilterCount OPTIONAL,
  IN EFI_MAC_ADDRESS              *McastFilter OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->ReceiveFilters (
                          Private->Io,
                          EnableBits,
                          DisableBits,
                          ResetMcastFilter,
                          McastFilterCount,
                          McastFilter
                          );
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpStationAddress (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      Reset,
  IN EFI_MAC_ADDRESS              *NewMacAddr OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->StationAddress (Private->Io, Reset, NewMacAddr);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpStatistics (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      Reset,
  IN OUT UINTN                    *StatisticsSize OPTIONAL,
  OUT EFI_NETWORK_STATISTICS      *StatisticsTable OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Statistics (Private->Io, Reset, StatisticsSize, StatisticsTable);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpMcastIptoMac (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      Ipv6,
  IN EFI_IP_ADDRESS               *Ip,
  OUT EFI_MAC_ADDRESS             *Mac
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->MCastIpToMac (Private->Io, Ipv6, Ip, Mac);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpNvdata (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      ReadOrWrite,
  IN UINTN                        Offset,
  IN UINTN                        BufferSize,
  IN OUT VOID                     *Buffer
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->NvData (Private->Io, ReadOrWrite, Offset, BufferSize, Buffer);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpGetStatus (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  OUT UINT32                      *InterruptStatus,
  OUT VOID                        **TxBuffer
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->GetStatus (Private->Io, InterruptStatus, TxBuffer);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpTransmit (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINTN                        HeaderSize,
  IN UINTN                        BufferSize,
  IN VOID                         *Buffer,
  IN EFI_MAC_ADDRESS              *SrcAddr OPTIONAL,
  IN EFI_MAC_ADDRESS              *DestAddr OPTIONAL,
  IN UINT16                       *Protocol OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Transmit (
                          Private->Io,
                          HeaderSize,
                          BufferSize,
                          Buffer,
                          SrcAddr,
                          DestAddr,
                          Protocol
                          );
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpReceive (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  OUT UINTN                       *HeaderSize OPTIONAL,
  IN OUT UINTN                    *BuffSize,
  OUT VOID                        *Buffer,
  OUT EFI_MAC_ADDRESS             *SourceAddr OPTIONAL,
  OUT EFI_MAC_ADDRESS             *DestinationAddr OPTIONAL,
  OUT UINT16                      *Protocol OPTIONAL
  )
{
  EFI_STATUS            Status;
  EMU_SNP_PRIVATE_DATA  *Private;
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (This);
 
  Status = Private->Io->Receive (
                          Private->Io,
                          HeaderSize,
                          BuffSize,
                          Buffer,
                          SourceAddr,
                          DestinationAddr,
                          Protocol
                          );
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS                Status;
  EMU_IO_THUNK_PROTOCOL     *EmuIoThunk;
  MAC_ADDR_DEVICE_PATH      *Node;
  EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 
  if (RemainingDevicePath != NULL) {
    if (!IsDevicePathEnd (RemainingDevicePath)) {
      Node = (MAC_ADDR_DEVICE_PATH *)RemainingDevicePath;
      if ((Node->Header.Type != MESSAGING_DEVICE_PATH) ||
          (Node->Header.SubType != MSG_MAC_ADDR_DP))
      {
        // If the remaining device path does not match we don't support the request
        return EFI_UNSUPPORTED;
      }
    }
  }
 
  //
  // Open the IO Abstraction(s) needed to perform the supported test
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  (VOID **)&EmuIoThunk,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Close the I/O Abstraction(s) used to perform the supported test
  //
  gBS->CloseProtocol (
         ControllerHandle,
         &gEmuIoThunkProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  //
  // Open the EFI Device Path protocol needed to perform the supported test
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&ParentDevicePath,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (Status == EFI_ALREADY_STARTED) {
    return EFI_SUCCESS;
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Make sure GUID is for a SNP handle.
  //
  Status = EFI_UNSUPPORTED;
  if (CompareGuid (EmuIoThunk->Protocol, &gEmuSnpProtocolGuid)) {
    Status = EFI_SUCCESS;
  }
 
  //
  // Close protocol, don't use device path protocol in the Support() function
  //
  gBS->CloseProtocol (
         ControllerHandle,
         &gEfiDevicePathProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS                Status;
  EMU_IO_THUNK_PROTOCOL     *EmuIoThunk;
  EMU_SNP_PRIVATE_DATA      *Private;
  MAC_ADDR_DEVICE_PATH      Node;
  EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 
  Private = NULL;
 
  //
  // Grab the protocols we need
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&ParentDevicePath,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status) && Status) {
    return Status;
  }
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  (VOID **)&EmuIoThunk,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (!CompareGuid (EmuIoThunk->Protocol, &gEmuSnpProtocolGuid)) {
    return EFI_UNSUPPORTED;
  }
 
  Status = EmuIoThunk->Open (EmuIoThunk);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  //  Allocate the private data.
  //
  Private = AllocateZeroPool (sizeof (EMU_SNP_PRIVATE_DATA));
  if (Private == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  CopyMem (&Private->Snp, &gEmuSnpTemplate, sizeof (EFI_SIMPLE_NETWORK_PROTOCOL));
  CopyMem (&Private->Mode, &gEmuSnpModeTemplate, sizeof (EFI_SIMPLE_NETWORK_MODE));
 
  Private->Signature           = EMU_SNP_PRIVATE_DATA_SIGNATURE;
  Private->IoThunk             = EmuIoThunk;
  Private->Io                  = EmuIoThunk->Interface;
  Private->EfiHandle           = ControllerHandle;
  Private->DeviceHandle        = NULL;
  Private->Snp.Mode            = &Private->Mode;
  Private->ControllerNameTable = NULL;
 
  Status = Private->Io->CreateMapping (Private->Io, &Private->Mode);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  // Build the device path by appending the MAC node to the ParentDevicePath
  // from the EmuIo handle.
  //
  ZeroMem (&Node, sizeof (MAC_ADDR_DEVICE_PATH));
 
  Node.Header.Type    = MESSAGING_DEVICE_PATH;
  Node.Header.SubType = MSG_MAC_ADDR_DP;
  Node.IfType         = Private->Mode.IfType;
 
  SetDevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *)&Node, sizeof (MAC_ADDR_DEVICE_PATH));
 
  CopyMem (&Node.MacAddress, &Private->Mode.CurrentAddress, sizeof (EFI_MAC_ADDRESS));
 
  //
  // Build the device path by appending the MAC node to the ParentDevicePath from the EmuIo handle.
  //
  Private->DevicePath = AppendDevicePathNode (ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&Node);
  if ( Private->DevicePath == NULL ) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  AddUnicodeString2 (
    "eng",
    gEmuSnpDriverComponentName.SupportedLanguages,
    &Private->ControllerNameTable,
    EmuIoThunk->ConfigString,
    TRUE
    );
 
  AddUnicodeString2 (
    "en",
    gEmuSnpDriverComponentName2.SupportedLanguages,
    &Private->ControllerNameTable,
    EmuIoThunk->ConfigString,
    FALSE
    );
 
  //
  // Create Child Handle
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Private->DeviceHandle,
                  &gEfiSimpleNetworkProtocolGuid,
                  &Private->Snp,
                  &gEfiDevicePathProtocolGuid,
                  Private->DevicePath,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  // Open For Child Device
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  (VOID **)&EmuIoThunk,
                  This->DriverBindingHandle,
                  Private->DeviceHandle,
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                  );
 
Done:
  if (EFI_ERROR (Status)) {
    if (Private != NULL) {
      FreePool (Private);
    }
 
    if (ParentDevicePath != NULL) {
      gBS->CloseProtocol (
             ControllerHandle,
             &gEfiDevicePathProtocolGuid,
             This->DriverBindingHandle,
             ControllerHandle
             );
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSnpDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_STATUS                   Status;
  EMU_SNP_PRIVATE_DATA         *Private = NULL;
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  VOID                         *EmuIoThunk;
 
  //
  // Complete all outstanding transactions to Controller.
  // Don't allow any new transaction to Controller to be started.
  //
  if (NumberOfChildren == 0) {
    //
    // Close the bus driver
    //
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEmuIoThunkProtocolGuid,
                    This->DriverBindingHandle,
                    ControllerHandle
                    );
 
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEfiDevicePathProtocolGuid,
                    This->DriverBindingHandle,
                    ControllerHandle
                    );
    return Status;
  }
 
  ASSERT (NumberOfChildren == 1);
 
  //
  // Get our context back.
  //
  Status = gBS->OpenProtocol (
                  ChildHandleBuffer[0],
                  &gEfiSimpleNetworkProtocolGuid,
                  (VOID **)&Snp,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  Private = EMU_SNP_PRIVATE_DATA_FROM_SNP_THIS (Snp);
  ASSERT (Private->DeviceHandle == ChildHandleBuffer[0]);
  ASSERT (Private->EfiHandle    == ControllerHandle);
 
  Status = gBS->CloseProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  This->DriverBindingHandle,
                  Private->DeviceHandle
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  Private->DeviceHandle,
                  &gEfiSimpleNetworkProtocolGuid,
                  &Private->Snp,
                  &gEfiDevicePathProtocolGuid,
                  Private->DevicePath,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    gBS->OpenProtocol (
           ControllerHandle,
           &gEmuIoThunkProtocolGuid,
           &EmuIoThunk,
           This->DriverBindingHandle,
           Private->DeviceHandle,
           EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
           );
  } else {
    Status = Private->IoThunk->Close (Private->IoThunk);
    ASSERT_EFI_ERROR (Status);
 
    FreePool (Private->DevicePath);
    FreeUnicodeStringTable (Private->ControllerNameTable);
    FreePool (Private);
  }
 
  return Status;
}
 
EFI_DRIVER_BINDING_PROTOCOL  gEmuSnpDriverBinding = {
  EmuSnpDriverBindingSupported,
  EmuSnpDriverBindingStart,
  EmuSnpDriverBindingStop,
  0xA,
  NULL,
  NULL
};
 
EFI_STATUS
EFIAPI
InitializeEmuSnpDriver (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Install the Driver Protocols
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gEmuSnpDriverBinding,
             ImageHandle,
             &gEmuSnpDriverComponentName,
             &gEmuSnpDriverComponentName2
             );
 
  return Status;
}