xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakePlatSamplePkg/Features/Amt/WifiProfileSync/WifiProfileSync.c

678 lines
24 KiB
C
Raw Blame History

/** @file
This driver is the WiFi Profile Sync with CSME through ASF supporting WLAN using
the WifiConnectionManager driver. This is used only when One Click Recovery driver
triggers an HTTPS boot recovery and the platfrom supports WLAN HTTPS image recovery
and boot.
@copyright
INTEL CONFIDENTIAL
Copyright 2021 Intel Corporation.
The source code contained or described herein and all documents related to the
source code ("Material") are owned by Intel Corporation or its suppliers or
licensors. Title to the Material remains with Intel Corporation or its suppliers
and licensors. The Material may contain trade secrets and proprietary and
confidential information of Intel Corporation and its suppliers and licensors,
and is protected by worldwide copyright and trade secret laws and treaty
provisions. No part of the Material may be used, copied, reproduced, modified,
published, uploaded, posted, transmitted, distributed, or disclosed in any way
without Intel's prior express written permission.
No license under any patent, copyright, trade secret or other intellectual
property right is granted to or conferred upon you by disclosure or delivery
of the Materials, either expressly, by implication, inducement, estoppel or
otherwise. Any license under such intellectual property rights must be
express and approved by Intel in writing.
Unless otherwise agreed by Intel in writing, you may not remove or alter
this notice or any other notice embedded in Materials by Intel or
Intel's suppliers or licensors in any way.
This file contains a 'Sample Driver' and is licensed as such under the terms
of your license agreement with Intel or your vendor. This file may be modified
by the user, subject to the additional terms of the license agreement.
@par Specification Reference:
**/
#include "WifiProfileSync.h"
#include "WifiProfileSyncUtils.h"
#include <WifiProfileSyncAsfMsgs.h>
#include <Protocol/WifiProfileSyncProtocol.h>
#include <Uefi.h>
#include <CpuRegs.h>
#include <SetupVariable.h>
//
// Libraries
//
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/TimerLib.h>
#include <Library/DxeAsfLib.h>
#include <Library/BootGuardLibVer1.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DxeAmtHeciLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
//
// GUID's
//
#include <Guid/EventGroup.h>
#include <Guid/GlobalVariable.h>
#include <Guid/AuthenticatedVariableFormat.h>
//
// Protocol's
//
#include <Protocol/WiFi2.h>
#include <Protocol/AsfProtocol.h>
#include <Protocol/AmtWrapperProtocol.h>
//
// WiFi Profile Sync Protocol
//
GLOBAL_REMOVE_IF_UNREFERENCED WIFI_PROFILE_SYNC_PROTOCOL mWiFiProfileSyncProtocol = {
WIFI_PROFILE_SYNC_PROTOCOL_REVISION,
WifiProfileSyncSetConnectStatus,
WifiProfileSyncGetConnectStatus,
WifiProfileSyncGetProfile
};
GLOBAL_REMOVE_IF_UNREFERENCED WIFI_PROFILE *mSyncProfile = NULL;
GLOBAL_REMOVE_IF_UNREFERENCED EFI_STATUS mWcmConnectionStatus;
/**
Function to set the WiFi connection status recieved by the WiFiConnectionManager
as EFI_80211_CONNECT_NETWORK_RESULT_CODE, this will get converted to EFI_STATUS
type
@param[in] EFI_80211_CONNECT_NETWORK_RESULT_CODE WiFi connection attempt results
**/
VOID
EFIAPI
WifiProfileSyncSetConnectStatus (
IN EFI_80211_CONNECT_NETWORK_RESULT_CODE ConnectionStatus
)
{
switch (ConnectionStatus) {
case ConnectSuccess:
mWcmConnectionStatus = EFI_SUCCESS;
break;
case ConnectRefused:
mWcmConnectionStatus = EFI_ACCESS_DENIED;
break;
case ConnectFailed:
mWcmConnectionStatus = EFI_DEVICE_ERROR;
break;
case ConnectFailureTimeout:
mWcmConnectionStatus = EFI_TIMEOUT;
break;
case ConnectFailedReasonUnspecified:
mWcmConnectionStatus = EFI_DEVICE_ERROR;
break;
default:
mWcmConnectionStatus = EFI_UNSUPPORTED;
}
}
/**
Function to retrieve the WiFi connection status when in OCR WLAN flow
@return EFI_SUCCESS WiFi connection completed succesfully
@return Others Error Occurred
**/
EFI_STATUS
EFIAPI
WifiProfileSyncGetConnectStatus (
VOID
)
{
return mWcmConnectionStatus;
}
/**
Setup data update to included wifi driver.
@param [in] NetworkSupport Determine if we are adding or removing the WiFi device from
PCI required for boot list
@retval EFI_SUCCESS Setup data set successfully
@retval EFI_UNSUPPORTED Failed to get or set the setup data
@retval Others Error occurred
**/
EFI_STATUS
IncludeWifiSetupData (
IN BOOLEAN NetworkSupport
)
{
EFI_STATUS Status;
SETUP_DATA SetupData;
UINT32 SetupAttributes;
UINTN VariableSize;
EFI_EVENT ReadyToBootServiceEvent;
VariableSize = sizeof (SETUP_DATA);
Status = gRT->GetVariable (
L"Setup",
&gSetupVariableGuid,
&SetupAttributes,
&VariableSize,
&SetupData
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get setup data EfiNetworkSupport during update.\n"));
return EFI_UNSUPPORTED;
}
SetupData.EfiNetworkSupport = NetworkSupport ? EfiNetworkWifi : EfiNetworkDisabled;
Status = gRT->SetVariable (
L"Setup",
&gSetupVariableGuid,
SetupAttributes,
sizeof (SETUP_DATA),
&SetupData
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to set setup data EfiNetworkSupport during update.\n"));
ASSERT_EFI_ERROR (Status);
return EFI_UNSUPPORTED;
}
if (NetworkSupport) {
// Register Ready to Boot Event for resetting the setup data to avoid triggering Wifi connection on regular boot
Status = EfiCreateEventReadyToBootEx (
TPL_CALLBACK,
WifiProfileSyncDisableNetwork,
NULL,
&ReadyToBootServiceEvent
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to to register callback to disable network setup data.\n"));
ASSERT_EFI_ERROR (Status);
return EFI_DEVICE_ERROR;
}
}
return EFI_SUCCESS;
}
/**
Callback to reset EFI newtork data setup data
@param[in] Event A pointer to the Event that triggered the callback
@param[in] Context A pointer to private data registered with the callback function
**/
VOID
EFIAPI
WifiProfileSyncDisableNetwork (
IN EFI_EVENT Event,
IN VOID *Context
)
{
// Remove WiFi device from PCI device needed for boot
IncludeWifiSetupData (FALSE);
}
/**
Event function to clear memory and uninstall WiFi profile protocol from system once
WiFi Connection Manager has aquired necessary profile data to during OCR WLAN boot flow.
@return EFI_SUCCESS Profiles returned
@return EFI_UNSUPPORTED Protocol not supported
@return Others Error Occurred
**/
EFI_STATUS
WifiProfileSyncClean (
VOID
)
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN NumHandle;
UINTN Index;
WIFI_PROFILE_SYNC_PROTOCOL *ProfileSyncProtocol;
HandleBuffer = NULL;
// Clean memory
if (mSyncProfile != NULL) {
ZeroMem (mSyncProfile, sizeof (mSyncProfile));
FreePool (mSyncProfile);
}
Status = gBS->LocateProtocol (&gWiFiProfileSyncProtocolGuid, NULL, (VOID **) &ProfileSyncProtocol);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to find profile protocol with status %r\n", Status));
return Status;
}
// Get handle for WiFi profile porotocol to uninstall protocol
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gWiFiProfileSyncProtocolGuid,
NULL,
&NumHandle,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get handle to uninstall protocol with status %r\n", Status));
return Status;
}
// Uninstall the WiFi profile protocol
for (Index = 0; Index < NumHandle; Index++) {
Status = gBS->UninstallMultipleProtocolInterfaces (
HandleBuffer[Index],
&gWiFiProfileSyncProtocolGuid,
&mWiFiProfileSyncProtocol,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to uninstall WiFi profile protocol."));
}
}
return Status;
}
/**
Callback set for exit boot services to clear the profile data from memory and unistall protocol
@param[in] Event A pointer to the Event that triggered the callback
@param[in] Context A pointer to private data registered with the callback function
**/
VOID
EFIAPI
WifiProfileSyncCleanCallback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
Status = WifiProfileSyncClean ();
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to clean WiFi profile secrets!"));
}
gBS->CloseEvent (Event);
}
/**
This API will be used by the WiFi connection manager to get the WiFi profile that ASF shared
and stored in WiFi profile protocol. This will as well align the ASF to the WCM profile
structure
@param[in, out] WcmProfile WiFi Connection Manager profile structure
@return EFI_SUCCESS Profiles returned
@return EFI_UNSUPPORTED Profile protocol sharing not supported or enabled
@return EFI_NOT_FOUND No profiles returned
@return Others Error Occurred
**/
EFI_STATUS
EFIAPI
WifiProfileSyncGetProfile (
IN OUT WIFI_MGR_NETWORK_PROFILE *WcmProfile
)
{
EFI_STATUS Status;
UINT32 Oui_Ieee_80211i;
// Send Sync'd ASF profile data to WCM profile data
WcmProfile->Signature = WIFI_MGR_PROFILE_SIGNATURE;
WcmProfile->NicIndex = 1;
WcmProfile->ProfileIndex = 0;
CopyMem (&WcmProfile->SSId, &mSyncProfile->ProfileData->SSId, mSyncProfile->ProfileData->SSIdLength);
// Psk Key
if (mSyncProfile->ProfileData->PskKeyType == PSK_NETWORK) {
Status = BufferToHexArray ((CHAR16 *) &WcmProfile->Password, PASSWORD_STORAGE_SIZE, (UINT8 *) &mSyncProfile->ProfileData->PskKey, mSyncProfile->ProfileData->PskKeyLen);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "[WiFiProfileSync] Failed to convert password with status of %r\n", Status));
return Status;
}
}
// CA Certificate
WcmProfile->CACertSize = mSyncProfile->CaCert->CertSize;
if (mSyncProfile->CaCert->CertSize > 0) {
WcmProfile->CACertData = (VOID *) &mSyncProfile->CaCert->Cert;
} else {
WcmProfile->CACertData = (VOID *) NULL;
}
// Client certificate and key
if (mSyncProfile->ProfileData->UserCredentialsClientCertificateAvailable) {
WcmProfile->ClientCertData = (VOID *) &mSyncProfile->Cert->Certificate;
WcmProfile->ClientCertSize = mSyncProfile->Cert->CertSize;
WcmProfile->PrivateKeyData = (VOID *) &mSyncProfile->Key->Key;
WcmProfile->PrivateKeyDataSize = mSyncProfile->Key->KeySize;
} else {
WcmProfile->ClientCertData = NULL;
WcmProfile->ClientCertSize = 0;
WcmProfile->PrivateKeyData = NULL;
WcmProfile->PrivateKeyDataSize = 0;
}
// 802.1x EAP
WcmProfile->IsAvailable = TRUE;
WcmProfile->EapAuthMethod = MapEapAuthMethod (mSyncProfile->ProfileData->AuthenticationProtocol_eapMethod);
if (StrLen ((CHAR16 *) &mSyncProfile->ProfileData->UserCredentialsRoamingIdentity) > 0 ) {
CopyMem (&WcmProfile->EapIdentity, &mSyncProfile->ProfileData->UserCredentialsRoamingIdentity, sizeof (mSyncProfile->ProfileData->UserCredentialsRoamingIdentity)-1);
} else {
CopyMem (&WcmProfile->EapIdentity, &mSyncProfile->ProfileData->UserCredentialsUsername, sizeof (mSyncProfile->ProfileData->UserCredentialsUsername)-1);
}
CopyMem (&WcmProfile->EapPassword, &mSyncProfile->ProfileData->UserCredentialsPassword, sizeof (mSyncProfile->ProfileData->UserCredentialsPassword));
WcmProfile->EapSecondAuthMethod = MapAuthInnerMethodToEapSecondAuthMethod (mSyncProfile->ProfileData->AuthenticationProtocolInnerMethod);
// Network authentication and encryption method
WcmProfile->Network.BSSType = IeeeInfrastructureBSS;
WcmProfile->Network.AKMSuite = (EFI_80211_AKM_SUITE_SELECTOR *) AllocateZeroPool (sizeof (EFI_80211_AKM_SUITE_SELECTOR));
WcmProfile->Network.CipherSuite = (EFI_80211_CIPHER_SUITE_SELECTOR *) AllocateZeroPool (sizeof (EFI_80211_CIPHER_SUITE_SELECTOR));
if ((WcmProfile->Network.AKMSuite == NULL) || (WcmProfile->Network.CipherSuite == NULL)) {
return EFI_OUT_OF_RESOURCES;
}
WcmProfile->Network.SSId.SSIdLen = mSyncProfile->ProfileData->SSIdLength;
CopyMem (&WcmProfile->Network.SSId.SSId, &mSyncProfile->ProfileData->SSId, sizeof (WcmProfile->Network.SSId.SSId));
WcmProfile->Network.AKMSuite->AKMSuiteCount = 1;
WcmProfile->Network.CipherSuite->CipherSuiteCount = 1;
Oui_Ieee_80211i = OUI_IEEE_80211I;
CopyMem (&WcmProfile->Network.AKMSuite->AKMSuiteList[0].Oui, &Oui_Ieee_80211i, sizeof (Oui_Ieee_80211i));
CopyMem (&WcmProfile->Network.CipherSuite->CipherSuiteList[0].Oui, &Oui_Ieee_80211i, sizeof (Oui_Ieee_80211i));
WcmProfile->Network.AKMSuite->AKMSuiteList[0].SuiteType = MapAuthenticationToAKM (mSyncProfile->ProfileData->AuthenticationMethod);
WcmProfile->Network.CipherSuite->CipherSuiteList[0].SuiteType = MapEncryptionToCipher (mSyncProfile->ProfileData->EncryptionMethod);
return EFI_SUCCESS;
}
/**
Retrieve WiFi profile information including client certificate and key using ASF
@param[in,out] Profile WiFi profile protocol structure aquired from ASF
@return EFI_SUCCESS Profiles returned
@return EFI_OUT_OF_RESOURCES Not enough memory
@return EFI_UNSUPPORTED Profile Sync is not supported via PCD or other parameter
@return Others Error Occurred
**/
EFI_STATUS
GetAsfWifiProfile (
IN OUT WIFI_PROFILE *Profile
)
{
EFI_STATUS Status;
UINT32 TimeoutCount = 0;
if (Profile == NULL) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Invalid profile address supplied!\n"));
return EFI_INVALID_PARAMETER;
}
while (TimeoutCount < ME_DELAY_COUNT) {
// Get ASF profile name
Profile->ProfileData = (WIFI_PROFILE_DATA *) AllocateZeroPool (sizeof (WIFI_PROFILE_DATA));
if (Profile->ProfileData == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = AsfWifiGetProfileName (Profile->ProfileData);
if (!EFI_ERROR (Status) && (Profile->ProfileData->Status == AmtStatusSuccess)) {
TimeoutCount = 0;
break;
}
MicroSecondDelay (ME_WLAN_DELAY);
TimeoutCount++;
if ((TimeoutCount >= ME_DELAY_COUNT) || (Profile->ProfileData->Status != AmtStatusNotFound)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get profile name within time limit with status 0x%X\n", Profile->ProfileData->Status));
return EFI_NOT_FOUND;
}
}
// Get profile data
Status = AsfWifiGetProfileData (Profile->ProfileData);
if (EFI_ERROR (Status) || (Profile->ProfileData->Status != AmtStatusSuccess)) {
return EFI_UNSUPPORTED;
}
if (Profile->ProfileData->UserCredentialsClientCertificateAvailable == 0x01) {
// Get Certificate
Profile->Cert = (WIFI_8021X_CLIENT_CERT *) AllocateZeroPool (sizeof (WIFI_8021X_CLIENT_CERT));
if (Profile->Cert == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = AsfWifiGetClientCertificate (Profile);
if (EFI_ERROR (Status) || (Profile->Cert->Status != AmtStatusSuccess)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get client certificate with status 0x%x\n", Profile->Cert->Status));
return Status;
}
// Get key
Profile->Key = (WIFI_8021X_CLIENT_KEY *) AllocateZeroPool (sizeof (WIFI_8021X_CLIENT_KEY));
if (Profile->Key == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = AsfWifiGetClientKey (Profile);
if (EFI_ERROR (Status) || (Profile->Key->Status != AmtStatusSuccess)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get client key with status 0x%x\n", Profile->Key->Status));
return Status;
}
}
if (Profile->ProfileData->RootCACertificateIndex != ROOT_CA_NOT_AVAILABLE) {
Profile->CaCert = (ROOT_CA_CERTIFICATE *) AllocateZeroPool (sizeof (ROOT_CA_CERTIFICATE));
if (Profile->CaCert == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = AsfGetRootCaCertificate (0, Profile->CaCert);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get root CA certificate with status 0x%x\n", Status));
}
}
return Status;
}
/**
Enable or disable HECI in the WiFI driver during HTTP boot flows.
@param[in] State Value corresponding to enable, TRUE, or disable, FALSE.
@return EFI_SUCCESS Successfully set the flag for the WiFi driver
@return EFI_UNSUPPORTED Failed to set the enable/disable flag
@return Others Error Occurred
**/
EFI_STATUS
EnableWifiAmtCoex (
IN BOOLEAN State
)
{
EFI_STATUS Status;
Status = gRT->SetVariable (
L"EnableWifiAmtCoex",
&gUefiIntelCnvWlanVariablesGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof(State),
&State
);
if (EFI_ERROR (Status)) {
ASSERT_EFI_ERROR (Status);
}
return Status;
}
/**
Main flow for profile sync drivers getting profile from ASF
@return EFI_SUCCESS Profiles returned
@return EFI_UNSUPPORTED Profile Sync is not supported to retrieve ASF profile
@return Others Error Occurred
**/
EFI_STATUS
WifiProfileSyncMain (
VOID
)
{
EFI_STATUS Status;
EFI_EVENT ExitBootServiceEvent;
WIFI_PROFILE_SYNC_PROTOCOL *ProfileSyncProtocol;
mWcmConnectionStatus = EFI_NOT_READY;
Status = gBS->LocateProtocol (&gWiFiProfileSyncProtocolGuid, NULL, (VOID **) &ProfileSyncProtocol);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to find profile protocol with status %r\n", Status));
ASSERT_EFI_ERROR (Status);
return Status;
}
mSyncProfile = (WIFI_PROFILE *) AllocateZeroPool (sizeof (WIFI_PROFILE));
if (mSyncProfile == NULL) {
return EFI_OUT_OF_RESOURCES;
}
// Get profile from ASF
Status = GetAsfWifiProfile (mSyncProfile);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to get ASF WiFi profile data, certificate, and key with status %r!\n", Status));
WifiProfileSyncClean ();
return EFI_LOAD_ERROR;
}
// Set supported network setup variable to WiFi network
IncludeWifiSetupData (TRUE);
// Set WiFi AMT coexistence flag true
Status = EnableWifiAmtCoex (TRUE);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to set enable WiFi AMT coexistence flag to TRUE with status %r!\n", Status));
ASSERT_EFI_ERROR (Status);
}
// Register Exit Boot Services Event to clear profile data from memory
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
WifiProfileSyncCleanCallback,
NULL,
&gEfiEventExitBootServicesGuid,
&ExitBootServiceEvent
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to register profile protocol clean callback with status %r\n", Status));
WifiProfileSyncClean ();
ASSERT_EFI_ERROR (Status);
}
return Status;
}
/**
Check for Secure boot, boot gaurd and proper boot options and pcd's are enabling for ProfileSync.
@return EFI_SUCCESS Profiles returned
@return EFI_UNSUPPORTED Protocol not supported
@return Others Error Occurred
**/
BOOLEAN
IsProfileSyncSupported (
VOID
)
{
EFI_STATUS Status;
UINT16 SpecialCommand;
UINT8 SecureBootState;
UINTN VarSize;
UINT32 VarAttributes;
UINT64 BootGuardBootStatus;
UINT64 BootGuardOperationMode;
AMT_WRAPPER_PROTOCOL *AmtWrapper;
// Check for secure boot enabled
VarSize = sizeof (UINT8);
Status = gRT->GetVariable (
EFI_SECURE_BOOT_ENABLE_NAME,
&gEfiSecureBootEnableDisableGuid,
&VarAttributes,
&VarSize,
&SecureBootState
);
if (EFI_ERROR (Status) || (SecureBootState == SECURE_BOOT_DISABLE)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Unsupported - Secureboot disabled!\n"));
return FALSE;
}
if (IsBootGuardSupported ()) {
BootGuardBootStatus = (*(UINT64 *) (UINTN) (TXT_PUBLIC_BASE + R_CPU_BOOT_GUARD_BOOTSTATUS) & (BIT63 | BIT62));
BootGuardOperationMode = AsmReadMsr64 (MSR_BOOT_GUARD_SACM_INFO) & (B_BOOT_GUARD_SACM_INFO_MEASURED_BOOT | B_BOOT_GUARD_SACM_INFO_VERIFIED_BOOT);
if ((BootGuardBootStatus == V_CPU_BOOT_GUARD_LOAD_ACM_SUCCESS) && (BootGuardOperationMode != 0)) {
SpecialCommand = AsfGetSpecialCommand ();
if (SpecialCommand == ASF_INTEL_OEM_FORCE_HTTPS_BOOT_CMD) {
return TRUE;
}
Status = gBS->LocateProtocol (&gAmtWrapperProtocolGuid, NULL, (VOID **) &AmtWrapper);
if (!EFI_ERROR (Status) && AmtWrapper->IsKvmEnabled ()) {
return TRUE;
}
} else {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Unsupported - Bootguard disabled!\n"));
}
} else {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Unsupported - Bootguard is not supported!\n"));
}
return FALSE;
}
/**
The entry point for the Wifi Profile Sync driver.
@param[in] ImageHandle The firmware allocated handle for the EFI image
@param[in] SystemTable A pointer to the EFI System Table
@retval EFI_SUCCESS The entry point is executed successfully
@retval other Some error occurs when executing this entry point
**/
EFI_STATUS
EFIAPI
WifiProfileSyncEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_TPL OldTpl;
if (!IsProfileSyncSupported ()) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] WiFi profile sync not supported!\n"));
return EFI_UNSUPPORTED;
}
Status = EnableWifiAmtCoex (FALSE);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to set enable WiFi AMT coexistence flag to FALSE with status %r!\n", Status));
ASSERT_EFI_ERROR (Status);
}
Status = gBS->InstallMultipleProtocolInterfaces (
&ImageHandle,
&gWiFiProfileSyncProtocolGuid,
&mWiFiProfileSyncProtocol,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "[WiFiProfileSync] Failed to install protocol with status %r\n", Status));
return EFI_UNSUPPORTED;
}
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
Status = WifiProfileSyncMain ();
gBS->RestoreTPL (OldTpl);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink