modules: Update FOTA process

Include more states in app.c to differ between different FOTA
scenarios.

Signed-off-by: Simen S. Røstad <simen.rostad@nordicsemi.no>

Author: simensrostad

app/src/modules/app/app.c

@@ -62,6 +62,11 @@ static void idle_run(void *o);
 static void fota_entry(void *o);
 static void fota_run(void *o);
 
+static void fota_downloading_run(void *o);
+
+static void fota_network_disconnect_and_reboot_entry(void *o);
+static void fota_network_disconnect_and_reboot_run(void *o);
+
 static void fota_network_disconnect_pending_entry(void *o);
 static void fota_network_disconnect_pending_run(void *o);
 
@@ -84,6 +89,8 @@ enum state {
 	STATE_PERIODIC_TRIGGERING,
 	STATE_IDLE,
 	STATE_FOTA,
+	STATE_FOTA_DOWNLOADING,
+	STATE_FOTA_NETWORK_DISCONNECT_AND_REBOOT,
 	STATE_FOTA_NETWORK_DISCONNECT_PENDING,
 	STATE_FOTA_IMAGE_APPLY_PENDING,
 	STATE_FOTA_REBOOTING,
@@ -148,6 +155,20 @@ static const struct smf_state states[] = {
 		fota_run,
 		NULL,
 		NULL,
+		&states[STATE_FOTA_DOWNLOADING]
+	),
+	[STATE_FOTA_DOWNLOADING] = SMF_CREATE_STATE(
+		NULL,
+		fota_downloading_run,
+		NULL,
+		&states[STATE_FOTA],
+		NULL
+	),
+	[STATE_FOTA_NETWORK_DISCONNECT_AND_REBOOT] = SMF_CREATE_STATE(
+		fota_network_disconnect_and_reboot_entry,
+		fota_network_disconnect_and_reboot_run,
+		NULL,
+		&states[STATE_FOTA],
 		NULL
 	),
 	[STATE_FOTA_NETWORK_DISCONNECT_PENDING] = SMF_CREATE_STATE(
@@ -400,11 +421,25 @@ static void fota_run(void *o)
 		case FOTA_DOWNLOAD_FAILED:
 			STATE_SET(app_state, STATE_RUNNING);
 			return;
-		case FOTA_NETWORK_DISCONNECT_NEEDED:
-			STATE_SET(app_state, STATE_FOTA_NETWORK_DISCONNECT_PENDING);
-			return;
+		default:
+			/* Don't care */
+			break;
+		}
+	}
+}
+
+/* STATE_FOTA_DOWNLOADING */
+static void fota_downloading_run(void *o)
+{
+	const struct app_state_object *state_object = (const struct app_state_object *)o;
+
+	if (state_object->chan == &FOTA_CHAN) {
+		switch (state_object->fota_status) {
 		case FOTA_REBOOT_NEEDED:
-			STATE_SET(app_state, STATE_FOTA_REBOOTING);
+			STATE_SET(app_state, STATE_FOTA_NETWORK_DISCONNECT_AND_REBOOT);
+			return;
+		case FOTA_NETWORK_DISCONNECT_AND_APPLY_NEEDED:
+			STATE_SET(app_state, STATE_FOTA_NETWORK_DISCONNECT_PENDING);
 			return;
 		default:
 			/* Don't care */
@@ -413,6 +448,37 @@ static void fota_run(void *o)
 	}
 }
 
+/* STATE_FOTA_NETWORK_DISCONNECT_AND_REBOOT */
+
+static void fota_network_disconnect_and_reboot_entry(void *o)
+{
+	ARG_UNUSED(o);
+
+	LOG_DBG("%s", __func__);
+
+	int err;
+	struct network_msg msg = {
+		.type = NETWORK_DISCONNECT
+	};
+
+	err = zbus_chan_pub(&NETWORK_CHAN, &msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+	}
+}
+
+static void fota_network_disconnect_and_reboot_run(void *o)
+{
+	const struct app_state_object *state_object = (const struct app_state_object *)o;
+
+	if (state_object->chan == &NETWORK_CHAN &&
+	    state_object->network_status == NETWORK_DISCONNECTED) {
+		STATE_SET(app_state, STATE_FOTA_REBOOTING);
+		return;
+	}
+}
+
 /* STATE_FOTA_NETWORK_DISCONNECT_PENDING */
 
 static void fota_network_disconnect_pending_entry(void *o)
@@ -453,7 +519,7 @@ static void fota_image_apply_pending_entry(void *o)
 	LOG_DBG("%s", __func__);
 
 	int err;
-	enum fota_msg_type msg = FOTA_APPLY_IMAGE;
+	enum fota_msg_type msg = FOTA_IMAGE_APPLY;
 
 	err = zbus_chan_pub(&FOTA_CHAN, &msg, K_SECONDS(1));
 	if (err) {

app/src/modules/fota/fota.c

@@ -50,12 +50,13 @@ static void fota_status(enum nrf_cloud_fota_status status, const char *const sta
 /* State machine */
 
 /* Defining modules states.
- * STATE_RUNNING: The FOTA module is initializing and waiting for a poll request.
- *	STATE_WAITING_FOR_POLL_REQUEST: The FOTA module is waiting for a poll request.
- *	STATE_POLLING_FOR_UPDATE: The FOTA module is polling for an update.
- *	STATE_DOWNLOADING_UPDATE: The FOTA module is downloading an update.
- *	STATE_WAITING_FOR_NETWORK_DISCONNECT: The FOTA module is waiting for a network disconnect
- *					      in order to apply the update.
+ * STATE_RUNNING: The module is initializing and waiting for a poll request.
+ *	STATE_WAITING_FOR_POLL_REQUEST: The module is waiting for a poll request.
+ *	STATE_POLLING_FOR_UPDATE: The module is polling for an update.
+ *	STATE_DOWNLOADING_UPDATE: The module is downloading an update.
+ *	STATE_WAITING_FOR_IMAGE_APPLY: The module is waiting for the event FOTA_IMAGE_APPLY to
+ *				       apply the image. This requires the application to
+ *				       disconnect from the network before sending the event.
  *	STATE_REBOOT_NEEDED: The FOTA module is waiting for a reboot.
  *	STATE_CANCELED: The FOTA module has been canceled, cleaning up.
  */
@@ -64,7 +65,7 @@ enum fota_module_state {
 	STATE_WAITING_FOR_POLL_REQUEST,
 	STATE_POLLING_FOR_UPDATE,
 	STATE_DOWNLOADING_UPDATE,
-	STATE_WAITING_FOR_NETWORK_DISCONNECT,
+	STATE_WAITING_FOR_IMAGE_APPLY,
 	STATE_REBOOT_NEEDED,
 	STATE_CANCELED,
 };
@@ -95,8 +96,8 @@ static void state_polling_for_update_entry(void *o);
 static void state_polling_for_update_run(void *o);
 static void state_downloading_update_entry(void *o);
 static void state_downloading_update_run(void *o);
-static void state_waiting_for_network_disconnect_entry(void *o);
-static void state_waiting_for_network_disconnect_run(void *o);
+static void state_waiting_for_image_apply_entry(void *o);
+static void state_waiting_for_image_apply_run(void *o);
 static void state_reboot_needed_entry(void *o);
 static void state_canceled_entry(void *o);
 
@@ -130,9 +131,9 @@ static const struct smf_state states[] = {
 				 NULL,
 				 &states[STATE_RUNNING],
 				 NULL),
-	[STATE_WAITING_FOR_NETWORK_DISCONNECT] =
-		SMF_CREATE_STATE(state_waiting_for_network_disconnect_entry,
-				 state_waiting_for_network_disconnect_run,
+	[STATE_WAITING_FOR_IMAGE_APPLY] =
+		SMF_CREATE_STATE(state_waiting_for_image_apply_entry,
+				 state_waiting_for_image_apply_run,
 				 NULL,
 				 &states[STATE_RUNNING],
 				 NULL),
@@ -200,7 +201,7 @@ static void fota_status(enum nrf_cloud_fota_status status, const char *const sta
 	case NRF_CLOUD_FOTA_FMFU_VALIDATION_NEEDED:
 		LOG_DBG("Full Modem FOTA Update validation needed, network disconnect required");
 
-		evt = FOTA_NETWORK_DISCONNECT_NEEDED;
+		evt = FOTA_NETWORK_DISCONNECT_AND_APPLY_NEEDED;
 		break;
 	default:
 		LOG_DBG("Unknown FOTA status: %d", status);
@@ -354,8 +355,8 @@ static void state_downloading_update_run(void *o)
 		const enum fota_msg_type evt = MSG_TO_FOTA_TYPE(state_object->msg_buf);
 
 		switch (evt) {
-		case FOTA_NETWORK_DISCONNECT_NEEDED:
-			STATE_SET(fota_state, STATE_WAITING_FOR_NETWORK_DISCONNECT);
+		case FOTA_NETWORK_DISCONNECT_AND_APPLY_NEEDED:
+			STATE_SET(fota_state, STATE_WAITING_FOR_IMAGE_APPLY);
 			break;
 		case FOTA_DOWNLOAD_FAILED:
 			STATE_SET(fota_state, STATE_WAITING_FOR_POLL_REQUEST);
@@ -367,22 +368,22 @@ static void state_downloading_update_run(void *o)
 	}
 }
 
-static void state_waiting_for_network_disconnect_entry(void *o)
+static void state_waiting_for_image_apply_entry(void *o)
 {
 	ARG_UNUSED(o);
 
 	LOG_DBG("%s", __func__);
 }
 
-static void state_waiting_for_network_disconnect_run(void *o)
+static void state_waiting_for_image_apply_run(void *o)
 {
 	struct fota_state *state_object = o;
 
 	if (&FOTA_CHAN == state_object->chan) {
 		const enum fota_msg_type evt = MSG_TO_FOTA_TYPE(state_object->msg_buf);
 
 		switch (evt) {
-		case FOTA_APPLY_IMAGE:
+		case FOTA_IMAGE_APPLY:
 
 			LOG_DBG("Applying downloaded firmware image");
 

app/src/modules/fota/fota.h

@@ -36,9 +36,9 @@ enum fota_msg_type {
 	FOTA_REBOOT_NEEDED,
 
 	/* Event notified when the module needs the network to disconnect in order to apply
-	 * an update. When network has been disconnect, send the event FOTA_APPLY_IMAGE.
+	 * an update. When the network has been disconnect, send the event FOTA_IMAGE_APPLY.
 	 */
-	FOTA_NETWORK_DISCONNECT_NEEDED,
+	FOTA_NETWORK_DISCONNECT_AND_APPLY_NEEDED,
 
 	/* Event notified when the FOTA update has been canceled. */
 	FOTA_CANCELED,
@@ -49,7 +49,7 @@ enum fota_msg_type {
 	FOTA_POLL_REQUEST,
 
 	/* Request to apply the downloaded firmware image. */
-	FOTA_APPLY_IMAGE,
+	FOTA_IMAGE_APPLY,
 
 	/* Cancel the FOTA process. */
 	FOTA_CANCEL,

tests/module/fota/src/fota_module_test.c

@@ -158,11 +158,11 @@ void test_fota_module_should_succeed(void)
 
 	/* 3. Download succeeded, validation needed */
 	invoke_nrf_cloud_fota_callback_stub_status(NRF_CLOUD_FOTA_FMFU_VALIDATION_NEEDED);
-	event_expect(FOTA_NETWORK_DISCONNECT_NEEDED);
+	event_expect(FOTA_NETWORK_DISCONNECT_AND_APPLY_NEEDED);
 
 	/* 4. Apply image */
-	event_send(FOTA_APPLY_IMAGE);
-	event_expect(FOTA_APPLY_IMAGE);
+	event_send(FOTA_IMAGE_APPLY);
+	event_expect(FOTA_IMAGE_APPLY);
 
 	/* 5. Reboot needed */
 	invoke_nrf_cloud_fota_callback_stub_reboot(FOTA_REBOOT_SUCCESS);