MnpDriver.c

Go to the documentation of this file.

 
#include "MnpDriver.h"
#include "MnpImpl.h"
#include "MnpVlan.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gMnpDriverBinding = {
  MnpDriverBindingSupported,
  MnpDriverBindingStart,
  MnpDriverBindingStop,
  0xa,
  NULL,
  NULL
};
 
EFI_STATUS
EFIAPI
MnpDestroyServiceDataEntry (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  MNP_SERVICE_DATA  *MnpServiceData;
 
  MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
  return MnpDestroyServiceData (MnpServiceData);
}
 
EFI_STATUS
EFIAPI
MnpDestroyServiceChildEntry (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  MNP_SERVICE_DATA  *MnpServiceData;
 
  MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
  return MnpDestroyServiceChild (MnpServiceData);
}
 
EFI_STATUS
EFIAPI
MnpDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS                   Status;
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
 
  //
  // Test to open the Simple Network protocol BY_DRIVER.
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiSimpleNetworkProtocolGuid,
                  (VOID **)&Snp,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Close the opened SNP protocol.
  //
  gBS->CloseProtocol (
         ControllerHandle,
         &gEfiSimpleNetworkProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
MnpDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS        Status;
  MNP_SERVICE_DATA  *MnpServiceData;
  MNP_DEVICE_DATA   *MnpDeviceData;
  LIST_ENTRY        *Entry;
  VLAN_TCI          *VlanVariable;
  UINTN             NumberOfVlan;
  UINTN             Index;
 
  VlanVariable = NULL;
 
  //
  // Initialize the Mnp Device Data
  //
  MnpDeviceData = AllocateZeroPool (sizeof (MNP_DEVICE_DATA));
  if (MnpDeviceData == NULL) {
    DEBUG ((DEBUG_ERROR, "MnpDriverBindingStart(): Failed to allocate the Mnp Device Data.\n"));
 
    return EFI_OUT_OF_RESOURCES;
  }
 
  Status = MnpInitializeDeviceData (MnpDeviceData, This->DriverBindingHandle, ControllerHandle);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "MnpDriverBindingStart: MnpInitializeDeviceData failed, %r.\n", Status));
 
    FreePool (MnpDeviceData);
    return Status;
  }
 
  //
  // Check whether NIC driver has already produced VlanConfig protocol
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiVlanConfigProtocolGuid,
                  NULL,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                  );
  if (!EFI_ERROR (Status)) {
    //
    // NIC hardware already implement VLAN,
    // no need to provide software VLAN implementation in MNP driver
    //
    MnpDeviceData->NumberOfVlan = 0;
    ZeroMem (&MnpDeviceData->VlanConfig, sizeof (EFI_VLAN_CONFIG_PROTOCOL));
    MnpServiceData = MnpCreateServiceData (MnpDeviceData, 0, 0);
    Status         = (MnpServiceData != NULL) ? EFI_SUCCESS : EFI_OUT_OF_RESOURCES;
    goto Exit;
  }
 
  //
  // Install VLAN Config Protocol
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &ControllerHandle,
                  &gEfiVlanConfigProtocolGuid,
                  &MnpDeviceData->VlanConfig,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto Exit;
  }
 
  //
  // Get current VLAN configuration from EFI Variable
  //
  NumberOfVlan = 0;
  Status       = MnpGetVlanVariable (MnpDeviceData, &NumberOfVlan, &VlanVariable);
  if (EFI_ERROR (Status)) {
    //
    // No VLAN is set, create a default MNP service data for untagged frame
    //
    MnpDeviceData->NumberOfVlan = 0;
    MnpServiceData              = MnpCreateServiceData (MnpDeviceData, 0, 0);
    Status                      = (MnpServiceData != NULL) ? EFI_SUCCESS : EFI_OUT_OF_RESOURCES;
    goto Exit;
  }
 
  //
  // Create MNP service data for each VLAN
  //
  MnpDeviceData->NumberOfVlan = NumberOfVlan;
  for (Index = 0; Index < NumberOfVlan; Index++) {
    MnpServiceData = MnpCreateServiceData (
                       MnpDeviceData,
                       VlanVariable[Index].Bits.Vid,
                       (UINT8)VlanVariable[Index].Bits.Priority
                       );
 
    if (MnpServiceData == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
 
      goto Exit;
    }
  }
 
