[SL-UP] Refactor Platform WiFi events

src/platform/silabs/CHIPDevicePlatformEvent.h

@@ -40,15 +40,15 @@ namespace DeviceEventType {
  */
 enum PublicPlatformSpecificEventTypes
 {
-    /* None currently defined */
+    kSLSystemEvent = kRange_PublicPlatformSpecific,
 };
 
 /**
  * Enumerates Silabs platform-specific event types that are internal to the Chip Device Layer.
  */
 enum InternalPlatformSpecificEventTypes
 {
-    kWFXSystemEvent = kRange_InternalPlatformSpecific,
+    kPlatformSLEvent = kRange_InternalPlatformSpecific,
 };
 
 } // namespace DeviceEventType

src/platform/silabs/ConnectivityManagerImpl.h

@@ -117,10 +117,14 @@ class ConnectivityManagerImpl final : public ConnectivityManager,
 
     // ===== Private members reserved for use by this class only.
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION
-    System::Clock::Timestamp mLastStationConnectFailTime;
+    // variables for tracking the station mode and state
     WiFiStationMode mWiFiStationMode;
     WiFiStationState mWiFiStationState;
+    // variables for tracking the last connection failure time and reconnect interval
+    System::Clock::Timestamp mLastStationConnectFailTime;
     System::Clock::Timeout mWiFiStationReconnectInterval;
+    uint8_t mWiFiStationReconnectCount;
+    // flags for tracking the internet connectivity state
     BitFlags<Flags> mFlags;
 
     void DriveStationState(void);

src/platform/silabs/NetworkCommissioningWiFiDriver.cpp

@@ -45,24 +45,32 @@ CHIP_ERROR SlWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChangeC
     mpConnectCallback      = nullptr;
     mpStatusChangeCallback = networkStatusChangeCallback;
     mDriver                = this;
-    // TODO: default to SL_WIFI_SSID and SL_WIFI_PSK if not defined
-#ifdef SL_ONNETWORK_PAIRING
-    memcpy(&mSavedNetwork.ssid[0], SL_WIFI_SSID, sizeof(SL_WIFI_SSID));
-    memcpy(&mSavedNetwork.key[0], SL_WIFI_PSK, sizeof(SL_WIFI_PSK));
-    mSavedNetwork.keyLen  = sizeof(SL_WIFI_PSK);
-    mSavedNetwork.ssidLen = sizeof(SL_WIFI_SSID);
-    err                   = CHIP_NO_ERROR;
-#else
     // If reading fails, wifi is not provisioned, no need to go further.
     err = SilabsConfig::ReadConfigValueBin(SilabsConfig::kConfigKey_WiFiSSID, mSavedNetwork.ssid, sizeof(mSavedNetwork.ssid),
                                            mSavedNetwork.ssidLen);
+    if (err != CHIP_NO_ERROR)
+    {
+#if defined(SL_ONNETWORK_PAIRING) && SL_ONNETWORK_PAIRING
+        memcpy(&mSavedNetwork.ssid, SL_WIFI_SSID, sizeof(SL_WIFI_SSID));
+        mSavedNetwork.ssidLen = sizeof(SL_WIFI_SSID);
+
+        err = CHIP_NO_ERROR;
+#endif // SL_ONNETWORK_PAIRING
+    }
     VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_NO_ERROR);
 
     err = SilabsConfig::ReadConfigValueBin(SilabsConfig::kConfigKey_WiFiPSK, mSavedNetwork.key, sizeof(mSavedNetwork.key),
                                            mSavedNetwork.keyLen);
-    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_NO_ERROR);
+    if (err != CHIP_NO_ERROR)
+    {
+#if defined(SL_ONNETWORK_PAIRING) && SL_ONNETWORK_PAIRING
+        memcpy(&mSavedNetwork.key, SL_WIFI_PSK, sizeof(SL_WIFI_PSK));
+        mSavedNetwork.keyLen = sizeof(SL_WIFI_PSK);
 
+        err = CHIP_NO_ERROR;
 #endif // SL_ONNETWORK_PAIRING
+    }
+    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_NO_ERROR);
     mStagingNetwork = mSavedNetwork;
     err             = ConnectWiFiNetwork(reinterpret_cast<const char *>(mSavedNetwork.ssid), mSavedNetwork.ssidLen,
                                          reinterpret_cast<const char *>(mSavedNetwork.key), mSavedNetwork.keyLen);
