modules: fota: Apply image on FMFU validation event

This change addresses the NRF_CLOUD_FOTA_FMFU_VALIDATION_NEEDED event
that was introduced in the updated nRF SDK version, which is currently
causing CI nightly failures.

Changes:
- Add NETWORK_DISCONNECT event handling in network module
- Implement proper state transitions for LTE disconnection
- Update FOTA module with new states for FMFU validation scenario

The system now correctly disconnects from LTE when the
validation event is received, ensuring proper FOTA completion for FMFU.

Signed-off-by: Simen S. Røstad <[email protected]>

Author: simensrostad

app/prj.conf

@@ -120,7 +120,8 @@ CONFIG_NRF_CLOUD_FOTA_DOWNLOAD_FRAGMENT_SIZE=1700
 CONFIG_NRF_CLOUD_COAP_DOWNLOADS=y
 CONFIG_FOTA_DOWNLOAD=y
 CONFIG_FOTA_DOWNLOAD_PROGRESS_EVT=y
-CONFIG_FOTA_DL_TIMEOUT_MIN=30
+CONFIG_FOTA_DL_TIMEOUT_MIN=60
+CONFIG_FOTA_SOCKET_RETRIES=5
 CONFIG_DFU_TARGET=y
 
 # COAP client

app/src/common/message_channel.h

@@ -55,6 +55,7 @@ struct payload {
 enum network_status {
 	NETWORK_DISCONNECTED = 0x1,
 	NETWORK_CONNECTED,
+	NETWORK_DISCONNECT_REQUEST,
 };
 
 #define MSG_TO_NETWORK_STATUS(_msg)	(*(const enum network_status *)_msg)

app/src/modules/fota/fota.c

@@ -33,8 +33,10 @@ ZBUS_MSG_SUBSCRIBER_DEFINE(fota);
 /* Observe channels */
 ZBUS_CHAN_ADD_OBS(TRIGGER_CHAN, fota, 0);
 ZBUS_CHAN_ADD_OBS(CLOUD_CHAN, fota, 0);
+ZBUS_CHAN_ADD_OBS(NETWORK_CHAN, fota, 0);
 
-#define MAX_MSG_SIZE MAX(sizeof(enum trigger_type), sizeof(enum cloud_status))
+#define MAX_MSG_SIZE MAX(MAX(sizeof(enum trigger_type), sizeof(enum cloud_status)), \
+			     sizeof(enum network_status))
 
 /* FOTA support context */
 static void fota_reboot(enum nrf_cloud_fota_reboot_status status);
@@ -48,13 +50,15 @@ static void fota_status(enum nrf_cloud_fota_status status, const char *const sta
  *	STATE_WAIT_FOR_CLOUD: The FOTA module is initialized and waiting for cloud connection.
  *	STATE_WAIT_FOR_TRIGGER: The FOTA module is waiting for a trigger to poll for updates.
  *	STATE_POLL_AND_PROCESS: The FOTA module is polling for updates and processing them.
+ *	STATE_WAIT_FOR_NETWORK_DISCONNECT: Waiting for network to disconnect before applying FMFU.
  *	STATE_REBOOT_PENDING: The nRF Cloud FOTA library has requested a reboot to complete an update.
  */
 enum fota_module_state {
 	STATE_RUNNING,
 	STATE_WAIT_FOR_CLOUD,
 	STATE_WAIT_FOR_TRIGGER,
 	STATE_POLL_AND_PROCESS,
+	STATE_WAIT_FOR_NETWORK_DISCONNECT,
 	STATE_REBOOT_PENDING,
 };
 
@@ -64,7 +68,10 @@ enum priv_fota_evt {
 	FOTA_PRIV_PROCESSING_DONE,
 	/* FOTA processing is completed, reboot is needed */
 	FOTA_PRIV_REBOOT_PENDING,
+	/* FMFU download complete, need validation of image */
+	FOTA_PRIV_FMFU_VALIDATION_NEEDED
 };
+
 /* User defined state object.
  * Used to transfer data between state changes.
  */
@@ -99,6 +106,8 @@ static void state_wait_for_cloud_run(void *o);
 static void state_wait_for_trigger_run(void *o);
 static void state_poll_and_process_entry(void *o);
 static void state_poll_and_process_run(void *o);
+static void state_wait_for_network_disconnect_entry(void *o);
+static void state_wait_for_network_disconnect_run(void *o);
 static void state_reboot_pending_entry(void *o);
 
 static struct s_object s_obj = {
@@ -124,6 +133,12 @@ static const struct smf_state states[] = {
 				 NULL,
 				 &states[STATE_RUNNING],
 				 NULL),
+	[STATE_WAIT_FOR_NETWORK_DISCONNECT] =
+		SMF_CREATE_STATE(state_wait_for_network_disconnect_entry,
+				 state_wait_for_network_disconnect_run,
+				 NULL,
+				 &states[STATE_RUNNING],
+				 NULL),
 	[STATE_REBOOT_PENDING] =
 		SMF_CREATE_STATE(state_reboot_pending_entry, NULL, NULL,
 				 &states[STATE_RUNNING],
@@ -224,13 +239,63 @@ static void state_poll_and_process_run(void *o)
 			/* The FOTA module has requested a reboot to complete an update */
 			STATE_SET(STATE_REBOOT_PENDING);
 			break;
+		case FOTA_PRIV_FMFU_VALIDATION_NEEDED:
+			/* FMFU download is complete, need to validate the image */
+			STATE_SET(STATE_WAIT_FOR_NETWORK_DISCONNECT);
+			break;
 		default:
 			LOG_ERR("Unknown event: %d", evt);
 			break;
 		}
 	}
 }
 
