Platform fixes for CC13x2_26x2 (#22502) (#22583)

* Add timer for fast advertisment Issue found in SVE#2 for TC-DD-2.1. * add reboot reason Added boot count and reboot reason to the configuration manager. Found in SVE#2 TC-DGGEN-2.1. * fix incorrect log * update interface total size Add the total image size to the mParams for OTA to allow for download tracking. Found in SVE#2 TC-SU-4.1. * clang-format * move reboot reason Implement the correct GetRebootReason. * update to use only one timer * Restyled by clang-format * add additional diagnostic functions * Restyled by clang-format Co-authored-by: Restyled.io <[email protected]> Co-authored-by: Seth Rickard <[email protected]> Co-authored-by: Restyled.io <[email protected]>
project-chip · Sep 13, 2022 · 8c915e0 · 8c915e0
1 parent 1f63bcd
commit 8c915e0
Show file tree

Hide file tree

Showing 15 changed files with 311 additions and 16 deletions.
diff --git a/src/platform/cc13x2_26x2/BLEManagerImpl.cpp b/src/platform/cc13x2_26x2/BLEManagerImpl.cpp
@@ -830,6 +830,15 @@ void BLEManagerImpl::ProcessEvtHdrMsg(QueuedEvt_t * pMsg)
                 {
 
                     // Start advertisement timeout timer
+                    if (sInstance.mFlags.Has(Flags::kFastAdvertisingEnabled))
+                    {
+                        Util_rescheduleClock(&sInstance.clkAdvTimeout, CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME);
+                    }
+                    else
+                    {
+                        Util_rescheduleClock(&sInstance.clkAdvTimeout,
+                                             ADV_TIMEOUT - CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME);
+                    }
                     Util_startClock(&sInstance.clkAdvTimeout);
 
                     sInstance.mFlags.Set(Flags::kAdvertising);
@@ -845,6 +854,9 @@ void BLEManagerImpl::ProcessEvtHdrMsg(QueuedEvt_t * pMsg)
                 sInstance.mFlags.Clear(Flags::kAdvertising);
 
                 Util_stopClock(&sInstance.clkAdvTimeout);
+
+                // reset fast advertising
+                sInstance.mFlags.Set(Flags::kFastAdvertisingEnabled);
             }
         }
     }
@@ -1093,6 +1105,8 @@ void BLEManagerImpl::ProcessGapMessage(gapEventHdr_t * pMsg)
 
         /* Stop advertisement timeout timer */
         Util_stopClock(&sInstance.clkAdvTimeout);
+        // reset fast advertising
+        sInstance.mFlags.Set(Flags::kFastAdvertisingEnabled);
 
         DriveBLEState();
 
@@ -1711,10 +1725,19 @@ void BLEManagerImpl::AdvTimeoutHandler(uintptr_t arg)
 
     if (sInstance.mFlags.Has(Flags::kAdvertisingEnabled))
     {
-        BLEMGR_LOG("BLEMGR: AdvTimeoutHandler ble adv 15 minute timeout");
+        if (sInstance.mFlags.Has(Flags::kFastAdvertisingEnabled))
+        {
+            BLEMGR_LOG("BLEMGR: Fast advertising timeout reached");
 
-        sInstance.mFlags.Clear(Flags::kAdvertisingEnabled);
+            sInstance.mFlags.Clear(Flags::kFastAdvertisingEnabled);
+            sInstance.mFlags.Set(Flags::kAdvertisingRefreshNeeded);
+        }
+        else
+        {
+            BLEMGR_LOG("BLEMGR: Advertising timeout reached");
 
+            sInstance.mFlags.Clear(Flags::kAdvertisingEnabled);
+        }
         /* Send event to process state change request */
         DriveBLEState();
     }

diff --git a/src/platform/cc13x2_26x2/BLEManagerImpl.h b/src/platform/cc13x2_26x2/BLEManagerImpl.h
@@ -327,6 +327,7 @@ class BLEManagerImpl final : public BLEManager, private BleLayer, private BlePla
     static void advCallback(uint32_t event, void * pBuf, uintptr_t arg);
     static void ClockHandler(uintptr_t arg);
     static void AdvTimeoutHandler(uintptr_t arg);
+    static void FastAdvTimeoutHandler(uintptr_t arg);
     static void CHIPoBLEProfile_charValueChangeCB(uint8_t paramId, uint16_t len, uint16_t connHandle);
     static void PasscodeCb(uint8_t * pDeviceAddr, uint16_t connHandle, uint8_t uiInputs, uint8_t uiOutputs, uint32_t numComparison);
     static void PairStateCb(uint16_t connHandle, uint8_t state, uint8_t status);

