implement error mapping from ameba to matter

src/platform/Ameba/AmebaUtils.cpp

@@ -40,10 +40,10 @@ constexpr char kWiFiCredentialsKeyName[] = "wifi-pass";
 
 CHIP_ERROR AmebaUtils::StartWiFi(void)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
  // Ensure that the WiFi layer is started.
- matter_wifi_on(RTW_MODE_STA);
- return err;
+ int32_t error = matter_wifi_on(RTW_MODE_STA);
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
+ return CHIP_NO_ERROR; // will fail if wifi is already initialized, let it pass
 }
 
 CHIP_ERROR AmebaUtils::IsStationEnabled(bool & staEnabled)
@@ -60,22 +60,23 @@ bool AmebaUtils::IsStationProvisioned(void)
 
 CHIP_ERROR AmebaUtils::IsStationConnected(bool & connected)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
- connected = (matter_wifi_is_connected_to_ap() == RTW_SUCCESS) ? 1 : 0;
+ int32_t error = matter_wifi_is_connected_to_ap();
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
+ connected = (err == CHIP_NO_ERROR) ? true : false;
  return err;
 }
 
 CHIP_ERROR AmebaUtils::EnableStationMode(void)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
  // Ensure that station mode is enabled in the WiFi layer.
- matter_wifi_set_mode(RTW_MODE_STA);
+ int32_t error = matter_wifi_set_mode(RTW_MODE_STA);
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
  return err;
 }
 
 CHIP_ERROR AmebaUtils::SetWiFiConfig(rtw_wifi_config_t * config)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
