WifiConnectionMgrDriver.c

Go to the documentation of this file.

 
#include "WifiConnectionMgrDxe.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gWifiMgrDxeDriverBinding = {
  WifiMgrDxeDriverBindingSupported,
  WifiMgrDxeDriverBindingStart,
  WifiMgrDxeDriverBindingStop,
  WIFI_MGR_DXE_VERSION,
  NULL,
  NULL
};
 
//
// The private global data for WiFi Connection Manager
//
WIFI_MGR_PRIVATE_DATA  *mPrivate = NULL;
 
//
// The private guid to identify WiFi Connection Manager
//
EFI_GUID  mEfiWifiMgrPrivateGuid = EFI_WIFIMGR_PRIVATE_GUID;
 
//
// The Hii config guids
//
EFI_GUID  gWifiConfigFormSetGuid            = WIFI_CONNECTION_MANAGER_CONFIG_GUID;
EFI_GUID  mWifiConfigNetworkListRefreshGuid = WIFI_CONFIG_NETWORK_LIST_REFRESH_GUID;
EFI_GUID  mWifiConfigConnectFormRefreshGuid = WIFI_CONFIG_CONNECT_FORM_REFRESH_GUID;
EFI_GUID  mWifiConfigMainFormRefreshGuid    = WIFI_CONFIG_MAIN_FORM_REFRESH_GUID;
 
//
// Wifi connection attempt counter for retries
//
extern UINT8  mWifiConnectionCount;
 
EFI_STATUS
EFIAPI
WifiMgrDxeDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &mEfiWifiMgrPrivateGuid,
                  NULL,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                  );
  if (!EFI_ERROR (Status)) {
    return EFI_ALREADY_STARTED;
  }
 
  //
  // Test for the wireless MAC connection 2 protocol
  //
  return gBS->OpenProtocol (
                ControllerHandle,
                &gEfiWiFi2ProtocolGuid,
                NULL,
                This->DriverBindingHandle,
                ControllerHandle,
                EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                );
}
 
EFI_STATUS
EFIAPI
WifiMgrDxeDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS                               Status;
  EFI_TPL                                  OldTpl;
  UINTN                                    AddressSize;
  WIFI_MGR_DEVICE_DATA                     *Nic;
  EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL  *Wmp;
  EFI_SUPPLICANT_PROTOCOL                  *Supplicant;
  EFI_EAP_CONFIGURATION_PROTOCOL           *EapConfig;
  EDKII_WIFI_PROFILE_SYNC_PROTOCOL         *WiFiProfileSyncProtocol;
 
  mWifiConnectionCount = 0;
  Nic                  = NULL;
 
  //
  // Open Protocols
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiWiFi2ProtocolGuid,
                  (VOID **)&Wmp,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiSupplicantProtocolGuid,
                  (VOID **)&Supplicant,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    Supplicant = NULL;
  }
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiEapConfigurationProtocolGuid,
                  (VOID **)&EapConfig,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    EapConfig = NULL;
  }
 
  //
  // Initialize Nic device data
  //
  Nic = AllocateZeroPool (sizeof (WIFI_MGR_DEVICE_DATA));
  if (Nic == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ERROR1;
  }
 
  Nic->Signature           = WIFI_MGR_DEVICE_DATA_SIGNATURE;
  Nic->DriverHandle        = This->DriverBindingHandle;
  Nic->ControllerHandle    = ControllerHandle;
  Nic->Private             = mPrivate;
  Nic->Wmp                 = Wmp;
  Nic->Supplicant          = Supplicant;
  Nic->EapConfig           = EapConfig;
  Nic->UserSelectedProfile = NULL;
  Nic->OneTimeScanRequest  = FALSE;
  Nic->ScanTickTime        = WIFI_SCAN_FREQUENCY;   // Initialize the first scan
 
  if (Nic->Supplicant != NULL) {
    WifiMgrGetSupportedSuites (Nic);
  }
 
  InitializeListHead (&Nic->ProfileList);
 
  //
  // WiFi profile sync protocol installation check for OS recovery flow.
  //
  Status = gBS->LocateProtocol (
                  &gEdkiiWiFiProfileSyncProtocolGuid,
                  NULL,
                  (VOID **)&WiFiProfileSyncProtocol
                  );
  if (!EFI_ERROR (Status)) {
    Nic->ConnectPendingNetwork = (WIFI_MGR_NETWORK_PROFILE *)AllocateZeroPool (sizeof (WIFI_MGR_NETWORK_PROFILE));
    if (Nic->ConnectPendingNetwork == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ERROR1;
    }
 
    WiFiProfileSyncProtocol->GetProfile (Nic->ConnectPendingNetwork, Nic->MacAddress);
    if (Nic->ConnectPendingNetwork != NULL) {
      Status = WifiMgrConnectToNetwork (Nic, Nic->ConnectPendingNetwork);
      if (!EFI_ERROR (Status)) {
        goto ERROR1;
      }
 
      WiFiProfileSyncProtocol->SetConnectState (Status);
    }
  } else {
    //
    // Record the MAC address of the incoming NIC.
    //
    Status = NetLibGetMacAddress (
               ControllerHandle,
               (EFI_MAC_ADDRESS *)&Nic->MacAddress,
               &AddressSize
               );
    if (EFI_ERROR (Status)) {
      goto ERROR2;
    }
 
    //
    // Create and start the timer for the status check
    //
    Status = gBS->CreateEvent (
                    EVT_NOTIFY_SIGNAL | EVT_TIMER,
                    TPL_CALLBACK,
                    WifiMgrOnTimerTick,
                    Nic,
                    &Nic->TickTimer
                    );
    if (EFI_ERROR (Status)) {
      goto ERROR2;
    }
 
    Status = gBS->SetTimer (Nic->TickTimer, TimerPeriodic, EFI_TIMER_PERIOD_MILLISECONDS (500));
    if (EFI_ERROR (Status)) {
      goto ERROR3;
    }
 
    Nic->ConnectState = WifiMgrDisconnected;
    Nic->ScanState    = WifiMgrScanFinished;
 
    OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
    InsertTailList (&mPrivate->NicList, &Nic->Link);
    Nic->NicIndex = mPrivate->NicCount++;
    if (mPrivate->CurrentNic == NULL) {
      mPrivate->CurrentNic = Nic;
    }
 
    gBS->RestoreTPL (OldTpl);
  }
 
  Status = gBS->InstallProtocolInterface (
                  &ControllerHandle,
                  &mEfiWifiMgrPrivateGuid,
                  EFI_NATIVE_INTERFACE,
                  &Nic->WifiMgrIdentifier
                  );
  if (EFI_ERROR (Status)) {
    goto ERROR4;
  }
 
  return EFI_SUCCESS;
 
