programmer-core 1.0.29__py3-none-any.whl

programmer_core/detect_flash_type.py

@@ -0,0 +1,316 @@
+"""
+Detect Flash Type Module
+
+This module provides functionality to detect the external flash type from a connected
+CC35XXE device. It handles the complete flow:
+1. Check connected devices (handle "auto" serial number)
+2. Download ti_programmer
+4. Read flash type from CFGAP registers
+5. Print the result
+"""
+
+import logging
+import time
+
+from communicator_core import (
+    Device,
+    BinaryDownloader,
+    CC3xxxRDeviceInfoReg,
+    DSSMStatus,
+    CC35XXE,
+    CC37XXR,
+)
+
+from flash_images_builder_core import (
+    UseHardware,
+    FLASH_DEVICE_SIZE_MAP,
+    FLASH_SIZE_MB_MAP,
+)
+
+from .utility import ProgrammerUtility, get_lifecycle_state_reg_class
+from .constants import TIMEOUT_POLLING_FLASH_DETECT
+
+# Logger for this module
+DETECT_FLASH_LOGGER = logging.getLogger("detect-flash-type-module")
+
+
+class DetectFlashType:
+    """
+    Class to detect the external flash type from a connected CC35XXE device.
+
+    This class handles the complete flow:
+    1. Check connected devices (handle "auto" serial number)
+    2. Download ti_programmer
+    4. Read flash type from CFGAP registers
+    5. Print the result
+    """
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        sysconfig=False,
+        jlink_speed_khz=None,
+    ):
+        """
+        Initialize the DetectFlashType instance.
+
+        Args:
+            interface_type: The interface type (e.g., "XDS110")
+            serial_number: The serial number of the XDS110 device, or "auto" to auto-select
+            programmer_artifacts_path: Path to the programmer artifacts directory
+            fib_artifacts_path: Path to the FIB artifacts directory
+            sysconfig: If True, show SysConfig-specific messages (when running from CCS)
+        """
+        self.interface_type = interface_type
+        self.serial_number = serial_number
+        self.device_type = None
+        self.result = None
+        self.sysconfig = sysconfig
+        self.jlink_speed_khz = jlink_speed_khz
+        self._lifecycle_reg_class = None  # Will be set when device_type is known
+        self.prog_utility = ProgrammerUtility(
+            programmer_artifacts_path, fib_artifacts_path
+        )
+
+    def detect(self):
+        """
+        Detect the external flash type from the connected device.
+
+        This is the main entry point that runs the complete detection flow:
+        1. Check connected devices (handle "auto" serial number)
+        2. Download ti_programmer
+        4. Read flash type from CFGAP registers
+        5. Print the result
+
+        Returns:
+            Tuple of (flash_type, flash_size_mb) - both None if not recognized
+
+        Raises:
+            Exception: If flash detection fails
+        """
+        DETECT_FLASH_LOGGER.info(
+            f"Starting flash type detection (SN: {self.serial_number})"
+        )
+
+        # Step 1: Check connected devices (handle "auto" serial number)
+        if self.serial_number.lower() == "auto":
+            if self.interface_type == Device.JLINK or self.interface_type == Device.CMSISDAP:
+                # For JLINK, "" means connect to the first available device
+                self.serial_number = ""
+            else:
+                DETECT_FLASH_LOGGER.debug("Checking connected XDS110 devices...")
+                connected_devices = Device.get_connected_xds110_devices()
+
+                if len(connected_devices) == 0:
+                    raise Exception(
+                        "No XDS110 devices found. Please connect a device and try again."
+                    )
+                elif len(connected_devices) > 1:
+                    # Multiple devices connected - print formatted box and exit
+                    self._print_multiple_devices_error(connected_devices)
+                    return None, None  # Signal to caller that detection should stop
+                else:
+                    # Only one device connected - use it
+                    self.serial_number = connected_devices[0]
+                    DETECT_FLASH_LOGGER.debug(f"Auto-selected device: {self.serial_number}")
+
+        # Step 2: Get device type and Check if device is CC35XXE - flash detection only supported on CC35XXE
+        DETECT_FLASH_LOGGER.debug("Getting device type...")
+        with Device(
+            interface_type=self.interface_type, serial_number=self.serial_number,
+        ) as dev:
+            self.device_type = dev.get_device_type()
+
+        if self.device_type is None:
+            raise Exception(
+                "Failed to detect device type. Please check the device connection."
+            )
+
+        if self.device_type not in [CC35XXE, CC37XXR]:
+            raise Exception(
+                f"Flash detection is only supported on CC35XXE/CC37XXR devices. "
+                f"Detected device type: {self.device_type}"
+            )
+
+        # Initialize device-specific lifecycle register class
+        self._lifecycle_reg_class = get_lifecycle_state_reg_class(self.device_type)
+
+        # Step 3: Download ti_programmer
+        path_to_ti_programmer = self.prog_utility.get_default_prog(self.device_type)
+        self._download_binary(path_to_ti_programmer, "TI programmer")
+
+        # Step 5: Read flash type from CFGAP registers
+        DETECT_FLASH_LOGGER.debug("Reading flash type from CFGAP registers...")
+        # Use device-specific register class
+        life_cycle_state_reg = self._lifecycle_reg_class(
+            interface=self.interface_type,
+            serial_number=self.serial_number,
+            verbose=False,
+        )
+
+        timeout = time.time() + TIMEOUT_POLLING_FLASH_DETECT
+        while time.time() < timeout:
+            life_cycle_state_reg.read_reg()
+            dssm_status = life_cycle_state_reg.dssm_status
+            if dssm_status == DSSMStatus.DSSM_READY:
+                break
+            time.sleep(0.05)
+
+        if self.device_type == CC37XXR:
+            life_cycle_state_reg.disconnect()
+            device_id_reg = CC3xxxRDeviceInfoReg(
+                interface=self.interface_type,
+                serial_number=self.serial_number,
+                verbose=False,
+            )
+            device_id_reg.read_reg()
+            flash_index = device_id_reg.external_flash_part_number_index
+            device_id_reg.disconnect()
+        else:
+            flash_index = life_cycle_state_reg.external_flash_part_number_index
+            life_cycle_state_reg.disconnect()
+
+        DETECT_FLASH_LOGGER.debug(f"Flash type index: 0x{flash_index:02X}")
+
+        # Check if flash detection failed (index = 0x3F)
+        if flash_index == 0x3F:
+            raise Exception(
+                "Flash detection failed. The device did not return a valid flash index. "
+            )
+
+        # Convert flash index to flash type name
+        flash_type = None
+        for ft in UseHardware:
+            if ft.value == flash_index:
+                flash_type = ft.name
+                break
+
+        # Check if the detected flash index is not in the enum (not supported)
+        if flash_type is None:
+            raise Exception(
+                f"Detected flash index 0x{flash_index:02X} is not supported. "
+            )
+
+        # Get flash size in MB
+        flash_size_mb = None
+        size_str = FLASH_DEVICE_SIZE_MAP.get(flash_type)
+        if size_str:
+            flash_size_mb = FLASH_SIZE_MB_MAP.get(size_str)
+
+        self.result = {
+            "flash_type": flash_type,
+            "flash_index": flash_index,
+            "flash_size_mb": flash_size_mb,
+        }
+
+        # Step 6: Print the result
+        self._print_result()
+
+        # Return flash type (None if not recognized)
+        return self.result["flash_type"], self.result["flash_size_mb"]
+
+    def _download_binary(self, path_to_binary, binary_name):
+        """
+        Download a binary to the device.
+
+        Args:
+            path_to_binary: Path to the binary file
+            binary_name: Name of the binary for logging
+
+        Raises:
+            Exception: If download fails
+        """
+        DETECT_FLASH_LOGGER.debug(f"{binary_name} path: {path_to_binary}")
+
+        binary_download = BinaryDownloader(
+            bin_file=path_to_binary,
+            interface_type=self.interface_type,
+            serial_number=self.serial_number,
+            tclk_delay=4,
+            chunk_size=1085,
+            jlink_speed_khz=self.jlink_speed_khz,
+        )
+
+        # Reset device and download binary
+        DETECT_FLASH_LOGGER.debug("Resetting device...")
+        binary_download.device.reset_device()
+
+        DETECT_FLASH_LOGGER.debug(f"Downloading {binary_name}...")
+        binary_download.daemon = True
+        binary_download.start()
+
+        while binary_download.is_alive():
+            binary_download.join(0.1)
+
+        error_code, error_msg = binary_download.download_status
+
+        if error_code <= 0:
+            raise Exception(f"Failed to download {binary_name}: {error_msg}")
+
+        DETECT_FLASH_LOGGER.debug(f"{binary_name} downloaded successfully")
+
+    def _print_multiple_devices_error(self, connected_devices):
+        """
+        Print a formatted error box when multiple XDS110 devices are connected.
+
+        Args:
+            connected_devices: List of connected device serial numbers
+        """
+        error_message = f"""
++==============================================================================+
+|                       MULTIPLE DEVICES DETECTED                              |
++==============================================================================+
+|                                                                              |
+|   Found {len(connected_devices)} XDS110 devices connected.                                          |
+|   Please specify the serial number of the device you want to use.            |
+|                                                                              |
+|   Connected devices:                                                         |
+"""
+        for sn in connected_devices:
+            error_message += f"|     - {sn:<71}|\n"
+
+        # Show SysConfig-specific message only when running from CCS
+        if self.sysconfig:
+            error_message += """|                                                                              |
+|   Set the serial number in SysConfig Memory Map section (Serial Number       |
+|   field)                                        |
+|                                                                              |
++==============================================================================+
+"""
+        else:
+            error_message += """|                                                                              |
+|   Use the -param1 argument to specify the serial number.                     |
+|                                                                              |
++==============================================================================+
+"""
+        DETECT_FLASH_LOGGER.error(error_message)
+
+    def _print_result(self):
+        """
+        Print the detection result in a formatted box.
+        At this point, flash detection has succeeded and flash_type is valid.
+        """
+        if self.result is None:
+            return
+
+        flash_type_display = self.result["flash_type"]
+        flash_size_display = (
+            f"{self.result['flash_size_mb']}MB"
+            if self.result["flash_size_mb"]
+            else "N/A"
+        )
+
+        result_message = f"""
+        +==============================================================================+
+        |                          FLASH DETECTION RESULT                              |
+        +==============================================================================+
+        |                                                                              |
+        |  Flash Type:  {flash_type_display:<63}|
+        |  Flash Size:  {flash_size_display:<63}|
+        |                                                                              |
+        +==============================================================================+
+"""
+        DETECT_FLASH_LOGGER.info(result_message)