diff --git a/src/platform/cc13x2_26x2/CC13X2_26X2Config.cpp b/src/platform/cc13x2_26x2/CC13X2_26X2Config.cpp
@@ -68,6 +68,10 @@ const CC13X2_26X2Config::Key CC13X2_26X2Config::kConfigKey_Spake2pSalt
                                                                              .itemID   = 0x000b } };
 const CC13X2_26X2Config::Key CC13X2_26X2Config::kConfigKey_Spake2pVerifier       = { { .systemID = kCC13X2_26X2ChipFactory_Sysid,
                                                                                  .itemID   = 0x000c } };
+const CC13X2_26X2Config::Key CC13X2_26X2Config::kConfigKey_BootCount             = { { .systemID = kCC13X2_26X2ChipFactory_Sysid,
+                                                                           .itemID   = 0x000d } };
+const CC13X2_26X2Config::Key CC13X2_26X2Config::kConfigKey_TotalOperationalHours = { { .systemID = kCC13X2_26X2ChipFactory_Sysid,
+                                                                                       .itemID   = 0x000f } };
 
 // Keys stored in the Chip-config namespace
 const CC13X2_26X2Config::Key CC13X2_26X2Config::kConfigKey_ServiceConfig      = { { .systemID = kCC13X2_26X2ChipConfig_Sysid,

diff --git a/src/platform/cc13x2_26x2/CC13X2_26X2Config.h b/src/platform/cc13x2_26x2/CC13X2_26X2Config.h
@@ -68,6 +68,8 @@ class CC13X2_26X2Config
     static const Key kConfigKey_Spake2pIterationCount;
     static const Key kConfigKey_Spake2pSalt;
     static const Key kConfigKey_Spake2pVerifier;
+    static const Key kConfigKey_BootCount;
+    static const Key kConfigKey_TotalOperationalHours;
 
     static CHIP_ERROR Init(void);
 

diff --git a/src/platform/cc13x2_26x2/ConfigurationManagerImpl.cpp b/src/platform/cc13x2_26x2/ConfigurationManagerImpl.cpp
@@ -66,7 +66,10 @@ CHIP_ERROR ConfigurationManagerImpl::Init()
 
     // Initialize the generic implementation base class.
     err = Internal::GenericConfigurationManagerImpl<CC13X2_26X2Config>::Init();
+    SuccessOrExit(err);
 
+    IncreaseBootCount();
+exit:
     return err;
 }
 
@@ -81,6 +84,46 @@ void ConfigurationManagerImpl::InitiateFactoryReset()
     PlatformMgr().ScheduleWork(DoFactoryReset);
 }
 
