programmer-core 1.0.29__py3-none-any.whl

programmer_core/__init__.py

@@ -0,0 +1,22 @@
+from .constants import CFGAP_OFFSET, REPORT_TYPE, WAIT_FOR_ERASE
+from .adapters import BaseAdapter, UDID
+from .activate_device import ActivateDevice
+from .utility import *
+from .debug_device import DebugDevice
+from .program_device import ProgramDevice
+from .full_flash_erase import FullFlashErase
+from .query_device import QueryDevice
+from .enter_rma import EnterRma
+from .factory_program_device import FactoryProgramDevice
+from .partial_fuse_programming import PartialFuseProgramming
+from .memory_validation_test import MemoryValidationTest
+from .detect_flash_type import DetectFlashType
+from .get_fuse_data import GetFuseData
+from .report import (
+    ProgrammingReportGeneratorCC35XX,
+    ProgrammingReportGeneratorCC35XXE,
+    QueryReportGeneratorCC35XX,
+    QueryReportGeneratorCC35XXE,
+    EnterRmaReportGeneratorCC35XX,
+    EnterRmaReportGeneratorCC35XXE,
+)

programmer_core/activate_device.py

@@ -0,0 +1,246 @@
+import logging
+import pathlib
+
+from communicator_core import (
+    BinaryDownloader,
+    DeviceLifeCycleNum,
+    DSSMStatus,
+    CC35XXE,
+    CC37XXR,
+)
+
+try:
+    from report import (
+        ProgrammingReportGeneratorCC35XXE,
+        ProgrammingReportGeneratorCC35XX,
+    )
+    from utility import ProgrammerUtility, get_lifecycle_state_reg_class
+except ImportError:
+    from .report import (
+        ProgrammingReportGeneratorCC35XXE,
+        ProgrammingReportGeneratorCC35XX,
+    )
+    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_ACTIVATE_LOGGER = logging.getLogger("activate")
+
+
+# note: 0x4110295c - hw life cycle address
+class ActivateDevice:
+    SIMULATION = "DEMO"
+    XDS110 = "XDS110"
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        prog_inst_image_path,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        device_type,
+        report_file_path=None,
+        reset_on_timeout=True,
+        path_to_tac=None,
+        wait_timeout=2,
+        write_timeout=0,
+        wait_for_resp=True,
+        verbose=False,
+        tclk_delay=4,
+        chunk_size=1085,
+        jlink_speed_khz=None,
+    ):
+        self.prog_utility = ProgrammerUtility(
+            programmer_artifacts_path, fib_artifacts_path
+        )
+        self.prog_inst_image_path = prog_inst_image_path
+        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)
+        self.path_to_tac = path_to_tac
+        if self.path_to_tac is None:
+            self.path_to_tac = self.prog_utility.get_default_activator(self.device_type)
+
+        self.report_file_path = (
+            report_file_path
+            if report_file_path
+            else (
+                pathlib.Path(self.prog_inst_image_path).parent / "activation_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.wait_for_resp = wait_for_resp
+
+        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 = ""
+
+        # 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,
+            )
+
+    def activate(self):
+
+        #################################################
+        ##                     Step 0                  ##
+        ##          check that all files exist         ##
+        #################################################
+
+        self.path_to_tac = self.prog_utility.fix_path(self.path_to_tac)
+        res = self.prog_utility.file_path_exist(self.path_to_tac, "TI Activation")
+        if res is not None:
+            self.error_message = res
+            PROGRAMMER_ACTIVATE_LOGGER.error(self.error_message)
+            return False
+        #################################################
+        ##                     Step 1                  ##
+        ##   reset device and download TI Bootloader   ##
+        #################################################
+
+        tbl_download = BinaryDownloader(
+            bin_file=self.path_to_tac,
+            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
+        tbl_download.device.reset_device()
+
+        # Download TI bootloader
+        tbl_download.daemon = True
+        tbl_download.start()
+
+        while tbl_download.is_alive():
+            tbl_download.join(0.1)
+
+        error_code, error_msg = tbl_download.download_status
+
+        if error_code > 0:
+            PROGRAMMER_ACTIVATE_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            self.error_message = f"Failed loading 'TI Activator' image"
+            PROGRAMMER_ACTIVATE_LOGGER.error(
+                f"Fail load binary with error code: {error_code}\nError message: {error_msg}"
+            )
+            return False
+
+        #################################################
+        ##                     Step 2                  ##
+        ## read CFGAP and check life-cycle/DSSM 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=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.OPERATIONAL,
+                DeviceLifeCycleNum.RMA_HW_ANALYSIS,
+                DeviceLifeCycleNum.RMA_FAILIURE_ANALYSIS,
+            ]
+            if life_cycle not in allowed_life_cycle:
+                self.error_message = "Life cycle is not valid"
+                PROGRAMMER_ACTIVATE_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 activation"
+                PROGRAMMER_ACTIVATE_LOGGER.error(self.error_message)
+                return False
+
+        #################################################
+        ##                     Step 3                  ##
+        ##         download programming image          ##
+        #################################################
+
+        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=self.wait_for_resp,
+            verbose=self.verbose,
+            expected_resp_size=self.report_generator.get_report_struct_size(),
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_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_ACTIVATE_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            self.error_message = f"Failed loading 'Programming Instruction' image"
+            PROGRAMMER_ACTIVATE_LOGGER.error(
+                f"Failed loading binary with error code: {error_code}\nError message: {error_msg}"
+            )
+            return False
+
+        #################################################
+        ##                     Step 4                  ##
+        ##    get response and print to the user       ##
+        #################################################
+
+        if self.wait_for_resp:
+
+            # get response
+            report_content_raw = prog_inst_downloader.resp
+
+            # generate report
+            if not self.report_generator.generate_report(report_content_raw):
+                self.error_message = self.report_generator.error_message
+                return False
+
+        return True

programmer_core/adapters.py

@@ -0,0 +1,23 @@
+from construct import Adapter
+
+
+class BaseAdapter(Adapter):
+    def _reverse_endian_obj(self, obj):
+        little_hex = bytearray.fromhex(obj)
+        little_hex.reverse()
+        str_little = "".join(format(x, "02x") for x in little_hex)
+
+        return str_little
+
+
+class UDID(BaseAdapter):
+    def _decode(self, obj, ctx, path):
+        str_little = "".join(map(lambda x: "%02x" % x, obj))
+        str_big = self._reverse_endian_obj(str_little)
+        return f"{str_big[:4]}-{str_big[4:8]}-{str_big[8:12]}-{str_big[12:16]}"
+
+    def _encode(self, obj, context, path):
+        obj = obj.replace("-", "")
+        str_little = self._reverse_endian_obj(obj)
+        obj_list = [str_little[i : i + 2] for i in range(0, len(str_little), 2)]
+        return list(map(lambda x: int(x, 16), obj_list))

programmer_core/constants.py

@@ -0,0 +1,50 @@
+import enum
+from construct import Byte, Enum, Int8ul
+
+
+# CFGAP
+class CFGAP_OFFSET(enum.IntEnum):
+    device_id_reg = 0x00
+    device_ext_info_reg = 0x04
+    debug_ss_version_reg = 0x08
+    sys_reg = 0x0C
+    device_info_reg = 0x10
+    life_cycle_state_reg = 0x14
+    dft_en_reg = 0x18
+    reset_req_reg = 0x1C
+    unique_device_id_reg_low = 0x28
+    unique_device_id_reg_high = 0x2C
+
+
+# report type
+class REPORT_TYPE(enum.IntEnum):
+    programming_pg1 = 0x01
+    query_pg1 = 0x02
+    debug_pg1 = 0x03
+    enter_rma_pg1 = 0x04
+    programming_pg2 = 0x16
+    query_pg2 = 0x17
+    debug_pg2 = 0x18
+    enter_rma_pg2 = 0x19
+    memory_validation_pg2 = 0x20
+
+
+# flash image header
+FLASH_IMAGE_HEADER = 12
+FLASH_DISCOVERY_CONF_SIZE_CC35XX = 844
+FLASH_DISCOVERY_CONF_SIZE_CC35XXE = 880
+
+
+# flash status for erase flow
+class FLASH_STATUS(enum.IntEnum):
+    ready_for_request = 0x00
+    ready_for_header = 0x01
+    erase_in_progress = 0x02
+    ready_for_content = 0x03
+
+
+# wait for erase - max time
+WAIT_FOR_ERASE = 110
+
+# Timeout for polling flash detection (in seconds)
+TIMEOUT_POLLING_FLASH_DETECT = 5

programmer_core/debug_device.py

@@ -0,0 +1,278 @@
+import logging
+import pathlib
+import time
+
+from communicator_core import (
+    BinaryDownloader,
+    DeviceLifeCycleNum,
+    DSSMStatus,
+    CC35XXE,
+    CC37XXR,
+)
+
+try:
+    from utility import (
+        ProgrammerUtility,
+        TI_DEBUG_CC35XXE,
+        TI_DEBUG_CC35XX,
+        TI_DEBUG_CC37XXR,
+        get_lifecycle_state_reg_class,
+    )
+except ImportError:
+    from .utility import (
+        ProgrammerUtility,
+        TI_DEBUG_CC35XXE,
+        TI_DEBUG_CC35XX,
+        TI_DEBUG_CC37XXR,
+        get_lifecycle_state_reg_class,
+    )
+
+# uncomment for debug communicator code without build pakage 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_DEBUG_LOGGER = logging.getLogger("debug")
+
+
+class DebugDevice:
+    SIMULATION = "DEMO"
+    XDS110 = "XDS110"
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        debug_action_req_path,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        device_type,
+        report_file_path=None,
+        reset_on_timeout=True,
+        path_to_tdb=None,
+        wait_timeout=1,
+        write_timeout=0,
+        wait_for_resp=False,
+        execution_busy_timeout=10,
+        tclk_delay=4,
+        chunk_size=1085,
+        verbose=False,
+    ):
+        self.debug_action_req_path = debug_action_req_path
+        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)
+
+        self.prog_utility = ProgrammerUtility(
+            programmer_artifacts_path, fib_artifacts_path
+        )
+        PATH_TI_DEBUG_CC35XX = (
+            pathlib.Path(self.prog_utility.get_tbl_dir_path()) / TI_DEBUG_CC35XX
+        )
+        PATH_TI_DEBUG_CC35XXE = (
+            pathlib.Path(self.prog_utility.get_tbl_dir_path()) / TI_DEBUG_CC35XXE
+        )
+        PATH_TI_DEBUG_CC37XXR = (
+            pathlib.Path(self.prog_utility.get_tbl_dir_path()) / TI_DEBUG_CC37XXR
+        )
+
+        self.path_to_tdb = path_to_tdb
+
+        if self.path_to_tdb is None:
+            if self.device_type == CC35XXE:
+                self.path_to_tdb = PATH_TI_DEBUG_CC35XXE
+            elif self.device_type == CC37XXR:
+                self.path_to_tdb = PATH_TI_DEBUG_CC37XXR
+            else:
+                self.path_to_tdb = PATH_TI_DEBUG_CC35XX
+
+        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.wait_for_resp = wait_for_resp
+        # wait until device execution done
+        self.execution_busy_timeout = execution_busy_timeout
+        self.tclk_delay = tclk_delay
+        self.chunk_size = chunk_size
+
+        self.verbose = verbose
+        self.log_level = logging.INFO if verbose else logging.DEBUG
+        self.error_message = ""
+
+    def debug(self):
+        if self.device_type is None:
+            PROGRAMMER_DEBUG_LOGGER.error("Failed to get device type")
+            self.error_message = "Failed to get device type"
+            return False
+        #################################################
+        ##                     Step 0                  ##
+        ##          check that all files exist         ##
+        #################################################
+
+        self.path_to_tdb = self.prog_utility.fix_path(self.path_to_tdb)
+
+        res = self.prog_utility.file_path_exist(self.path_to_tdb, "TI Debug")
+        if res is not None:
+            self.error_message = res
+            PROGRAMMER_DEBUG_LOGGER.error(self.error_message)
+            return False
+
+        self.debug_action_req_path = self.prog_utility.fix_path(
+            self.debug_action_req_path
+        )
+
+        res = self.prog_utility.file_path_exist(
+            self.debug_action_req_path, "debug_request"
+        )
+        if res is not None:
+            self.error_message = res
+            PROGRAMMER_DEBUG_LOGGER.error(self.error_message)
+            return False
+
+        #################################################
+        ##                     Step 1                  ##
+        ##   reset device and download TI Bootloader   ##
+        #################################################
+
+        tbl_download = BinaryDownloader(
+            bin_file=self.path_to_tdb,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            wait_timeout=self.wait_timeout,
+            write_timeout=self.write_timeout,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            verbose=self.verbose,
+        )
+
+        # reset device
+        tbl_download.device.reset_device()
+
+        # Download TI bootloader
+        tbl_download.daemon = True
+        tbl_download.start()
+
+        while tbl_download.is_alive():
+            tbl_download.join(0.1)
+
+        error_code, error_msg = tbl_download.download_status
+
+        if error_code > 0:
+            PROGRAMMER_DEBUG_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            PROGRAMMER_DEBUG_LOGGER.log(
+                self.log_level,
+                f"Fail load binary with error code: {error_code}\nError message: {error_msg}",
+            )
+            self.error_message = f"Failed loading 'TI Debug' image"
+            return False
+
+        #################################################
+        ##                     Step 2                  ##
+        ## read CFGAP and check life-cycle/dssm 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=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:
+                PROGRAMMER_DEBUG_LOGGER.log(
+                    self.log_level,
+                    f"Process is stopped. Life cycle  {DeviceLifeCycleNum(life_cycle).name} is not valid.",
+                )
+                self.error_message = f"Life cycle is not valid"
+                return False
+
+            # Check if dssm status is DSSM_READY
+            if not dssm_status == DSSMStatus.DSSM_READY:
+                PROGRAMMER_DEBUG_LOGGER.log(
+                    self.log_level, f"Device is not ready for debug"
+                )
+                self.error_message = f"Device is not ready for debug"
+                return False
+
+        #################################################
+        ##                     Step 3                  ##
+        ##          download debug action req          ##
+        #################################################
+
+        debug_req_downloader = BinaryDownloader(
+            bin_file=self.debug_action_req_path,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            wait_timeout=self.wait_timeout,
+            write_timeout=self.write_timeout,
+            wait_for_resp=self.wait_for_resp,
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+            verbose=self.verbose,
+        )
+        debug_req_downloader.daemon = True
+        debug_req_downloader.start()
+
+        while debug_req_downloader.is_alive():
+            debug_req_downloader.join(0.1)
+
+        error_code, error_msg = debug_req_downloader.download_status
+
+        if error_code > 0:
+            PROGRAMMER_DEBUG_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            PROGRAMMER_DEBUG_LOGGER.log(
+                self.log_level,
+                f"Fail load binary with error code: {error_code}\nError message: {error_msg}",
+            )
+            self.error_message = f"Failed loading 'Debug Action Request'"
+            return False
+
+        # check execution busy
+        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()
+            execution_busy = life_cycle_state_reg.execution_busy
+
+            timeout_time = time.perf_counter() + self.execution_busy_timeout
+            timeout_occur = time.perf_counter() > timeout_time
+            # Wait until execution_busy != 1 or if timeout occure
+            while execution_busy == 1 and not timeout_occur:
+                life_cycle_state_reg.read_reg()
+                execution_busy = life_cycle_state_reg.execution_busy
+                timeout_occur = time.perf_counter() > timeout_time
+                time.sleep(0.01)
+
+            life_cycle_state_reg.disconnect()
+            if timeout_occur and execution_busy == 1:
+                PROGRAMMER_DEBUG_LOGGER.error(
+                    f"Timeout occur while waiting for acknowledge from device before move to execution"
+                )
+                self.error_message = "Timeout occur while waiting for acknowledge from device before move to execution"
+                return False
+
+        PROGRAMMER_DEBUG_LOGGER.log(self.log_level, f"Successfully start debug mode")
+
+        return True