programmer-core 1.0.29__py3-none-any.whl

programmer_core/program_device.py

@@ -0,0 +1,775 @@
+import os
+from os.path import basename, isfile
+import json
+import pathlib
+import logging
+import time
+
+from communicator_core import (
+    BinaryDownloader,
+    DeviceLifeCycleNum,
+    DSSMStatus,
+    CC35XX,
+    CC35XXE,
+    CC37XXR,
+)
+from flash_images_builder_core import (
+    FlashImage,
+    ProgInstImgBuilder,
+    BootSectorFromImgBuilder,
+    ActionReqBuilder,
+    FIBUtility,
+    GPE_MANIFEST_INTEGRITY_SIZE
+)
+
+try:
+    from report import (
+        ProgrammingReportGeneratorCC35XXE,
+        ProgrammingReportGeneratorCC35XX,
+    )
+    from constants import FLASH_STATUS, FLASH_IMAGE_HEADER, WAIT_FOR_ERASE
+    from utility import (
+        ProgrammerUtility,
+        get_lifecycle_state_reg_class,
+    )
+except ImportError:
+    from .report import (
+        ProgrammingReportGeneratorCC35XXE,
+        ProgrammingReportGeneratorCC35XX,
+    )
+    from .constants import FLASH_STATUS, FLASH_IMAGE_HEADER, WAIT_FOR_ERASE
+    from .utility import (
+        ProgrammerUtility,
+        get_lifecycle_state_reg_class,
+    )
+
+# uncomment for debug communicator code without build package communicator_core for every change
+# if 'communicator' in sys.modules.keys():
+#     from communicator.communicator_core.core.cc35xx_config_ap import DeviceLifeCycleNum, DSSMStatus, LifeCycleStateReg
+#     from communicator.communicator_core.core.binary_downloader import BinaryDownloader
+
+
+PROGRAMMER_PROGRAM_LOGGER = logging.getLogger("program")
+
+
+# note: 0x4110295c - hw life cycle address
+class ProgramDevice:
+    SIMULATION = "DEMO"
+
+    FLASH_IMAGE_TYPE_CC35XX = {
+        "boot_sector": "boot_sector_logical",
+        "primary_tbl": "ti_bl_slot1_logical",
+        "secondary_tbl": "ti_bl_slot2_logical",
+        "primary_vendor_sbl": "vendor_sbl_slot1_logical",
+        "secondary_vendor_sbl": "vendor_sbl_slot2_logical",
+        "primary_vendor_image": "vendor_img_slot1_logical",
+        "secondary_vendor_image": "vendor_img_slot2_logical",
+        "primary_ti_wsoc": "ti_wsoc_img_slot1_logical",
+        "secondary_ti_wsoc": "ti_wsoc_img_slot2_logical",
+    }
+    FLASH_IMAGE_TYPE_CC35XXE = {
+        "boot_sector": "boot_sector_logical",
+        "primary_tbl": "ti_bl_slot1_logical",
+        "secondary_tbl": "ti_bl_slot2_logical",
+        "primary_vendor_sbl": "vendor_sbl_slot1_logical",
+        "secondary_vendor_sbl": "vendor_sbl_slot2_logical",
+        "primary_vendor_image": "vendor_img_slot1_logical",
+        "secondary_vendor_image": "vendor_img_slot2_logical",
+        "primary_ti_wsoc": "ti_wsoc_img_slot1_logical",
+        "secondary_ti_wsoc": "ti_wsoc_img_slot2_logical",
+        "primary_ti_wsoc_bl2": "ti_wsoc_bl2_img_slot1_logical",
+        "secondary_ti_wsoc_bl2": "ti_wsoc_bl2_img_slot2_logical",
+        "protected_storage": "nvs_slot_logical",
+    }
+    # Dictionary to map device types to their corresponding flash image types
+    # TODO: temporary - using CC35XXE FLASH_IMAGE_TYPES until CC37XXR FLASH_IMAGE_TYPES are available
+    FLASH_IMAGE_TYPES = {
+        CC35XXE: FLASH_IMAGE_TYPE_CC35XXE,
+        CC35XX: FLASH_IMAGE_TYPE_CC35XX,
+        CC37XXR: FLASH_IMAGE_TYPE_CC35XXE,
+    }
+    SMART_ERASE_FILE_SIZE_THOLD = 750e3
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        tool_settings,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        device_type,
+        report_file_path=None,
+        reset_on_timeout=True,
+        wait_timeout=40,
+        wait_for_erase=None,
+        write_timeout=0,
+        tclk_delay=4,
+        chunk_size=1085,
+        verbose=False,
+        update_progress=None,
+        push_message=None,
+        jlink_speed_khz=None,
+    ):
+        self.tool_settings = tool_settings
+        self.prog_inst_image_path = None
+        self.programming_action_req_path = None
+        self.flash_images_list = []
+        self.path_to_ti_programmer = None
+        self.prog_utility = ProgrammerUtility(
+            programmer_artifacts_path, fib_artifacts_path
+        )
+        self.fib_utility = FIBUtility(
+            fib_artifacts_path=fib_artifacts_path
+        )
+
+        self.report_file_path = (
+            report_file_path
+            if report_file_path
+            else (pathlib.Path(self.tool_settings).parent / "programming_report.txt")
+        )
+        self.reset_on_timeout = reset_on_timeout
+
+        self.interface_type = interface_type
+        self.serial_number = serial_number
+        self.wait_timeout = wait_timeout
+        self.write_timeout = write_timeout
+        self.erase_wait_timeout = (
+            WAIT_FOR_ERASE if wait_for_erase is None else wait_for_erase
+        )
+        self.vendor_ask_for_update_fuse = False
+        self.full_flash_erase = False
+
+        # just for download flash images - Step 5
+        self.tclk_delay = tclk_delay
+        self.chunk_size = chunk_size
+        self.jlink_speed_khz = jlink_speed_khz
+
+        self.verbose = verbose
+        self.log_level = logging.INFO if verbose else logging.DEBUG
+
+        self.error_message = ""
+        self.rollback_mismatches = []
+        self.device_type = device_type
+
+        # Initialize the appropriate LifeCycleStateReg class based on device type
+        self._lifecycle_reg_class = get_lifecycle_state_reg_class(self.device_type)
+
+        # TODO: temporary - CC37XXR uses CC35XXE report generator until CC37XXR specific generators are available
+        if self.device_type in [CC35XXE, CC37XXR]:
+            self.report_generator = ProgrammingReportGeneratorCC35XXE(
+                programmer_artifacts_path=programmer_artifacts_path,
+                fib_artifacts_path=fib_artifacts_path,
+                report_file_path=self.report_file_path,
+                verbose=self.verbose,
+            )
+        else:
+            self.report_generator = ProgrammingReportGeneratorCC35XX(
+                programmer_artifacts_path=programmer_artifacts_path,
+                fib_artifacts_path=fib_artifacts_path,
+                report_file_path=self.report_file_path,
+                verbose=self.verbose,
+            )
+
+        self.path_to_ti_bootloader = self.prog_utility.get_default_tbl_img(
+            self.device_type
+        )
+
+        self.path_to_ti_programmer = self.prog_utility.get_default_prog(
+            self.device_type
+        )
+
+        # For Uniflash Support
+        self.update_progress = update_progress
+        self.push_message = push_message
+
+    def _create_boot_sector(self):
+        abs_dir_out_path = pathlib.Path(self.tool_settings).parent
+        # TODO: get the version from prog_inst_image
+        boot_sector_builder = BootSectorFromImgBuilder(
+            image_file_path=self.prog_inst_image_path,
+            abs_dir_out_path=abs_dir_out_path,
+            version="0.0.1.0",
+            device=self.device_type,
+            verbose=self.verbose,
+        )
+        boot_sector_builder.build()
+
+        return boot_sector_builder.boot_sector_image_out_path
+
+    def _get_selected_images(self, prog_action_req_path):
+
+        with open(prog_action_req_path, "rb") as f:
+            action_req_content_row = f.read()
+
+        action_req_builder = ActionReqBuilder(
+            header_version=None,
+            type=ActionReqBuilder.PROGRAMMING,
+            device_type=self.device_type,
+            payload_param=None,
+        )
+
+        action_req_parsed = action_req_builder.parse(action_req_content_row)
+
+        # TODO: check if this field exist or catch an error if false
+        selected_images = action_req_parsed["payload"]["action_payload"][
+            "prog_req_content"
+        ]
+
+        return selected_images
+
+    def _get_flash_images(self, json_cont):
+        flash_images_list = []
+        vendor_images = []  # Store vendor_images to append after all non-vendor images
+        vendor_bl3_images = []  # Store vendor_bl3 images to append after vendor_images
+        # TODO: for future get_flash_map_entity is part of boot_sector_generation
+        prog_inst_flash_map = ProgInstImgBuilder.get_flash_map_entity(
+            self.prog_inst_image_path, self.device_type
+        )
+
+        selected_images = self._get_selected_images(self.programming_action_req_path)
+        for image_type in selected_images:
+            # check if user want to download the image
+            # TODO: change bitinteger(1) to Flag in FIB in order to get true/false as a return value
+            if selected_images[image_type] == 1:
+                # Check if the image can be a flash image
+                if (
+                    self.device_type in self.FLASH_IMAGE_TYPES
+                    and image_type
+                    not in self.FLASH_IMAGE_TYPES[self.device_type].keys()
+                ):
+                    # Check if the user asks for fuse update
+                    if image_type == "fuse_programming_instruction_update":
+                        self.vendor_ask_for_update_fuse = True
+                    elif image_type == "flash_factory_reset":
+                        self.full_flash_erase = True
+                    continue
+
+                if image_type == "boot_sector":
+                    # check if the user didnt gave path
+                    if json_cont[image_type] is None or json_cont[image_type] == "":
+                        # create boot sector
+                        image_path = self.prog_utility.build_boot_sector(
+                            programming_sign_image_path=self.prog_inst_image_path,
+                            dir_out_path=pathlib.Path(self.prog_inst_image_path).parent,
+                            device_type=self.device_type,
+                        )
+                    else:
+                        image_path = json_cont[image_type]
+
+                elif image_type == "primary_tbl":
+                    # creating primary_tbl if he is in action req and not in tool_settings.json
+                    if json_cont[image_type] is None or json_cont[image_type] == "":
+                        image_path = self.prog_utility.build_tbl_image(
+                            ti_sign_container=self.path_to_ti_bootloader,
+                            dir_out_path=pathlib.Path(self.prog_inst_image_path).parent,
+                            device=self.device_type,
+                        )
+                    else:
+                        image_path = json_cont[image_type]
+                else:
+                    image_path = json_cont[image_type]
+
+                if image_path in [None, ""]:
+                    self.error_message = f'Path to "{image_type}" is invalid or not provided in tool_settings.json'
+                    PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+                    return []
+
+                image_path = self.prog_utility.fix_path(image_path)
+                # check image path validation
+                res = self.prog_utility.file_path_exist(image_path, image_type)
+                if res is not None:
+                    self.error_message = res
+                    PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+                    return []
+
+                # get flash_map_img_index by the location in FLASH_IMAGE_TYPE
+                image_address = hex(
+                    prog_inst_flash_map[
+                        self.FLASH_IMAGE_TYPES[self.device_type][image_type]
+                    ]
+                )
+
+                # minus 16 bytes if the device is cc35xxe
+                if (self.device_type in [CC35XXE, CC37XXR]) and image_type not in [
+                    "boot_sector",
+                    "protected_storage",
+                ]:
+                    image_address = hex(
+                        int(image_address, 16) - GPE_MANIFEST_INTEGRITY_SIZE
+                    )
+
+                # wrap flash image file with address-len-paddinglen with FIB function
+                flash_img_builder = FlashImage(
+                    image_path=image_path, address=image_address, verbose=self.verbose
+                )
+                flash_img_builder.build()
+
+                # save flash_image
+                flash_image_name = (
+                    basename(image_path).split(".")[0] + ".flashready.bin"
+                )
+                flash_image_path = pathlib.Path(image_path).parent / flash_image_name
+                with open(flash_image_path, "wb") as f:
+                    f.write(flash_img_builder.flash_image_content_raw)
+                PROGRAMMER_PROGRAM_LOGGER.log(
+                    self.log_level, f"Saved flash image bin file at {flash_image_path}"
+                )
+
+                # add image to list
+                if image_type == "boot_sector":
+                    flash_images_list.insert(0, flash_image_path)
+                elif image_type in ("primary_vendor_image", "secondary_vendor_image"):
+                    vendor_images.append(flash_image_path)
+                elif image_type in ("primary_vendor_sbl", "secondary_vendor_sbl"):
+                    vendor_bl3_images.append(flash_image_path)
+                else:
+                    flash_images_list.append(flash_image_path)
+
+        # Append vendor_images, then vendor_bl3 images at the end
+        flash_images_list.extend(vendor_images)
+        flash_images_list.extend(vendor_bl3_images)
+
+        return flash_images_list
+
+    def _delete_flash_images(self):
+        for flash_image in self.flash_images_list:
+            if os.path.exists(flash_image):
+                os.remove(flash_image)
+
+    # For Uniflash Support
+    def _uniflash_update_progress(self, message, progress, error=False):
+        if self.update_progress and self.push_message:
+            self.update_progress(message, progress)
+            self.push_message(message, 0 if not error else 2)
+
+    def program(self):
+
+        # pull out images path from json
+        with open(self.prog_utility.fix_path(self.tool_settings), "r") as f:
+            tool_settings_cont = json.load(f)
+
+        programming_components = tool_settings_cont[
+            "programming_debug_and_ota_signed_components"
+        ]
+
+        # define programming tbl path
+        if programming_components["tbl_container_programming"] is not None:
+            self.path_to_ti_programmer = programming_components[
+                "tbl_container_programming"
+            ]
+
+        self.path_to_ti_programmer = self.prog_utility.fix_path(
+            self.path_to_ti_programmer
+        )
+        res = self.prog_utility.file_path_exist(
+            self.path_to_ti_programmer, "tbl_container_programming"
+        )
+        if res is not None:
+            self.error_message = res
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+            return False
+
+        # check if required path exist
+        if programming_components["programming_instructions"] in [None, ""]:
+            self.error_message = (
+                'Path to "programming_instructions" is required in tool_settings.json'
+            )
+            PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+            return False
+
+        self.prog_inst_image_path = self.prog_utility.fix_path(
+            programming_components["programming_instructions"]
+        )
+        res = self.prog_utility.file_path_exist(
+            self.prog_inst_image_path, "programming_instructions"
+        )
+        if res is not None:
+            self.error_message = res
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+            return False
+
+        if programming_components["actions_req_paths"]["programming"] in [None, ""]:
+            self.error_message = 'Path to "programming" in "actions_req_paths" is required in tool_settings.json'
+            PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+            return False
+
+        self.programming_action_req_path = self.prog_utility.fix_path(
+            programming_components["actions_req_paths"]["programming"]
+        )
+        res = self.prog_utility.file_path_exist(
+            self.programming_action_req_path, "programming_actions_req"
+        )
+        if res is not None:
+            self.error_message = res
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+            return False
+
+        self.flash_images_list = self._get_flash_images(programming_components)
+
+        # check if at least one request inside action req is on
+        # if (
+        #     self.flash_images_list == []
+        #     and not self.vendor_ask_for_update_fuse
+        #     and not self.full_flash_erase
+        # ):
+        #     if self.error_message == "":
+        #         self.error_message = "Action Request does not contain any programming request content. Please fix it and try again."
+        #         self._uniflash_update_progress(self.error_message, 0, True)
+        #         PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+        #     return False
+
+        #################################################
+        ##                     Step 1                  ##
+        ##   Reset device and download TI Programmer   ##
+        #################################################
+        self._uniflash_update_progress("Reset device and download TI Programmer", 20)
+
+        ti_programmer_download = BinaryDownloader(
+            bin_file=self.path_to_ti_programmer,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            wait_timeout=self.wait_timeout,
+            write_timeout=self.write_timeout,
+            verbose=self.verbose,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            jlink_speed_khz=self.jlink_speed_khz,
+        )
+
+        # reset device
+        ti_programmer_download.device.reset_device()
+
+        # Download TI bootloader
+        ti_programmer_download.daemon = True
+        ti_programmer_download.start()
+
+        while ti_programmer_download.is_alive():
+            ti_programmer_download.join(0.1)
+
+        error_code, error_msg = ti_programmer_download.download_status
+
+        if error_code > 0:
+            PROGRAMMER_PROGRAM_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            self.error_message = f"Failed loading 'TI Programmer' image"
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(
+                f"Failed loading binary with error code: {error_code}\nError message: {error_msg}"
+            )
+            return False
+
+        #################################################
+        ##                     Step 2                  ##
+        ## Read CFGAP and check life-cycle/dssm status ##
+        #################################################
+        self._uniflash_update_progress(
+            "Read CFGAP and check life-cycle/dssm status", 25
+        )
+
+        if self.interface_type != self.SIMULATION:
+            # Read cfgap - use device-specific register class
+            life_cycle_state_reg = self._lifecycle_reg_class(
+                interface=self.interface_type,
+                serial_number=self.serial_number,
+                verbose=self.verbose,
+            )
+            life_cycle_state_reg.read_reg()
+            life_cycle = life_cycle_state_reg.life_cycle_sw_coded
+            dssm_status = life_cycle_state_reg.dssm_status
+            life_cycle_state_reg.disconnect()
+
+            # Check if life cycle is one of allowed_life_cycle
+            allowed_life_cycle = [
+                DeviceLifeCycleNum.DEPLOYED,
+                DeviceLifeCycleNum.RMA_HW_ANALYSIS,
+                DeviceLifeCycleNum.RMA_FAILIURE_ANALYSIS,
+            ]
+            if life_cycle not in allowed_life_cycle:
+                self.error_message = "Life cycle is not valid"
+                self._uniflash_update_progress(self.error_message, 0, True)
+                PROGRAMMER_PROGRAM_LOGGER.error(
+                    f"Process is stopped. Life cycle {DeviceLifeCycleNum(life_cycle).name} is not valid."
+                )
+                return False
+
+            # Check if dssm status is DSSM_READY
+            if not dssm_status == DSSMStatus.DSSM_READY:
+                self.error_message = f"Device is not ready for programming"
+                self._uniflash_update_progress(self.error_message, 0, True)
+                PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+                return False
+
+        #################################################
+        ##                     Step 3                  ##
+        ##      Download programming action request    ##
+        #################################################
+        self._uniflash_update_progress("Download programming action request", 30)
+
+        programming_req_download = BinaryDownloader(
+            bin_file=self.programming_action_req_path,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            wait_timeout=self.wait_timeout,
+            write_timeout=self.write_timeout,
+            verbose=self.verbose,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            jlink_speed_khz=self.jlink_speed_khz,
+        )
+
+        programming_req_download.daemon = True
+        programming_req_download.start()
+
+        while programming_req_download.is_alive():
+            programming_req_download.join(0.1)
+
+        error_code, error_msg = programming_req_download.download_status
+
+        if error_code > 0:
+            PROGRAMMER_PROGRAM_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            self.error_message = f"Failed loading 'Programming Action Request'"
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(
+                f"Failed loading binary with error code: {error_code}\nError message: {error_msg}"
+            )
+            return False
+
+        #################################################
+        ##                     Step 4                  ##
+        ##   Download programming instructions image   ##
+        #################################################
+        self._uniflash_update_progress("Download programming instructions image", 35)
+
+        wait_for_resp = True if len(self.flash_images_list) == 0 else False
+
+        prog_inst_downloader = BinaryDownloader(
+            bin_file=self.prog_inst_image_path,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            wait_timeout=self.wait_timeout,
+            write_timeout=self.write_timeout,
+            wait_for_resp=wait_for_resp,
+            verbose=self.verbose,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            expected_resp_size=self.report_generator.get_report_struct_size(),
+            jlink_speed_khz=self.jlink_speed_khz,
+        )
+        prog_inst_downloader.daemon = True
+        prog_inst_downloader.start()
+
+        while prog_inst_downloader.is_alive():
+            prog_inst_downloader.join(0.1)
+
+        error_code, error_msg = prog_inst_downloader.download_status
+
+        if error_code > 0:
+            PROGRAMMER_PROGRAM_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            self.error_message = "Failed loading 'Programming Instruction' image"
+            self._uniflash_update_progress(self.error_message, 0, True)
+            PROGRAMMER_PROGRAM_LOGGER.error(
+                f"Failed loading binary with error code: {error_code}\nError message: {error_msg}"
+            )
+            return False
+
+        #################################################
+        ##                     Step 5                  ##
+        ##            Download flash images            ##
+        #################################################
+        total_flash_images = len(self.flash_images_list)
+        start_percent = 35  # already shown before the loop
+        end_percent = 90  # where we want to finish
+
+        for idx, flash_image in enumerate(self.flash_images_list):
+            cur_percent = int(
+                start_percent
+                + (idx + 1) / total_flash_images * (end_percent - start_percent)
+            )
+            self._uniflash_update_progress(
+                f"Downloading {basename(flash_image)} ...", cur_percent
+            )
+
+        for flash_image in self.flash_images_list:
+            # if image is last element --> wait_for_resp depend on the user input
+            wait_for_resp = flash_image == self.flash_images_list[-1]
+
+            # split file image to 2 files - one with the header and other with the rest of the image. then create 2 binarydownloader
+            file_name = flash_image.stem
+            file_name_header = "header_" + file_name + ".bin"
+            file_name_content = "content_" + file_name + ".bin"
+            image_header_path = flash_image.parent / file_name_header
+            image_content_path = flash_image.parent / file_name_content
+
+            with open(flash_image, "rb") as f:
+                header_data = f.read(FLASH_IMAGE_HEADER)
+                content_data = f.read()
+
+            with open(image_header_path, "wb") as f:
+                f.write(header_data)
+
+            with open(image_content_path, "wb") as f:
+                f.write(content_data)
+
+            flash_image_header_download = BinaryDownloader(
+                bin_file=image_header_path,
+                interface_type=self.interface_type,
+                serial_number=self.serial_number,
+                wait_timeout=self.wait_timeout,
+                write_timeout=self.write_timeout,
+                verbose=self.verbose,
+                # tclk_delay=self.tclk_delay,
+                # chunk_size=self.chunk_size,
+            )
+
+            flash_image_content_download = BinaryDownloader(
+                bin_file=image_content_path,
+                interface_type=self.interface_type,
+                serial_number=self.serial_number,
+                wait_timeout=self.wait_timeout,
+                write_timeout=self.write_timeout,
+                wait_for_resp=wait_for_resp,
+                verbose=self.verbose,
+                tclk_delay=self.tclk_delay,
+                chunk_size=self.chunk_size,
+                expected_resp_size=self.report_generator.get_report_struct_size(),
+                jlink_speed_khz=self.jlink_speed_khz,
+            )
+
+            # check flash status
+            if self.interface_type != self.SIMULATION:
+                # Read cfgap - use device-specific register class
+                life_cycle_state_reg = self._lifecycle_reg_class(
+                    interface=self.interface_type,
+                    serial_number=self.serial_number,
+                    verbose=False,
+                )
+                life_cycle_state_reg.read_reg()
+                flash_status = life_cycle_state_reg.flash_status
+                # print(f"header: flash_status first read: {flash_status}",  flush=True)
+
+                timeout_time = time.perf_counter() + self.erase_wait_timeout
+                timeout_occur = time.perf_counter() > timeout_time
+                # Wait until flash_status == 0 or flash_status == 3 or if timeout occur
+                # print("header: flash_status read in loop: ", end=" ", flush=True)
+                while (
+                    flash_status != FLASH_STATUS.ready_for_header.value
+                    and not timeout_occur
+                ):
+                    time.sleep(0.1)
+                    life_cycle_state_reg.read_reg()
+                    flash_status = life_cycle_state_reg.flash_status
+                    timeout_occur = time.perf_counter() > timeout_time
+                    # print(f"{flash_status}", end=" ", flush=True)
+                life_cycle_state_reg.disconnect()
+                if timeout_occur:
+                    self.error_message = "Timeout occur while waiting for acknowledge from device before download image header"
+                    self._uniflash_update_progress(self.error_message, 0, True)
+                    PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+                    return False
+
+            # send image header
+            flash_image_header_download.daemon = True
+            flash_image_header_download.start()
+
+            while flash_image_header_download.is_alive():
+                flash_image_header_download.join(0.1)
+
+            error_code, error_msg = flash_image_header_download.download_status
+
+            if error_code > 0:
+                PROGRAMMER_PROGRAM_LOGGER.log(
+                    self.log_level, "Successfully loaded binary"
+                )
+            else:
+                self.error_message = "Failed loading image flash header"
+                self._uniflash_update_progress(self.error_message, 0, True)
+                PROGRAMMER_PROGRAM_LOGGER.error(
+                    f"Failed loading binary with error code: {error_code}\nError message: {error_msg}"
+                )
+                return False
+
+            # check flash status
+            if self.interface_type != self.SIMULATION:
+                # Added by Danil 9/11 for give programmer chance to update flash_status after download header
+                time.sleep(1)
+
+                # Read cfgap - use device-specific register class
+                life_cycle_state_reg = self._lifecycle_reg_class(
+                    interface=self.interface_type,
+                    serial_number=self.serial_number,
+                    verbose=False,
+                )
+                life_cycle_state_reg.read_reg()
+                flash_status = life_cycle_state_reg.flash_status
+                # print(f"content: flash_status first read: {flash_status}",  flush=True)
+
+                timeout_time = time.perf_counter() + self.erase_wait_timeout
+                timeout_occur = time.perf_counter() > timeout_time
+                # Wait until flash_status == 2 or flash_status == 3 or if timeout occur
+                # print("content: flash_status read in loop: ", end=" ", flush=True)
+                while (
+                    flash_status != FLASH_STATUS.ready_for_content.value
+                    and not timeout_occur
+                ):
+                    time.sleep(0.1)
+                    life_cycle_state_reg.read_reg()
+                    flash_status = life_cycle_state_reg.flash_status
+                    timeout_occur = time.perf_counter() > timeout_time
+                    # print(f"{flash_status}", end=" ", flush=True)
+
+                life_cycle_state_reg.disconnect()
+                if timeout_occur:
+                    self.error_message = "Timeout occur while waiting for acknowledge from device before download image content"
+                    self._uniflash_update_progress(self.error_message, 0, True)
+                    PROGRAMMER_PROGRAM_LOGGER.error(self.error_message)
+                    return False
+
+            # send image content
+            flash_image_content_download.daemon = True
+            flash_image_content_download.start()
+
+            while flash_image_content_download.is_alive():
+                flash_image_content_download.join(0.1)
+
+            error_code, error_msg = flash_image_content_download.download_status
+
+            if error_code > 0:
+                PROGRAMMER_PROGRAM_LOGGER.log(
+                    self.log_level, "Successfully loaded binary"
+                )
+            else:
+                self.error_message = f"Failed loading image flash content"
+                self._uniflash_update_progress(self.error_message, 0, True)
+                PROGRAMMER_PROGRAM_LOGGER.error(
+                    f"Failed load binary with error code: {error_code}\nError message: {error_msg}"
+                )
+                return False
+
+        #################################################
+        ##                     Step 6                  ##
+        ##    Get response and print to the user       ##
+        #################################################
+        self._uniflash_update_progress(f"Get response", 90)
+        if wait_for_resp:
+            # get response
+            if self.flash_images_list == []:
+                report_content_raw = prog_inst_downloader.resp
+            else:
+                report_content_raw = flash_image_content_download.resp
+
+            # generate report
+            if not self.report_generator.generate_report(report_content_raw):
+                self.error_message = self.report_generator.error_message
+                self._uniflash_update_progress(self.error_message, 0, True)
+                return False
+
+            self.rollback_mismatches = self.fib_utility.check_rollback_mismatches(
+                programming_components,  self.report_generator.report_container.vendor_fuse_report, self.device_type
+            )
+
+        return True