Disabling the softdevice hangs when using LFRC with an active watchdog

[fwst303]

Using LFRC as the softdevice LFCLK source, enabling and running the WDT causes the softdevice to hang until the watchdog reset when calling nrf_sdh_disable_request. This is with SDK v15.3.0 on both S112 and S140.


Configuring the WDT to pause on debugging, I was able to trace the call to following:

1. nrf_sdh_disable_request

2. sdh_state_observer_notify

3. handler(evt, p_observer->p_context) (which is sd_state_evt_handler in the first iteration of my loop)

4. nrfx_clock_enable

5. nrf_drv_clock_lfclk_release

6. lfclk_stop
7. nrfx_clock_lfclk_stop

8. while(nrf_clock_lf_is_running()). <--- Hangs here (nrfx_clock.c:245)


The PS states "When started, the watchdog will automatically force the 32.768 kHz RC oscillator on as long as no other 32.768 kHz clock source is running and generating the 32.768 kHz system clock".

Therefore, I presume that the hang is caused from the softdevice entering a blocking while loop waiting for an LFCLK src to stop that never will because of the WDT.

Given the functions below, I don't see a way for the softdevice to successfully disable while using an LFRC that is also in use by the WDT, without registering an m_clock_cb.lfclk_requests, which the nrfx_wdt drivers do not appear to do:

/**
 * @brief SoftDevice enable/disable state handler.
 *
 * @param[in] state     State.
 * @param[in] p_context Context.
 */
static void sd_state_evt_handler(nrf_sdh_state_evt_t state, void * p_context)
{
    switch (state)
    {
        case NRF_SDH_EVT_STATE_ENABLE_PREPARE:
            NVIC_DisableIRQ(POWER_CLOCK_IRQn);
            break;

        case NRF_SDH_EVT_STATE_ENABLED:
            CRITICAL_REGION_ENTER();
            /* Make sure that nrf_drv_clock module is initialized */
            if (!m_clock_cb.module_initialized)
            {
                (void)nrf_drv_clock_init();
            }
            /* SD is one of the LFCLK requesters, but it will enable it by itself. */
            ++(m_clock_cb.lfclk_requests);
            m_clock_cb.lfclk_on = true;
            CRITICAL_REGION_EXIT();
            break;

        case NRF_SDH_EVT_STATE_DISABLED:
            /* Reinit interrupts */
            ASSERT(m_clock_cb.module_initialized);
            nrfx_clock_enable();

            /* SD leaves LFCLK enabled - disable it if it is no longer required. */
            nrf_drv_clock_lfclk_release();
            break;

        default:
            break;
    }
}

void nrf_drv_clock_lfclk_release(void)
{
    ASSERT(m_clock_cb.module_initialized);
    ASSERT(m_clock_cb.lfclk_requests > 0);

    CRITICAL_REGION_ENTER();
    --(m_clock_cb.lfclk_requests);
    if (m_clock_cb.lfclk_requests == 0)
    {
        lfclk_stop();
    }
    CRITICAL_REGION_EXIT();
}

nrfx_err_t nrfx_wdt_init(nrfx_wdt_config_t const * p_config,
                         nrfx_wdt_event_handler_t  wdt_event_handler)
{
    NRFX_ASSERT(p_config);
    nrfx_err_t err_code;

#if !NRFX_CHECK(NRFX_WDT_CONFIG_NO_IRQ)
    NRFX_ASSERT(wdt_event_handler != NULL);
    m_wdt_event_handler = wdt_event_handler;
#else
    NRFX_ASSERT(wdt_event_handler == NULL);
    (void)wdt_event_handler;
#endif
    if (m_state == NRFX_DRV_STATE_UNINITIALIZED)
    {
        m_state = NRFX_DRV_STATE_INITIALIZED;
    }
    else
    {
        err_code = NRFX_ERROR_INVALID_STATE;
        NRFX_LOG_WARNING("Function: %s, error code: %s.",
                         __func__,
                         NRFX_LOG_ERROR_STRING_GET(err_code));
        return err_code;
    }

    nrf_wdt_behaviour_set(p_config->behaviour);

    nrf_wdt_reload_value_set((p_config->reload_value * 32768) / 1000);

#if !NRFX_CHECK(NRFX_WDT_CONFIG_NO_IRQ)
    NRFX_IRQ_PRIORITY_SET(WDT_IRQn, p_config->interrupt_priority);
    NRFX_IRQ_ENABLE(WDT_IRQn);
#endif

    err_code = NRFX_SUCCESS;
    NRFX_LOG_INFO("Function: %s, error code: %s.", __func__, NRFX_LOG_ERROR_STRING_GET(err_code));
    return err_code;
}

Am I missing a softdevice call or step that enables it to proceed while sharing the LFCLK source with WDT?

Here are my clock settings for the softdevice:

// <o> NRF_SDH_CLOCK_LF_SRC  - SoftDevice clock source.

// <0=> NRF_CLOCK_LF_SRC_RC
// <1=> NRF_CLOCK_LF_SRC_XTAL
// <2=> NRF_CLOCK_LF_SRC_SYNTH

#ifndef NRF_SDH_CLOCK_LF_SRC
#define NRF_SDH_CLOCK_LF_SRC 1
#endif

// <o> NRF_SDH_CLOCK_LF_RC_CTIV - SoftDevice calibration timer interval.
#ifndef NRF_SDH_CLOCK_LF_RC_CTIV
#define NRF_SDH_CLOCK_LF_RC_CTIV 16
#endif

// <o> NRF_SDH_CLOCK_LF_RC_TEMP_CTIV - SoftDevice calibration timer interval under constant temperature.
// <i> How often (in number of calibration intervals) the RC oscillator shall be calibrated
// <i>  if the temperature has not changed.

#ifndef NRF_SDH_CLOCK_LF_RC_TEMP_CTIV
#define NRF_SDH_CLOCK_LF_RC_TEMP_CTIV 2
#endif

Commenting out the call to nrf_drv_clock_lfclk_release or lfclk_stop prevents the hang.

Also, if I switch NRF_SDH_CLOCK_LF_SRC to LFSYNT, the softdevice disables successfully without any hanging.  However, the softdevice documentation states that there are only two sources usable for the softdevice: the internal RC and XTAL.

Is LFSYNT not recommended for the softdevice? Or is this a valid alternative as an "internal RC" if the additional current consumption is acceptable?

[Einar Thorsrud]

Hi,

I think you can see this as a bug in the clock drivers. I have reported it internally. 

I am not sure exactly where this should be fixed. If you tell nrfx to disable the clock by calling nrfx_clock_lfclk_stop(), it could perhaps return an error if the watchdog is enabled, or silently handle this by not waiting for the clock to stop if the watchdog timer is ready. Alternatively, you could modify sd_state_evt_handler() to not call nrf_drv_clock_lfclk_release() on the NRF_SDH_EVT_STATE_DISABLED event as you do, or check if the WDT is enabled, and only call it if not.

[fwst303]

Thanks a lot, Einar!

I like the idea of some sort of notification being returned about the driver not being able to shut down its LFCLK. Then an app could decide to ignore this or handle it as needed.

For the softdevice, if the WDT is running then caring about the LFRC getting shut down is kind of moot, so maybe some sort of error check or "if !(WDT is running && softdevice LFCLK == LFRC)" guard around the call for would suffice there.