Merge branch 'feature/add_rollback_flags' into 'master'

bootloader/app_update: Add a support of an app rollback.

See merge request idf/esp-idf!3547

components/app_update/esp_ota_ops.c

@@ -39,6 +39,7 @@
 #include "esp_flash_data_types.h"
 #include "bootloader_common.h"
 #include "sys/param.h"
+#include "esp_system.h"
 
 #define SUB_TYPE_ID(i) (i & 0x0F) 
 
@@ -115,6 +116,16 @@ static esp_err_t image_validate(const esp_partition_t *partition, esp_image_load
     return ESP_OK;
 }
 
+static esp_ota_img_states_t set_new_state_otadata(void)
+{
+#ifdef CONFIG_APP_ROLLBACK_ENABLE
+    ESP_LOGD(TAG, "Monitoring the first boot of the app is enabled.");
+    return ESP_OTA_IMG_NEW;
+#else
+    return ESP_OTA_IMG_UNDEFINED;
+#endif
+}
+
 esp_err_t esp_ota_begin(const esp_partition_t *partition, size_t image_size, esp_ota_handle_t *out_handle)
 {
     ota_ops_entry_t *new_entry;
@@ -347,10 +358,12 @@ static esp_err_t esp_rewrite_ota_data(esp_partition_subtype_t subtype)
             i++;
         }
         int next_otadata = (~active_otadata)&1; // if 0 -> will be next 1. and if 1 -> will be next 0.
+        otadata[next_otadata].ota_state = set_new_state_otadata();
         return rewrite_ota_seq(otadata, (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, next_otadata, otadata_partition);
     } else {
         /* Both OTA slots are invalid, probably because unformatted... */
         int next_otadata = 0;
+        otadata[next_otadata].ota_state = set_new_state_otadata();
         return rewrite_ota_seq(otadata, SUB_TYPE_ID(subtype) + 1, next_otadata, otadata_partition);
     }
 }
@@ -546,3 +559,185 @@ esp_err_t esp_ota_get_partition_description(const esp_partition_t *partition, es
 
     return ESP_OK;
 }