+static void state_wait_for_network_disconnect_entry(void *o)
+{
+	int err;
+	enum network_status network_msg = NETWORK_DISCONNECT_REQUEST;
+
+	ARG_UNUSED(o);
+
+	LOG_DBG("Requesting network disconnect for FMFU application");
+
+	err = zbus_chan_pub(&NETWORK_CHAN, &network_msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+	}
+}
+
+static void state_wait_for_network_disconnect_run(void *o)
+{
+	struct s_object *state_object = o;
+	int err;
+
+	if (&NETWORK_CHAN == state_object->chan) {
+		const enum network_status status = MSG_TO_NETWORK_STATUS(state_object->msg_buf);
+
+		if (status == NETWORK_DISCONNECTED) {
+			LOG_DBG("Network disconnected, applying FMFU");
+
+			err = nrf_cloud_fota_poll_update_apply(&state_object->fota_ctx);
+			if (err) {
+				LOG_ERR("nrf_cloud_fota_poll_update_apply, error: %d", err);
+				SEND_FATAL_ERROR();
+				return;
+			}
+		}
+	}
+
+	if (&PRIV_FOTA_CHAN == state_object->chan) {
+		const enum priv_fota_evt evt = *(const enum priv_fota_evt *)state_object->msg_buf;
+
+		if (evt == FOTA_PRIV_REBOOT_PENDING) {
+			STATE_SET(STATE_REBOOT_PENDING);
+			return;
+		}
+	}
+}
+
 static void state_reboot_pending_entry(void *o)
 {
 	ARG_UNUSED(o);
@@ -357,6 +422,11 @@ static void fota_status(enum nrf_cloud_fota_status status, const char *const sta
 	case NRF_CLOUD_FOTA_FAILED:
 		LOG_ERR("Firmware download failed");
 
+		status_events_notify(FOTA_STATUS_STOP);
+		break;
+	case NRF_CLOUD_FOTA_CANCELED:
+		LOG_WRN("Firmware download canceled");
+
 		status_events_notify(FOTA_STATUS_STOP);
 		break;
 	case NRF_CLOUD_FOTA_TIMED_OUT:
@@ -369,6 +439,11 @@ static void fota_status(enum nrf_cloud_fota_status status, const char *const sta
 
 		status_events_notify(FOTA_STATUS_STOP);
 		return;
+	case NRF_CLOUD_FOTA_FMFU_VALIDATION_NEEDED:
+		LOG_DBG("Full modem FOTA validation needed");
+
+		evt = FOTA_PRIV_FMFU_VALIDATION_NEEDED;
+		break;
 	default:
 		LOG_ERR("Unknown FOTA status: %d", status);
 		break;

app/src/modules/location/location.c

@@ -41,7 +41,6 @@ ZBUS_CHAN_ADD_OBS(NETWORK_CHAN, location, 0);
 		         sizeof(enum network_status)))))))
 
 static bool gnss_enabled;
