liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-2269] Core2 OTA (#1144)

Browse Source 
* C2OTA: wip
* Update Cube to 1.13.3
* Fixed prio
* Functional Core2 updater
* Removed hardware CRC usage; code cleanup & linter fixes
* Moved hardcoded stack params to copro.mk
* Fixing CI bundling of core2 fw
* Removed last traces of hardcoded radio stack
* OB processing draft
* Python scripts cleanup
* Support for comments in ob data
* Sacrificed SD card icon in favor of faster update. Waiting for Storage fix
* Additional handling for OB mismatched values
* Description for new furi_hal apis; spelling fixes
* Rework of OB write, WIP
* Properly restarting OB verification loop
* Split update_task_workers.c
* Checking OBs after enabling post-update mode
* Moved OB verification before flashing
* Removed ob.data for custom stacks
* Fixed progress calculation for OB
* Removed unnecessary OB mask cast

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
hedger
2022-04-27 18:53:48 +03:00
committed by GitHub
parent 81aeda86db
commit 7ce305fca3
41 changed files with 1622 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/bt/bt_cli.c
View File

@@ -148,7 +148,7 @@ static void bt_cli_command_packet_rx(Cli* cli, string_t args, void* context) {
static void bt_cli_scan_callback(GapAddress address, void* context) {
furi_assert(context);
osMessageQueueId_t queue = context;
osMessageQueuePut(queue, &address, NULL, 250);
osMessageQueuePut(queue, &address, 0, 250);
}
static void bt_cli_command_scan(Cli* cli, string_t args, void* context) {

7
applications/bt/bt_service/bt.c
View File

@@ -319,6 +319,13 @@ static void bt_change_profile(Bt* bt, BtMessage* message) {
int32_t bt_srv() {
Bt* bt = bt_alloc();
if(furi_hal_rtc_get_boot_mode() != FuriHalRtcBootModeNormal) {
FURI_LOG_W(TAG, "Skipped BT init: device in special startup mode");
ble_glue_wait_for_c2_start(FURI_HAL_BT_C2_START_TIMEOUT);
furi_record_create("bt", bt);
return 0;
}
// Read keys
if(!bt_keys_storage_load(bt)) {
FURI_LOG_W(TAG, "Failed to load bonding keys");

13
applications/updater/scenes/updater_scene_main.c
View File

@@ -36,9 +36,9 @@ void updater_scene_main_on_enter(void* context) {
* will be missing from UI, however, /ext will be fully operational. So, until it's fixed, this
* should remain commented out. */
// If (somehow) we started after SD card is mounted, initiate update immediately
//if(storage_sd_status(updater->storage) == FSE_OK) {
// view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventStartUpdate);
//}
if(storage_sd_status(updater->storage) == FSE_OK) {
view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventStartUpdate);
}
updater_main_set_view_dispatcher(main_view, updater->view_dispatcher);
view_dispatcher_switch_to_view(updater->view_dispatcher, UpdaterViewMain);
@@ -64,13 +64,6 @@ bool updater_scene_main_on_event(void* context, SceneManagerEvent event) {
} else if(event.type == SceneManagerEventTypeCustom) {
switch(event.event) {
case UpdaterCustomEventStartUpdate:
if(!update_task_is_running(updater->update_task) &&
update_task_init(updater->update_task)) {
update_task_start(updater->update_task);
}
consumed = true;
break;
case UpdaterCustomEventRetryUpdate:
if(!update_task_is_running(updater->update_task) &&
(update_task_get_state(updater->update_task)->stage != UpdateTaskStageCompleted))

23
applications/updater/util/update_task.c
View File

@@ -15,13 +15,18 @@ static const char* update_task_stage_descr[] = {
[UpdateTaskStageValidateDFUImage] = "Checking DFU file",
[UpdateTaskStageFlashWrite] = "Writing flash",
[UpdateTaskStageFlashValidate] = "Validating",
[UpdateTaskStageRadioImageValidate] = "Checking radio image",
[UpdateTaskStageRadioErase] = "Removing radio stack",
[UpdateTaskStageRadioWrite] = "Writing radio stack",
[UpdateTaskStageRadioCommit] = "Applying radio stack",
[UpdateTaskStageRadioInstall] = "Installing radio stack",
[UpdateTaskStageRadioBusy] = "Core2 is updating",
[UpdateTaskStageOBValidation] = "Validating opt. bytes",
[UpdateTaskStageLfsBackup] = "Backing up LFS",
[UpdateTaskStageLfsRestore] = "Restoring LFS",
[UpdateTaskStageResourcesUpdate] = "Updating resources",
[UpdateTaskStageCompleted] = "Completed!",
[UpdateTaskStageError] = "Error",
[UpdateTaskStageOBError] = "OB error, pls report",
};
static void update_task_set_status(UpdateTask* update_task, const char* status) {
@@ -37,7 +42,10 @@ static void update_task_set_status(UpdateTask* update_task, const char* status)
void update_task_set_progress(UpdateTask* update_task, UpdateTaskStage stage, uint8_t progress) {
if(stage != UpdateTaskStageProgress) {
update_task->state.stage = stage;
// do not override more specific error states
if((update_task->state.stage < UpdateTaskStageError) || (stage < UpdateTaskStageError)) {
update_task->state.stage = stage;
}
update_task->state.current_stage_idx++;
update_task_set_status(update_task, NULL);
}
@@ -53,7 +61,7 @@ void update_task_set_progress(UpdateTask* update_task, UpdateTaskStage stage, ui
progress,
update_task->state.current_stage_idx,
update_task->state.total_stages,
update_task->state.stage == UpdateTaskStageError,
update_task->state.stage >= UpdateTaskStageError,
update_task->status_change_cb_state);
}
}
@@ -116,6 +124,7 @@ UpdateTask* update_task_alloc() {
update_task->storage = furi_record_open("storage");
update_task->file = storage_file_alloc(update_task->storage);
update_task->status_change_cb = NULL;
string_init(update_task->update_path);
FuriThread* thread = update_task->thread = furi_thread_alloc();
@@ -152,12 +161,6 @@ void update_task_free(UpdateTask* update_task) {
free(update_task);
}
bool update_task_init(UpdateTask* update_task) {
furi_assert(update_task);
string_init(update_task->update_path);
return true;
}
bool update_task_parse_manifest(UpdateTask* update_task) {
furi_assert(update_task);
update_task_set_progress(update_task, UpdateTaskStageReadManifest, 0);
@@ -224,4 +227,4 @@ UpdateTaskState const* update_task_get_state(UpdateTask* update_task) {
UpdateManifest const* update_task_get_manifest(UpdateTask* update_task) {
furi_assert(update_task);
return update_task->manifest;
}
}

9
applications/updater/util/update_task.h
View File

@@ -19,13 +19,18 @@ typedef enum {
UpdateTaskStageValidateDFUImage,
UpdateTaskStageFlashWrite,
UpdateTaskStageFlashValidate,
UpdateTaskStageRadioImageValidate,
UpdateTaskStageRadioErase,
UpdateTaskStageRadioWrite,
UpdateTaskStageRadioCommit,
UpdateTaskStageRadioInstall,
UpdateTaskStageRadioBusy,
UpdateTaskStageOBValidation,
UpdateTaskStageLfsBackup,
UpdateTaskStageLfsRestore,
UpdateTaskStageResourcesUpdate,
UpdateTaskStageCompleted,
UpdateTaskStageError,
UpdateTaskStageOBError
} UpdateTaskStage;
typedef struct {
@@ -50,8 +55,6 @@ UpdateTask* update_task_alloc();
void update_task_free(UpdateTask* update_task);
bool update_task_init(UpdateTask* update_task);
void update_task_set_progress_cb(UpdateTask* update_task, updateProgressCb cb, void* state);
bool update_task_start(UpdateTask* update_task);

92
applications/updater/util/update_task_workers.c → applications/updater/util/update_task_worker_backup.c
View File

@@ -9,99 +9,17 @@
#include <update_util/lfs_backup.h>
#include <update_util/update_operation.h>
#include <toolbox/tar/tar_archive.h>
#include <toolbox/crc32_calc.h>
#define TAG "UpdWorkerBackup"
#define CHECK_RESULT(x) \
if(!(x)) { \
break; \
}
#define STM_DFU_VENDOR_ID 0x0483
#define STM_DFU_PRODUCT_ID 0xDF11
/* Written into DFU file by build pipeline */
#define FLIPPER_ZERO_DFU_DEVICE_CODE 0xFFFF
#define EXT_PATH "/ext"
static const DfuValidationParams flipper_dfu_params = {
.device = FLIPPER_ZERO_DFU_DEVICE_CODE,
.product = STM_DFU_PRODUCT_ID,
.vendor = STM_DFU_VENDOR_ID,
};
static void update_task_dfu_progress(const uint8_t progress, void* context) {
UpdateTask* update_task = context;
update_task_set_progress(update_task, UpdateTaskStageProgress, progress);
}
static bool page_task_compare_flash(
const uint8_t i_page,
const uint8_t* update_block,
uint16_t update_block_len) {
const size_t page_addr = furi_hal_flash_get_base() + furi_hal_flash_get_page_size() * i_page;
return (memcmp(update_block, (void*)page_addr, update_block_len) == 0);
}
/* Verifies a flash operation address for fitting into writable memory
*/
static bool check_address_boundaries(const size_t address) {
const size_t min_allowed_address = furi_hal_flash_get_base();
const size_t max_allowed_address = (size_t)furi_hal_flash_get_free_end_address();
return ((address >= min_allowed_address) && (address < max_allowed_address));
}
int32_t update_task_worker_flash_writer(void* context) {
furi_assert(context);
UpdateTask* update_task = context;
bool success = false;
DfuUpdateTask page_task = {
.address_cb = &check_address_boundaries,
.progress_cb = &update_task_dfu_progress,
.task_cb = &furi_hal_flash_program_page,
.context = update_task,
};
update_task->state.current_stage_idx = 0;
update_task->state.total_stages = 4;
do {
CHECK_RESULT(update_task_parse_manifest(update_task));
if(!string_empty_p(update_task->manifest->firmware_dfu_image)) {
update_task_set_progress(update_task, UpdateTaskStageValidateDFUImage, 0);
CHECK_RESULT(
update_task_open_file(update_task, update_task->manifest->firmware_dfu_image));
CHECK_RESULT(
dfu_file_validate_crc(update_task->file, &update_task_dfu_progress, update_task));
const uint8_t valid_targets =
dfu_file_validate_headers(update_task->file, &flipper_dfu_params);
if(valid_targets == 0) {
break;
}
update_task_set_progress(update_task, UpdateTaskStageFlashWrite, 0);
CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
page_task.task_cb = &page_task_compare_flash;
update_task_set_progress(update_task, UpdateTaskStageFlashValidate, 0);
CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
}
update_task_set_progress(update_task, UpdateTaskStageCompleted, 100);
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
success = true;
} while(false);
if(!success) {
update_task_set_progress(update_task, UpdateTaskStageError, update_task->state.progress);
}
return success ? UPDATE_TASK_NOERR : UPDATE_TASK_FAILED;
}
static bool update_task_pre_update(UpdateTask* update_task) {
bool success = false;
string_t backup_file_path;
@@ -143,7 +61,8 @@ static bool update_task_post_update(UpdateTask* update_task) {
string_t file_path;
string_init(file_path);
update_task->state.total_stages = 2;
// status text is too long, too few stages to bother with a counter
update_task->state.total_stages = 0;
do {
CHECK_RESULT(update_task_parse_manifest(update_task));
@@ -184,6 +103,7 @@ static bool update_task_post_update(UpdateTask* update_task) {
}
tar_archive_free(archive);
}
success = true;
} while(false);
string_clear(file_path);

363
applications/updater/util/update_task_worker_flasher.c Normal file
View File

@@ -0,0 +1,363 @@
#include "update_task.h"
#include "update_task_i.h"
#include <furi.h>
#include <furi_hal.h>
#include <storage/storage.h>
#include <toolbox/path.h>
#include <update_util/dfu_file.h>
#include <update_util/lfs_backup.h>
#include <update_util/update_operation.h>
#include <toolbox/tar/tar_archive.h>
#include <toolbox/crc32_calc.h>
#define TAG "UpdWorkerRAM"
#define CHECK_RESULT(x) \
if(!(x)) { \
break; \
}
#define STM_DFU_VENDOR_ID 0x0483
#define STM_DFU_PRODUCT_ID 0xDF11
/* Written into DFU file by build pipeline */
#define FLIPPER_ZERO_DFU_DEVICE_CODE 0xFFFF
/* Time, in ms, to wait for system restart by C2 before crashing */
#define C2_MODE_SWITCH_TIMEOUT 10000
static const DfuValidationParams flipper_dfu_params = {
.device = FLIPPER_ZERO_DFU_DEVICE_CODE,
.product = STM_DFU_PRODUCT_ID,
.vendor = STM_DFU_VENDOR_ID,
};
static void update_task_file_progress(const uint8_t progress, void* context) {
UpdateTask* update_task = context;
update_task_set_progress(update_task, UpdateTaskStageProgress, progress);
}
static bool page_task_compare_flash(
const uint8_t i_page,
const uint8_t* update_block,
uint16_t update_block_len) {
const size_t page_addr = furi_hal_flash_get_base() + furi_hal_flash_get_page_size() * i_page;
return (memcmp(update_block, (void*)page_addr, update_block_len) == 0);
}
/* Verifies a flash operation address for fitting into writable memory
*/
static bool check_address_boundaries(const size_t address) {
const size_t min_allowed_address = furi_hal_flash_get_base();
const size_t max_allowed_address = (size_t)furi_hal_flash_get_free_end_address();
return ((address >= min_allowed_address) && (address < max_allowed_address));
}
static bool update_task_write_dfu(UpdateTask* update_task) {
DfuUpdateTask page_task = {
.address_cb = &check_address_boundaries,
.progress_cb = &update_task_file_progress,
.task_cb = &furi_hal_flash_program_page,
.context = update_task,
};
bool success = false;
do {
update_task_set_progress(update_task, UpdateTaskStageValidateDFUImage, 0);
CHECK_RESULT(
update_task_open_file(update_task, update_task->manifest->firmware_dfu_image));
CHECK_RESULT(
dfu_file_validate_crc(update_task->file, &update_task_file_progress, update_task));
const uint8_t valid_targets =
dfu_file_validate_headers(update_task->file, &flipper_dfu_params);
if(valid_targets == 0) {
break;
}
update_task_set_progress(update_task, UpdateTaskStageFlashWrite, 0);
CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
page_task.task_cb = &page_task_compare_flash;
update_task_set_progress(update_task, UpdateTaskStageFlashValidate, 0);
CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
success = true;
} while(false);
return success;
}
static bool update_task_write_stack_data(UpdateTask* update_task) {
furi_check(storage_file_is_open(update_task->file));
const size_t FLASH_PAGE_SIZE = furi_hal_flash_get_page_size();
uint32_t stack_size = storage_file_size(update_task->file);
storage_file_seek(update_task->file, 0, true);
if(!check_address_boundaries(update_task->manifest->radio_address) ||
!check_address_boundaries(update_task->manifest->radio_address + stack_size)) {
return false;
}
update_task_set_progress(update_task, UpdateTaskStageRadioWrite, 0);
uint8_t* fw_block = malloc(FLASH_PAGE_SIZE);
uint16_t bytes_read = 0;
uint32_t element_offs = 0;
while(element_offs < stack_size) {
uint32_t n_bytes_to_read = FLASH_PAGE_SIZE;
if((element_offs + n_bytes_to_read) > stack_size) {
n_bytes_to_read = stack_size - element_offs;
}
bytes_read = storage_file_read(update_task->file, fw_block, n_bytes_to_read);
if(bytes_read == 0) {
break;
}
int16_t i_page =
furi_hal_flash_get_page_number(update_task->manifest->radio_address + element_offs);
if(i_page < 0) {
break;
}
if(!furi_hal_flash_program_page(i_page, fw_block, bytes_read)) {
break;
}
element_offs += bytes_read;
update_task_set_progress(
update_task, UpdateTaskStageProgress, element_offs * 100 / stack_size);
}
free(fw_block);
return element_offs == stack_size;
}
static void update_task_wait_for_restart(UpdateTask* update_task) {
update_task_set_progress(update_task, UpdateTaskStageRadioBusy, 10);
osDelay(C2_MODE_SWITCH_TIMEOUT);
furi_crash("C2 timeout");
}
static bool update_task_write_stack(UpdateTask* update_task) {
bool success = false;
do {
FURI_LOG_W(TAG, "Writing stack");
update_task_set_progress(update_task, UpdateTaskStageRadioImageValidate, 0);
CHECK_RESULT(update_task_open_file(update_task, update_task->manifest->radio_image));
CHECK_RESULT(
crc32_calc_file(update_task->file, &update_task_file_progress, update_task) ==
update_task->manifest->radio_crc);
CHECK_RESULT(update_task_write_stack_data(update_task));
update_task_set_progress(update_task, UpdateTaskStageRadioInstall, 0);
CHECK_RESULT(
ble_glue_fus_stack_install(update_task->manifest->radio_address, 0) !=
BleGlueCommandResultError);
update_task_set_progress(update_task, UpdateTaskStageRadioInstall, 80);
CHECK_RESULT(ble_glue_fus_wait_operation() == BleGlueCommandResultOK);
update_task_set_progress(update_task, UpdateTaskStageRadioInstall, 100);
/* ...system will restart here. */
update_task_wait_for_restart(update_task);
success = true;
} while(false);
return success;
}
static bool update_task_remove_stack(UpdateTask* update_task) {
bool success = false;
do {
FURI_LOG_W(TAG, "Removing stack");
update_task_set_progress(update_task, UpdateTaskStageRadioErase, 30);
CHECK_RESULT(ble_glue_fus_stack_delete() != BleGlueCommandResultError);
update_task_set_progress(update_task, UpdateTaskStageRadioErase, 80);
CHECK_RESULT(ble_glue_fus_wait_operation() == BleGlueCommandResultOK);
update_task_set_progress(update_task, UpdateTaskStageRadioErase, 100);
/* ...system will restart here. */
update_task_wait_for_restart(update_task);
success = true;
} while(false);
return success;
}
static bool update_task_manage_radiostack(UpdateTask* update_task) {
bool success = false;
do {
CHECK_RESULT(ble_glue_wait_for_c2_start(FURI_HAL_BT_C2_START_TIMEOUT));
const BleGlueC2Info* c2_state = ble_glue_get_c2_info();
const UpdateManifestRadioVersion* radio_ver = &update_task->manifest->radio_version;
bool stack_version_match = (c2_state->VersionMajor == radio_ver->version.major) &&
(c2_state->VersionMinor == radio_ver->version.minor) &&
(c2_state->VersionSub == radio_ver->version.sub) &&
(c2_state->VersionBranch == radio_ver->version.branch) &&
(c2_state->VersionReleaseType == radio_ver->version.release);
bool stack_missing = (c2_state->VersionMajor == 0) && (c2_state->VersionMinor == 0);
if(c2_state->mode == BleGlueC2ModeStack) {
/* Stack type is not available when we have FUS running. */
bool total_stack_match = stack_version_match &&
(c2_state->StackType == radio_ver->version.type);
if(total_stack_match) {
/* Nothing to do. */
FURI_LOG_W(TAG, "Stack version is up2date");
furi_hal_rtc_reset_flag(FuriHalRtcFlagC2Update);
success = true;
break;
} else {
/* Version or type mismatch. Let's boot to FUS and start updating. */
FURI_LOG_W(TAG, "Restarting to FUS");
furi_hal_rtc_set_flag(FuriHalRtcFlagC2Update);
CHECK_RESULT(furi_hal_bt_ensure_c2_mode(BleGlueC2ModeFUS));
/* ...system will restart here. */
update_task_wait_for_restart(update_task);
}
} else if(c2_state->mode == BleGlueC2ModeFUS) {
/* OK, we're in FUS mode. */
update_task_set_progress(update_task, UpdateTaskStageRadioBusy, 10);
FURI_LOG_W(TAG, "Waiting for FUS to settle");
ble_glue_fus_wait_operation();
if(stack_version_match) {
/* We can't check StackType with FUS, but partial version matches */
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagC2Update)) {
/* This flag was set when full version was checked.
* And something in versions of the stack didn't match.
* So, clear the flag and drop the stack. */
furi_hal_rtc_reset_flag(FuriHalRtcFlagC2Update);
FURI_LOG_W(TAG, "Forcing stack removal (match)");
CHECK_RESULT(update_task_remove_stack(update_task));
} else {
/* We might just had the stack installed.
* Let's start it up to check its version */
FURI_LOG_W(TAG, "Starting stack to check full version");
update_task_set_progress(update_task, UpdateTaskStageRadioBusy, 40);
CHECK_RESULT(furi_hal_bt_ensure_c2_mode(BleGlueC2ModeStack));
/* ...system will restart here. */
update_task_wait_for_restart(update_task);
}
} else {
if(stack_missing) {
/* Install stack. */
CHECK_RESULT(update_task_write_stack(update_task));
} else {
CHECK_RESULT(update_task_remove_stack(update_task));
}
}
}
} while(false);
return success;
}
bool update_task_validate_optionbytes(UpdateTask* update_task) {
update_task_set_progress(update_task, UpdateTaskStageOBValidation, 0);
bool match = true;
bool ob_dirty = false;
const UpdateManifest* manifest = update_task->manifest;
const FuriHalFlashRawOptionByteData* device_data = furi_hal_flash_ob_get_raw_ptr();
for(size_t idx = 0; idx < FURI_HAL_FLASH_OB_TOTAL_VALUES; ++idx) {
update_task_set_progress(
update_task, UpdateTaskStageProgress, idx * 100 / FURI_HAL_FLASH_OB_TOTAL_VALUES);
const uint32_t ref_value = manifest->ob_reference.obs[idx].values.base;
const uint32_t device_ob_value = device_data->obs[idx].values.base;
const uint32_t device_ob_value_masked = device_ob_value &
manifest->ob_compare_mask.obs[idx].values.base;
if(ref_value != device_ob_value_masked) {
match = false;
FURI_LOG_E(
TAG,
"OB MISMATCH: #%d: real %08X != %08X (exp.), full %08X",
idx,
device_ob_value_masked,
ref_value,
device_ob_value);
/* any bits we are allowed to write?.. */
bool can_patch = ((device_ob_value_masked ^ ref_value) &
manifest->ob_write_mask.obs[idx].values.base) != 0;
if(can_patch) {
/* patch & restart loop */
const uint32_t patched_value =
/* take all non-writable bits from real value */
(device_ob_value & ~(manifest->ob_write_mask.obs[idx].values.base)) |
/* take all writable bits from reference value */
(manifest->ob_reference.obs[idx].values.base &
manifest->ob_write_mask.obs[idx].values.base);
FURI_LOG_W(TAG, "Fixing up OB byte #%d to %08X", idx, patched_value);
ob_dirty = true;
bool is_fixed = furi_hal_flash_ob_set_word(idx, patched_value) &&
((device_data->obs[idx].values.base &
manifest->ob_compare_mask.obs[idx].values.base) == ref_value);
if(!is_fixed) {
/* Things are so bad that fixing what we are allowed to still doesn't match
* reference value
*/
FURI_LOG_W(
TAG,
"OB #%d is FUBAR (fixed&masked %08X, not %08X)",
idx,
patched_value,
ref_value);
}
}
} else {
FURI_LOG_I(
TAG,
"OB MATCH: #%d: real %08X == %08X (exp.)",
idx,
device_ob_value_masked,
ref_value);
}
}
if(!match) {
update_task_set_progress(update_task, UpdateTaskStageOBError, 95);
}
if(ob_dirty) {
FURI_LOG_W(TAG, "OB were changed, applying");
furi_hal_flash_ob_apply();
}
return match;
}
int32_t update_task_worker_flash_writer(void* context) {
furi_assert(context);
UpdateTask* update_task = context;
bool success = false;
update_task->state.current_stage_idx = 0;
update_task->state.total_stages = 0;
do {
CHECK_RESULT(update_task_parse_manifest(update_task));
if(!string_empty_p(update_task->manifest->radio_image)) {
CHECK_RESULT(update_task_manage_radiostack(update_task));
}
bool check_ob = update_manifest_has_obdata(update_task->manifest);
if(check_ob) {
update_task->state.total_stages++;
CHECK_RESULT(update_task_validate_optionbytes(update_task));
}
if(!string_empty_p(update_task->manifest->firmware_dfu_image)) {
update_task->state.total_stages += 4;
CHECK_RESULT(update_task_write_dfu(update_task));
}
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
update_task_set_progress(update_task, UpdateTaskStageCompleted, 100);
success = true;
} while(false);
return success ? UPDATE_TASK_NOERR : UPDATE_TASK_FAILED;
}