Exit:
  if (VlanVariable != NULL) {
    FreePool (VlanVariable);
  }
 
  if (EFI_ERROR (Status)) {
    //
    // Destroy all MNP service data
    //
    while (!IsListEmpty (&MnpDeviceData->ServiceList)) {
      Entry          = GetFirstNode (&MnpDeviceData->ServiceList);
      MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
      MnpDestroyServiceData (MnpServiceData);
    }
 
    //
    // Uninstall the VLAN Config Protocol if any
    //
    if (MnpDeviceData->VlanConfig.Set != NULL) {
      gBS->UninstallMultipleProtocolInterfaces (
             MnpDeviceData->ControllerHandle,
             &gEfiVlanConfigProtocolGuid,
             &MnpDeviceData->VlanConfig,
             NULL
             );
    }
 
    //
    // Destroy Mnp Device Data
    //
    MnpDestroyDeviceData (MnpDeviceData, This->DriverBindingHandle);
    FreePool (MnpDeviceData);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  EFI_STATUS                    Status;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  EFI_VLAN_CONFIG_PROTOCOL      *VlanConfig;
  MNP_DEVICE_DATA               *MnpDeviceData;
  MNP_SERVICE_DATA              *MnpServiceData;
  LIST_ENTRY                    *List;
  UINTN                         ListLength;
 
  //
  // Try to retrieve MNP service binding protocol from the ControllerHandle
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiManagedNetworkServiceBindingProtocolGuid,
                  (VOID **)&ServiceBinding,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    //
    // Retrieve VLAN Config Protocol from the ControllerHandle
    //
    Status = gBS->OpenProtocol (
                    ControllerHandle,
                    &gEfiVlanConfigProtocolGuid,
                    (VOID **)&VlanConfig,
                    This->DriverBindingHandle,
                    ControllerHandle,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "MnpDriverBindingStop: try to stop unknown Controller.\n"));
      return EFI_DEVICE_ERROR;
    }
 
    MnpDeviceData = MNP_DEVICE_DATA_FROM_THIS (VlanConfig);
  } else {
    MnpServiceData = MNP_SERVICE_DATA_FROM_THIS (ServiceBinding);
    MnpDeviceData  = MnpServiceData->MnpDeviceData;
  }
 
  if (NumberOfChildren == 0) {
    //
    // Destroy all MNP service data
    //
    List   = &MnpDeviceData->ServiceList;
    Status = NetDestroyLinkList (
               List,
               MnpDestroyServiceDataEntry,
               NULL,
               &ListLength
               );
    if (EFI_ERROR (Status) || (ListLength != 0)) {
      return EFI_DEVICE_ERROR;
    }
 
    //
    // Uninstall the VLAN Config Protocol if any
    //
    if (MnpDeviceData->VlanConfig.Set != NULL) {
      gBS->UninstallMultipleProtocolInterfaces (
             MnpDeviceData->ControllerHandle,
             &gEfiVlanConfigProtocolGuid,
             &MnpDeviceData->VlanConfig,
             NULL
             );
    }
 
    //
    // Destroy Mnp Device Data
    //
    MnpDestroyDeviceData (MnpDeviceData, This->DriverBindingHandle);
    FreePool (MnpDeviceData);
 
    if (gMnpControllerNameTable != NULL) {
      FreeUnicodeStringTable (gMnpControllerNameTable);
      gMnpControllerNameTable = NULL;
    }
 
    return EFI_SUCCESS;
  }
 
  //
  // Stop all MNP child
  //
  List   = &MnpDeviceData->ServiceList;
  Status = NetDestroyLinkList (
             List,
             MnpDestroyServiceChildEntry,
             NULL,
             &ListLength
             );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
MnpServiceBindingCreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS         Status;
  MNP_SERVICE_DATA   *MnpServiceData;
  MNP_INSTANCE_DATA  *Instance;
  VOID               *MnpSb;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  MnpServiceData = MNP_SERVICE_DATA_FROM_THIS (This);
 
  //
  // Allocate buffer for the new instance.
  //
  Instance = AllocateZeroPool (sizeof (MNP_INSTANCE_DATA));
  if (Instance == NULL) {
    DEBUG ((DEBUG_ERROR, "MnpServiceBindingCreateChild: Failed to allocate memory for the new instance.\n"));
 
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Init the instance data.
  //
  MnpInitializeInstanceData (MnpServiceData, Instance);
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiManagedNetworkProtocolGuid,
                  &Instance->ManagedNetwork,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    DEBUG (
      (DEBUG_ERROR,
       "MnpServiceBindingCreateChild: Failed to install the MNP protocol, %r.\n",
       Status)
      );
 
    goto ErrorExit;
  }
 
  //
  // Save the instance's childhandle.
  //
  Instance->Handle = *ChildHandle;
 
  Status = gBS->OpenProtocol (
                  MnpServiceData->ServiceHandle,
                  &gEfiManagedNetworkServiceBindingProtocolGuid,
                  (VOID **)&MnpSb,
                  gMnpDriverBinding.DriverBindingHandle,
                  Instance->Handle,
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                  );
  if (EFI_ERROR (Status)) {
    goto ErrorExit;
  }
 
  //
  // Add the child instance into ChildrenList.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  InsertTailList (&MnpServiceData->ChildrenList, &Instance->InstEntry);
  MnpServiceData->ChildrenNumber++;
 
  gBS->RestoreTPL (OldTpl);
 
ErrorExit:
 
  if (EFI_ERROR (Status)) {
    if (Instance->Handle != NULL) {
      gBS->UninstallMultipleProtocolInterfaces (
             Instance->Handle,
             &gEfiManagedNetworkProtocolGuid,
             &Instance->ManagedNetwork,
             NULL
             );
    }
 
    FreePool (Instance);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpServiceBindingDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    ChildHandle
  )
{
  EFI_STATUS                    Status;
  MNP_SERVICE_DATA              *MnpServiceData;
  EFI_MANAGED_NETWORK_PROTOCOL  *ManagedNetwork;
  MNP_INSTANCE_DATA             *Instance;
  EFI_TPL                       OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  MnpServiceData = MNP_SERVICE_DATA_FROM_THIS (This);
 
  //
  // Try to retrieve ManagedNetwork Protocol from ChildHandle.
  //
  Status = gBS->OpenProtocol (
                  ChildHandle,
                  &gEfiManagedNetworkProtocolGuid,
                  (VOID **)&ManagedNetwork,
                  gMnpDriverBinding.DriverBindingHandle,
                  ChildHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = MNP_INSTANCE_DATA_FROM_THIS (ManagedNetwork);
 
  //
  // MnpServiceBindingDestroyChild may be called twice: first called by
  // MnpServiceBindingStop, second called by uninstalling the MNP protocol
  // in this ChildHandle. Use destroyed to make sure the resource clean code
  // will only excecute once.
  //
  if (Instance->Destroyed) {
    return EFI_SUCCESS;
  }
 
  Instance->Destroyed = TRUE;
 
  //
  // Close the Simple Network protocol.
  //
  gBS->CloseProtocol (
         MnpServiceData->ServiceHandle,
         &gEfiManagedNetworkServiceBindingProtocolGuid,
         MnpServiceData->MnpDeviceData->ImageHandle,
         ChildHandle
         );
 
  //
  // Uninstall the ManagedNetwork protocol.
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiManagedNetworkProtocolGuid,
                  &Instance->ManagedNetwork,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    DEBUG (
      (DEBUG_ERROR,
       "MnpServiceBindingDestroyChild: Failed to uninstall the ManagedNetwork protocol, %r.\n",
       Status)
      );
 
    Instance->Destroyed = FALSE;
    return Status;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Reset the configuration.
  //
  ManagedNetwork->Configure (ManagedNetwork, NULL);
 
  //
  // Try to flush the RcvdPacketQueue.
  //
  MnpFlushRcvdDataQueue (Instance);
 
  //
  // Clean the RxTokenMap.
  //
  NetMapClean (&Instance->RxTokenMap);
 
  //
  // Remove this instance from the ChildrenList.
  //
  RemoveEntryList (&Instance->InstEntry);
  MnpServiceData->ChildrenNumber--;
 
  gBS->RestoreTPL (OldTpl);
 
  FreePool (Instance);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MnpDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EfiLibInstallDriverBindingComponentName2 (
           ImageHandle,
           SystemTable,
           &gMnpDriverBinding,
           ImageHandle,
           &gMnpComponentName,
           &gMnpComponentName2
           );
}