Memfault Firmware SDK 1.1.2 (Build 2861)

Author: Memfault Inc

CHANGES.md

@@ -1,3 +1,19 @@
+### Changes between Memfault SDK 1.1.1 and 1.1.2 - July 11, 2023
+
+#### :chart_with_upwards_trend: Improvements
+
+- Improve compatibility in
+  [reboot reason tracking](ports/emlib/rmu_reboot_tracking.c) and
+  [watchdog implementation](ports/emlib/wdog_software_watchdog.c) on Silicon
+  Labs Series 2 MCUs
+
+- Zephyr:
+  - Fix a build error when `CONFIG_MEMFAULT_LOGGING=n`, see
+    [#56](https://github.com/memfault/memfault-firmware-sdk/issues/56). Thanks
+    to @JordanYates for reporting this issue!
+  - Fix a potential bug in the Memfault Log Backend when
+    `CONFIG_LOG_MODE_IMMEDIATE=y` when flushing of fault logs during a crash
+
 ### Changes between Memfault SDK 1.1.0 and 1.1.1 - June 30, 2023
 
 #### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 2709
-GIT COMMIT: c403952a4
+BUILD ID: 2861
+GIT COMMIT: 3a1297110

components/include/memfault/version.h

@@ -19,7 +19,7 @@ typedef struct {
   uint8_t patch;
 } sMfltSdkVersion;
 
-#define MEMFAULT_SDK_VERSION   { .major = 1, .minor = 1, .patch = 1 }
+#define MEMFAULT_SDK_VERSION   { .major = 1, .minor = 1, .patch = 2 }
 
 #ifdef __cplusplus
 }

ports/emlib/README.md

@@ -0,0 +1,25 @@
+# Silicon Labs emlib Port
+
+This port adds implementations for coredump storage, reboot reasons, and
+watchdog features using the Gecko SDK/emblib.
+
+## Compatibility
+
+The port has been built against v3.0 of the Gecko SDK. The port has been built
+and tested against v4.3.0 using SimplicityStudio.
+
+## Features
+
+The port provides the following features:
+
+- Coredump storage using a linker-defined region in internal Flash
+- Reboot reason implementation for collecting reboot events
+- An integration with the Watchdog peripheral to capture watchdog-triggered
+  traces
+
+## Adding To Your Project
+
+The simplest way to add this to your project is to do the following:
+
+1. Add the source files in `ports/emblib` to your build system
+2. Add the include directory at `ports/include`

ports/emlib/rmu_reboot_tracking.c

@@ -12,18 +12,19 @@
 
 #include "memfault/ports/reboot_reason.h"
 
-#include "em_rmu.h"
+// non-module headers below
+#include "em_device.h"
 #include "em_emu.h"
-
+#include "em_rmu.h"
 #include "memfault/config.h"
 #include "memfault/core/debug_log.h"
 #include "memfault/core/reboot_reason_types.h"
 #include "memfault/core/sdk_assert.h"
 
 #if MEMFAULT_ENABLE_REBOOT_DIAG_DUMP
-#define MEMFAULT_PRINT_RESET_INFO(...) MEMFAULT_LOG_INFO(__VA_ARGS__)
+  #define MEMFAULT_PRINT_RESET_INFO(...) MEMFAULT_LOG_INFO(__VA_ARGS__)
 #else
-#define MEMFAULT_PRINT_RESET_INFO(...)
+  #define MEMFAULT_PRINT_RESET_INFO(...)
 #endif
 
 #if defined(_RMU_RSTCAUSE_MASK)
@@ -36,21 +37,21 @@ static eMemfaultRebootReason prv_get_and_print_reason(uint32_t reset_cause) {
   if (reset_cause & RMU_RSTCAUSE_PORST) {
     MEMFAULT_PRINT_RESET_INFO(" Power on Reset");
     return kMfltRebootReason_PowerOnReset;
-#if defined(RMU_RSTCAUSE_AVDDBOD)
+  #if defined(RMU_RSTCAUSE_AVDDBOD)
   } else if (reset_cause & RMU_RSTCAUSE_AVDDBOD) {
     MEMFAULT_PRINT_RESET_INFO(" AVDD Brown Out");
     return kMfltRebootReason_BrownOutReset;
-#endif
-#if defined(RMU_RSTCAUSE_DVDDBOD)
+  #endif
+  #if defined(RMU_RSTCAUSE_DVDDBOD)
   } else if (reset_cause & RMU_RSTCAUSE_DVDDBOD) {
     MEMFAULT_PRINT_RESET_INFO(" DVDD Brown Out");
     return kMfltRebootReason_BrownOutReset;
-#endif
-#if defined(RMU_RSTCAUSE_DECBOD)
+  #endif
+  #if defined(RMU_RSTCAUSE_DECBOD)
   } else if (reset_cause & RMU_RSTCAUSE_DECBOD) {
     MEMFAULT_PRINT_RESET_INFO(" DEC Brown Out");
     return kMfltRebootReason_BrownOutReset;
-#endif
+  #endif
   } else if (reset_cause & RMU_RSTCAUSE_LOCKUPRST) {
     MEMFAULT_PRINT_RESET_INFO(" Lockup");
     return kMfltRebootReason_Lockup;
@@ -60,11 +61,11 @@ static eMemfaultRebootReason prv_get_and_print_reason(uint32_t reset_cause) {
   } else if (reset_cause & RMU_RSTCAUSE_WDOGRST) {
     MEMFAULT_PRINT_RESET_INFO(" Watchdog");
     return kMfltRebootReason_HardwareWatchdog;
-#if defined(RMU_RSTCAUSE_EM4WURST)
+  #if defined(RMU_RSTCAUSE_EM4WURST)
   } else if (reset_cause & RMU_RSTCAUSE_EM4RST) {
     MEMFAULT_PRINT_RESET_INFO(" EM4 Wakeup");
     return kMfltRebootReason_DeepSleep;
-#endif
+  #endif
   } else if (reset_cause & RMU_RSTCAUSE_EXTRST) {
     MEMFAULT_PRINT_RESET_INFO(" Pin Reset");
     return kMfltRebootReason_ButtonReset;
@@ -94,7 +95,7 @@ static eMemfaultRebootReason prv_get_and_print_reason(uint32_t reset_cause) {
   } else if (reset_cause & EMU_RSTCAUSE_DVDDBOD) {
     MEMFAULT_PRINT_RESET_INFO(" DVDD Brown Out");
     return kMfltRebootReason_BrownOutReset;
-  } else if (reset_cause &  EMU_RSTCAUSE_DVDDLEBOD) {
+  } else if (reset_cause & EMU_RSTCAUSE_DVDDLEBOD) {
     MEMFAULT_PRINT_RESET_INFO(" DVDDLE Brown Out");
     return kMfltRebootReason_BrownOutReset;
   } else if (reset_cause & EMU_RSTCAUSE_DECBOD) {
@@ -118,12 +119,26 @@ static eMemfaultRebootReason prv_get_and_print_reason(uint32_t reset_cause) {
   } else if (reset_cause & EMU_RSTCAUSE_SETAMPER) {
     MEMFAULT_PRINT_RESET_INFO(" SE Tamper");
     return kMfltRebootReason_UnknownError;
+  #if defined(EMU_RSTCAUSE_SESYSREQ)
   } else if (reset_cause & EMU_RSTCAUSE_SESYSREQ) {
-    MEMFAULT_PRINT_RESET_INFO(" SE Software Reset");
+    MEMFAULT_PRINT_RESET_INFO(" SE System Reset");
+    return kMfltRebootReason_SoftwareReset;
+  #endif
+  #if defined(EMU_RSTCAUSE_SYSREQ)
+  } else if (reset_cause & EMU_RSTCAUSE_SYSREQ) {
+    MEMFAULT_PRINT_RESET_INFO("Software Reset");
     return kMfltRebootReason_SoftwareReset;
+  #endif
+  #if defined(EMU_RSTCAUSE_SELOCKUP)
   } else if (reset_cause & EMU_RSTCAUSE_SELOCKUP) {
-    MEMFAULT_PRINT_RESET_INFO(" SE Lockup");
+    MEMFAULT_PRINT_RESET_INFO("SE Lockup");
+    return kMfltRebootReason_Lockup;
+  #endif
+  #if defined(EMU_RSTCAUSE_LOCKUP)
+  } else if (reset_cause & EMU_RSTCAUSE_LOCKUP) {
+    MEMFAULT_PRINT_RESET_INFO("Lockup");
     return kMfltRebootReason_Lockup;
+  #endif
   } else if (reset_cause & EMU_RSTCAUSE_PIN) {
     MEMFAULT_PRINT_RESET_INFO(" SE Pin Reset");
     return kMfltRebootReason_PinReset;
@@ -133,7 +148,7 @@ static eMemfaultRebootReason prv_get_and_print_reason(uint32_t reset_cause) {
   return kMfltRebootReason_Unknown;
 }
 #else
-#error "Unexpected RSTCTRL configuration"
+  #error "Unexpected RSTCTRL configuration"
 #endif
 
 void memfault_reboot_reason_get(sResetBootupInfo *info) {
@@ -154,7 +169,7 @@ void memfault_reboot_reason_get(sResetBootupInfo *info) {
   RMU_ResetCauseClear();
 #endif
 
-  *info = (sResetBootupInfo) {
+  *info = (sResetBootupInfo){
     .reset_reason_reg = reset_cause,
     .reset_reason = reset_reason,
   };

ports/emlib/wdog_software_watchdog.c

@@ -17,33 +17,34 @@
 //! - The WDOG peripheral supports discrete timeouts. This port chooses the closest period
 //!   that is less than or equal to the requested value. Valid selections for
 //!   MEMFAULT_WATCHDOG_SW_TIMEOUT_SECS range from 1s - 128s.
-
 #include "memfault/ports/watchdog.h"
 
+// non-module includes below
+#include "em_cmu.h"
+#include "em_wdog.h"
 #include "memfault/config.h"
 #include "memfault/core/debug_log.h"
 
-#include "em_wdog.h"
-#include "em_cmu.h"
-
 #if defined(WDOG0)
-#define MEMFAULT_WDOG WDOG0
-#define MEMFAULT_WDOG_IRQn WDOG0_IRQn
+  #define MEMFAULT_WDOG WDOG0
+  #define MEMFAULT_WDOG_IRQn WDOG0_IRQn
 
-#ifndef MEMFAULT_EXC_HANDLER_WATCHDOG
-#  error "Port expects following define to be set: -DMEMFAULT_EXC_HANDLER_WATCHDOG=WDOG0_IRQHandler"
-#endif
+  #ifndef MEMFAULT_EXC_HANDLER_WATCHDOG
+    #error \
+      "Port expects following define to be set: -DMEMFAULT_EXC_HANDLER_WATCHDOG=WDOG0_IRQHandler"
+  #endif
 
 #elif defined(WDOG)
-#define MEMFAULT_WDOG WDOG
-#define MEMFAULT_WDOG_IRQn WDOG_IRQn
+  #define MEMFAULT_WDOG WDOG
+  #define MEMFAULT_WDOG_IRQn WDOG_IRQn
 
-#ifndef MEMFAULT_EXC_HANDLER_WATCHDOG
-#  error "Port expects following define to be set: -DMEMFAULT_EXC_HANDLER_WATCHDOG=WDOG_IRQHandler"
-#endif
+  #ifndef MEMFAULT_EXC_HANDLER_WATCHDOG
+    #error \
+      "Port expects following define to be set: -DMEMFAULT_EXC_HANDLER_WATCHDOG=WDOG_IRQHandler"
+  #endif
 
 #else
-# error "Could not find an available WDOG to use"
+  #error "Could not find an available WDOG to use"
 #endif
 
 #define MEMFAULT_EM_WDOG_FREQ_HZ 1000
@@ -55,6 +56,7 @@
 
 #define MEMFAULT_EM_WDOG_MAX_TIMEOUT_MS (MEMFAULT_EM_WDOG_PERSEL_TO_TIMEOUT_MS(wdogPeriod_256k))
 
+// clang-format off
 static void prv_build_configuration(WDOG_Init_TypeDef *cfg, uint32_t persel) {
   *cfg = (WDOG_Init_TypeDef) {
     .enable = true,
@@ -70,8 +72,6 @@ static void prv_build_configuration(WDOG_Init_TypeDef *cfg, uint32_t persel) {
 #if defined(_WDOG_CTRL_CLKSEL_MASK)
     // use internal 1kHz clock for largest range
     .clkSel = wdogClkSelULFRCO,
-#else
-    #error "Port doesn't support WDOG Variant - cannot configure clock"
 #endif
     .perSel = persel,
 
@@ -91,41 +91,44 @@ static void prv_build_configuration(WDOG_Init_TypeDef *cfg, uint32_t persel) {
 #endif
   };
 }
+// clang-format on
 
 static int prv_configure_watchdog_with_timeout(uint32_t timeout_ms) {
-
   // NB: An interrupt can be configured to fire at 25%, 50%, or 75% of the watchdog cycle
   // configured. We'll use this interrupt as our "software watchdog" and configure it to be at
   // the 50% interval
-  const size_t sw_wdog_max_ms = MEMFAULT_EM_WDOG_WARNING_TIMEOUT_MS(MEMFAULT_EM_WDOG_MAX_TIMEOUT_MS);
+  const size_t sw_wdog_max_ms =
+    MEMFAULT_EM_WDOG_WARNING_TIMEOUT_MS(MEMFAULT_EM_WDOG_MAX_TIMEOUT_MS);
   if (timeout_ms > sw_wdog_max_ms) {
-    MEMFAULT_LOG_ERROR("Requested wdog timeout (%d) exceeds max supported (%d)",
-                       (int)timeout_ms, (int)sw_wdog_max_ms);
+    MEMFAULT_LOG_ERROR("Requested wdog timeout (%d) exceeds max supported (%d)", (int)timeout_ms,
+                       (int)sw_wdog_max_ms);
     return -1;
   }
 
   uint32_t persel = wdogPeriod_9;
   while (persel <= wdogPeriod_256k) {
     const uint32_t warning_timeout_ms =
-        MEMFAULT_EM_WDOG_WARNING_TIMEOUT_MS(MEMFAULT_EM_WDOG_PERSEL_TO_TIMEOUT_MS(persel));
+      MEMFAULT_EM_WDOG_WARNING_TIMEOUT_MS(MEMFAULT_EM_WDOG_PERSEL_TO_TIMEOUT_MS(persel));
     if (warning_timeout_ms > timeout_ms) {
       break;
     }
     persel++;
   }
 
   // choose the closest timeout without going over the desired max
-  persel = (persel == 0)  ? 0 : persel - 1;
+  persel = (persel == 0) ? 0 : persel - 1;
 
   const size_t actual_timeout_ms = MEMFAULT_EM_WDOG_PERSEL_TO_TIMEOUT_MS(persel);
   MEMFAULT_LOG_DEBUG("Configuring SW Watchdog. SW Timeout=%dms HW Timeout=%dms",
                      (int)MEMFAULT_EM_WDOG_WARNING_TIMEOUT_MS(actual_timeout_ms),
                      actual_timeout_ms);
 
   // Low energy clock must be on to use the watchdog
-  if ((CMU->HFBUSCLKEN0 & CMU_HFBUSCLKEN0_LE) == 0) {
-    CMU->HFBUSCLKEN0 |= CMU_HFBUSCLKEN0_LE;
-  }
+#if defined(_SILICON_LABS_32B_SERIES_2)
+  CMU_ClockEnable(cmuClock_WDOG0, true);
+#else   // !defined(_SILICON_LABS_32B_SERIES_2)
+  CMU_ClockEnable(cmuClock_HFLE, true);
+#endif  // defined(_SILICON_LABS_32B_SERIES_2)
 
   if (WDOGn_IsLocked(MEMFAULT_WDOG)) {
     MEMFAULT_LOG_ERROR("Watchdog is locked and cannot be reconfigured");
@@ -137,13 +140,18 @@ static int prv_configure_watchdog_with_timeout(uint32_t timeout_ms) {
   NVIC_DisableIRQ(MEMFAULT_WDOG_IRQn);
   NVIC_ClearPendingIRQ(MEMFAULT_WDOG_IRQn);
 
+  // Series 2 chips select the watchdog source via the CMU
+#if defined(_SILICON_LABS_32B_SERIES_2)
+  CMU_ClockSelectSet(cmuClock_WDOG0, cmuSelect_ULFRCO);
+#endif  // defined(_SILICON_LABS_32B_SERIES_2)
+
   WDOG_Init_TypeDef cfg;
   prv_build_configuration(&cfg, persel);
   WDOGn_Init(MEMFAULT_WDOG, &cfg);
 
   // enable the warning interrupt. This will be used to capture a coredump rather than just letting
   // the hardware watchdog immediately reboot the system
-  const uint32_t warn_int_mask = 0x2; // "WARN Interrupt Enable"
+  const uint32_t warn_int_mask = 0x2;  // "WARN Interrupt Enable"
   WDOGn_IntClear(MEMFAULT_WDOG, warn_int_mask);
   WDOGn_IntEnable(MEMFAULT_WDOG, warn_int_mask);
 
@@ -154,7 +162,6 @@ static int prv_configure_watchdog_with_timeout(uint32_t timeout_ms) {
 
   // finally, with everything setup, start the watchdog!
   WDOGn_Enable(MEMFAULT_WDOG, true);
-  WDOGn_SyncWait(MEMFAULT_WDOG);
   return 0;
 }
 
@@ -182,6 +189,6 @@ int memfault_software_watchdog_feed(void) {
   // Enteriung EM2 or EM3 power states while this is in progress will
   // cause the operation to be aborted. WDOGn_SyncWait() can be used to
   // block until the operation is complete!
-  WDOG_Feed();
+  WDOGn_Feed(MEMFAULT_WDOG);
   return 0;
 }

ports/zephyr/common/memfault_logging.c

@@ -152,13 +152,23 @@ LOG_BACKEND_DEFINE(log_backend_mflt, log_backend_mflt_api, true);
 
 // Tie Memfault's log function to the Zephyr buffer sender. This is *the* connection to Memfault.
 static int prv_log_out(uint8_t *data, size_t length, void *ctx) {
-  sMfltLogProcessCtx *mflt_ctx = (sMfltLogProcessCtx*)ctx;
-  size_t save_length = length;
+  // In synchronous mode, logging can occur from ISRs. The zephyr fault handlers are chatty so
+  // don't save info while in an ISR to avoid wrapping over the info we are collecting.
+  // This function may also be run from LOG_PANIC. We also want to skip saving data in this case
+  // because the context object uses local stack memory which may not be valid when run from
+  // LOG_PANIC
+  if (memfault_arch_is_inside_isr()) {
+    return (int)length;
+  }
 
+  // Ensure we have control over logging context, drop data if we cannot obtain control
   if (prv_sem_take() != 0) {
     return (int)length;
   }
 
+  sMfltLogProcessCtx *mflt_ctx = (sMfltLogProcessCtx *)ctx;
+  size_t save_length = length;
+
 #if CONFIG_LOG_MODE_IMMEDIATE
   // A check to help us catch if behavior changes in a future release of Zephyr
   MEMFAULT_SDK_ASSERT(length <= 1);

ports/zephyr/common/memfault_platform_core.c

@@ -39,7 +39,7 @@
 // so we can preserve the pristine fault register values.
 void __wrap_z_arm_fault(uint32_t msp, uint32_t psp, uint32_t exc_return,
                         _callee_saved_t *callee_regs) {
-  #if MEMFAULT_ZEPHYR_VERSION_GT(3, 1) || defined(CONFIG_LOG2)
+  #if CONFIG_MEMFAULT_LOGGING && (MEMFAULT_ZEPHYR_VERSION_GT(3, 1) || defined(CONFIG_LOG2))
   // Trigger a LOG_PANIC() early to flush any buffered logs, then disable the
   // Memfault log backend to prevent any further logs from being captured
   // (primarily the Zephyr fault logs, which can fill up the Memfault log

scripts/cmsis_pack_bundle.py

@@ -126,7 +126,7 @@ def build_cmsis_pack(
     if not os.path.isdir(memfault_sdk_dir) or not os.path.isfile(
         "{}/VERSION".format(memfault_sdk_dir)
     ):
-        raise Exception(
+        raise ValueError(
             "Invalid path to memfault-firmware-sdk (missing VERSION file) at {}".format(
                 memfault_sdk_dir
             )
@@ -141,7 +141,8 @@ def build_cmsis_pack(
     tree = ET.ElementTree(
         ET.fromstring(  # noqa: S314
             PDSC_TEMPLATE.format(
-                SDK_VERSION=sdk_version, SDK_DATE=datetime.date.today().strftime("%Y-%m-%d")
+                SDK_VERSION=sdk_version,
+                SDK_DATE=datetime.datetime.now(tz=datetime.timezone.utc).strftime("%Y-%m-%d"),
             )
         )
     )