+ CHIP_ERROR err;
  // don't store if ssid is null
  if (config->ssid[0] == 0)
  {
@@ -95,7 +96,7 @@ CHIP_ERROR AmebaUtils::SetWiFiConfig(rtw_wifi_config_t * config)
 
 CHIP_ERROR AmebaUtils::GetWiFiConfig(rtw_wifi_config_t * config)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
+ CHIP_ERROR err;
  size_t ssidLen = 0;
  size_t credentialsLen = 0;
 
@@ -117,8 +118,8 @@ CHIP_ERROR AmebaUtils::GetWiFiConfig(rtw_wifi_config_t * config)
 CHIP_ERROR AmebaUtils::ClearWiFiConfig()
 {
  /* Clear Wi-Fi Configurations in Storage */
- CHIP_ERROR err = CHIP_NO_ERROR;
- err  = PersistedStorage::KeyValueStoreMgr().Delete(kWiFiSSIDKeyName);
+ CHIP_ERROR err;
+ err = PersistedStorage::KeyValueStoreMgr().Delete(kWiFiSSIDKeyName);
  SuccessOrExit(err);
 
  err = PersistedStorage::KeyValueStoreMgr().Delete(kWiFiCredentialsKeyName);
@@ -130,43 +131,46 @@ CHIP_ERROR AmebaUtils::ClearWiFiConfig()
 
 CHIP_ERROR AmebaUtils::WiFiDisconnect(void)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
- ChipLogProgress(DeviceLayer, "matter_wifi_disconnect");
- err = (matter_wifi_disconnect() == RTW_SUCCESS) ? CHIP_NO_ERROR : CHIP_ERROR_INTERNAL;
+ ChipLogProgress(DeviceLayer, "Disconnecting WiFi");
+ int32_t error = matter_wifi_disconnect();
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
+ if (err == CHIP_NO_ERROR)
+ {
+ ChipLogProgress(DeviceLayer, "matter_lwip_releaseip");
+ matter_lwip_releaseip();
+ }
  return err;
 }
 
 CHIP_ERROR AmebaUtils::WiFiConnectProvisionedNetwork(void)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
  rtw_wifi_config_t * config = (rtw_wifi_config_t *) pvPortMalloc(sizeof(rtw_wifi_config_t));
  memset(config, 0, sizeof(rtw_wifi_config_t));
  GetWiFiConfig(config);
  ChipLogProgress(DeviceLayer, "Connecting to AP : [%s]", (char *) config->ssid);
- int ameba_err = matter_wifi_connect((char *) config->ssid, RTW_SECURITY_WPA_WPA2_MIXED, (char *) config->password,
+ int32_t error  = matter_wifi_connect((char *) config->ssid, RTW_SECURITY_WPA_WPA2_MIXED, (char *) config->password,
  strlen((const char *) config->ssid), strlen((const char *) config->password), 0, nullptr);
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
 
  vPortFree(config);
- err = (ameba_err == RTW_SUCCESS) ? CHIP_NO_ERROR : CHIP_ERROR_INTERNAL;
  return err;
 }
 
 CHIP_ERROR AmebaUtils::WiFiConnect(const char * ssid, const char * password)
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
  ChipLogProgress(DeviceLayer, "Connecting to AP : [%s]", (char *) ssid);
- int ameba_err = matter_wifi_connect((char *) ssid, RTW_SECURITY_WPA_WPA2_MIXED, (char *) password, strlen(ssid),
+ int32_t error  = matter_wifi_connect((char *) ssid, RTW_SECURITY_WPA_WPA2_MIXED, (char *) password, strlen(ssid),
  strlen(password), 0, nullptr);
- err  = (ameba_err == RTW_SUCCESS) ? CHIP_NO_ERROR : CHIP_ERROR_INTERNAL;
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
  return err;
 }
 
 CHIP_ERROR AmebaUtils::SetCurrentProvisionedNetwork()
 {
- CHIP_ERROR err = CHIP_NO_ERROR;
  rtw_wifi_setting_t pSetting;
- int ret = matter_get_sta_wifi_info(&pSetting);
- if (ret < 0)
+ int32_t error = matter_get_sta_wifi_info(&pSetting);
+ CHIP_ERROR err = MapError(error, AmebaErrorType::kWiFiError);
+ if (err != CHIP_NO_ERROR)
  {
  ChipLogProgress(DeviceLayer, "STA No Wi-Fi Info");
  goto exit;
@@ -197,3 +201,52 @@ CHIP_ERROR AmebaUtils::SetCurrentProvisionedNetwork()
 exit:
  return err;
 }
+
+CHIP_ERROR AmebaUtils::MapError(int32_t error, AmebaErrorType type)
+{
+ if (type == AmebaErrorType::kDctError)
+ {
+ return MapDctError(error);
+ }
+ if (type == AmebaErrorType::kFlashError)
+ {
+ return MapFlashError(error);
+ }
+ if (type == AmebaErrorType::kWiFiError)
+ {
+ return MapWiFiError(error);
+ }
+ return CHIP_ERROR_INTERNAL;
+}
+
+CHIP_ERROR AmebaUtils::MapDctError(int32_t error)
+{
+ if (error == DCT_SUCCESS)
+ return CHIP_NO_ERROR;
+ if (error == DCT_ERR_NO_MEMORY)
+ return CHIP_ERROR_NO_MEMORY;
+ if (error == DCT_ERR_NOT_FIND)
+ return CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND;
+ if (error == DCT_ERR_SIZE_OVER)
+ return CHIP_ERROR_INVALID_ARGUMENT;
+ if (error == DCT_ERR_MODULE_BUSY)
+ return CHIP_ERROR_BUSY;
+
+ return CHIP_ERROR_INTERNAL;
+}
+
+CHIP_ERROR AmebaUtils::MapFlashError(int32_t error)
+{
+ if (error == 1)
+ return CHIP_NO_ERROR;
+
+ return CHIP_ERROR_INTERNAL;
+}
+
+CHIP_ERROR AmebaUtils::MapWiFiError(int32_t error)
+{
+ if (error == RTW_SUCCESS)
+ return CHIP_NO_ERROR;
+
+ return CHIP_ERROR_INTERNAL;
+}

src/platform/Ameba/AmebaUtils.h

@@ -24,6 +24,13 @@ namespace chip {
 namespace DeviceLayer {
 namespace Internal {
 
+enum class AmebaErrorType
+{
+ kDctError,
+ kFlashError,
+ kWiFiError,
+};
+
 class AmebaUtils
 {
 public:
@@ -39,6 +46,14 @@ class AmebaUtils
  static CHIP_ERROR WiFiConnectProvisionedNetwork(void);
  static CHIP_ERROR WiFiConnect(const char * ssid, const char * password);
  static CHIP_ERROR SetCurrentProvisionedNetwork(void);
+ static CHIP_ERROR WiFiConnect(void);
+
+ static CHIP_ERROR MapError(int32_t error, AmebaErrorType type);
+
+private:
+ static CHIP_ERROR MapDctError(int32_t error);
+ static CHIP_ERROR MapFlashError(int32_t error);
+ static CHIP_ERROR MapWiFiError(int32_t error);
 };
 
 } // namespace Internal

src/platform/Ameba/ConfigurationManagerImpl.cpp

@@ -25,6 +25,7 @@
 #include <platform/internal/CHIPDeviceLayerInternal.h>
 
 #include <platform/Ameba/AmebaConfig.h>
+#include <platform/Ameba/AmebaUtils.h>
 #include <platform/ConfigurationManager.h>
 #include <platform/DiagnosticDataProvider.h>
 #include <platform/internal/GenericConfigurationManagerImpl.ipp>
@@ -152,13 +153,22 @@ CHIP_ERROR ConfigurationManagerImpl::GetLocationCapability(uint8_t & location)
 
 CHIP_ERROR ConfigurationManagerImpl::GetPrimaryWiFiMACAddress(uint8_t * buf)
 {
+ CHIP_ERROR err;
+ int32_t error;
+
  char temp[32];
  uint32_t mac[ETH_ALEN];
- int i = 0;
+ char * token = strtok(temp, ":");
+ int i = 0;
 
- wifi_get_mac_address(temp);
+ error = matter_wifi_get_mac_address(temp);
+ err = AmebaUtils::MapError(error, AmebaErrorType::kWiFiError);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(DeviceLayer, "Failed to get mac address");
+ goto exit;
+ }
 
- char * token = strtok(temp, ":");
  while (token != NULL)
  {
  mac[i] = (uint32_t) strtol(token, NULL, 16);
@@ -169,7 +179,8 @@ CHIP_ERROR ConfigurationManagerImpl::GetPrimaryWiFiMACAddress(uint8_t * buf)
  for (i = 0; i < ETH_ALEN; i++)
  buf[i] = mac[i] & 0xFF;
 
- return CHIP_NO_ERROR;
+exit:
+ return err;
 }
 
 bool ConfigurationManagerImpl::CanFactoryReset()
@@ -188,10 +199,6 @@ CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform:
  AmebaConfig::Key configKey{ AmebaConfig::kConfigNamespace_ChipCounters, key };
 
  CHIP_ERROR err = ReadConfigValue(configKey, value);
- if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
- {
- err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND;
- }
  return err;
 }
 

src/platform/Ameba/ConnectivityManagerImpl.cpp

@@ -524,7 +524,7 @@ void ConnectivityManagerImpl::DriveStationState()
  {
  WiFiStationState prevState = mWiFiStationState;
  ChangeWiFiStationState(kWiFiStationState_NotConnected);
- if (prevState != kWiFiStationState_Connecting_Failed)
+ if (prevState == kWiFiStationState_Connecting_Failed)
  {
  ChipLogProgress(DeviceLayer, "WiFi station failed to connect");
  // TODO: check retry count if exceeded, then clearwificonfig
@@ -858,13 +858,13 @@ void ConnectivityManagerImpl::RtkWiFiScanCompletedHandler(void)
 
 void ConnectivityManagerImpl::DHCPProcessThread(void * param)
 {
- matter_lwip_dhcp(0, DHCP_START);
+ matter_lwip_dhcp();
  PlatformMgr().LockChipStack();
  sInstance.OnStationIPv4AddressAvailable();
  PlatformMgr().UnlockChipStack();
 #if LWIP_VERSION_MAJOR > 2 || LWIP_VERSION_MINOR > 0
 #if LWIP_IPV6
- matter_lwip_dhcp(0, DHCP6_START);
+ matter_lwip_dhcp6();
  PlatformMgr().LockChipStack();
  sInstance.OnIPv6AddressAvailable();
  PlatformMgr().UnlockChipStack();