programmer-core 1.0.29__py3-none-any.whl

programmer_core/utility.py

@@ -0,0 +1,1822 @@
+import argparse
+from os.path import (
+    isabs,
+    abspath,
+    join,
+    dirname,
+    basename,
+    dirname,
+    join,
+    isdir,
+    isfile,
+    normcase,
+    normpath,
+    exists,
+)
+from os import getcwd, makedirs, remove
+import re
+from sys import executable
+from construct import Int16ul, Int32ul, Int8ul, Padding, Struct, GreedyBytes
+import sys
+import logging
+import pathlib
+import json
+from tabulate import tabulate
+import shutil
+
+from communicator_core import (
+    CC35XXE,
+    CC37XXR,
+    CC33XX,
+    CC35XX,
+    CC36XXR,
+    LifeCycleStateReg,
+    CC35xxELifeCycleStateReg,
+    CC3xxxRLifeCycleStateReg,
+)
+
+from flash_images_builder_core import (
+    ProgInstImgBuilder,
+    GPEBuilder,
+    BootSectorFromImgBuilder,
+    VendorImageBuilder,
+    ActionReqBuilder,
+    TBLImageBuilder,
+    BL3ImageBuilder,
+    CleanImageBuilder,
+    WSOCImageBuilder,
+    SUPPORTED_FLASH_TYPES,
+    PsramOption,
+    FIBUtility,
+    KEY_INFO_MAGIC_DEFAULT,
+    KEY_INFO_VERSION_DEFAULT,
+    KEY_INFO_SVN_DEFAULT,
+    KEY_INFO_SVN_POLICY_DEFAULT,
+)
+
+CC33XX = "CC33XX"
+CC35X1 = "CC35X1"
+CC35X1E = "CC35X1E"
+CC360XR = "CC360XR"
+CC370XR = "CC370XR"
+
+
+PROGRAMMER_DIR = "programmer"
+PROGRAMMER_TBL_DIR = "bl2"
+PROGRAMMER_WSOC_DIR = "ti_wireless_firmware"
+VENDOR_APP_FOLDER = "pre_complied_application"
+PROGRAMMING_FILES_FOLDER_NAME = "programming"
+ACTIVATION_FILES_FOLDER_NAME = "activation_n_initial_programming"
+SDK_EXAMPLE_KEY_FILES_FOLDER_NAME = "sdk_example_key"
+AUTHENTICATION_BYPASS_FILES_FOLDER_NAME = "authentication_bypass"
+VENDOR_KEY_FILES_FOLDER_NAME = "vendor_key"
+CONFIG_FOLDER_NAME = "configuration_files"
+TOOL_SETTINGS_TEMPLATE = "tool_settings.template.json"
+TOOL_SETTINGS = "tool_settings.json"
+CONNECTION_INFO_FILE_NAME = "connection_info.json"
+ACTION_PARAMS_TEMPLATE = "action_params.template.json"
+ACTION_PARAMS = "action_params.json"
+BINARIES_FOLDER_NAME = "binaries"
+
+# files that are inside jsons folder
+EXTMEM_JSON_NAME = "flash_disc_param_ext_mem.json"
+OTFDE_JSON_NAME = "flash_disc_param_otfde.json"
+XSPI_JSON_NAME = "flash_disc_param_xspi.json"
+
+# files that are inside jsons folder
+EXTMEM_JSON_MOD_NAME = "flash_disc_param_ext_mem.mod.json"
+OTFDE_JSON_MOD_NAME = "flash_disc_param_otfde.mod.json"
+XSPI_JSON_MOD_NAME = "flash_disc_param_xspi.mod.json"
+
+# files that are inside images folder
+VENDOR_OUT_NAME_CC35XX = "vendor_app.CC35XX.out"
+VENDOR_OUT_NAME_CC35XXE = "vendor_app.CC35XXE.out"
+VENDOR_OUT_NAME_CC37XXR = "vendor_app.CC37XXR.out"
+
+# files that are inside ti_wireless_firmware folder
+WSOC_NAME_CC35XX = "ti_wireless_firmware.CC35XX.bin"
+WSOC_NAME_CC35XXE = "ti_wireless_firmware.CC35XXE.bin"
+WSOC_NAME_CC37XXR = "ti_wireless_firmware.CC37XXR.bin"
+CONF_BIN_NAME_CC35XXE = "ti_wireless_firmware.CC35XXE.conf.bin"
+CONF_BIN_NAME_CC37XXR = "ti_wireless_firmware.CC37XXR.conf.bin"
+
+# files that in fuze folder
+FUSE_PROG_NAME_CC35XX = "fuse_prog_inst_param.CC35XX.json"
+FUSE_PROG_NAME_CC35XXE = "fuse_prog_inst_param.CC35XXE.json"
+FUSE_PROG_NAME_CC37XXR = "fuse_prog_inst_param.CC37XXR.json"
+FUSE_PROG_NAME_CC35XXE_TEMPLATE = "fuse_prog_inst_param.template.json"
+
+# CC35XX BL2
+TI_BOOTLOADER_CC35XX = "ti_bootloader.CC35XX.sign.bin"
+TI_PROGRAMMER_CC35XX = "ti_programmer.CC35XX.sign.bin"
+TI_DEBUG_CC35XX = "ti_programmer.CC35XX.sign.bin"
+TI_RMA_CC35XX = "ti_programmer.CC35XX.sign.bin"
+TI_ACTIVATION_CC35XX = "ti_programmer.CC35XX.sign.bin"
+
+# CC35XXE BL2
+TI_BOOTLOADER_CC35XXE = "ti_bootloader.CC35XXE.sign.bin"
+TI_PROGRAMMER_CC35XXE = "ti_programmer.CC35XXE.sign.bin"
+TI_DEBUG_CC35XXE = "ti_debug.CC35XXE.sign.bin"
+TI_RMA_CC35XXE = "ti_rma.CC35XXE.sign.bin"
+TI_ACTIVATION_CC35XXE = "ti_activation.CC35XXE.sign.bin"
+
+# CC37XXR BL2
+TI_BOOTLOADER_CC37XXR = "ti_bootloader.CC37XXR.sign.bin"
+TI_PROGRAMMER_CC37XXR = "ti_programmer.CC37XXR.sign.bin"
+TI_ACTIVATION_CC37XXR = "ti_activation.CC37XXR.sign.bin"
+TI_DEBUG_CC37XXR = "ti_debug.CC37XXR.sign.bin"
+
+# Short names
+# TBL = TI BootLoader
+# TPR = TI PRogrammer
+# TAC = TI ACtivation
+# TDB = TI DeBug
+# TRM = TI RMA
+
+# Supported country codes (ISO 3166-1 alpha-2)
+VALID_COUNTRY_CODES = {
+    "WW",
+    "US",
+    "JP",
+    "AF",
+    "AL",
+    "DZ",
+    "AS",
+    "AD",
+    "AI",
+    "AR",
+    "AM",
+    "AW",
+    "AU",
+    "AT",
+    "AZ",
+    "BS",
+    "BH",
+    "BD",
+    "BB",
+    "BY",
+    "BE",
+    "BZ",
+    "BM",
+    "BT",
+    "BO",
+    "BA",
+    "BR",
+    "BN",
+    "BG",
+    "BF",
+    "KH",
+    "CA",
+    "KY",
+    "CF",
+    "TD",
+    "CL",
+    "CN",
+    "CX",
+    "CO",
+    "CR",
+    "CI",
+    "HR",
+    "CU",
+    "CY",
+    "CZ",
+    "DK",
+    "DM",
+    "DO",
+    "EC",
+    "EG",
+    "SV",
+    "EE",
+    "ET",
+    "FI",
+    "FR",
+    "GF",
+    "PF",
+    "GE",
+    "DE",
+    "GH",
+    "GR",
+    "GL",
+    "GD",
+    "GP",
+    "GU",
+    "GT",
+    "GY",
+    "HT",
+    "HN",
+    "HK",
+    "HU",
+    "IS",
+    "IN",
+    "ID",
+    "IR",
+    "IE",
+    "IL",
+    "IT",
+    "JM",
+    "JO",
+    "KZ",
+    "KE",
+    "KP",
+    "KR",
+    "KW",
+    "LV",
+    "LB",
+    "LS",
+    "LI",
+    "LT",
+    "LU",
+    "MO",
+    "MK",
+    "MG",
+    "MW",
+    "MY",
+    "MV",
+    "MT",
+    "MH",
+    "MQ",
+    "MR",
+    "MU",
+    "YT",
+    "MX",
+    "FM",
+    "MD",
+    "MC",
+    "MN",
+    "ME",
+    "MA",
+    "NP",
+    "NL",
+    "AN",
+    "NZ",
+    "NI",
+    "NG",
+    "MP",
+    "NO",
+    "OM",
+    "PK",
+    "PW",
+    "PA",
+    "PG",
+    "PY",
+    "PE",
+    "PH",
+    "PL",
+    "PT",
+    "PR",
+    "QA",
+    "RE",
+    "RO",
+    "RU",
+    "RW",
+    "BL",
+    "KN",
+    "LC",
+    "PM",
+    "VC",
+    "WS",
+    "SA",
+    "SN",
+    "RS",
+    "SG",
+    "SK",
+    "SI",
+    "ZA",
+    "ES",
+    "LK",
+    "SR",
+    "SE",
+    "CH",
+    "SY",
+    "TW",
+    "TZ",
+    "TH",
+    "TG",
+    "TT",
+    "TN",
+    "TR",
+    "TC",
+    "UG",
+    "UA",
+    "AE",
+    "GB",
+    "UY",
+    "UZ",
+    "VU",
+    "VE",
+    "VN",
+    "VI",
+    "WF",
+    "YE",
+    "ZW",
+}
+
+# For display purposes (sorted list)
+COUNTRY_CODES_LIST = sorted(VALID_COUNTRY_CODES)
+
+PROGRAMMER_UTILITY_LOGGER = logging.getLogger("programmer-utility")
+
+
+def get_lifecycle_state_reg_class(device_type):
+    """
+    Get the appropriate LifeCycleStateReg class based on device type.
+
+    This function selects the correct CFGAP register implementation for each
+    device variant (CC35XX, CC35XXE, CC37XXR, etc.), ensuring correct field
+    parsing for device-specific register layouts.
+
+    Args:
+        device_type (str): Device type constant (CC35XX, CC35XXE, CC37XXR, CC36XXR)
+
+    Returns:
+        class: Device-appropriate LifeCycleStateReg class
+    """
+    if device_type == CC35XXE:
+        return CC35xxELifeCycleStateReg
+    elif device_type in [CC37XXR, CC36XXR]:
+        return CC3xxxRLifeCycleStateReg
+    else:
+        # Default to CC35XX for CC35XX and any other devices
+        return LifeCycleStateReg
+
+
+class ProgrammerUtility:
+    def __init__(
+        self, programmer_artifacts_path, fib_artifacts_path, is_internal_release=True
+    ):
+        # Convert to Path object if it's not already
+        self.is_internal_release = is_internal_release
+
+        self.programmer_path = pathlib.Path(programmer_artifacts_path)
+        self.fib_utility = FIBUtility(
+            fib_artifacts_path, is_internal_release=self.is_internal_release
+        )
+
+    def get_device_type_from_family(self, device_family):
+        """Map device family string to device type constant.
+
+        Args:
+            device_family: Device family string (e.g., "CC35X1E", "CC35X1", "CC370XR", "CC360XR", "CC33XX")
+
+        Returns:
+            Device type constant (CC35XXE, CC35XX, CC37XXR, CC36XXR or CC33XX)
+        """
+        device_family_upper = device_family.upper()
+        if device_family_upper in [CC35X1E, CC35XXE]:
+            return CC35XXE
+        elif device_family_upper in [CC370XR, CC37XXR]:
+            return CC37XXR
+        elif device_family_upper in [CC360XR, CC36XXR]:
+            # TODO: temporary - CC360XR currently not supported
+            return CC36XXR
+        elif device_family_upper in [CC33XX]:
+            return CC33XX
+        elif device_family_upper in [CC35X1, CC35XX]:
+            return CC35XX
+        else:
+            return None
+
+    def get_programmer_dir_path(self):
+        return str(self.programmer_path)
+
+    def get_tbl_dir_path(self):
+        binaries_path = self.get_binaries_folder()
+        return join(binaries_path, PROGRAMMER_TBL_DIR)
+
+    def get_wsoc_dir_path(self):
+        binaries_path = self.get_binaries_folder()
+        return join(binaries_path, PROGRAMMER_WSOC_DIR)
+
+    def get_programming_tmp_folder(self):
+        tmp_dir = self.get_tmp_folder()
+        prog_tmp_folder = join(tmp_dir, PROGRAMMING_FILES_FOLDER_NAME)
+        makedirs(prog_tmp_folder, exist_ok=True)
+
+        return prog_tmp_folder
+
+    def get_tmp_folder(self):
+        programmer_dir = self.get_programmer_dir_path()
+        tmp_folder = join(programmer_dir, "tmp")
+        makedirs(tmp_folder, exist_ok=True)
+
+        return tmp_folder
+
+    def get_prog_tools_settings(self):
+        prog_tmp_folder = self.get_programming_tmp_folder()
+        return join(prog_tmp_folder, TOOL_SETTINGS)
+
+    def get_tool_settings_template(self):
+        return join(self.get_config_folder(), TOOL_SETTINGS_TEMPLATE)
+
+    def move_flash_json_files(
+        self,
+        flash_type_files_folder,
+        flash_device,
+        enable_ota=False,
+    ):
+        tmp_dir = self.get_programming_tmp_folder()
+
+        if flash_device in SUPPORTED_FLASH_TYPES:
+            jsons_flash_type_files_folder = join(flash_type_files_folder, flash_device)
+
+        xspi_json = self.copy_file(
+            jsons_flash_type_files_folder, tmp_dir, XSPI_JSON_NAME
+        )
+        otfde_json = self.copy_file(
+            jsons_flash_type_files_folder, tmp_dir, OTFDE_JSON_NAME
+        )
+        ext_mem_json = self.copy_file(
+            jsons_flash_type_files_folder, tmp_dir, EXTMEM_JSON_NAME
+        )
+
+        return xspi_json, otfde_json, ext_mem_json
+
+    def get_mod_flash_jsons(self):
+        tmp_dir = self.get_programming_tmp_folder()
+
+        xspi_json = join(tmp_dir, XSPI_JSON_MOD_NAME)
+        otfde_json = join(tmp_dir, OTFDE_JSON_MOD_NAME)
+        ext_mem_json = join(tmp_dir, EXTMEM_JSON_MOD_NAME)
+
+        return xspi_json, otfde_json, ext_mem_json
+
+    def get_act_n_init_tmp_folder(self):
+        tmp_folder = self.get_tmp_folder()
+        act_tmp_folder = join(tmp_folder, ACTIVATION_FILES_FOLDER_NAME)
+        makedirs(act_tmp_folder, exist_ok=True)
+
+        return act_tmp_folder
+
+    def get_flash_jsons(
+        self,
+        flash_type_files_folder,
+        flash_device,
+        tmp_dir_path,
+        psram_type=PsramOption.NO_PSRAM.name,
+        enable_ota=False,
+    ):
+        if flash_device in SUPPORTED_FLASH_TYPES:
+            jsons_flash_type_files_folder = join(flash_type_files_folder, flash_device)
+
+        xspi_json = join(jsons_flash_type_files_folder, XSPI_JSON_NAME)
+        otfde_json = join(jsons_flash_type_files_folder, OTFDE_JSON_NAME)
+        ext_mem_json = join(jsons_flash_type_files_folder, EXTMEM_JSON_NAME)
+
+        updated_xspi = self.update_xspi_to_psram_type(
+            xspi_json_path=xspi_json,
+            psram_type=psram_type,
+            output_dir_path=tmp_dir_path,
+        )
+
+        return updated_xspi, otfde_json, ext_mem_json
+
+    def get_default_tbl_img(self, device_type):
+        tbl_folder_name = self.get_tbl_dir_path()
+        if device_type == CC35XXE:
+            path_to_tbl = join(tbl_folder_name, TI_BOOTLOADER_CC35XXE)
+        elif device_type == CC37XXR:
+            path_to_tbl = join(tbl_folder_name, TI_BOOTLOADER_CC37XXR)
+        else:
+            path_to_tbl = join(tbl_folder_name, TI_BOOTLOADER_CC35XX)
+        return path_to_tbl
+
+    def get_default_vendor_app(self, device_type, enable_ota=False):
+        vendor_folder = join(self.get_binaries_folder(), VENDOR_APP_FOLDER)
+
+        # Map device type to vendor app filename
+        vendor_app_map = {
+            CC35XX: VENDOR_OUT_NAME_CC35XX,
+            CC35XXE: VENDOR_OUT_NAME_CC35XXE,
+            CC37XXR: VENDOR_OUT_NAME_CC37XXR,
+        }
+
+        vendor_app_name = vendor_app_map.get(device_type)
+
+        # For advanced devices (CC35XXE and CC37XXR), use OTA-specific folders
+        if device_type in (CC35XXE, CC37XXR):
+            source_dir = "vendor_app_ota" if enable_ota else "vendor_app_no_ota"
+            return join(vendor_folder, source_dir, vendor_app_name)
+
+        # For CC35XX, use flat structure
+        return join(vendor_folder, vendor_app_name)
+
+    def get_default_conf_bin(self, device_type):
+        wsoc_folder = self.get_wsoc_dir_path()
+
+        conf_map = {
+            CC35XXE: CONF_BIN_NAME_CC35XXE,
+            CC37XXR: CONF_BIN_NAME_CC37XXR,
+        }
+
+        conf_name = conf_map.get(device_type, None)
+        if conf_name is None:
+            return None
+        return join(wsoc_folder, conf_name)
+
+        return path_to_conf_bin
+
+    def get_default_prog(self, device_type):
+        tbl_folder_name = self.get_tbl_dir_path()
+        if device_type == CC35XXE:
+            path_to_ti_prog = join(tbl_folder_name, TI_PROGRAMMER_CC35XXE)
+        elif device_type == CC37XXR:
+            path_to_ti_prog = join(tbl_folder_name, TI_PROGRAMMER_CC37XXR)
+        else:
+            path_to_ti_prog = join(tbl_folder_name, TI_PROGRAMMER_CC35XX)
+        return path_to_ti_prog
+
+    def get_default_activator(self, device_type):
+        tbl_folder_name = self.get_tbl_dir_path()
+        if device_type == CC35XXE:
+            path_to_tac = join(tbl_folder_name, TI_ACTIVATION_CC35XXE)
+        elif device_type == CC37XXR:
+            path_to_tac = join(tbl_folder_name, TI_ACTIVATION_CC37XXR)
+        else:
+            path_to_tac = join(tbl_folder_name, TI_ACTIVATION_CC35XX)
+        return path_to_tac
+
+    def get_default_wsoc(self, device_type):
+        wsoc_folder = self.get_wsoc_dir_path()
+
+        # Map device type to WSOC firmware filename
+        wsoc_map = {
+            CC35XX: WSOC_NAME_CC35XX,
+            CC35XXE: WSOC_NAME_CC35XXE,
+            CC37XXR: WSOC_NAME_CC37XXR,
+        }
+
+        wsoc_name = wsoc_map.get(device_type)
+        if wsoc_name is None:
+            return None
+        return join(wsoc_folder, wsoc_name)
+
+    def get_action_params_template(self):
+        jsons_folder = self.get_config_folder()
+        action_params_template = join(jsons_folder, ACTION_PARAMS_TEMPLATE)
+
+        return action_params_template
+
+    def get_binaries_folder(self):
+        programmer_dir = self.get_programmer_dir_path()
+        binaries_folder = join(programmer_dir, BINARIES_FOLDER_NAME)
+
+        return binaries_folder
+
+    def get_config_folder(self):
+        programmer_dir = self.get_programmer_dir_path()
+        jsons_folder = join(programmer_dir, CONFIG_FOLDER_NAME)
+
+        return jsons_folder
+
+    def get_fuses_params_template(self):
+        fuses_param_json_template_path = (
+            pathlib.Path(self.get_config_folder()) / FUSE_PROG_NAME_CC35XXE_TEMPLATE
+        )
+        with open(fuses_param_json_template_path, "r") as json_file:
+            fuses_dict = json.loads(json_file.read())
+
+        return fuses_dict
+
+    def get_fuse_json_name(self, device_type):
+
+        fuses_param_map = {
+            CC35XX: FUSE_PROG_NAME_CC35XX,
+            CC35XXE: FUSE_PROG_NAME_CC35XXE,
+            CC37XXR: FUSE_PROG_NAME_CC37XXR,
+        }
+
+        fuses_param_name = fuses_param_map.get(device_type, None)
+        if fuses_param_name is None:
+            return None
+
+        return fuses_param_name
+
+    def create_new_fuses_json_file(self, dict_updated_data, full_path_to_save):
+        """
+        Creates a JSON file from the provided dictionary data.
+
+        Args:
+            dict_updated_data (dict): The dictionary containing the updated fuse parameters.
+            full_path_to_save (str): The full path to save the JSON file.
+        """
+        fuses_dict = self.get_fuses_params_template()
+
+        # Iterate through the updated dictionary and update existing keys in the template
+        for key, value in dict_updated_data.items():
+            if key in fuses_dict:
+                fuses_dict[key] = value
+
+        self.dict_to_json(fuses_dict, full_path_to_save)
+
+    def copy_file(self, source_path, destination_folder, filename):
+        """Copy PS image to destination folder"""
+        try:
+            # Ensure destination folder exists
+            makedirs(destination_folder, exist_ok=True)
+
+            # Build full destination path
+            destination_path = join(destination_folder, filename)
+            source_path = join(source_path, filename)
+
+            # Copy file
+            shutil.copy(source_path, destination_path)
+
+            return destination_path
+        except Exception as e:
+            print(f"Error copying file: {e}")
+            return None
+
+    def get_container_version(self, path_to_container):
+        container_struct = Struct(
+            # header
+            "magic_number" / Int32ul,
+            "record_type" / Int16ul,
+            "reserved" / Padding(2, b"\xff"),
+            "h_len" / Int32ul,
+            # payload
+            "container_format_version" / Int8ul,
+            "container_type" / Int16ul,
+            "container_type_format" / Int8ul,
+            "major_version" / Int8ul,
+            "minor_version" / Int8ul,
+            "rest" / GreedyBytes,
+        )
+
+        with open(path_to_container, "rb") as f:
+            container_cont = f.read()
+
+        parsed_container = container_struct.parse(container_cont)
+
+        return (parsed_container.major_version, parsed_container.minor_version)
+
+    def file_path_exist(self, path, image_name):
+        if path is None or path == "":
+            error_message = f"Path to {image_name} not exist"
+        elif not isfile(path):
+            error_message = f"Path to {image_name} is invalid"
+        else:
+            error_message = None
+
+        return error_message
+
+    @classmethod
+    def fix_path(cls, path, alt_base_path=None):
+        fixed_path = path
+
+        if not isabs(path):
+            cwd = getcwd()
+            fixed_path = normpath(normcase(join(cwd, path)))
+            if exists(fixed_path):
+                return fixed_path
+            PROGRAMMER_UTILITY_LOGGER.debug(
+                f"Unable to locate '{path}' relative to CWD ({cwd}). Continuing search..."
+            )
+
+            if alt_base_path is not None:
+                fixed_path = normpath(normcase(join(alt_base_path, path)))
+                if exists(fixed_path):
+                    return fixed_path
+                PROGRAMMER_UTILITY_LOGGER.debug(
+                    f"Unable to locate '{path}' relative to tool_settings.json ({alt_base_path}). Continuing search..."
+                )
+
+            if getattr(sys, "frozen", False):
+                if isabs(executable):
+                    fixed_path = join(dirname(executable), path)
+                else:
+                    fixed_path = abspath(path)
+
+        return fixed_path
+
+    def build_programming_image(
+        self,
+        version,
+        pub_key_path,
+        activation_type,
+        dir_out_path,
+        fuses_programming_instructions,
+        flash_discovery_config_xspi,
+        flash_discovery_config_otfde,
+        flash_discovery_config_ext_mem,
+        device,
+        signing_module=None,
+        logging_level=logging.DEBUG,
+        signing_mode="classic_rot",
+    ):
+        # combin xspi json and otfde json to one file
+        flash_discovery_config_path = None
+        dir_out_path = pathlib.Path(dir_out_path)
+        if flash_discovery_config_xspi:
+            flash_discovery_config_path = (
+                dir_out_path / "flash_discovery_configuration.json"
+            )
+
+            with open(flash_discovery_config_xspi, "r") as f:
+                xspi_data = json.load(f)
+
+            with open(flash_discovery_config_otfde, "r") as f:
+                otfde_data = json.load(f)
+
+            with open(flash_discovery_config_ext_mem, "r") as f:
+                ext_mem_data = json.load(f)
+
+            with open(flash_discovery_config_path, "w") as f:
+                xspi_data.update(otfde_data)
+                xspi_data.update({"otfde_external_memory_map": ext_mem_data})
+                f.write(json.dumps(xspi_data, indent=4))
+
+        tmp_fuses_programming_instructions = fuses_programming_instructions
+        if activation_type is not None:
+            tmp_fuses_programming_instructions = (
+                self.fib_utility.update_rot_in_fuses_for_programming_instructions(
+                    fuses_programming_instructions,
+                    dir_out_path,
+                    activation_type,
+                    signing_module,
+                    signing_mode,
+                )
+            )
+
+        # build image
+        prog_inst_img_builder = ProgInstImgBuilder(
+            flash_fuse_programming_inst_json=tmp_fuses_programming_instructions,
+            flash_discovery_conf_file=flash_discovery_config_path,
+            version=version,
+            abs_dir_out_path=dir_out_path,
+            pub_key_path=pub_key_path,
+            device=device,
+            verbose=False,
+            signing_mode=signing_mode,
+        )
+        if not prog_inst_img_builder.build():
+            return None, None
+
+        # save image with dummy sign
+        programming_unsign_image = (
+            prog_inst_img_builder.abs_dir_out_path
+            / "programming_instructions_image.unsign.bin"
+        )
+        with open(programming_unsign_image, "wb") as fb:
+            fb.write(prog_inst_img_builder.programming_image_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved programming instructions image with dummy signature bin file at {programming_unsign_image}",
+        )
+
+        # save image to sign
+        programming_image_to_sign_out_path = (
+            prog_inst_img_builder.abs_dir_out_path
+            / "programming_instructions_image.forsign.bin"
+        )
+        with open(programming_image_to_sign_out_path, "wb") as fb:
+            fb.write(prog_inst_img_builder.programming_image_to_sign_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved part of programming instructions image bin file to sign at {programming_image_to_sign_out_path}",
+        )
+
+        if isfile(tmp_fuses_programming_instructions):
+            remove(tmp_fuses_programming_instructions)
+
+        return programming_unsign_image, programming_image_to_sign_out_path
+
+    # use always classic_rot when calling this function - multi key chaining not relevant to programming image
+    def sign_programming_image(
+        self,
+        programming_unsign_image,
+        programming_forsign_image,
+        dir_out_path,
+        private_key=None,
+        public_key=None,
+        activation_type=None,
+        signing_module=None,
+        signature_bin=None,
+        logging_level=logging.DEBUG,
+        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,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        basename_programming_unsign_image = str(
+            programming_unsign_image.stem.split(".")[0]
+        )
+
+        if activation_type is not None:
+            private_key = None
+            public_key, signature_bin = self.fib_utility.get_public_key_and_signature(
+                activation_type,
+                signing_module,
+                programming_forsign_image,
+                dir_out_path,
+                basename_programming_unsign_image,
+                signing_mode,
+            )
+
+        # Build KEY_INFO_TLV for multi-level mode (before calling sign_gpe)
+        key_info_tlv_bin = None
+        if signing_mode == "multi_level" and signing_module:
+            # Build KEY_INFO_TLV on-the-fly or get pre-built from signing module
+            key_info_tlv_bin = self.fib_utility.get_key_info_tlv(
+                signing_module_path=signing_module,
+                magic=magic,
+                key_info_version=key_info_version,
+                svn_policy_str=svn_policy,
+                svn=svn,
+                verbose=False,
+            )
+            if key_info_tlv_bin is None:
+                PROGRAMMER_UTILITY_LOGGER.log(
+                    logging_level,
+                    "Failed to build/get KEY_INFO_TLV for multi-level signing mode",
+                )
+                return None
+
+        # sign programming image
+        prog_image = GPEBuilder.sign_gpe(
+            unsign_image=programming_unsign_image,
+            private_key=private_key,
+            signature_bin=signature_bin,
+            public_key=public_key,
+            log_level=logging.DEBUG,
+            signing_mode=signing_mode,
+            key_info_tlv_bin=key_info_tlv_bin,
+        )
+
+        # save sign programming image file
+        programming_sign_image = dir_out_path / (
+            basename_programming_unsign_image + ".sign.bin"
+        )
+        with open(programming_sign_image, "wb") as f:
+            f.write(prog_image)
+
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved sign programming image bin file at {programming_sign_image}",
+        )
+
+        return programming_sign_image
+
+    def build_vendor_image(
+        self,
+        vendor_out_file,
+        conf_bin_file,
+        dir_out_path,
+        device,
+        pub_key_path=None,
+        version="0.0.1.0",
+        logging_level=logging.DEBUG,
+        slot=None,
+        signing_mode="classic_rot",
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        vendor_image_builder = VendorImageBuilder(
+            vendor_out_file_path=vendor_out_file,
+            conf_bin_file=conf_bin_file,
+            abs_dir_out_path=dir_out_path,
+            version=version,
+            pub_key_path=pub_key_path,
+            device=device,
+            verbose=False,
+            signing_mode=signing_mode,
+        )
+
+        if vendor_image_builder.build():
+            base_file_name = "vendor_image"
+            if slot is not None:
+                base_file_name += f"_slot{slot}"
+
+            # save image with dummy sign
+            vendor_image_out_path_unsign = (
+                vendor_image_builder.abs_dir_out_path / f"{base_file_name}.unsign.bin"
+            )
+            with open(vendor_image_out_path_unsign, "wb") as fb:
+                fb.write(vendor_image_builder.vendor_image_gpe_content_raw)
+            PROGRAMMER_UTILITY_LOGGER.log(
+                logging_level,
+                f"Saved vendor image with dummy signature bin file at {vendor_image_out_path_unsign}",
+            )
+
+            # save image to sign
+            vendor_image_out_path_for_sign = (
+                vendor_image_builder.abs_dir_out_path / f"{base_file_name}.forsign.bin"
+            )
+            with open(vendor_image_out_path_for_sign, "wb") as fb:
+                fb.write(vendor_image_builder.vendor_image_to_sign_gpe_content_raw)
+            PROGRAMMER_UTILITY_LOGGER.log(
+                logging_level,
+                f"Saved part of vendor image bin file to sign at {vendor_image_out_path_for_sign}",
+            )
+
+        return vendor_image_out_path_unsign, vendor_image_out_path_for_sign
+
+    def sign_vendor_image(
+        self,
+        vendor_unsign_image,
+        vendor_forsign_image,
+        dir_out_path,
+        device,
+        private_key=None,
+        public_key=None,
+        activation_type=None,
+        signing_module=None,
+        signature_bin=None,
+        logging_level=logging.DEBUG,
+        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,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        basename_vendor_unsign_image = str(
+            pathlib.Path(vendor_unsign_image).stem.split(".")[0]
+        )
+
+        if activation_type is not None:
+            private_key = None
+            public_key, signature_bin = self.fib_utility.get_public_key_and_signature(
+                activation_type,
+                signing_module,
+                vendor_forsign_image,
+                dir_out_path,
+                basename_vendor_unsign_image,
+                signing_mode,
+            )
+
+        # Build KEY_INFO_TLV for multi-level mode (before calling sign_gpe)
+        key_info_tlv_bin = None
+        if signing_mode == "multi_level" and signing_module:
+            # Build KEY_INFO_TLV on-the-fly or get pre-built from signing module
+            key_info_tlv_bin = self.fib_utility.get_key_info_tlv(
+                signing_module_path=signing_module,
+                magic=magic,
+                key_info_version=key_info_version,
+                svn_policy_str=svn_policy,
+                svn=svn,
+                verbose=False,
+            )
+            if key_info_tlv_bin is None:
+                PROGRAMMER_UTILITY_LOGGER.log(
+                    logging_level,
+                    "Failed to build/get KEY_INFO_TLV for multi-level signing mode",
+                )
+                return None
+
+        # sign vendor image
+        vendor_image = GPEBuilder.sign_gpe(
+            unsign_image=vendor_unsign_image,
+            private_key=private_key,
+            signature_bin=signature_bin,
+            public_key=public_key,
+            log_level=False,
+            device=device,
+            signing_mode=signing_mode,
+            key_info_tlv_bin=key_info_tlv_bin,
+        )
+
+        # save sign vendor image file
+        vendor_image_out_path = dir_out_path / (
+            basename_vendor_unsign_image + ".sign.bin"
+        )
+        with open(vendor_image_out_path, "wb") as f:
+            f.write(vendor_image)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved sign vendor image bin file at {vendor_image_out_path}",
+        )
+
+        return vendor_image_out_path
+
+    def build_action_request_image(
+        self,
+        params_json,
+        type,
+        dir_out_path,
+        device,
+        logging_level=logging.DEBUG,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        # extract the neccesery data by type
+        with open(params_json, "r") as f:
+            action_req_param = json.load(f)
+
+        action_req_param = action_req_param[type]
+        # make sure public key in action params is ""
+        action_req_param["pub_key"] = ""
+
+        # build action request
+        action_req_builder = ActionReqBuilder.from_dict(
+            action_req_dict=action_req_param,
+            type=type,
+            device_type=device,
+            verbose=False,
+        )
+        action_req_builder.build()
+
+        # save action req file with dummy sig
+        action_req_out_path = dir_out_path / f"{type}_action_request.unsign.bin"
+        with open(action_req_out_path, "wb") as f:
+            f.write(action_req_builder.action_req_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level, f"Saved action request bin file at {action_req_out_path}"
+        )
+
+        # save action req to sign
+        action_req_to_sign_out_path = (
+            dir_out_path / f"{type}_action_request.forsign.bin"
+        )
+        with open(action_req_to_sign_out_path, "wb") as f:
+            f.write(action_req_builder.action_req_wo_sign_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved action request to sign bin file at {action_req_to_sign_out_path}",
+        )
+
+        return action_req_out_path, action_req_to_sign_out_path
+
+    def sign_action_request_image(
+        self,
+        unsign_request,
+        forsign_request,
+        dir_out_path,
+        private_key=None,
+        public_key=None,
+        activation_type=None,
+        signing_module=None,
+        udid="0000-0000-0000-0000",
+        signature_bin=None,
+        logging_level=logging.DEBUG,
+        signing_mode="classic_rot",
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        basename_unsign_request = str(pathlib.Path(unsign_request).stem.split(".")[0])
+
+        if activation_type is not None:
+            private_key = None
+            public_key, signature_bin = self.fib_utility.get_public_key_and_signature(
+                activation_type,
+                signing_module,
+                forsign_request,
+                dir_out_path,
+                basename_unsign_request,
+                signing_mode,
+            )
+
+        # sign action request
+        sign_action_request, type = ActionReqBuilder.sign_action_req(
+            unsign_request=unsign_request,
+            private_key=private_key,
+            signature_bin=signature_bin,
+            public_key=public_key,
+            udid=udid,
+            log_level=False,
+        )
+
+        # save sign action req file
+        action_req_out_path = dir_out_path / (basename_unsign_request + ".sign.bin")
+        with open(action_req_out_path, "wb") as f:
+            f.write(sign_action_request)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved sign action request bin file at {action_req_out_path}",
+        )
+
+        return action_req_out_path
+
+    def get_invalid_size_flags(
+        self,
+        image_paths,
+        bl2_size_kb,
+        wsoc_size_kb,
+        vendor_size_kb,
+        boot_sector_size_kb,
+        vendor_bl3_size_kb=None,
+        protected_storage_size_kb=None,
+    ):
+        """Returns a dict mapping each slot key whose built image exceeds its
+        allocated size to the corresponding size-validation error message
+        (via fib_utility.validate_images_sizes)."""
+        _, failed_images = self.fib_utility.validate_images_sizes(
+            primary_tbl_path=image_paths.get("primary_tbl"),
+            secondary_tbl_path=image_paths.get("secondary_tbl"),
+            tbl_size_kb=bl2_size_kb,
+            primary_wsoc_path=image_paths.get("primary_ti_wsoc"),
+            secondary_wsoc_path=image_paths.get("secondary_ti_wsoc"),
+            wsoc_size_kb=wsoc_size_kb,
+            primary_vendor_path=image_paths.get("primary_vendor_image"),
+            secondary_vendor_path=image_paths.get("secondary_vendor_image"),
+            vendor_size_kb=vendor_size_kb,
+            primary_vendor_bl3_path=image_paths.get("primary_vendor_sbl"),
+            secondary_vendor_bl3_path=image_paths.get("secondary_vendor_sbl"),
+            vendor_bl3_size_kb=vendor_bl3_size_kb,
+            boot_sector_path=image_paths.get("boot_sector"),
+            boot_sector_size_kb=boot_sector_size_kb,
+            protected_storage_path=image_paths.get("protected_storage"),
+            protected_storage_size_kb=protected_storage_size_kb,
+        )
+
+        failed_messages = {
+            image_path: self.fib_utility.get_size_validation_error_msg(actual_kb, limit_kb)
+            for _, image_path, actual_kb, limit_kb in failed_images
+        }
+        return {
+            slot: failed_messages[path]
+            for slot, path in image_paths.items()
+            if path in failed_messages
+        }
+
+    def get_connection_info(self):
+        """Returns the last-saved connection info dict, or None if none was saved yet."""
+        connection_info_file = join(self.get_tmp_folder(), CONNECTION_INFO_FILE_NAME)
+        if not isfile(connection_info_file):
+            return None
+        with open(connection_info_file, "r") as f:
+            return json.load(f)
+
+    def update_connection_info(self, connection_info_data):
+        connection_info_file = join(self.get_tmp_folder(), CONNECTION_INFO_FILE_NAME)
+        with open(connection_info_file, "w") as f:
+            json.dump(connection_info_data, f, indent=4)
+        return connection_info_data
+
+    def build_tbl_image(
+        self,
+        ti_sign_container,
+        dir_out_path,
+        device,
+        logging_level=logging.DEBUG,
+        slot=None,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+
+        tbl_image_builder = TBLImageBuilder(
+            ti_container_file_path=ti_sign_container,
+            abs_dir_out_path=dir_out_path,
+            device=device,
+            verbose=False,
+        )
+        tbl_image_builder.build()
+
+        base_file_name = "tbl_image"
+        if slot is not None:
+            base_file_name += f"_slot{slot}"
+
+        # save image
+        tbl_image_out_path = (
+            pathlib.Path(tbl_image_builder.abs_dir_out_path) / f"{base_file_name}.bin"
+        )
+        with open(tbl_image_out_path, "wb") as fb:
+            fb.write(tbl_image_builder.ti_image_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved ti bootloader image GPE bin file at {tbl_image_out_path}",
+        )
+
+        return tbl_image_out_path
+
+    def build_vendor_bl3_image(
+        self,
+        bl3_bin_path,
+        dir_out_path,
+        device,
+        version,
+        pub_key_path=None,
+        slot=None,
+        signing_mode="classic_rot",
+        logging_level=logging.DEBUG,
+    ):
+        """Build vendor BL3 image from binary file
+
+        Args:
+            bl3_bin_path: Path to vendor BL3 binary file
+            dir_out_path: Output directory path
+            device: Device type (CC35XX, CC35XXE, CC37XXR)
+            version: Image version (e.g., "1.0.0.0")
+            pub_key_path: Path to public key for VA TLV (optional)
+            slot: Target slot number (0 or 1), None for auto-naming
+            signing_mode: Signing mode ("classic_rot" or "multi_level")
+            logging_level: Logging level
+
+        Returns:
+            Path to built vendor BL3 image
+        """
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+
+        # Build vendor BL3 image
+        bl3_builder = BL3ImageBuilder(
+            bl3_out_file_path=bl3_bin_path,
+            abs_dir_out_path=str(dir_out_path),
+            version=version,
+            pub_key_path=pub_key_path,
+            device=device,
+            verbose=False,
+            signing_mode=signing_mode,
+        )
+
+        if not bl3_builder.build():
+            raise Exception("Failed to build vendor BL3 image")
+
+        base_file_name = "vendor_bl3_image"
+        if slot is not None:
+            base_file_name += f"_slot{slot}"
+
+        # save image with dummy sign
+        vendor_bl3_out_path_unsign = dir_out_path / f"{base_file_name}.unsign.bin"
+        with open(vendor_bl3_out_path_unsign, "wb") as fb:
+            fb.write(bl3_builder.bl3_image_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved vendor BL3 image with dummy signature bin file at {vendor_bl3_out_path_unsign}",
+        )
+
+        # save image to sign
+        vendor_bl3_out_path_for_sign = dir_out_path / f"{base_file_name}.forsign.bin"
+        with open(vendor_bl3_out_path_for_sign, "wb") as fb:
+            fb.write(bl3_builder.bl3_image_to_sign_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved part of vendor BL3 image bin file to sign at {vendor_bl3_out_path_for_sign}",
+        )
+
+        return vendor_bl3_out_path_unsign, vendor_bl3_out_path_for_sign
+
+    def sign_vendor_bl3_image(
+        self,
+        vendor_bl3_unsign_image,
+        vendor_bl3_forsign_image,
+        dir_out_path,
+        device,
+        private_key=None,
+        public_key=None,
+        activation_type=None,
+        signing_module=None,
+        signature_bin=None,
+        logging_level=logging.DEBUG,
+        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,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+        basename_vendor_unsign_image = str(
+            pathlib.Path(vendor_bl3_unsign_image).stem.split(".")[0]
+        )
+
+        if activation_type is not None:
+            private_key = None
+            public_key, signature_bin = self.fib_utility.get_public_key_and_signature(
+                activation_type,
+                signing_module,
+                vendor_bl3_forsign_image,
+                dir_out_path,
+                basename_vendor_unsign_image,
+                signing_mode,
+            )
+
+        # Build KEY_INFO_TLV for multi-level mode (before calling sign_gpe)
+        key_info_tlv_bin = None
+        if signing_mode == "multi_level" and signing_module:
+            key_info_tlv_bin = self.fib_utility.get_key_info_tlv(
+                signing_module_path=signing_module,
+                magic=magic,
+                key_info_version=key_info_version,
+                svn_policy_str=svn_policy,
+                svn=svn,
+                verbose=False,
+            )
+            if key_info_tlv_bin is None:
+                PROGRAMMER_UTILITY_LOGGER.log(
+                    logging_level,
+                    "Failed to build/get KEY_INFO_TLV for multi-level signing mode",
+                )
+                return None
+
+        # sign vendor bl3 image
+        vendor_bl3_image = GPEBuilder.sign_gpe(
+            unsign_image=vendor_bl3_unsign_image,
+            private_key=private_key,
+            signature_bin=signature_bin,
+            public_key=public_key,
+            log_level=logging.DEBUG,
+            device=device,
+            signing_mode=signing_mode,
+            key_info_tlv_bin=key_info_tlv_bin,
+        )
+
+        # save sign vendor image file
+        vendor_bl3_image_out_path = dir_out_path / (
+            basename_vendor_unsign_image + ".sign.bin"
+        )
+        with open(vendor_bl3_image_out_path, "wb") as f:
+            f.write(vendor_bl3_image)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved sign Vendor BL3 image bin file at {vendor_bl3_image_out_path}",
+        )
+
+        return vendor_bl3_image_out_path
+
+    def get_vendor_bl3_version(self, vendor_bl3_image_path, device_type):
+        """Extract version from vendor BL3 image
+
+        Args:
+            vendor_bl3_image_path: Path to vendor BL3 image
+            device_type: Device type enum
+
+        Returns:
+            Version string (e.g., "1.0.0.0") or "N/A" if cannot extract
+        """
+        try:
+            version = BL3ImageBuilder.get_image_version(
+                vendor_bl3_image_path, device=device_type
+            )
+            return version if version != "-1.-1.-1.-1" else "N/A"
+        except Exception as e:
+            PROGRAMMER_UTILITY_LOGGER.error(
+                f"Failed to extract version from vendor BL3 image: {e}"
+            )
+            return "N/A"
+
+    def build_boot_sector(
+        self,
+        programming_sign_image_path,
+        dir_out_path,
+        device_type,
+        version="0.0.1.0",
+        logging_level=logging.DEBUG,
+    ):
+        # build boot sector for initial programming
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+
+        boot_sector_builder = BootSectorFromImgBuilder(
+            image_file_path=programming_sign_image_path,
+            abs_dir_out_path=dir_out_path,
+            version=version,
+            device=device_type,
+            verbose=False,
+        )
+        boot_sector_builder.build()
+        boot_sector_path = boot_sector_builder.boot_sector_image_out_path
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level, f"Saved boot sector image file at {boot_sector_path}"
+        )
+
+        return boot_sector_path
+
+    def get_supported_devices_family_list(self, supported_devices):
+        ret = []
+        if any(
+            [device in ["CC350x", "CC355x", "CC356x"] for device in supported_devices]
+        ):
+            ret.append(CC35X1)
+
+        if any(
+            [
+                device in ["CC350xE", "CC355xE", "CC356xE"]
+                for device in supported_devices
+            ]
+        ):
+            ret.append(CC35X1E)
+
+        # if any([device in ["CC360xR"] for device in supported_devices]):
+        #     ret.append(CC360XR)
+
+        if any([device in ["CC370xR"] for device in supported_devices]):
+            ret.append(CC370XR)
+
+        if any(
+            [device in ["CC330x", "CC335x", "CC336x"] for device in supported_devices]
+        ):
+            ret.append(CC33XX)
+
+        return ret
+
+    def format_nested(self, obj):
+        if obj is None:
+            return "None"
+        elif isinstance(obj, dict):
+            if not obj:
+                return "None"
+            else:
+                return tabulate(
+                    [
+                        [k, self.format_nested(v)]
+                        for k, v in obj.items()
+                        if not k.startswith("_")
+                    ],
+                    tablefmt="grid",
+                )
+        else:
+            return str(obj)
+
+    def create_table_from_json(self, json_obj):
+        if not isinstance(json_obj, dict):
+            return self.format_nested(json_obj)
+        else:
+            table_data = [
+                [k, self.format_nested(v)]
+                for k, v in json_obj.items()
+                if not k.startswith("_")
+            ]
+            return tabulate(
+                table_data,
+                tablefmt="grid",
+                headers=["Key", "Value"],
+            )
+
+    def build_clean_image(
+        self, image_file_name, image_size, dir_out_path, logging_level=logging.DEBUG
+    ):
+        # build boot sector for initial programming
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+
+        clean_image_builder = CleanImageBuilder(
+            image_size=image_size,
+            image_file_name=image_file_name,
+            abs_dir_out_path=dir_out_path,
+            verbose=False if logging_level == logging.DEBUG else True,
+        )
+        clean_image_builder.build()
+        clean_image_path = clean_image_builder.clean_image_path
+
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level, f"Clean image file created at {clean_image_path}"
+        )
+
+        return clean_image_path
+
+    def build_wsoc_image(
+        self,
+        ti_sign_container,
+        dir_out_path,
+        device,
+        logging_level=logging.DEBUG,
+        slot=None,
+    ):
+        dir_out_path = pathlib.Path(dir_out_path).absolute()
+
+        wsoc_image_builder = WSOCImageBuilder(
+            ti_container_file_path=ti_sign_container,
+            abs_dir_out_path=dir_out_path,
+            device=device,
+            verbose=False,
+        )
+
+        wsoc_image_builder.build()
+
+        base_file_name = "ti_wireless_fw_image"
+        if slot is not None:
+            base_file_name += f"_slot{slot}"
+
+        # save image
+        wsoc_image_out_path = (
+            pathlib.Path(wsoc_image_builder.abs_dir_out_path) / f"{base_file_name}.bin"
+        )
+        with open(wsoc_image_out_path, "wb") as fb:
+            fb.write(wsoc_image_builder.ti_image_gpe_content_raw)
+        PROGRAMMER_UTILITY_LOGGER.log(
+            logging_level,
+            f"Saved TI Wireless FW image GPE bin file at {wsoc_image_out_path}",
+        )
+
+        return wsoc_image_out_path
+
+    def update_xspi_to_psram_type(self, xspi_json_path, psram_type, output_dir_path):
+        # create updated temp jsons depends on the psram type
+        with open(xspi_json_path, "r") as f:
+            xspi_data = json.load(f)
+
+        xspi_data["xspi_header"]["ram_name"] = psram_type
+
+        # save updated jsons
+        updated_xspi = join(output_dir_path, basename(xspi_json_path))
+
+        with open(updated_xspi, "w") as f:
+            json.dump(xspi_data, f, indent=4)
+
+        return updated_xspi
+
+    def check_if_file_exist_else_exit(self, key, path):
+        if not isfile(path):
+            PROGRAMMER_UTILITY_LOGGER.error(
+                f"ERROR: Path to {key} after path correction couldn't be found at {path}"
+            )
+            sys.exit(1)
+
+    def fix_paths_in_tool_settings(self, tool_settings_path):
+        tool_settings_path_obj = pathlib.Path(tool_settings_path)
+
+        if tool_settings_path_obj.is_absolute():
+            base_path = tool_settings_path_obj.parent
+        else:
+            base_path = pathlib.Path(getcwd())
+
+        mod_tool_settings = tool_settings_path.replace(".json", ".mod.json")
+
+        mod_tool_settings_content = json.load(open(tool_settings_path, "r"))
+
+        ## Fix path in programming_debug_and_ota_signed_components
+        if (
+            "programming_debug_and_ota_signed_components"
+            not in mod_tool_settings_content
+        ):
+            PROGRAMMER_UTILITY_LOGGER.error(
+                "ERROR: Provided tool_settings.json is incorrect format, 'programming_debug_and_ota_signed_components' is missing."
+            )
+            sys.exit(1)
+
+        programming_debug_and_ota_signed_components = mod_tool_settings_content[
+            "programming_debug_and_ota_signed_components"
+        ]
+
+        for key, value in programming_debug_and_ota_signed_components.items():
+            if type(value) is str and value != "":
+                p = pathlib.Path(value)
+                if not p.is_absolute():
+                    p = self.fix_path(str(p), alt_base_path=str(base_path))
+                    programming_debug_and_ota_signed_components[key] = p
+
+                self.check_if_file_exist_else_exit(key, str(p))
+
+            elif type(value) is dict:
+                for value_key, value_value in value.items():
+                    if type(value_value) is str and value_value != "":
+                        p = pathlib.Path(value_value)
+                        if not p.is_absolute():
+                            p = self.fix_path(str(p), alt_base_path=str(base_path))
+                            value[value_key] = p
+
+                        self.check_if_file_exist_else_exit(key, str(p))
+
+                    else:
+                        pass
+
+            else:
+                pass
+
+        json.dump(mod_tool_settings_content, open(mod_tool_settings, "w"), indent=4)
+
+        return mod_tool_settings
+
+    def dict_to_json(self, dict_data, json_file_path, indent=4):
+        with open(json_file_path, "w") as f:
+            json.dump(dict_data, f, indent=indent)
+
+    def enable_ota_supported(self, enable_ota):
+        """
+        Validates and converts the enable_ota parameter (0/1, "yes"/"no", True/False)
+        to a standardized integer flag (0 or 1).
+        """
+        VALID_OPTIONS = {
+            "yes": 1,
+            "no": 0,
+            "true": 1,
+            "false": 0,
+            1: 1,
+            0: 0,
+            True: 1,
+            False: 0,
+        }
+
+        # Handle string input (case-insensitive)
+        if isinstance(enable_ota, str):
+            input_lower = enable_ota.lower()
+            if input_lower in VALID_OPTIONS:
+                return VALID_OPTIONS[input_lower]
+
+        # Handle integer or boolean input
+        elif isinstance(enable_ota, (int, bool)):
+            if enable_ota in VALID_OPTIONS:
+                return VALID_OPTIONS[enable_ota]
+
+        # If none of the above match, raise an error
+        raise ValueError(
+            f"Invalid value for 'enable_ota': '{enable_ota}'. "
+            f"Expected 0, 1, True, False, 'yes', 'no', 'true', or 'false'."
+        )
+
+    def normalize_restrict_ini_hex_to_int(self, restrict_ini):
+        """
+        Validates that the input for 'restrict_ini' is a hex value (string or int),
+        ensures it fits within a 0 to 0xFFFFFFFF, and converts it to an integer.
+        """
+        if restrict_ini == "" or restrict_ini is None:
+            return 0
+
+        if isinstance(restrict_ini, int):
+            if 0 <= restrict_ini <= 0xFFFFFFFF:
+                return restrict_ini
+            else:
+                raise argparse.ArgumentTypeError(  # Changed from ValueError
+                    f"Integer value for 'restrict_ini' out of range (0 to 0xFFFFFFFF): {restrict_ini}"
+                )
+
+        if not isinstance(restrict_ini, str):
+            raise argparse.ArgumentTypeError(  # Changed from TypeError
+                f"Invalid input type for 'restrict_ini': {type(restrict_ini)}. Expected string or int."
+            )
+
+        restrict_ini = restrict_ini.upper()
+        restrict_ini_normalized_hex = restrict_ini.replace("0X", "")
+
+        if not re.fullmatch(r"^[0-9A-F]+$", restrict_ini_normalized_hex):
+            raise argparse.ArgumentTypeError(  # Changed from ValueError
+                f"Invalid hexadecimal characters in 'restrict_ini': '{restrict_ini}'"
+            )
+
+        try:
+            restrict_ini_int_value = int(restrict_ini_normalized_hex, 16)
+        except ValueError:
+            raise argparse.ArgumentTypeError(  # Changed from ValueError
+                f"Failed to convert 'restrict_ini' value '{restrict_ini}' to integer."
+            )
+
+        MAX_32BIT_VALUE = 0xFFFFFFFF
+        if restrict_ini_int_value > MAX_32BIT_VALUE or restrict_ini_int_value < 0:
+            raise argparse.ArgumentTypeError(  # Changed from ValueError
+                f"'restrict_ini' value out of range (0 to 0xFFFFFFFF). Value: 0x{restrict_ini_normalized_hex} (Decimal: {restrict_ini_int_value})."
+            )
+
+        return restrict_ini_int_value
+
+    def validate_hex(self, value, max_length):
+        """
+        Validate hex value.
+        - Must be hexadecimal characters only
+        - Validate max length of max_length hex characters
+        - Accepts with or without 0x prefix
+        - Returns normalized value with 0x prefix, or None if empty
+        """
+        if value is None or value == "":
+            return None
+
+        value_str = str(value)
+
+        # Check if it starts with 0x prefix
+        if value_str.lower().startswith("0x"):
+            hex_part = value_str[2:]
+        else:
+            hex_part = value_str
+
+        # Validate hexadecimal characters only
+        if not re.match(r"^[0-9a-fA-F]*$", hex_part):
+            raise argparse.ArgumentTypeError(
+                f"Invalid hexadecimal value '{value}'. Must contain only hexadecimal characters (0-9, a-f, A-F)."
+            )
+
+        # Check max length
+        if len(hex_part) > max_length:
+            raise argparse.ArgumentTypeError(
+                f"Invalid hexadecimal value '{value}'. Maximum length is {max_length} hexadecimal characters ({max_length * 4} bits), got {len(hex_part)} characters."
+            )
+
+        # Return normalized with 0x prefix
+        return "0x" + hex_part if hex_part else None
+
+    def convert_mac_to_int(self, mac_address):
+        """
+        Converts a string MAC address (e.g., "00:1A:2B:3C:4D:5E") into a 64-bit integer.
+        Accepts formats: XX:XX:XX:XX:XX:XX, XX-XX-XX-XX-XX-XX, or XXXXXXXXXXXX
+
+        Used by both CLI and REST API.
+        """
+
+        if mac_address == "":
+            return 0
+
+        # Remove any separators (':', '-', or '.') from the string
+        mac_address_clean = re.sub(r"[:\-.]", "", str(mac_address)).upper()
+
+        # Ensure the string is exactly 12 hexadecimal characters long
+        if len(mac_address_clean) != 12:
+            raise argparse.ArgumentTypeError(
+                f"Invalid MAC address length: '{mac_address}'. Must be 12 hexadecimal digits."
+            )
+
+        # Validate hex characters
+        if not re.match(r"^[0-9A-F]{12}$", mac_address_clean):
+            raise argparse.ArgumentTypeError(
+                f"Invalid MAC address: '{mac_address}'. Must contain only hexadecimal digits (0-9, A-F)."
+            )
+
+        try:
+            # Convert the hex string to an integer
+            mac_address_int = int(mac_address_clean, 16)
+            return mac_address_int
+        except ValueError:
+            raise argparse.ArgumentTypeError(
+                f"Failed to convert MAC address to integer: '{mac_address}'"
+            )
+
+    def normalize_wifi6_disable(self, wifi6_disable):
+        """
+        Validates and converts the wifi6_disable parameter (0/1 or "yes"/"no")
+        to a standardized integer flag (0 or 1).
+        """
+        VALID_OPTIONS = {"yes": 1, "no": 0, "1": 1, "0": 0, 1: 1, 0: 0}
+
+        if wifi6_disable == "":
+            return 0
+
+        if isinstance(wifi6_disable, str):
+            input_lower = wifi6_disable.lower()
+            if input_lower in VALID_OPTIONS:
+                return VALID_OPTIONS[input_lower]
+        elif isinstance(wifi6_disable, int):
+            if wifi6_disable in VALID_OPTIONS:
+                return VALID_OPTIONS[wifi6_disable]
+
+        raise ValueError(
+            f"Invalid value for 'wifi6_disable': '{wifi6_disable}'. "
+            f"Expected 0, 1, 'yes', or 'no'."
+        )
+
+    def is_valid_country_code(self, code):
+        """Check if country code is valid"""
+        if not code:
+            return False
+        return code.upper() in VALID_COUNTRY_CODES
+
+    def get_country_codes_list(self):
+        return COUNTRY_CODES_LIST
+
+    def calculate_device_country_code_int(self, country_code):
+        """
+        Converts a 2-char country code string to a 16-bit integer.
+        Validates against predefined list of supported country codes.
+        Args:
+            country_code: 2-letter country code (e.g., 'US', 'GB') or 0
+        Returns:
+            int: 16-bit integer representation (big-endian ASCII)
+        Examples:
+            'US' -> 21845 (0x5553)
+            'GB' -> 18242 (0x4742)
+            0 or '0' -> 0
+        """
+        # Handle zero/empty cases
+        if country_code in (0, -1, "0", "-1", "", None):
+            return 0
+
+        # Reject integer input (except 0)
+        if isinstance(country_code, int):
+            if country_code == 0:
+                return 0
+            raise argparse.ArgumentTypeError(
+                f"Country code must be a 2-letter string (e.g., US, GB), not integer: {country_code}"
+            )
+
+        # Validate type
+        if not isinstance(country_code, str):
+            raise argparse.ArgumentTypeError(
+                f"Invalid type: {type(country_code).__name__}. Expected 2-letter country code string."
+            )
+
+        # Validate length
+        if len(country_code) != 2:
+            raise argparse.ArgumentTypeError(
+                f"Invalid country code length: '{country_code}'. Must be exactly 2 letters.\n"
+                f"Examples: US, GB, FR, DE, JP, CN"
+            )
+
+        # Validate characters (only letters)
+        if not country_code.isalpha():
+            raise argparse.ArgumentTypeError(
+                f"Invalid characters in '{country_code}'. Only letters (A-Z) allowed."
+            )
+
+        # Convert to uppercase
+        country_code_upper = country_code.upper()
+
+        # Validate against supported country codes
+        if country_code_upper not in VALID_COUNTRY_CODES:
+            raise argparse.ArgumentTypeError(
+                f"Unsupported country code: '{country_code}'. "
+                f"Must be one of the supported codes (e.g., US, GB, FR, DE, JP, CN).\n"
+            )
+
+        if country_code_upper == "WW":
+            country_code_upper = "00"
+
+        # Calculate 16-bit integer (big-endian)
+        char1_ascii = ord(country_code_upper[0])
+        char2_ascii = ord(country_code_upper[1])
+        result = (char1_ascii << 8) | char2_ascii  # Changed to big-endian
+
+        return result
+
+    def split_mac_address(self, mac_address):
+        if isinstance(mac_address, str):
+            clean_mac = mac_address.replace(":", "").upper()
+            first_part = clean_mac[:8]
+            second_part = clean_mac[8:]
+
+            return int(first_part, 16), int(second_part, 16)
+
+        else:
+            mac_address_31_0 = mac_address & 0xFFFFFFFF
+            mac_address_47_32 = (mac_address >> 32) & 0xFFFF
+
+            return mac_address_31_0, mac_address_47_32