programmer_core/enter_rma.py

@@ -0,0 +1,264 @@
+import logging
+import pathlib
+
+from communicator_core import (
+    BinaryDownloader,
+    DeviceLifeCycleNum,
+    DSSMStatus,
+    CC35XXE,
+)
+
+try:
+    from report import EnterRmaReportGeneratorCC35XXE, EnterRmaReportGeneratorCC35XX
+    from utility import ProgrammerUtility, TI_PROGRAMMER_CC35XX, TI_PROGRAMMER_CC35XXE, get_lifecycle_state_reg_class
+except ImportError:
+    from .report import EnterRmaReportGeneratorCC35XXE, EnterRmaReportGeneratorCC35XX
+    from .utility import ProgrammerUtility, TI_PROGRAMMER_CC35XX, TI_PROGRAMMER_CC35XXE, 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_RMA_LOGGER = logging.getLogger("enter_rma")
+
+
+class EnterRma:
+    SIMULATION = "DEMO"
+    XDS110 = "XDS110"
+
+    def __init__(
+        self,
+        interface_type,
+        serial_number,
+        rma_action_req_path,
+        programmer_artifacts_path,
+        fib_artifacts_path,
+        device_type,
+        report_file_path=None,
+        reset_on_timeout=True,
+        path_to_trm=None,
+        wait_timeout=1,
+        write_timeout=0,
+        wait_for_resp=True,
+        verbose=False,
+        tclk_delay=4,
+        chunk_size=1085,
+    ):
+        self.rma_action_req_path = rma_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_RMA_CC35XX = (
+            pathlib.Path(self.prog_utility.get_tbl_dir_path()) / TI_PROGRAMMER_CC35XX
+        )
+        PATH_TI_RMA_CC35XXE = (
+            pathlib.Path(self.prog_utility.get_tbl_dir_path()) / TI_PROGRAMMER_CC35XXE
+        )
+        self.path_to_trm = path_to_trm
+        if self.path_to_trm is None:
+            self.path_to_trm = (
+                PATH_TI_RMA_CC35XXE
+                if self.device_type == CC35XXE
+                else PATH_TI_RMA_CC35XX
+            )
+
+        self.report_file_path = (
+            report_file_path
+            if report_file_path
+            else (
+                pathlib.Path(self.rma_action_req_path).parent / "enter_rma_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.verbose = verbose
+        self.log_level = logging.INFO if verbose else logging.DEBUG
+        self.error_message = ""
+
+        if self.device_type == CC35XXE:
+            self.report_generator = EnterRmaReportGeneratorCC35XXE(
+                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 = EnterRmaReportGeneratorCC35XX(
+                programmer_artifacts_path=programmer_artifacts_path,
+                fib_artifacts_path=fib_artifacts_path,
+                report_file_path=self.report_file_path,
+                verbose=self.verbose,
+            )
+
+    def enter_rma(self):
+        if self.device_type is None:
+            PROGRAMMER_RMA_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_trm = self.prog_utility.fix_path(self.path_to_trm)
+        res = self.prog_utility.file_path_exist(self.path_to_trm, "TI RMA")
+        if res is not None:
+            self.error_message = res
+            PROGRAMMER_RMA_LOGGER.error(self.error_message)
+            return False
+
+        res = self.prog_utility.file_path_exist(self.rma_action_req_path, "rma_request")
+        if res is not None:
+            self.error_message = res
+            PROGRAMMER_RMA_LOGGER.error(self.error_message)
+            return False
+
+        #################################################
+        ##                     Step 1                  ##
+        ##   reset device and download TI Bootloader   ##
+        #################################################
+
+        tbl_download = BinaryDownloader(
+            bin_file=self.path_to_trm,
+            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,
+        )
+
+        # 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_RMA_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            PROGRAMMER_RMA_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 RMA' 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]
+
+            if life_cycle not in allowed_life_cycle:
+                self.error_message = f"Life cycle is not valid"
+                PROGRAMMER_RMA_LOGGER.log(
+                    self.log_level,
+                    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:
+                PROGRAMMER_RMA_LOGGER.log(
+                    self.log_level, f"Device is not ready for rma"
+                )
+                self.error_message = f"Device is not ready for rma"
+                return False
+
+        #################################################
+        ##                     Step 3                  ##
+        ##          download rma action req          ##
+        #################################################
+
+        rma_req_downloader = BinaryDownloader(
+            bin_file=self.rma_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,
+            verbose=self.verbose,
+            expected_resp_size=self.report_generator.get_report_struct_size(),
+            tclk_delay=self.tclk_delay,
+            chunk_size=self.chunk_size,
+        )
+        rma_req_downloader.daemon = True
+        rma_req_downloader.start()
+
+        while rma_req_downloader.is_alive():
+            rma_req_downloader.join(0.1)
+
+        error_code, error_msg = rma_req_downloader.download_status
+
+        if error_code > 0:
+            PROGRAMMER_RMA_LOGGER.log(self.log_level, "Successfully loaded binary")
+        else:
+            PROGRAMMER_RMA_LOGGER.log(
+                self.log_level,
+                f"Fail load binary with error code: {error_code}\nError message: {error_msg}",
+            )
+            self.error_message = f"Failed loading 'Rma Action Request'"
+            return False
+
+        #################################################
+        ##                     Step 4                  ##
+        ##    get response and print to the user       ##
+        #################################################
+
+        if self.wait_for_resp:
+
+            # get response
+            report_content_raw = rma_req_downloader.resp
+
+            # generate report
+            if not self.report_generator.generate_report(report_content_raw):
+                self.error_message = self.report_generator.error_message
+                return False
+
+            # check if rma entry done
+            if (
+                self.report_generator.report_container.enter_rma_response_content.rma_entry_done
+            ):
+                PROGRAMMER_RMA_LOGGER.log(
+                    self.log_level, f"Successfully enter rma mode"
+                )
+            else:
+                PROGRAMMER_RMA_LOGGER.log(self.log_level, f"failed to enter rma mode")
+                return False
+
+        return True