ERROR4:
 
  gBS->SetTimer (Nic->TickTimer, TimerCancel, 0);
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  RemoveEntryList (&Nic->Link);
  mPrivate->NicCount--;
  gBS->RestoreTPL (OldTpl);
 
ERROR3:
 
  gBS->CloseEvent (Nic->TickTimer);
 
ERROR2:
 
  if (Nic->Supplicant != NULL) {
    if (Nic->SupportedSuites.SupportedAKMSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedAKMSuites);
    }
 
    if (Nic->SupportedSuites.SupportedSwCipherSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedSwCipherSuites);
    }
 
    if (Nic->SupportedSuites.SupportedHwCipherSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedHwCipherSuites);
    }
  }
 
  FreePool (Nic);
 
ERROR1:
 
  if (Supplicant != NULL) {
    gBS->CloseProtocol (
           ControllerHandle,
           &gEfiSupplicantProtocolGuid,
           This->DriverBindingHandle,
           ControllerHandle
           );
  }
 
  if (EapConfig != NULL) {
    gBS->CloseProtocol (
           ControllerHandle,
           &gEfiEapConfigurationProtocolGuid,
           This->DriverBindingHandle,
           ControllerHandle
           );
  }
 
  gBS->CloseProtocol (
         ControllerHandle,
         &gEfiWiFi2ProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
WifiMgrDxeDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  EFI_STATUS                        Status;
  EFI_TPL                           OldTpl;
  WIFI_MGR_PRIVATE_PROTOCOL         *WifiMgrIdentifier;
  WIFI_MGR_DEVICE_DATA              *Nic;
  EDKII_WIFI_PROFILE_SYNC_PROTOCOL  *WiFiProfileSyncProtocol;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &mEfiWifiMgrPrivateGuid,
                  (VOID **)&WifiMgrIdentifier,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  Nic = WIFI_MGR_DEVICE_DATA_FROM_IDENTIFIER (WifiMgrIdentifier);
  if (Nic == NULL) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Close Event
  //
  gBS->SetTimer (Nic->TickTimer, TimerCancel, 0);
  gBS->CloseEvent (Nic->TickTimer);
 
  //
  // Clean Supported Suites
  //
  if (Nic->Supplicant != NULL) {
    if (Nic->SupportedSuites.SupportedAKMSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedAKMSuites);
    }
 
    if (Nic->SupportedSuites.SupportedSwCipherSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedSwCipherSuites);
    }
 
    if (Nic->SupportedSuites.SupportedHwCipherSuites != NULL) {
      FreePool (Nic->SupportedSuites.SupportedHwCipherSuites);
    }
  }
 
  //
  // Close Protocols
  //
  Status = gBS->UninstallProtocolInterface (
                  ControllerHandle,
                  &mEfiWifiMgrPrivateGuid,
                  &Nic->WifiMgrIdentifier
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->CloseProtocol (
                  ControllerHandle,
                  &gEfiWiFi2ProtocolGuid,
                  Nic->DriverHandle,
                  Nic->ControllerHandle
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Nic->Supplicant != NULL) {
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEfiSupplicantProtocolGuid,
                    Nic->DriverHandle,
                    Nic->ControllerHandle
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  if (Nic->EapConfig != NULL) {
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEfiEapConfigurationProtocolGuid,
                    Nic->DriverHandle,
                    Nic->ControllerHandle
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Remove this Nic from Nic list
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Status = gBS->LocateProtocol (
                  &gEdkiiWiFiProfileSyncProtocolGuid,
                  NULL,
                  (VOID **)&WiFiProfileSyncProtocol
                  );
  if (EFI_ERROR (Status)) {
    RemoveEntryList (&Nic->Link);
  }
 
  mPrivate->NicCount--;
  if (mPrivate->CurrentNic == Nic) {
    mPrivate->CurrentNic = NULL;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  WifiMgrFreeProfileList (&Nic->ProfileList);
  FreePool (Nic);
 
  DEBUG ((DEBUG_INFO, "[WiFi Connection Manager] Device Controller has been Disconnected!\n"));
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
WifiMgrDxeDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gWifiMgrDxeDriverBinding,
             ImageHandle,
             &gWifiMgrDxeComponentName,
             &gWifiMgrDxeComponentName2
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Initialize the global private data structure.
  //
  mPrivate = AllocateZeroPool (sizeof (WIFI_MGR_PRIVATE_DATA));
  if (mPrivate == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ERROR1;
  }
 
  mPrivate->Signature    = WIFI_MGR_PRIVATE_DATA_SIGNATURE;
  mPrivate->DriverHandle = ImageHandle;
  InitializeListHead (&mPrivate->NicList);
  mPrivate->NicCount   = 0;
  mPrivate->CurrentNic = NULL;
  InitializeListHead (&mPrivate->HiddenNetworkList);
  mPrivate->HiddenNetworkCount = 0;
 
  //
  // Create events for page refresh
  //
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  WifiMgrInternalEmptyFunction,
                  NULL,
                  &mWifiConfigNetworkListRefreshGuid,
                  &mPrivate->NetworkListRefreshEvent
                  );
  if (EFI_ERROR (Status)) {
    goto ERROR2;
  }
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  WifiMgrInternalEmptyFunction,
                  NULL,
                  &mWifiConfigConnectFormRefreshGuid,
                  &mPrivate->ConnectFormRefreshEvent
                  );
  if (EFI_ERROR (Status)) {
    goto ERROR3;
  }
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  WifiMgrInternalEmptyFunction,
                  NULL,
                  &mWifiConfigMainFormRefreshGuid,
                  &mPrivate->MainPageRefreshEvent
                  );
  if (EFI_ERROR (Status)) {
    goto ERROR4;
  }
 
  Status = WifiMgrDxeConfigFormInit (mPrivate);
  if (EFI_ERROR (Status)) {
    goto ERROR5;
  }
 
  return Status;
 
ERROR5:
  gBS->CloseEvent (mPrivate->MainPageRefreshEvent);
 
ERROR4:
  gBS->CloseEvent (mPrivate->ConnectFormRefreshEvent);
 
ERROR3:
  gBS->CloseEvent (mPrivate->NetworkListRefreshEvent);
 
ERROR2:
  if (mPrivate != NULL) {
    FreePool (mPrivate);
    mPrivate = NULL;
  }
 
ERROR1:
  gBS->UninstallMultipleProtocolInterfaces (
         ImageHandle,
         &gEfiDriverBindingProtocolGuid,
         &gWifiMgrDxeDriverBinding,
         &gEfiComponentNameProtocolGuid,
         &gWifiMgrDxeComponentName,
         &gEfiComponentName2ProtocolGuid,
         &gWifiMgrDxeComponentName2,
         NULL
         );
 
  return Status;
}