+
+// if valid == false - will done rollback with reboot. After reboot will boot previous OTA[x] or Factory partition.
+// if valid == true  - it confirm that current OTA[x] is workable. Reboot will not happen.
+static esp_err_t esp_ota_current_ota_is_workable(bool valid)
+{
+    esp_ota_select_entry_t otadata[2];
+    const esp_partition_t *otadata_partition = read_otadata(otadata);
+    if (otadata_partition == NULL) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    int active_otadata = bootloader_common_get_active_otadata(otadata);
+    if (active_otadata != -1 && get_ota_partition_count() != 0) {
+        if (valid == true && otadata[active_otadata].ota_state != ESP_OTA_IMG_VALID) {
+            otadata[active_otadata].ota_state = ESP_OTA_IMG_VALID;
+            ESP_LOGD(TAG, "OTA[current] partition is marked as VALID");
+            return rewrite_ota_seq(otadata, otadata[active_otadata].ota_seq, active_otadata, otadata_partition);
+        } else if (valid == false) {
+            ESP_LOGD(TAG, "OTA[current] partition is marked as INVALID");
+            otadata[active_otadata].ota_state = ESP_OTA_IMG_INVALID;
+            esp_err_t err = rewrite_ota_seq(otadata, otadata[active_otadata].ota_seq, active_otadata, otadata_partition);
+            if (err != ESP_OK) {
+                return err;
+            }
+            ESP_LOGI(TAG, "Rollback to previously worked partition. Restart.");
+            esp_restart();
+        }
+    } else {
+        ESP_LOGE(TAG, "Running firmware is factory");
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_ota_mark_app_valid_cancel_rollback()
+{
+    return esp_ota_current_ota_is_workable(true);
+}
+
+esp_err_t esp_ota_mark_app_invalid_rollback_and_reboot()
+{
+    return esp_ota_current_ota_is_workable(false);
+}
+
+static bool check_invalid_otadata (const esp_ota_select_entry_t *s) {
+    return s->ota_seq != UINT32_MAX &&
+           s->crc == bootloader_common_ota_select_crc(s) &&
+           (s->ota_state == ESP_OTA_IMG_INVALID ||
+            s->ota_state == ESP_OTA_IMG_ABORTED);
+}
+
+static int get_last_invalid_otadata(const esp_ota_select_entry_t *two_otadata)
+{
+    int num_invalid_otadata = -1;
+
+    bool invalid_otadata[2];
+    invalid_otadata[0] = check_invalid_otadata(&two_otadata[0]);
+    invalid_otadata[1] = check_invalid_otadata(&two_otadata[1]);
+    if (invalid_otadata[0] == true && invalid_otadata[1] == true) {
+        if (MIN(two_otadata[0].ota_seq, two_otadata[1].ota_seq) == two_otadata[0].ota_seq) {
+            num_invalid_otadata = 0;
+        } else {
+            num_invalid_otadata = 1;
+        }
+    } else {
+        for (int i = 0; i < 2; ++i) {
+            if(invalid_otadata[i]) {
+                num_invalid_otadata = i;
+                break;
+            }
+        }
+    }
+
+    ESP_LOGD(TAG, "Invalid otadata[%d]", num_invalid_otadata);
+    return num_invalid_otadata;
+}
+
+const esp_partition_t* esp_ota_get_last_invalid_partition()
+{
+    esp_ota_select_entry_t otadata[2];
+    if (read_otadata(otadata) == NULL) {
+        return NULL;
+    }
+
+    int invalid_otadata = get_last_invalid_otadata(otadata);
+
+    int ota_app_count = get_ota_partition_count();
+    if (invalid_otadata != -1 && ota_app_count != 0) {
+        int ota_slot = (otadata[invalid_otadata].ota_seq - 1) % ota_app_count;
+        ESP_LOGD(TAG, "Find invalid ota_%d app", ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot);
+
+        const esp_partition_t* invalid_partition = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot, NULL);
+        if (invalid_partition != NULL) {
+            if (image_validate(invalid_partition, ESP_IMAGE_VERIFY_SILENT) != ESP_OK) {
+                ESP_LOGD(TAG, "Last invalid partition has corrupted app");
+                return NULL;
+            }
+        }
+        return invalid_partition;
+    }
+    return NULL;
+}
+
+esp_err_t esp_ota_get_state_partition(const esp_partition_t *partition, esp_ota_img_states_t *ota_state)
+{
+    if (partition == NULL || ota_state == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!is_ota_partition(partition)) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    esp_ota_select_entry_t otadata[2];
+    int ota_app_count = get_ota_partition_count();
+    if (read_otadata(otadata) == NULL || ota_app_count == 0) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    int req_ota_slot = partition->subtype - ESP_PARTITION_SUBTYPE_APP_OTA_MIN;
+    bool not_found = true;
+    for (int i = 0; i < 2; ++i) {
+        int ota_slot = (otadata[i].ota_seq - 1) % ota_app_count;
+        if (ota_slot == req_ota_slot && otadata[i].crc == bootloader_common_ota_select_crc(&otadata[i])) {
+            *ota_state = otadata[i].ota_state;
+            not_found = false;
+            break;
+        }
+    }
+
+    if (not_found) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_ota_erase_last_boot_app_partition(void)
+{
+    esp_ota_select_entry_t otadata[2];
+    const esp_partition_t* ota_data_partition = read_otadata(otadata);
+    if (ota_data_partition == NULL) {
+        return ESP_FAIL;
+    }
+
+    int active_otadata = bootloader_common_get_active_otadata(otadata);
+    int ota_app_count = get_ota_partition_count();
+    if (active_otadata == -1 || ota_app_count == 0) {
+        return ESP_FAIL;
+    }
+
+    int inactive_otadata = (~active_otadata)&1;
+    if (otadata[inactive_otadata].ota_seq == UINT32_MAX || otadata[inactive_otadata].crc != bootloader_common_ota_select_crc(&otadata[inactive_otadata])) {
+        return ESP_FAIL;
+    }
+
+    int ota_slot = (otadata[inactive_otadata].ota_seq - 1) % ota_app_count; // Actual OTA partition selection
+    ESP_LOGD(TAG, "finding last_boot_app_partition ota_%d app...", ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot);
+
+    const esp_partition_t* last_boot_app_partition_from_otadata = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot, NULL);
+    if (last_boot_app_partition_from_otadata == NULL) {
+        return ESP_FAIL;
+    }
+
+    const esp_partition_t* running_partition = esp_ota_get_running_partition();
+    if (running_partition == NULL || last_boot_app_partition_from_otadata == running_partition) {
+        return ESP_FAIL;
+    }
+
+    esp_err_t err = esp_partition_erase_range(last_boot_app_partition_from_otadata, 0, last_boot_app_partition_from_otadata->size);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    int sec_id = inactive_otadata;
+    err = esp_partition_erase_range(ota_data_partition, sec_id * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    return ESP_OK;
+}

components/app_update/include/esp_ota_ops.h

@@ -21,6 +21,7 @@
 #include "esp_err.h"
 #include "esp_partition.h"
 #include "esp_image_format.h"
+#include "esp_flash_data_types.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -195,6 +196,52 @@ const esp_partition_t* esp_ota_get_next_update_partition(const esp_partition_t *
  */
 esp_err_t esp_ota_get_partition_description(const esp_partition_t *partition, esp_app_desc_t *app_desc);
 
+/**
+ * @brief This function is called to indicate that the running app is working well.
+ *
+ * @return
+ *  - ESP_OK: if successful.
+ */
+esp_err_t esp_ota_mark_app_valid_cancel_rollback();
+
+/**
+ * @brief This function is called to roll back to the previously workable app with reboot.
+ *
+ * If rollback is successful then device will reset else API will return with error code.
+ * @return
+ *  - ESP_FAIL: if not successful.
+ */
+esp_err_t esp_ota_mark_app_invalid_rollback_and_reboot();
+
+/**
+ * @brief Returns last partition with invalid state (ESP_OTA_IMG_INVALID or ESP_OTA_IMG_ABORTED).
+ *
+ * @return partition.
+ */
+const esp_partition_t* esp_ota_get_last_invalid_partition();
+
+/**
+ * @brief Returns state for given partition.
+ *
+ * @param[in] partition  Pointer to partition.
+ * @param[out] ota_state state of partition (if this partition has a record in otadata).
+ * @return
+ *        - ESP_OK:                 Successful.
+ *        - ESP_ERR_INVALID_ARG:    partition or ota_state arguments were NULL.
+ *        - ESP_ERR_NOT_SUPPORTED:  partition is not ota.
+ *        - ESP_ERR_NOT_FOUND:      Partition table does not have otadata or state was not found for given partition.
+ */
+esp_err_t esp_ota_get_state_partition(const esp_partition_t *partition, esp_ota_img_states_t *ota_state);
+
+/**
+ * @brief Erase previous boot app partition and corresponding otadata select for this partition.
+ *
+ * When current app is marked to as valid then you can erase previous app partition.
+ * @return
+ *        - ESP_OK:   Successful, otherwise ESP_ERR.
+ */
+esp_err_t esp_ota_erase_last_boot_app_partition(void);
+
 #ifdef __cplusplus
 }
 #endif

components/app_update/test/test_switch_ota.c

@@ -476,3 +476,244 @@ static void test_flow5(void)
 // 4 Stage: run factory    -> check it -> erase OTA_DATA for next tests             -> PASS
 TEST_CASE_MULTIPLE_STAGES("Switching between factory, test, factory", "[app_update][reset=DEEPSLEEP_RESET, DEEPSLEEP_RESET, DEEPSLEEP_RESET]", start_test, test_flow5, test_flow5, test_flow5);
 #endif
+
+static const esp_partition_t* app_update(void)
+{
+    const esp_partition_t *cur_app = get_running_firmware();
+    const esp_partition_t* update_partition = esp_ota_get_next_update_partition(NULL);
+    TEST_ASSERT_NOT_NULL(update_partition);
+    esp_ota_handle_t update_handle = 0;
+    TEST_ESP_OK(esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle));
+    copy_app_partition(update_handle, cur_app);
+    TEST_ESP_OK(esp_ota_end(update_handle));
+    TEST_ESP_OK(esp_ota_set_boot_partition(update_partition));
+    return update_partition;
+}
+
+
+static void test_rollback1(void)
+{
+    boot_count++;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    esp_ota_img_states_t ota_state = 0x5555AAAA;
+    const esp_partition_t* update_partition = NULL;
+    switch (boot_count) {
+        case 2:
+            ESP_LOGI(TAG, "Factory");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, cur_app->subtype);
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_ERR(ESP_ERR_NOT_SUPPORTED, esp_ota_get_state_partition(cur_app, &ota_state));
+            update_partition = app_update();
+            TEST_ESP_OK(esp_ota_get_state_partition(update_partition, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_NEW, ota_state);
+#endif
+            reboot_as_deep_sleep();
+            break;
+        case 3:
+            ESP_LOGI(TAG, "OTA0");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_0, cur_app->subtype);
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_PENDING_VERIFY, ota_state);
+#endif
+            esp_ota_mark_app_valid_cancel_rollback();
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_VALID, ota_state);
+            reboot_as_deep_sleep();
+            break;
+        case 4:
+            ESP_LOGI(TAG, "OTA0");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_0, cur_app->subtype);
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_VALID, ota_state);
+            TEST_ESP_OK(esp_ota_mark_app_invalid_rollback_and_reboot());
+            break;
+        default:
+            erase_ota_data();
+            TEST_FAIL_MESSAGE("Unexpected stage");
+            break;
+    }
+}
+
+static void test_rollback1_1(void)
+{
+    boot_count = 5;
+    esp_ota_img_states_t ota_state = 0x5555AAAA;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    ESP_LOGI(TAG, "Factory");
+    TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, cur_app->subtype);
+
+    const esp_partition_t *invalid_partition = esp_ota_get_last_invalid_partition();
+    const esp_partition_t* next_update_partition = esp_ota_get_next_update_partition(NULL);
+    TEST_ASSERT_NOT_NULL(invalid_partition);
+    TEST_ASSERT_NOT_NULL(next_update_partition);
+    TEST_ASSERT_EQUAL_PTR(invalid_partition, next_update_partition);
+    TEST_ESP_ERR(ESP_ERR_NOT_SUPPORTED, esp_ota_get_state_partition(cur_app, &ota_state));
+    TEST_ESP_OK(esp_ota_get_state_partition(invalid_partition, &ota_state));
+    TEST_ASSERT_EQUAL(ESP_OTA_IMG_INVALID, ota_state);
+
+    erase_ota_data();
+}
+
+// 1 Stage: After POWER_RESET erase OTA_DATA for this test                          -> reboot through deep sleep.
+// 2 Stage: run factory    -> check it -> copy factory to next app slot             -> reboot  --//--
+// 3 Stage: run OTA0       -> check it -> esp_ota_mark_app_valid_cancel_rollback()                 -> reboot  --//--
+// 4 Stage: run OTA0       -> check it -> esp_ota_mark_app_invalid_rollback_and_reboot()         -> reboot
+// 5 Stage: run factory    -> check it -> erase OTA_DATA for next tests             -> PASS
+TEST_CASE_MULTIPLE_STAGES("Test rollback. factory, OTA0, OTA0, rollback -> factory", "[app_update][reset=DEEPSLEEP_RESET, DEEPSLEEP_RESET, DEEPSLEEP_RESET, SW_CPU_RESET]", start_test, test_rollback1, test_rollback1, test_rollback1, test_rollback1_1);
+
+static void test_rollback2(void)
+{
+    boot_count++;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    esp_ota_img_states_t ota_state = 0x5555AAAA;
+    const esp_partition_t* update_partition = NULL;
+    switch (boot_count) {
+        case 2:
+            ESP_LOGI(TAG, "Factory");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, cur_app->subtype);
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_ERR(ESP_ERR_NOT_SUPPORTED, esp_ota_get_state_partition(cur_app, &ota_state));
+            update_partition = app_update();
+            TEST_ESP_OK(esp_ota_get_state_partition(update_partition, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_NEW, ota_state);
+#endif
+            reboot_as_deep_sleep();
+            break;
+        case 3:
+            ESP_LOGI(TAG, "OTA0");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_0, cur_app->subtype);
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_PENDING_VERIFY, ota_state);
+#endif
+            esp_ota_mark_app_valid_cancel_rollback();
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_VALID, ota_state);
+            update_partition = app_update();
+            TEST_ESP_OK(esp_ota_get_state_partition(update_partition, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_NEW, ota_state);
+#endif
+            reboot_as_deep_sleep();
+            break;
+        case 4:
+            ESP_LOGI(TAG, "OTA1");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_1, cur_app->subtype);
+            TEST_ASSERT_NULL(esp_ota_get_last_invalid_partition());
+            TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_UNDEFINED, ota_state);
+            TEST_ESP_OK(esp_ota_mark_app_invalid_rollback_and_reboot());
+#else
+            TEST_ASSERT_EQUAL(ESP_OTA_IMG_PENDING_VERIFY, ota_state);
+            reboot_as_deep_sleep();
+#endif
+            break;
+        default:
+            erase_ota_data();
+            TEST_FAIL_MESSAGE("Unexpected stage");
+            break;
+    }
+}
+
+static void test_rollback2_1(void)
+{
+    boot_count = 5;
+    esp_ota_img_states_t ota_state = 0x5555AAAA;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    ESP_LOGI(TAG, "OTA0");
+    TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_0, cur_app->subtype);
+
+    const esp_partition_t *invalid_partition = esp_ota_get_last_invalid_partition();
+    TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_1, invalid_partition->subtype);
+    const esp_partition_t* next_update_partition = esp_ota_get_next_update_partition(NULL);
+    TEST_ASSERT_NOT_NULL(invalid_partition);
+    TEST_ASSERT_NOT_NULL(next_update_partition);
+    TEST_ASSERT_EQUAL_PTR(invalid_partition, next_update_partition);
+    TEST_ESP_OK(esp_ota_get_state_partition(cur_app, &ota_state));
+    TEST_ASSERT_EQUAL(ESP_OTA_IMG_VALID, ota_state);
+    TEST_ESP_OK(esp_ota_get_state_partition(invalid_partition, &ota_state));
+#ifndef CONFIG_APP_ROLLBACK_ENABLE
+    TEST_ASSERT_EQUAL(ESP_OTA_IMG_INVALID, ota_state);
+#else
+    TEST_ASSERT_EQUAL(ESP_OTA_IMG_ABORTED, ota_state);
+#endif
+    erase_ota_data();
+}
+
+// 1 Stage: After POWER_RESET erase OTA_DATA for this test                                     -> reboot through deep sleep.
+// 2 Stage: run factory        -> check it -> copy factory to next app slot                    -> reboot  --//--
+// 3 Stage: run OTA0           -> check it -> esp_ota_mark_app_valid_cancel_rollback(), copy to next app slot -> reboot  --//--
+// 4 Stage: run OTA1           -> check it -> PENDING_VERIFY/esp_ota_mark_app_invalid_rollback_and_reboot() -> reboot
+// 5 Stage: run OTA0(rollback) -> check it -> erase OTA_DATA for next tests                    -> PASS
+TEST_CASE_MULTIPLE_STAGES("Test rollback. factory, OTA0, OTA1, rollback -> OTA0", "[app_update][reset=DEEPSLEEP_RESET, DEEPSLEEP_RESET, DEEPSLEEP_RESET, SW_CPU_RESET]", start_test, test_rollback2, test_rollback2, test_rollback2, test_rollback2_1);
+
+static void test_erase_last_app_flow(void)
+{
+    boot_count++;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    switch (boot_count) {
+        case 2:
+            ESP_LOGI(TAG, "Factory");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, cur_app->subtype);
+            app_update();
+            reboot_as_deep_sleep();
+            break;
+        case 3:
+            ESP_LOGI(TAG, "OTA0");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_0, cur_app->subtype);
+            app_update();
+            reboot_as_deep_sleep();
+            break;
+        case 4:
+            ESP_LOGI(TAG, "OTA1");
+            TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_OTA_1, cur_app->subtype);
+            TEST_ESP_OK(esp_ota_erase_last_boot_app_partition());
+            TEST_ESP_OK(esp_ota_mark_app_invalid_rollback_and_reboot());
+            reboot_as_deep_sleep();
+            break;
+        default:
+            erase_ota_data();
+            TEST_FAIL_MESSAGE("Unexpected stage");
+            break;
+    }
+}
+
+static void test_erase_last_app_rollback(void)
+{
+    boot_count = 5;
+    ESP_LOGI(TAG, "boot count %d", boot_count);
+    const esp_partition_t *cur_app = get_running_firmware();
+    ESP_LOGI(TAG, "erase_last_app");
+    TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, cur_app->subtype);
+    TEST_ESP_ERR(ESP_FAIL, esp_ota_erase_last_boot_app_partition());
+    erase_ota_data();
+}
+
+// 1 Stage: After POWER_RESET erase OTA_DATA for this test                                     -> reboot through deep sleep.
+// 2 Stage: run factory        -> check it -> copy factory to OTA0                             -> reboot  --//--
+// 3 Stage: run OTA0           -> check it -> copy factory to OTA1                             -> reboot  --//--
+// 4 Stage: run OTA1           -> check it -> erase OTA0 and rollback                          -> reboot
+// 5 Stage: run factory        -> check it -> erase OTA_DATA for next tests                    -> PASS
+TEST_CASE_MULTIPLE_STAGES("Test erase_last_boot_app_partition. factory, OTA1, OTA0, factory", "[app_update][reset=DEEPSLEEP_RESET, DEEPSLEEP_RESET, DEEPSLEEP_RESET, SW_CPU_RESET]", start_test, test_erase_last_app_flow, test_erase_last_app_flow, test_erase_last_app_flow, test_erase_last_app_rollback);