programmer-core 1.0.29__py3-none-any.whl

programmer_core/factory_program_device.py

@@ -0,0 +1,667 @@
+from os import makedirs
+from os.path import join, isdir, isfile
+import logging
+import json
+import pathlib
+
+from flash_images_builder_core import (
+    PsramOption,
+    PSImageBuilder,
+    FIBUtility,
+    ACTIVATION_TYPE,
+    KEY_INFO_MAGIC_DEFAULT,
+    KEY_INFO_VERSION_DEFAULT,
+    KEY_INFO_SVN_DEFAULT,
+    KEY_INFO_SVN_POLICY_DEFAULT,
+    BOOT_SECTOR_SIZE_DEFAULT_KB,
+)
+
+try:
+    from utility import (
+        ProgrammerUtility,
+        AUTHENTICATION_BYPASS_FILES_FOLDER_NAME,
+        TOOL_SETTINGS,
+        ACTION_PARAMS,
+    )
+    from program_device import ProgramDevice
+except ImportError:
+    from .utility import (
+        ProgrammerUtility,
+        AUTHENTICATION_BYPASS_FILES_FOLDER_NAME,
+        TOOL_SETTINGS,
+        ACTION_PARAMS,
+    )
+    from .program_device import ProgramDevice
+
+
+FACTORY_PROGRAM_LOGGER = logging.getLogger("factory-program")
+
+
+class FactoryProgramDevice:
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        flash_type,
+        activation_type,
+        device_type,
+        verbose,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        signing_module=None,
+        full_flash_erase=False,
+        rollback_protection=True,
+        psram_type=PsramOption.NO_PSRAM.name,
+        enable_ota=False,
+        nvs_size=None,
+        key_storage_size=None,
+        vendor_specific_size=None,
+        bl2_size=None,
+        wsoc_size=None,
+        vendor_bl3_size=None,
+        tclk_delay=4,
+        chunk_size=1085,
+        signing_mode="classic_rot",
+        magic=KEY_INFO_MAGIC_DEFAULT,
+        key_info_version=KEY_INFO_VERSION_DEFAULT,
+        svn=KEY_INFO_SVN_DEFAULT,
+        svn_policy=KEY_INFO_SVN_POLICY_DEFAULT,
+        jlink_speed_khz=None,
+    ):
+        self.interface_type = interface_type
+        self.serial_number = serial_number
+
+        self.flash_type = flash_type
+        self.activation_type = activation_type
+        self.signing_module = signing_module
+        self.signing_mode = signing_mode
+        self.magic = magic
+        self.key_info_version = key_info_version
+        self.svn = svn
+        self.svn_policy = svn_policy
+        self.device_type = device_type
+        self.verbose = verbose
+        self.enable_ota = enable_ota
+        self.psram_type = psram_type
+        self.full_flash_erase = full_flash_erase
+        self.rollback_protection = rollback_protection
+
+        self.nvs_size = nvs_size
+        self.key_storage_size = key_storage_size
+        self.vendor_specific_size = vendor_specific_size
+        self.vendor_bl3_size = vendor_bl3_size
+        self.bl2_size = bl2_size
+        self.wsoc_size = wsoc_size
+
+        self.tclk_delay = tclk_delay
+        self.chunk_size = chunk_size
+        self.jlink_speed_khz = jlink_speed_khz
+
+        self.prog_dir = programmer_artifacts_path
+        self.fib_dir = fib_artifacts_path
+        self.prog_utility = ProgrammerUtility(self.prog_dir, self.fib_dir)
+        self.fib_utility = FIBUtility(self.fib_dir)
+        self.jsons_folder = self.prog_utility.get_config_folder()
+        self.logging_level = logging.INFO if verbose else logging.DEBUG
+
+        self.tmp_folder = self.prog_utility.get_programming_tmp_folder()
+
+        self.fuse_json_name = self.prog_utility.get_fuse_json_name(self.device_type)
+
+        self.fuse_conf_json = join(
+            self.jsons_folder,
+            AUTHENTICATION_BYPASS_FILES_FOLDER_NAME,
+            self.fuse_json_name,
+        )
+
+        # Get limits for default values
+        limits = self.fib_utility.get_limits_by_flash_device_name(
+            self.flash_type, self.enable_ota
+        )
+
+        if self.nvs_size is None:
+            self.nvs_size = limits["protected_storage"]["nvsSize"]["default"]
+        if self.key_storage_size is None:
+            self.key_storage_size = limits["protected_storage"]["keyStorageSize"][
+                "default"
+            ]
+        if self.vendor_specific_size is None:
+            self.vendor_specific_size = limits["protected_storage"]["vendorSize"]["default"]
+        if self.bl2_size is None:
+            self.bl2_size = limits["ti_components"]["bl2_size"]["default"]
+        if self.wsoc_size is None:
+            self.wsoc_size = limits["ti_components"]["wsoc_size"]["default"]
+        if self.vendor_bl3_size is None:
+            self.vendor_bl3_size = limits["vendor_components"]["vendorBl3Size"][
+                "default"
+            ]
+
+        ext_flash_dir_path = self.fib_utility.get_ext_flash_dir_path()
+        # move flash jsons files to tmp folder
+        self.xspi_json, self.otfde_json, self.ext_mem_json = (
+            self.prog_utility.move_flash_json_files(
+                flash_type_files_folder=ext_flash_dir_path,
+                flash_device=self.flash_type,
+                enable_ota=self.enable_ota,
+            )
+        )
+
+        if (
+            not isfile(self.xspi_json)
+            or not isfile(self.otfde_json)
+            or not isfile(self.ext_mem_json)
+        ):
+            raise Exception(
+                f"Some JSONs are missing for Flash Device {self.flash_type}"
+            )
+
+        # modify jsons by user parameters
+        self.ext_mem_json, self.otfde_json, self.xspi_json = (
+            self.fib_utility.update_flash_configuration_files(
+                ext_mem_json_path=self.ext_mem_json,
+                otfde_json_path=self.otfde_json,
+                xspi_json_path=self.xspi_json,
+                nvs_size_kb=self.nvs_size,
+                ks_size_kb=self.key_storage_size,
+                vs_size_kb=self.vendor_specific_size,
+                bl2_size_kb=self.bl2_size,
+                wsoc_size_kb=self.wsoc_size,
+                device_type=self.device_type,
+                vendor_bl3_size_kb=self.vendor_bl3_size,
+                psram_type=self.psram_type,
+                ota_enabled=self.enable_ota,
+            )
+        )
+
+        if (
+            not isfile(self.xspi_json)
+            or not isfile(self.otfde_json)
+            or not isfile(self.ext_mem_json)
+        ):
+            raise Exception(f"Some Modify JSONs are missing")
+
+        self.default_vendor_out_file = self.prog_utility.get_default_vendor_app(
+            device_type=self.device_type, enable_ota=self.enable_ota
+        )
+
+        self.default_conf_bin_file = self.prog_utility.get_default_conf_bin(device_type)
+
+        tbl_dir_path = self.prog_utility.get_tbl_dir_path()
+        self.tbl_bootloader_path = self.prog_utility.get_default_tbl_img(
+            self.device_type
+        )
+
+        self.wsoc_path = self.prog_utility.get_default_wsoc(self.device_type)
+
+        self.programming_sign_image_path = ""
+        self.vendor_sign_image_path = ""
+        self.vendor_bl3_sign_image_path = ""
+        self.prog_action_req_sign_path = ""
+        self.tbl_image_path = ""
+        self.wsoc_image_path = ""
+        self.tbl_programmer_path = self.prog_utility.get_default_prog(self.device_type)
+        self.boot_sector_image_path = ""
+        self.tool_settings_json_template = (
+            self.prog_utility.get_tool_settings_template()
+        )
+        self.is_rollback_fuse_prog_required = False
+
+    def _generate_programming_inst_image(self):
+
+        fuse_conf_json_mod = self.fuse_conf_json
+
+        if self.is_rollback_fuse_prog_required:
+            # Update fuses with rollback protection values based on image versions
+            fuses_name_json_mod = self.fuse_json_name.replace(".json", ".mod.json")
+            fuse_conf_json_mod = join(self.tmp_folder, fuses_name_json_mod)
+            with (
+                open(self.fuse_conf_json, "r") as fuses_file,
+                open(fuse_conf_json_mod, "w") as fuses_out,
+            ):
+                fuses_obj = json.load(fuses_file)
+                fuses_obj["rot"] = None
+
+                fuses_obj = self.fib_utility.update_rollback_fuses(
+                    fuses_json_content=fuses_obj,
+                    primary_tbl_image_path=self.tbl_image_path or None,
+                    primary_wsoc_image_path=self.wsoc_image_path or None,
+                    primary_vendor_image_path=self.vendor_sign_image_path or None,
+                    device=self.device_type,
+                )
+                json.dump(fuses_obj, fuses_out, indent=4)
+
+        # build programming image
+        programming_unsign_image_path, programming_forsign_image_path = (
+            self.prog_utility.build_programming_image(
+                version="0.0.1.0",
+                pub_key_path=None,
+                activation_type=ACTIVATION_TYPE.AUTHENTICATION_BYPASS.value,
+                dir_out_path=self.tmp_folder,
+                fuses_programming_instructions=fuse_conf_json_mod,
+                flash_discovery_config_xspi=self.xspi_json,
+                flash_discovery_config_otfde=self.otfde_json,
+                flash_discovery_config_ext_mem=self.ext_mem_json,
+                device=self.device_type,
+                logging_level=self.logging_level,
+            )
+        )
+
+        # sign programming image
+        self.programming_sign_image_path = self.prog_utility.sign_programming_image(
+            programming_unsign_image=programming_unsign_image_path,
+            programming_forsign_image=programming_forsign_image_path,
+            activation_type=self.activation_type,
+            signing_module=self.signing_module,
+            dir_out_path=self.tmp_folder,
+            logging_level=self.logging_level,
+        )
+
+        # generate boot sector image
+        self.boot_sector_image_path = self.prog_utility.build_boot_sector(
+            programming_sign_image_path=self.programming_sign_image_path,
+            dir_out_path=self.tmp_folder,
+            device_type=self.device_type,
+            logging_level=self.logging_level,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info(
+            "Successfully generated Programming Instruction Image and boot sector image"
+        )
+
+    def _generate_vendor_image(
+        self, vendor_out_file=None, conf_bin_file=None, vendor_app_version="0.0.1.0"
+    ):
+        # build vendor image
+        vendor_unsign_image_path, vendor_forsign_image_path = (
+            self.prog_utility.build_vendor_image(
+                vendor_out_file=(
+                    self.default_vendor_out_file
+                    if vendor_out_file is None
+                    else vendor_out_file
+                ),
+                conf_bin_file=(
+                    self.default_conf_bin_file
+                    if conf_bin_file is None
+                    else conf_bin_file
+                ),
+                version=vendor_app_version,
+                dir_out_path=self.tmp_folder,
+                device=self.device_type,
+                logging_level=self.logging_level,
+                signing_mode=self.signing_mode,
+            )
+        )
+
+        # sign vendor image
+        self.vendor_sign_image_path = self.prog_utility.sign_vendor_image(
+            vendor_unsign_image=vendor_unsign_image_path,
+            vendor_forsign_image=vendor_forsign_image_path,
+            activation_type=self.activation_type,
+            signing_module=self.signing_module,
+            dir_out_path=self.tmp_folder,
+            device=self.device_type,
+            logging_level=self.logging_level,
+            signing_mode=self.signing_mode,
+            magic=self.magic,
+            key_info_version=self.key_info_version,
+            svn=self.svn,
+            svn_policy=self.svn_policy,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info("Successfully generated Vendor Image")
+
+    def _generate_vendor_bl3_image(
+        self, vendor_bl3_out_file, vendor_bl3_version="0.0.1.0"
+    ):
+        vendor_bl3_unsign_path, vendor_bl3_forsign_path = (
+            self.prog_utility.build_vendor_bl3_image(
+                bl3_bin_path=vendor_bl3_out_file,
+                dir_out_path=self.tmp_folder,
+                device=self.device_type,
+                version=vendor_bl3_version,
+                logging_level=self.logging_level,
+                signing_mode=self.signing_mode,
+            )
+        )
+
+        self.vendor_bl3_sign_image_path = self.prog_utility.sign_vendor_bl3_image(
+            vendor_bl3_unsign_image=vendor_bl3_unsign_path,
+            vendor_bl3_forsign_image=vendor_bl3_forsign_path,
+            activation_type=self.activation_type,
+            signing_module=self.signing_module,
+            dir_out_path=self.tmp_folder,
+            device=self.device_type,
+            logging_level=self.logging_level,
+            signing_mode=self.signing_mode,
+            magic=self.magic,
+            key_info_version=self.key_info_version,
+            svn=self.svn,
+            svn_policy=self.svn_policy,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info("Successfully generated Vendor BL3 Image")
+
+    def _generate_prog_action_request(self):
+        template_action_params_path = self.prog_utility.get_action_params_template()
+        updated_action_params_path = join(self.tmp_folder, ACTION_PARAMS)
+
+        with open(template_action_params_path, "r") as f:
+            action_request_json_content = json.load(f)
+
+        prog_req_content = action_request_json_content["programming"]["payload_param"][
+            "payload"
+        ]["prog_req_content"]
+
+        # update action request json with programming flags
+        prog_req_content.update(
+            {
+                "fuse_programming_instruction_update": self.is_rollback_fuse_prog_required,
+                "flash_factory_reset": self.full_flash_erase,
+                "boot_sector": True,
+                "primary_tbl": True,
+                "secondary_tbl": False,
+                "primary_vendor_image": True,
+                "primary_vendor_sbl": self.vendor_bl3_size > 0,
+                "secondary_vendor_image": False,
+                "secondary_vendor_sbl": False,
+                "primary_ti_wsoc": False if self.wsoc_size == 0 else True,
+                "secondary_ti_wsoc": False,
+                "primary_ti_wsoc_bl2": False,
+                "secondary_ti_wsoc_bl2": False,
+                "protected_storage": True,
+            }
+        )
+
+        action_request_json_content["programming"]["payload_param"]["payload"][
+            "prog_req_content"
+        ] = prog_req_content
+
+        with open(updated_action_params_path, "w") as f:
+            json.dump(action_request_json_content, f, indent=4)
+
+        # build action request
+        prog_action_req_unsign_path, prog_action_req_forsign_path = (
+            self.prog_utility.build_action_request_image(
+                params_json=updated_action_params_path,
+                type="programming",
+                dir_out_path=self.tmp_folder,
+                device=self.device_type,
+                logging_level=self.logging_level,
+            )
+        )
+
+        # sign action request
+        self.prog_action_req_sign_path = self.prog_utility.sign_action_request_image(
+            unsign_request=prog_action_req_unsign_path,
+            forsign_request=prog_action_req_forsign_path,
+            activation_type=self.activation_type,
+            signing_module=self.signing_module,
+            dir_out_path=self.tmp_folder,
+            logging_level=self.logging_level,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info("Successfully generated Action Request Image")
+
+    def _generate_tbl_flash_image(self):
+        self.tbl_image_path = self.prog_utility.build_tbl_image(
+            ti_sign_container=self.tbl_bootloader_path,
+            dir_out_path=self.tmp_folder,
+            device=self.device_type,
+            logging_level=self.logging_level,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info("Successfully generated TI Bootloader image")
+
+    def _generate_wsoc_flash_image(self, wsoc_container_file=None):
+        wsoc_path = (
+            self.wsoc_path if wsoc_container_file is None else wsoc_container_file
+        )
+
+        self.wsoc_image_path = self.prog_utility.build_wsoc_image(
+            ti_sign_container=wsoc_path,
+            dir_out_path=self.tmp_folder,
+            device=self.device_type,
+            logging_level=self.logging_level,
+        )
+
+        FACTORY_PROGRAM_LOGGER.info(
+            f"Successfully generated TI Wireless Firmware image from {wsoc_path}"
+        )
+
+    def _generate_ps_image(self, vendor_specific_file=None):
+        vendor_specific_data = b""
+        if vendor_specific_file is not None:
+            with open(vendor_specific_file, "rb") as f:
+                vendor_specific_data = f.read()
+
+        self.vendor_specific_file = vendor_specific_file
+
+        psimg_builder = PSImageBuilder(
+            device=self.device_type,
+            vendor_specific_size_kb=self.vendor_specific_size,
+            nvs_data_max_size_kb=self.nvs_size,
+            key_storage_data_max_size_kb=self.key_storage_size,
+            vendor_specific_data=vendor_specific_data,
+            abs_dir_out_path=self.tmp_folder,
+        )
+
+        # Build and save
+        if not psimg_builder.build():
+            FACTORY_PROGRAM_LOGGER.error("Failed to build PS image")
+            raise Exception("Failed to build PS image")
+
+        if not psimg_builder.save("ps_image.bin"):
+            FACTORY_PROGRAM_LOGGER.error("Failed to save PS image")
+            raise Exception("Failed to save PS image")
+
+        # Success
+        self.psimage_path = join(self.tmp_folder, "ps_image.bin")
+        FACTORY_PROGRAM_LOGGER.info("Successfully generated Protect Storage Image")
+
+    def _generate_images(
+        self,
+        vendor_out_file=None,
+        conf_bin_file=None,
+        vendor_app_version="0.0.1.0",
+        wsoc_container_file=None,
+        vendor_specific_file=None,
+        vendor_bl3_out_file=None,
+        vendor_bl3_version="0.0.1.0",
+    ):
+        self._generate_tbl_flash_image()
+
+        if self.wsoc_size > 0:
+            self._generate_wsoc_flash_image(wsoc_container_file=wsoc_container_file)
+
+        self._generate_vendor_image(
+            vendor_out_file=vendor_out_file,
+            conf_bin_file=conf_bin_file,
+            vendor_app_version=vendor_app_version,
+        )
+
+        if self.vendor_bl3_size > 0:
+            self._generate_vendor_bl3_image(
+                vendor_bl3_out_file=vendor_bl3_out_file,
+                vendor_bl3_version=vendor_bl3_version,
+            )
+
+        # Check if rollback fuse programming is required (if rollback protection is enabled)
+        if not self.rollback_protection:
+            self.is_rollback_fuse_prog_required = False
+        else:
+            self.is_rollback_fuse_prog_required = (
+                self.fib_utility.is_rollback_fuse_programming_required(
+                    primary_tbl_image_path=(
+                        self.tbl_image_path if self.tbl_image_path != "" else None
+                    ),
+                    primary_wsoc_image_path=(
+                        self.wsoc_image_path if self.wsoc_image_path != "" else None
+                    ),
+                    primary_vendor_image_path=(
+                        self.vendor_sign_image_path
+                        if self.vendor_sign_image_path != ""
+                        else None
+                    ),
+                    device=self.device_type,
+                )
+            )
+
+        self._generate_programming_inst_image()
+
+        self._generate_ps_image(vendor_specific_file=vendor_specific_file)
+
+        self._generate_prog_action_request()
+
+    def _validate_generated_image_sizes(self):
+        is_valid, message, *_, max_vendor_app_size = (
+            self.fib_utility.validate_total_images_size(
+                flash_device=self.flash_type,
+                bl2_size_kb=self.bl2_size,
+                wsoc_size_kb=self.wsoc_size,
+                nvs_size_kb=self.nvs_size,
+                key_storage_size_kb=self.key_storage_size,
+                vendor_specific_size_kb=self.vendor_specific_size,
+                vendor_bl3_size_kb=self.vendor_bl3_size,
+                enable_ota=self.enable_ota,
+            )
+        )
+        if is_valid == False:
+            FACTORY_PROGRAM_LOGGER.error(message)
+            return False
+
+        protected_storage_size_kb = (
+            self.fib_utility.calc_protected_storage_size_bytes(
+                nvs_bytes=self.nvs_size * 1024,
+                key_storage_bytes=self.key_storage_size * 1024,
+                vendor_specific_bytes=self.vendor_specific_size * 1024,
+            )
+            / 1024
+        )
+
+        is_valid, _ = self.fib_utility.validate_images_sizes(
+            primary_tbl_path=self.tbl_image_path,
+            tbl_size_kb=self.bl2_size,
+            primary_wsoc_path=self.wsoc_image_path,
+            wsoc_size_kb=self.wsoc_size,
+            primary_vendor_path=self.vendor_sign_image_path,
+            vendor_size_kb=max_vendor_app_size,
+            primary_vendor_bl3_path=self.vendor_bl3_sign_image_path,
+            vendor_bl3_size_kb=self.vendor_bl3_size,
+            boot_sector_path=self.boot_sector_image_path,
+            boot_sector_size_kb=BOOT_SECTOR_SIZE_DEFAULT_KB,
+            vendor_specific_path=self.vendor_specific_file,
+            vendor_specific_size_kb=self.vendor_specific_size,
+            protected_storage_path=self.psimage_path,
+            protected_storage_size_kb=protected_storage_size_kb,
+        )
+        return is_valid
+
+    def _update_tool_settings_json(self):
+        tool_settings = json.load(open(self.tool_settings_json_template, "r"))
+
+        programming_debug_and_ota_signed_components = tool_settings[
+            "programming_debug_and_ota_signed_components"
+        ]
+
+        programming_debug_and_ota_signed_components["programming_instructions"] = str(
+            self.programming_sign_image_path
+        )
+
+        programming_debug_and_ota_signed_components["primary_vendor_image"] = str(
+            self.vendor_sign_image_path
+        )
+
+        programming_debug_and_ota_signed_components["actions_req_paths"][
+            "programming"
+        ] = str(self.prog_action_req_sign_path)
+
+        programming_debug_and_ota_signed_components["primary_tbl"] = str(
+            self.tbl_image_path
+        )
+
+        programming_debug_and_ota_signed_components["primary_ti_wsoc"] = (
+            None if self.wsoc_size == 0 else str(self.wsoc_image_path)
+        )
+
+        programming_debug_and_ota_signed_components["tbl_container_programming"] = str(
+            self.tbl_programmer_path
+        )
+
+        programming_debug_and_ota_signed_components["boot_sector"] = str(
+            self.boot_sector_image_path
+        )
+        programming_debug_and_ota_signed_components["protected_storage"] = str(
+            self.psimage_path
+        )
+
+        if self.vendor_bl3_sign_image_path:
+            programming_debug_and_ota_signed_components["primary_vendor_sbl"] = str(
+                self.vendor_bl3_sign_image_path
+            )
+
+        self.tool_settings_mod_json = join(
+            self.prog_utility.get_programming_tmp_folder(), TOOL_SETTINGS
+        )
+
+        json.dump(tool_settings, open(self.tool_settings_mod_json, "w"), indent=4)
+
+        FACTORY_PROGRAM_LOGGER.log(
+            self.logging_level,
+            f"Update tool settings json at: {self.tool_settings_mod_json}",
+        )
+
+        FACTORY_PROGRAM_LOGGER.info(
+            "Updated tool settings json with new images for factory programming"
+        )
+
+    def program(
+        self,
+        vendor_out_file=None,
+        conf_bin_file=None,
+        vendor_app_version="0.0.1.0",
+        wsoc_container_file=None,
+        vendor_specific_file=None,
+        vendor_bl3_out_file=None,
+        vendor_bl3_version="0.0.1.0",
+    ):
+        FACTORY_PROGRAM_LOGGER.info("Factory programming started")
+
+        self._generate_images(
+            vendor_out_file=vendor_out_file,
+            conf_bin_file=conf_bin_file,
+            vendor_app_version=vendor_app_version,
+            wsoc_container_file=wsoc_container_file,
+            vendor_specific_file=vendor_specific_file,
+            vendor_bl3_out_file=vendor_bl3_out_file,
+            vendor_bl3_version=vendor_bl3_version,
+        )
+
+        if not self._validate_generated_image_sizes():
+            FACTORY_PROGRAM_LOGGER.error(
+                "Error: Image size validation failed"
+            )
+            return False
+
+        self._update_tool_settings_json()
+
+        program_device = ProgramDevice(
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            tool_settings=self.tool_settings_mod_json,
+            device_type=self.device_type,
+            report_file_path=(pathlib.Path(self.tmp_folder) / "programming_report.txt"),
+            programmer_artifacts_path=self.prog_dir,
+            fib_artifacts_path=self.fib_dir,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            verbose=self.verbose,
+            jlink_speed_khz=self.jlink_speed_khz,
+        )
+
+        if not program_device.program():
+            FACTORY_PROGRAM_LOGGER.error("Error: Factory programming failed")
+            return False
+        else:
+            FACTORY_PROGRAM_LOGGER.info("Factory programming ended successfully")
+            return True