@@ -100,17 +108,19 @@ Status SlWiFiDriver::AddOrUpdateNetwork(ByteSpan ssid, ByteSpan credentials, Mut
                                         uint8_t & outNetworkIndex)
 {
     outDebugText.reduce_size(0);
+    // since we only support one network, we always return 0
     outNetworkIndex = 0;
+    // using ssid as the networkId
     VerifyOrReturnError(mStagingNetwork.ssidLen == 0 || NetworkMatch(mStagingNetwork, ssid), Status::kBoundsExceeded);
     VerifyOrReturnError(credentials.size() <= sizeof(mStagingNetwork.key), Status::kOutOfRange);
     VerifyOrReturnError(ssid.size() <= sizeof(mStagingNetwork.ssid), Status::kOutOfRange);
 
-    VerifyOrReturnError(ssid.data() != nullptr, Status::kNetworkNotFound);
+    VerifyOrReturnError(ssid.data() != nullptr, Status::kNetworkIDNotFound);
     MutableByteSpan ssidSpan(mStagingNetwork.ssid, sizeof(mStagingNetwork.ssid));
     VerifyOrReturnError(CopySpanToMutableSpan(ssid, ssidSpan) == CHIP_NO_ERROR, Status::kBoundsExceeded);
     mStagingNetwork.ssidLen = ssid.size();
 
-    VerifyOrReturnError(credentials.data() != nullptr, Status::kNetworkNotFound);
+    VerifyOrReturnError(credentials.data() != nullptr, Status::kNetworkIDNotFound);
     MutableByteSpan keySpan(mStagingNetwork.key, sizeof(mStagingNetwork.key));
     VerifyOrReturnError(CopySpanToMutableSpan(credentials, keySpan) == CHIP_NO_ERROR, Status::kBoundsExceeded);
     mStagingNetwork.keyLen = credentials.size();
@@ -140,8 +150,10 @@ Status SlWiFiDriver::ReorderNetwork(ByteSpan networkId, uint8_t index, MutableCh
 
 CHIP_ERROR SlWiFiDriver::ConnectWiFiNetwork(const char * ssid, uint8_t ssidLen, const char * key, uint8_t keyLen)
 {
+    // if the WiFi station is provisioned, disconnect it and clear the credentials
     if (ConnectivityMgr().IsWiFiStationProvisioned())
     {
+        ConnectivityMgr().ClearWiFiStationProvision();
         ChipLogProgress(DeviceLayer, "Disconnecting for current wifi");
         WifiInterface::GetInstance().TriggerDisconnection();
     }
@@ -158,11 +170,11 @@ CHIP_ERROR SlWiFiDriver::ConnectWiFiNetwork(const char * ssid, uint8_t ssidLen,
     memcpy(wifiConfig.key, key, keyLen);
     wifiConfig.keyLen = keyLen;
 
+    // dummy value which is overridden by the actual security value when connecting to the access point
     wifiConfig.security.Set(chip::app::Clusters::NetworkCommissioning::WiFiSecurityBitmap::kWpa2Personal);
 
     ChipLogProgress(NetworkProvisioning, "Setting up connection for WiFi SSID: %s", NullTerminated(ssid, ssidLen).c_str());
-    // Resetting the retry connection state machine for a new access point connection
-    WifiInterface::GetInstance().ResetConnectionRetryInterval();
+
     ReturnErrorOnFailure(WifiInterface::GetInstance().SetWifiCredentials(wifiConfig));
     ReturnErrorOnFailure(ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Disabled));
     ReturnErrorOnFailure(ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled));
@@ -172,22 +184,14 @@ CHIP_ERROR SlWiFiDriver::ConnectWiFiNetwork(const char * ssid, uint8_t ssidLen,
 // TODO: Re-write implementation with proper driver based callback
 void SlWiFiDriver::UpdateNetworkingStatus()
 {
-    if (mpStatusChangeCallback == nullptr)
-    {
-        ChipLogError(NetworkProvisioning, "networkStatusChangeCallback is nil");
-        return;
-    }
-
-    if (mStagingNetwork.ssidLen == 0)
-    {
-        ChipLogError(NetworkProvisioning, "ssidLen is 0");
-        return;
-    }
+    VerifyOrReturn(mpStatusChangeCallback != nullptr);
+    VerifyOrReturn(mStagingNetwork.ssidLen != 0);
 
     ByteSpan networkId = ByteSpan((const unsigned char *) mStagingNetwork.ssid, mStagingNetwork.ssidLen);
     if (!WifiInterface::GetInstance().IsStationConnected())
     {
         // TODO: https://github.com/project-chip/connectedhomeip/issues/26861
+        // TODO: use the mLastDisconnectionReason to set the networking status
         mpStatusChangeCallback->OnNetworkingStatusChange(Status::kUnknownError, MakeOptional(networkId),
                                                          MakeOptional(static_cast<int32_t>(SL_STATUS_FAIL)));
         return;
@@ -199,7 +203,7 @@ void SlWiFiDriver::OnConnectWiFiNetwork()
 {
     if (mpConnectCallback)
     {
-        TEMPORARY_RETURN_IGNORED CommitConfiguration();
+        // TODO: use the mLastDisconnectionReason to set the networking status
         mpConnectCallback->OnResult(Status::kSuccess, CharSpan(), 0);
         mpConnectCallback = nullptr;
     }
@@ -226,6 +230,7 @@ void SlWiFiDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * callback
     {
         ChipLogError(NetworkProvisioning, "Failed to connect to WiFi network: %" CHIP_ERROR_FORMAT, err.Format());
         mpConnectCallback = nullptr;
+        // TODO: use the mLastDisconnectionReason to set the networking status
         callback->OnResult(networkingStatus, CharSpan(), 0);
     }
 }

src/platform/silabs/PlatformManagerImpl.cpp

@@ -195,7 +195,7 @@ void HandleWFXSystemEvent(sl_wfx_generic_message_t * eventData)
 
     ChipDeviceEvent event;
     memset(&event, 0, sizeof(event));
-    event.Type = DeviceEventType::kWFXSystemEvent;
+    event.Type = DeviceEventType::kPlatformSLEvent;
 
     switch (eventData->header.id)
     {

src/platform/silabs/wifi/SiWx/WifiInterfaceImpl.cpp

@@ -36,7 +36,7 @@
 #include <inet/UDPEndPointImplLwIP.h>
 // TODO: Remove nogncheck once we have a proper way to include this file.
 #include <platform/CHIPDeviceLayer.h> // nogncheck
-#endif // SL_INET_CONFIG_UDP_LWIP_QUEUE_UNTIL_NETIF_READY
+#endif                                // SL_INET_CONFIG_UDP_LWIP_QUEUE_UNTIL_NETIF_READY
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CHIPMemString.h>
 #include <lib/support/logging/CHIPLogging.h>
@@ -709,7 +709,8 @@ sl_status_t WifiInterfaceImpl::JoinWifiNetwork(void)
 #endif // SL_MATTER_NEUTRAL_LESS_SWITCH_WIFI
 
     wfx_rsi.dev_state.Clear(WifiInterface::WifiState::kStationConnecting).Clear(WifiInterface::WifiState::kStationConnected);
-    ScheduleConnectionAttempt();
+    mLastDisconnectionReason = static_cast<uint16_t>(status);
+    WifiInterface::NotifyDisconnection(mLastDisconnectionReason);
 
     return status;
 }
@@ -742,7 +743,10 @@ sl_status_t WifiInterfaceImpl::JoinCallback(sl_wifi_event_t event, char * result
         ChipLogError(DeviceLayer, "JoinCallback: failed: 0x%lx", status);
         wfx_rsi.dev_state.Clear(WifiInterface::WifiState::kStationConnected);
 
-        mInstance.ScheduleConnectionAttempt();
+        uint16_t reason               = static_cast<uint16_t>(status);
+        WifiInterfaceImpl & self      = WifiInterfaceImpl::GetInstance();
+        self.mLastDisconnectionReason = reason;
+        self.NotifyDisconnection(self.mLastDisconnectionReason);
     }
 
     return status;
@@ -848,6 +852,8 @@ sl_status_t WifiInterfaceImpl::TriggerPlatformWifiDisconnection()
     sl_status_t status = sl_net_down(SL_NET_WIFI_CLIENT_INTERFACE);
     VerifyOrReturnError(status == SL_STATUS_OK, status, ChipLogError(DeviceLayer, "sl_net_down failed: 0x%lx", status));
 
+    mLastDisconnectionReason = static_cast<uint16_t>(status);
+    WifiInterface::NotifyDisconnection(mLastDisconnectionReason);
     return SL_STATUS_OK;
 }
 
@@ -893,8 +899,6 @@ CHIP_ERROR WifiInterfaceImpl::InitLitPrecheckInReconnectTimer()
 
 CHIP_ERROR WifiInterfaceImpl::ConfigureLITConnect()
 {
-    ResetConnectionRetryInterval();
-
     VerifyOrReturnError(IsWifiProvisioned(), CHIP_NO_ERROR);
 
     VerifyOrReturnError(!IsStationConnected(), CHIP_NO_ERROR);
@@ -1129,9 +1133,10 @@ CHIP_ERROR WifiInterfaceImpl::StartWifiTask()
     return CHIP_NO_ERROR;
 }
 
-void WifiInterfaceImpl::ConfigureStationMode()
+CHIP_ERROR WifiInterfaceImpl::EnableStationMode()
 {
     wfx_rsi.dev_state.Set(WifiState::kStationMode);
+    return CHIP_NO_ERROR;
 }
 
 bool WifiInterfaceImpl::IsStationModeEnabled()
@@ -1229,6 +1234,55 @@ CHIP_ERROR WifiInterfaceImpl::ConnectToAccessPoint()
     return CHIP_NO_ERROR;
 }
 
+chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum
+WifiInterfaceImpl::MapToNetworkCommissioningStatusEnum(uint32_t reason)
+{
+    /*
+    kSuccess
+    kOutOfRange
+    kBoundsExceeded
+    kNetworkIDNotFound
+    kDuplicateNetworkID
+    kNetworkNotFound
+    kRegulatoryError
+    kAuthFailure
+    kUnsupportedSecurity
+    kOtherConnectionFailure
+    kIPV6Failed
+    kIPBindFailed
+    kUnknownError
+    */
+    using Status = chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum;
+
+    switch (reason)
+    {
+    case SL_STATUS_OK:
+        return Status::kSuccess;
+    case SL_STATUS_SI91X_NO_AP_FOUND:
+    case SL_STATUS_SI91X_BEACON_MISSED_FROM_AP_DURING_JOIN:
+    case SL_STATUS_SI91X_REJOIN_FAILURE:
+        return Status::kNetworkNotFound;
+    case SL_STATUS_SI91X_INVALID_CHANNEL:
+        return Status::kRegulatoryError;
+    case SL_STATUS_SI91X_INVALID_PSK_IN_WEP_SECURITY:
+    case SL_STATUS_SI91X_DEAUTHENTICATION_RECEIVED_FROM_AP:
+    case SL_STATUS_SI91X_ASSOCIATION_FAILED:
+    case SL_STATUS_SI91X_JOIN_AUTHENTICATION_FAILED:
+    case SL_STATUS_SI91X_MAX_BEACON_MISCOUNT:
+    case SL_STATUS_SI91X_DEAUTH_REQUEST_FROM_SUPPLICANT:
+    case SL_STATUS_SI91X_DEAUTH_REQUEST_FROM_FROM_AP:
+    case SL_STATUS_SI91X_AUTHENTICATION_TIMEOUT:
+        return Status::kAuthFailure;
+    case SL_STATUS_SI91X_INVALID_SECURITY_MODE_IN_JOIN_COMMAND:
+        return Status::kUnsupportedSecurity;
+    case SL_STATUS_SI91X_ASSOCIATION_TIMEOUT:
+    case SL_STATUS_SI91X_FOUR_WAY_HANDSHAKE_FAILED:
+        return Status::kOtherConnectionFailure;
+    default:
+        return Status::kUnknownError;
+    }
+}
+
 bool WifiInterfaceImpl::HasAnIPv4Address()
 {
     bool hasIPv4 = false;

src/platform/silabs/wifi/SiWx/WifiInterfaceImpl.h

@@ -53,7 +53,7 @@ class WifiInterfaceImpl final : public WifiInterface
     CHIP_ERROR GetMacAddress(sl_wfx_interface_t interface, chip::MutableByteSpan & addr) override;
     CHIP_ERROR StartNetworkScan(chip::ByteSpan ssid, ScanCallback callback) override;
     CHIP_ERROR StartWifiTask() override;
-    void ConfigureStationMode() override;
+    CHIP_ERROR EnableStationMode() override;
     bool IsStationConnected() override;
     bool IsStationModeEnabled() override;
     bool IsStationReady() override;
@@ -70,7 +70,7 @@ class WifiInterfaceImpl final : public WifiInterface
     CHIP_ERROR GetAccessPointInfo(chip::DeviceLayer::NetworkCommissioning::WiFiScanResponse & info) override;
     CHIP_ERROR GetAccessPointExtendedInfo(wfx_wifi_scan_ext_t & info) override;
     CHIP_ERROR ResetCounters() override;
-
+    chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum MapToNetworkCommissioningStatusEnum(uint32_t reason) override;
 #if CHIP_CONFIG_ENABLE_ICD_SERVER
     CHIP_ERROR ConfigureBroadcastFilter(bool enableBroadcastFilter) override;
     CHIP_ERROR ConfigurePowerSave(PowerSaveInterface::PowerSaveConfiguration configuration, uint32_t listenInterval) override;