-static bool gnss_initialized;
 
 static void location_event_handler(const struct location_event_data *event_data);
 
@@ -99,22 +98,22 @@ void trigger_location_update(void)
 	}
 }
 
-void handle_network_chan(enum network_status status) {
-	int err = 0;
-
-	if (gnss_initialized) {
-		return;
-	}
+void handle_network_chan(enum network_status status)
+{
+	int err;
 
 	if (status == NETWORK_CONNECTED) {
-		/* GNSS has to be enabled after the modem is initialized and enabled */
 		err = lte_lc_func_mode_set(LTE_LC_FUNC_MODE_ACTIVATE_GNSS);
 		if (err) {
 			LOG_ERR("Unable to init GNSS: %d", err);
 			SEND_FATAL_ERROR();
-		} else {
-			gnss_initialized = true;
-			LOG_DBG("GNSS initialized");
+		}
+
+	} else if (status == NETWORK_DISCONNECTED) {
+		err = lte_lc_func_mode_set(LTE_LC_FUNC_MODE_DEACTIVATE_GNSS);
+		if (err) {
+			LOG_ERR("Unable to init GNSS: %d", err);
+			SEND_FATAL_ERROR();
 		}
 	}
 }

app/src/modules/network/network.c

@@ -28,8 +28,10 @@ ZBUS_MSG_SUBSCRIBER_DEFINE(network);
 /* Observe trigger channel */
 ZBUS_CHAN_ADD_OBS(TRIGGER_CHAN, network, 0);
 ZBUS_CHAN_ADD_OBS(TIME_CHAN, network, 0);
+ZBUS_CHAN_ADD_OBS(NETWORK_CHAN, network, 0);
 
-#define MAX_MSG_SIZE (MAX(sizeof(enum trigger_type), sizeof(enum time_status)))
+#define MAX_MSG_SIZE (MAX(MAX(sizeof(enum trigger_type), sizeof(enum time_status)), \
+			      sizeof(enum network_status)))
 
 /* Macros used to subscribe to specific Zephyr NET management events. */
 #define L4_EVENT_MASK (NET_EVENT_L4_CONNECTED | NET_EVENT_L4_DISCONNECTED)
@@ -45,11 +47,14 @@ static struct net_mgmt_event_callback conn_cb;
 /* Module states.
  *
  * STATE_INIT: The module is initializing and waiting for time to be available.
- * STATE_SAMPLING: The  module is ready to sample upon receiving a trigger.
+ * STATE_SAMPLING: The module is ready to sample upon receiving a trigger.
+ * STATE_DISCONNECTED: The module is disconnected from the network, sampling is blocked.
  */
 enum network_module_state {
 	STATE_INIT,
 	STATE_SAMPLING,
+	STATE_WAIT_FOR_NETWORK_DISCONNECT,
+	STATE_DISCONNECTED,
 };
 
 /* State object.
@@ -68,6 +73,8 @@ struct s_object {
 /* Forward declarations of state handlers */
 static void state_init_run(void *o);
 static void state_sampling_run(void *o);
+static void state_disconnected_entry(void *o);
+static void state_wait_for_network_disconnect_run(void *o);
 
 static struct s_object s_obj;
 static const struct smf_state states[] = {
@@ -79,6 +86,14 @@ static const struct smf_state states[] = {
 		SMF_CREATE_STATE(NULL, state_sampling_run, NULL,
 				 NULL,
 				 NULL),
+	[STATE_WAIT_FOR_NETWORK_DISCONNECT] =
+		SMF_CREATE_STATE(NULL, state_wait_for_network_disconnect_run, NULL,
+				 NULL,
+				 NULL),
+	[STATE_DISCONNECTED] =
+		SMF_CREATE_STATE(state_disconnected_entry, NULL, NULL,
+				 NULL,
+				 NULL),
 };
 
 static void network_status_notify(enum network_status status)
@@ -244,6 +259,45 @@ static void state_sampling_run(void *obj)
 			}
 		}
 	}