+CHIP_ERROR ConfigurationManagerImpl::GetRebootCount(uint32_t & rebootCount)
+{
+    return ReadConfigValue(CC13X2_26X2Config::kConfigKey_BootCount, rebootCount);
+}
+
+CHIP_ERROR ConfigurationManagerImpl::IncreaseBootCount(void)
+{
+    CHIP_ERROR ret;
+    uint32_t bootCount = 0;
+
+    ret = ReadConfigValue(CC13X2_26X2Config::kConfigKey_BootCount, bootCount);
+
+    if (CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND == ret || CHIP_NO_ERROR == ret)
+    {
+        ret = WriteConfigValue(CC13X2_26X2Config::kConfigKey_BootCount, bootCount + 1);
+    }
+
+    return ret;
+}
+
+CHIP_ERROR ConfigurationManagerImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours)
+{
+    CHIP_ERROR ret;
+
+    ret = ReadConfigValue(CC13X2_26X2Config::kConfigKey_TotalOperationalHours, totalOperationalHours);
+
+    if (CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND == ret)
+    {
+        totalOperationalHours = 0;
+        return CHIP_NO_ERROR;
+    }
+
+    return ret;
+}
+
+CHIP_ERROR ConfigurationManagerImpl::StoreTotalOperationalHours(uint32_t totalOperationalHours)
+{
+    return WriteConfigValue(CC13X2_26X2Config::kConfigKey_TotalOperationalHours, totalOperationalHours);
+}
+
 CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value)
 {
     CC13X2_26X2Config::Key configKey{ { CC13X2_26X2Config::kCC13X2_26X2ChipCounters_Sysid, key } };

diff --git a/src/platform/cc13x2_26x2/ConfigurationManagerImpl.h b/src/platform/cc13x2_26x2/ConfigurationManagerImpl.h
@@ -39,6 +39,11 @@ class ConfigurationManagerImpl : public Internal::GenericConfigurationManagerImp
     // This returns an instance of this class.
     static ConfigurationManagerImpl & GetDefaultInstance();
 
+    CHIP_ERROR GetRebootCount(uint32_t & rebootCount);
+    CHIP_ERROR IncreaseBootCount(void);
+    CHIP_ERROR GetTotalOperationalHours(uint32_t & totalOperationalHours);
+    CHIP_ERROR StoreTotalOperationalHours(uint32_t totalOperationalHours);
+
 private:
     // ===== Members that implement the ConfigurationManager public interface.
 

diff --git a/src/platform/cc13x2_26x2/DiagnosticDataProviderImpl.cpp b/src/platform/cc13x2_26x2/DiagnosticDataProviderImpl.cpp
@@ -28,6 +28,8 @@
 #include <platform/DiagnosticDataProvider.h>
 #include <platform/cc13x2_26x2/DiagnosticDataProviderImpl.h>
 
+#include <driverlib/sys_ctrl.h>
+
 namespace chip {
 namespace DeviceLayer {
 
@@ -117,6 +119,152 @@ void DiagnosticDataProviderImpl::ReleaseThreadMetrics(ThreadMetrics * threadMetr
     }
 }
 
+// General Diagnostics Getters
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetRebootCount(uint16_t & rebootCount)
+{
+    uint32_t count = 0;
+    CHIP_ERROR err = ConfigurationMgr().GetRebootCount(count);
+
+    if (err == CHIP_NO_ERROR)
+    {
+        VerifyOrReturnError(count <= UINT16_MAX, CHIP_ERROR_INVALID_INTEGER_VALUE);
+        rebootCount = static_cast<uint16_t>(count);
+    }
+
+    return err;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetBootReason(BootReasonType & bootReason)
+{
+    switch (SysCtrlResetSourceGet())
+    {
+    case RSTSRC_PWR_ON:
+    case RSTSRC_WAKEUP_FROM_SHUTDOWN:
+        bootReason = BootReasonType::kPowerOnReboot;
+        break;
+
+    case RSTSRC_PIN_RESET:
+    case RSTSRC_WAKEUP_FROM_TCK_NOISE:
+        bootReason = BootReasonType::kHardwareWatchdogReset;
+        break;
+
+    case RSTSRC_VDDS_LOSS:
+    case RSTSRC_VDDR_LOSS:
+    case RSTSRC_CLK_LOSS:
+        bootReason = BootReasonType::kBrownOutReset;
+        break;
+
+    case RSTSRC_SYSRESET:
+    case RSTSRC_WARMRESET:
+        bootReason = BootReasonType::kSoftwareReset;
+        // We do not have a clean way to differentiate between a software reset
+        // and a completed software update.
+        // bootReason = kSoftwareUpdateCompleted;
+        break;
+
+    default:
+        bootReason = BootReasonType::kUnknownEnumValue;
+        break;
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetUpTime(uint64_t & upTime)
+{
+    System::Clock::Timestamp currentTime = System::SystemClock().GetMonotonicTimestamp();
+    System::Clock::Timestamp startTime   = PlatformMgrImpl().GetStartTime();
+
+    if (currentTime >= startTime)
+    {
+        upTime = std::chrono::duration_cast<System::Clock::Seconds64>(currentTime - startTime).count();
+        return CHIP_NO_ERROR;
+    }
+
+    return CHIP_ERROR_INVALID_TIME;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours)
+{
+    uint64_t upTime = 0;
+
+    if (GetUpTime(upTime) == CHIP_NO_ERROR)
+    {
+        uint32_t totalHours = 0;
+        if (ConfigurationMgr().GetTotalOperationalHours(totalHours) == CHIP_NO_ERROR)
+        {
+            VerifyOrReturnError(upTime / 3600 <= UINT32_MAX, CHIP_ERROR_INVALID_INTEGER_VALUE);
+            totalOperationalHours = totalHours + static_cast<uint32_t>(upTime / 3600);
+            return CHIP_NO_ERROR;
+        }
+    }
+
+    return CHIP_ERROR_INVALID_TIME;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetActiveHardwareFaults(GeneralFaults<kMaxHardwareFaults> & hardwareFaults)
+{
+#if CHIP_CONFIG_TEST
+    ReturnErrorOnFailure(hardwareFaults.add(EMBER_ZCL_HARDWARE_FAULT_TYPE_RADIO));
+    ReturnErrorOnFailure(hardwareFaults.add(EMBER_ZCL_HARDWARE_FAULT_TYPE_SENSOR));
+    ReturnErrorOnFailure(hardwareFaults.add(EMBER_ZCL_HARDWARE_FAULT_TYPE_POWER_SOURCE));
+    ReturnErrorOnFailure(hardwareFaults.add(EMBER_ZCL_HARDWARE_FAULT_TYPE_USER_INTERFACE_FAULT));
+#endif
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetActiveRadioFaults(GeneralFaults<kMaxRadioFaults> & radioFaults)
+{
+#if CHIP_CONFIG_TEST
+    ReturnErrorOnFailure(radioFaults.add(EMBER_ZCL_RADIO_FAULT_TYPE_THREAD_FAULT));
+    ReturnErrorOnFailure(radioFaults.add(EMBER_ZCL_RADIO_FAULT_TYPE_BLE_FAULT));
+#endif
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetActiveNetworkFaults(GeneralFaults<kMaxNetworkFaults> & networkFaults)
+{
+#if CHIP_CONFIG_TEST
+    ReturnErrorOnFailure(networkFaults.add(EMBER_ZCL_NETWORK_FAULT_TYPE_HARDWARE_FAILURE));
+    ReturnErrorOnFailure(networkFaults.add(EMBER_ZCL_NETWORK_FAULT_TYPE_NETWORK_JAMMED));
+    ReturnErrorOnFailure(networkFaults.add(EMBER_ZCL_NETWORK_FAULT_TYPE_CONNECTION_FAILED));
+#endif
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DiagnosticDataProviderImpl::GetNetworkInterfaces(NetworkInterface ** netifpp)
+{
+    NetworkInterface * ifp = new NetworkInterface();
+
+    const char * threadNetworkName = otThreadGetNetworkName(ThreadStackMgrImpl().OTInstance());
+    ifp->name                      = Span<const char>(threadNetworkName, strlen(threadNetworkName));
+    ifp->isOperational             = true;
+    ifp->offPremiseServicesReachableIPv4.SetNull();
+    ifp->offPremiseServicesReachableIPv6.SetNull();
+    ifp->type = EMBER_ZCL_INTERFACE_TYPE_THREAD;
+
+    otExtAddress extAddr;
+    ThreadStackMgrImpl().GetExtAddress(extAddr);
+    ifp->hardwareAddress = ByteSpan(extAddr.m8, OT_EXT_ADDRESS_SIZE);
+
+    *netifpp = ifp;
+    return CHIP_NO_ERROR;
+}
+
+void DiagnosticDataProviderImpl::ReleaseNetworkInterfaces(NetworkInterface * netifp)
+{
+    while (netifp)
+    {
+        NetworkInterface * del = netifp;
+        netifp                 = netifp->Next;
+        delete del;
+    }
+}
+
 DiagnosticDataProvider & GetDiagnosticDataProviderImpl()
 {
     return DiagnosticDataProviderImpl::GetDefaultInstance();

diff --git a/src/platform/cc13x2_26x2/DiagnosticDataProviderImpl.h b/src/platform/cc13x2_26x2/DiagnosticDataProviderImpl.h
@@ -35,11 +35,19 @@ class DiagnosticDataProviderImpl : public DiagnosticDataProvider
 public:
     static DiagnosticDataProviderImpl & GetDefaultInstance();
 
-    // ===== Methods that implement the PlatformManager abstract interface.
+    CHIP_ERROR GetRebootCount(uint16_t & rebootCount) override;
+    CHIP_ERROR GetBootReason(BootReasonType & bootReason) override;
+    CHIP_ERROR GetUpTime(uint64_t & upTime) override;
+    CHIP_ERROR GetTotalOperationalHours(uint32_t & totalOperationalHours) override;
     CHIP_ERROR GetCurrentHeapFree(uint64_t & currentHeapFree) override;
     CHIP_ERROR GetCurrentHeapUsed(uint64_t & currentHeapUsed) override;
     CHIP_ERROR GetThreadMetrics(ThreadMetrics ** threadMetricsOut) override;
     void ReleaseThreadMetrics(ThreadMetrics * threadMetrics) override;
+    CHIP_ERROR GetActiveHardwareFaults(GeneralFaults<kMaxHardwareFaults> & hardwareFaults) override;
+    CHIP_ERROR GetActiveRadioFaults(GeneralFaults<kMaxRadioFaults> & radioFaults) override;
+    CHIP_ERROR GetActiveNetworkFaults(GeneralFaults<kMaxNetworkFaults> & networkFaults) override;
+    CHIP_ERROR GetNetworkInterfaces(NetworkInterface ** netifpp) override;
+    void ReleaseNetworkInterfaces(NetworkInterface * netifp) override;
 };
 
 /**