| # Copyright (c) 2023, Antmicro <www.antmicro.com> |
| # |
| # Based on J-Link runner |
| # Copyright (c) 2017 Linaro Limited. |
| # SPDX-License-Identifier: Apache-2.0 |
| |
| """ |
| Runner that implements flashing with SiLabs Simplicity Commander binary tool. |
| See SiLabs UG162: "Simplicity Commander Reference Guide" for more info. |
| """ |
| |
| import ipaddress |
| import os |
| import re |
| import shlex |
| |
| from runners.core import FileType, RunnerCaps, ZephyrBinaryRunner |
| |
| DEFAULT_APP = 'commander' |
| |
| def is_ip(ip): |
| if not ip: |
| return False |
| try: |
| ipaddress.ip_address(ip.split(':')[0]) |
| except ValueError: |
| return False |
| return True |
| |
| class SiLabsCommanderBinaryRunner(ZephyrBinaryRunner): |
| def __init__(self, cfg, device, dev_id, commander, dt_flash, erase, speed, tool_opt, |
| dev_id_type): |
| super().__init__(cfg) |
| self.file = cfg.file |
| self.file_type = cfg.file_type |
| self.hex_name = cfg.hex_file |
| self.bin_name = cfg.bin_file |
| self.elf_name = cfg.elf_file |
| self.device = device |
| self.dev_id = dev_id |
| self.commander = commander |
| self.dt_flash = dt_flash |
| self.erase = erase |
| self.speed = speed |
| self.dev_id_type = dev_id_type |
| |
| self.tool_opt = [] |
| for opts in [shlex.split(opt) for opt in tool_opt]: |
| self.tool_opt += opts |
| |
| @staticmethod |
| def _detect_dev_id_type(dev_id): |
| """Detect device type based on dev_id pattern.""" |
| if not dev_id: |
| return None |
| |
| # Check if dev_id is numeric (serialno) |
| if re.match(r'^[0-9]+$', dev_id): |
| return 'serialno' |
| |
| # Check if dev_id is an existing file (tty) |
| if os.path.exists(dev_id): |
| return 'tty' |
| |
| # Check if dev_id is a valid IPv4 |
| if is_ip(dev_id): |
| return 'ip' |
| |
| # No match found |
| return None |
| |
| @classmethod |
| def name(cls): |
| return 'silabs_commander' |
| |
| @classmethod |
| def capabilities(cls): |
| return RunnerCaps(commands={'flash'}, |
| dev_id=True, flash_addr=True, erase=True, |
| tool_opt=True, file=True) |
| |
| @classmethod |
| def dev_id_help(cls) -> str: |
| return '''Device identifier. Can be either a serial number (for a USB connection), a path |
| to a tty device, an IP address or a tunnel address. User can enforce the type of |
| the identifier with --dev-id-type. |
| If not specified, the first USB device detected is used. ''' |
| |
| @classmethod |
| def tool_opt_help(cls) -> str: |
| return "Additional options for Simplicity Commander, e.g. '--noreset'" |
| |
| @classmethod |
| def do_add_parser(cls, parser): |
| # Required: |
| parser.add_argument('--device', required=True, |
| help='device part number') |
| |
| # Optional: |
| parser.add_argument('--commander', default=DEFAULT_APP, |
| help='path to Simplicity Commander executable') |
| parser.add_argument('--speed', default=None, |
| help='JTAG/SWD speed to use') |
| parser.add_argument('--dev-id-type', choices=['auto', 'serialno', 'tty', 'ip'], |
| default='auto', help='Device type. "auto" (default) auto-detects ' |
| 'the type, or specify explicitly') |
| |
| @classmethod |
| def do_create(cls, cfg, args): |
| return SiLabsCommanderBinaryRunner( |
| cfg, args.device, |
| dev_id=args.dev_id, |
| commander=args.commander, |
| dt_flash=args.dt_flash, |
| erase=args.erase, |
| speed=args.speed, |
| tool_opt=args.tool_opt, |
| dev_id_type=args.dev_id_type) |
| |
| def do_run(self, command, **kwargs): |
| self.require(self.commander) |
| |
| opts = ['--device', self.device] |
| if self.erase: |
| opts.append('--masserase') |
| if self.dev_id: |
| # Determine dev_id_type |
| if self.dev_id_type == 'auto': |
| # Auto-detect device type |
| detected_type = self._detect_dev_id_type(self.dev_id) |
| else: |
| # Use manually specified device type |
| detected_type = self.dev_id_type |
| |
| # Add appropriate option based on device type |
| if detected_type == 'serialno': |
| opts.extend(['--serialno', self.dev_id]) |
| elif detected_type == 'tty': |
| opts.extend(['--identifybyserialport', self.dev_id]) |
| elif detected_type == 'ip': |
| opts.extend(['--ip', self.dev_id]) |
| else: |
| # Fallback to legacy behavior (serialno) |
| opts.extend(['--serialno', self.dev_id]) |
| self.logger.warning(f'"{self.dev_id}" does not match any known pattern') |
| |
| if self.speed is not None: |
| opts.extend(['--speed', self.speed]) |
| |
| # Get the build artifact to flash |
| |
| if self.dt_flash: |
| flash_addr = self.flash_address_from_build_conf(self.build_conf) |
| else: |
| flash_addr = 0 |
| |
| if self.file is not None: |
| # use file provided by the user |
| if not os.path.isfile(self.file): |
| raise ValueError(f'Cannot flash; file ({self.file}) not found') |
| |
| flash_file = self.file |
| |
| if self.file_type == FileType.HEX: |
| flash_args = [flash_file] |
| elif self.file_type == FileType.BIN: |
| flash_args = ['--binary', '--address', f'0x{flash_addr:x}', flash_file] |
| else: |
| raise ValueError('Cannot flash; this runner only supports hex and bin files') |
| |
| else: |
| # use hex or bin file provided by the buildsystem, preferring .hex over .bin |
| if self.hex_name is not None and os.path.isfile(self.hex_name): |
| flash_file = self.hex_name |
| flash_args = [flash_file] |
| elif self.bin_name is not None and os.path.isfile(self.bin_name): |
| flash_file = self.bin_name |
| flash_args = ['--binary', '--address', f'0x{flash_addr:x}', flash_file] |
| else: |
| raise ValueError(f'Cannot flash; no hex ({self.hex_name}) or ' |
| f'bin ({self.bin_name}) files found.') |
| |
| args = [self.commander, 'flash'] + opts + self.tool_opt + flash_args |
| |
| self.logger.info(f'Flashing file: {flash_file}') |
| self.check_call(args) |