+
+	if (&NETWORK_CHAN == state_object->chan) {
+		enum network_status status = MSG_TO_NETWORK_STATUS(state_object->msg_buf);
+
+		if (status == NETWORK_DISCONNECT_REQUEST) {
+			LOG_DBG("Network disconnect request request received");
+
+			int err = conn_mgr_all_if_disconnect(true);
+
+			if (err) {
+				LOG_ERR("conn_mgr_all_if_disconnect, error: %d", err);
+				SEND_FATAL_ERROR();
+			}
+
+			STATE_SET(STATE_WAIT_FOR_NETWORK_DISCONNECT);
+		}
+	}
+}
+
+static void state_wait_for_network_disconnect_run(void *o)
+{
+	struct s_object *state_object = o;
+
+	if (&NETWORK_CHAN == state_object->chan) {
+		const enum network_status status = MSG_TO_NETWORK_STATUS(state_object->msg_buf);
+
+		if (status == NETWORK_DISCONNECTED) {
+			LOG_DBG("Network disconnected, sampling is blocked");
+
+			STATE_SET(STATE_DISCONNECTED);
+		}
+	}
+}
+
+static void state_disconnected_entry(void *obj)
+{
+	ARG_UNUSED(obj);
+
+	LOG_DBG("state_disconnected_entry");
 }
 
 static void task_wdt_callback(int channel_id, void *user_data)

tests/module/network/src/main.c

@@ -25,6 +25,7 @@ FAKE_VALUE_FUNC(int, task_wdt_feed, int);
 FAKE_VALUE_FUNC(int, task_wdt_add, uint32_t, task_wdt_callback_t, void *);
 FAKE_VALUE_FUNC(int, lte_lc_conn_eval_params_get, struct lte_lc_conn_eval_params *);
 FAKE_VALUE_FUNC(int, conn_mgr_all_if_connect, bool);
+FAKE_VALUE_FUNC(int, conn_mgr_all_if_disconnect, bool);
 FAKE_VALUE_FUNC(int, conn_mgr_all_if_up, bool);
 FAKE_VOID_FUNC(net_mgmt_add_event_callback, struct net_mgmt_event_callback *);
 
@@ -96,6 +97,14 @@ static void send_trigger(void)
 	TEST_ASSERT_EQUAL(0, err);
 }
 
+static void send_network_disconnect_request(void)
+{
+	enum network_status status = NETWORK_DISCONNECT_REQUEST;
+	int err = zbus_chan_pub(&NETWORK_CHAN, &status, K_SECONDS(1));
+
+	TEST_ASSERT_EQUAL(0, err);
+}
+
 static void wait_for_and_decode_payload(struct conn_info_object *conn_info_obj)
 {
 	const struct zbus_channel *chan;
@@ -138,6 +147,7 @@ void setUp(void)
 	RESET_FAKE(lte_lc_conn_eval_params_get);
 	RESET_FAKE(conn_mgr_all_if_connect);
 	RESET_FAKE(conn_mgr_all_if_up);
+	RESET_FAKE(conn_mgr_all_if_disconnect);
 
 	date_time_now_fake.custom_fake = date_time_now_custom_fake;
 	send_time_available();
@@ -238,6 +248,22 @@ void test_no_events_on_zbus_until_watchdog_timeout(void)
 	TEST_ASSERT_GREATER_OR_EQUAL(1, task_wdt_feed_fake.call_count);
 }
 
+void test_network_disconnect_request_calls_disconnect_function(void)
+{
+	/* Given */
+	conn_mgr_all_if_disconnect_fake.return_val = 0;
+
+	/* When */
+	send_network_disconnect_request();
+
+	/* Allow the test thread to sleep so that the DUT's thread is allowed to run. */
+	k_sleep(K_MSEC(100));
+
+	/* Then */
+	TEST_ASSERT_EQUAL(1, conn_mgr_all_if_disconnect_fake.call_count);
+	TEST_ASSERT_EQUAL(true, conn_mgr_all_if_disconnect_fake.arg0_val);
+}
+
 /* This is required to be added to each test. That is because unity's
  * main may return nonzero, while zephyr's main currently must
  * return 0 in all cases (other values are reserved).