west: runners: probe-rs: Add enhanced functionality

Add comprehensive enhancements to the probe-rs runner:

- New parameters: --reset, --protocol, --speed, --verify, etc
- RTT logging support via 'attach' command
- Smart binary format detection with FileType support
- Enhanced debug/debugserver with improved GDB integration
- Conditional reset after flashing instead of always resetting

Maintains upstream compatibility while significantly expanding
probe-rs capabilities for embedded development workflows.

Signed-off-by: Jared Wolff <hello@jaredwolff.com>

Author: jaredwolff

scripts/west_commands/runners/probe_rs.py

@@ -3,7 +3,7 @@
 
 '''Runner for probe-rs.'''
 
-from runners.core import RunnerCaps, ZephyrBinaryRunner
+from runners.core import FileType, RunnerCaps, ZephyrBinaryRunner
 
 DEFAULT_PROBE_RS_GDB_HOST = 'localhost'
 DEFAULT_PROBE_RS_GDB_PORT = 1337
@@ -17,22 +17,46 @@ def __init__(self, cfg, chip,
                  gdb_port=DEFAULT_PROBE_RS_GDB_PORT,
                  dev_id=None,
                  erase=False,
+                 reset=False,
+                 protocol='swd',
+                 speed=None,
+                 connect_under_reset=False,
+                 verify=False,
+                 binary_format='elf',
                  tool_opt=None):
         super().__init__(cfg)
 
         self.probe_rs = probe_rs
         self.erase = erase
+        self.reset = reset
+        self.protocol = protocol
+        self.speed = speed
+        self.connect_under_reset = connect_under_reset
+        self.verify = verify
+        self.binary_format = binary_format
 
         self.args = ['--chip', chip]
 
         if dev_id is not None:
             self.args += ['--probe', dev_id]
 
+        if protocol != 'swd':
+            self.args += ['--protocol', protocol]
+
+        if speed is not None:
+            self.args += ['--speed', str(speed)]
+
+        if connect_under_reset:
+            self.args += ['--connect-under-reset']
+
         if tool_opt is not None:
             self.args += tool_opt
 
+        self.file = cfg.file
+        self.file_type = cfg.file_type
         self.elf_name = cfg.elf_file
 
+        # GDB configuration (upstream compatible)
         self.gdb_cmd = cfg.gdb
         self.gdb_host = gdb_host
         self.gdb_port = gdb_port
@@ -43,23 +67,33 @@ def name(cls):
 
     @classmethod
     def capabilities(cls):
-        return RunnerCaps(commands={'flash', 'debug', 'debugserver'},
+        return RunnerCaps(commands={'flash', 'debug', 'debugserver', 'attach'},
                           dev_id=True,
                           erase=True,
-                          tool_opt=True)
+                          reset=True,
+                          tool_opt=True,
+                          rtt=True,
+                          file=True)
 
     @classmethod
     def do_add_parser(cls, parser):
         parser.add_argument('--chip', required=True,
                             help='chip name')
         parser.add_argument('--probe-rs', default='probe-rs',
                             help='path to probe-rs tool, default is probe-rs')
+        parser.add_argument('--protocol', choices=['swd', 'jtag'], default='swd',
+                            help='debug protocol to use (swd or jtag)')
+        parser.add_argument('--speed', type=int,
+                            help='protocol speed in kHz')
+        parser.add_argument('--connect-under-reset', action='store_true',
+                            help='connect under reset')
+        parser.add_argument('--verify', action='store_true',
+                            help='verify flash after programming')
         parser.add_argument('--gdb-host', default=DEFAULT_PROBE_RS_GDB_HOST,
                             help=f'probe-rs gdb host, defaults to {DEFAULT_PROBE_RS_GDB_HOST}')
-        parser.add_argument('--gdb-port', default=DEFAULT_PROBE_RS_GDB_PORT,
+        parser.add_argument('--gdb-port', type=int, default=DEFAULT_PROBE_RS_GDB_PORT,
                             help=f'probe-rs gdb port, defaults to {DEFAULT_PROBE_RS_GDB_PORT}')
 
-
     @classmethod
     def dev_id_help(cls) -> str:
         return '''select a specific probe, in the form `VID:PID:<Serial>`'''
@@ -69,12 +103,36 @@ def tool_opt_help(cls) -> str:
         return '''additional options for probe-rs,
                   e.g. --chip-description-path=/path/to/chip.yml'''
 
+    @classmethod
+    def _get_binary_format_from_args(cls, args):
+        '''Determine binary format from args.'''
+        if args.file_type:
+            # Map FileType to probe-rs format names
+            format_map = {
+                FileType.HEX: 'hex',
+                FileType.BIN: 'bin',
+                FileType.ELF: 'elf'
+            }
+            return format_map.get(args.file_type, 'elf')
+        elif args.file and args.file.endswith('.hex'):
+            return 'hex'
+        else:
+            return 'elf'
+
     @classmethod
     def do_create(cls, cfg, args):
         return ProbeRsBinaryRunner(cfg, args.chip,
                                    probe_rs=args.probe_rs,
                                    dev_id=args.dev_id,
                                    erase=args.erase,
+                                   reset=args.reset,
+                                   protocol=args.protocol,
+                                   speed=args.speed,
+                                   connect_under_reset=args.connect_under_reset,
+                                   verify=args.verify,
+                                   gdb_host=args.gdb_host,
+                                   gdb_port=args.gdb_port,
+                                   binary_format=cls._get_binary_format_from_args(args),
                                    tool_opt=args.tool_opt)
 
     def do_run(self, command, **kwargs):
@@ -83,24 +141,53 @@ def do_run(self, command, **kwargs):
             self.do_flash(**kwargs)
         elif command in ('debug', 'debugserver'):
             self.do_debug_debugserver(command, **kwargs)
+        elif command == 'attach':
+            self.do_attach(**kwargs)
 
     def do_flash(self, **kwargs):
         download_args = []
         if self.erase:
             download_args += ['--chip-erase']
-        download_args += [self.elf_name]
+        if self.verify:
+            download_args += ['--verify']
+        # Use provided file or default ELF file
+        flash_file = self.file if self.file else self.elf_name
+        # Determine format based on file_type or binary_format
+        if self.file_type:
+            format_map = {
+                FileType.HEX: 'hex',
+                FileType.BIN: 'bin',
+                FileType.ELF: 'elf'
+            }
+            flash_format = format_map.get(self.file_type, 'elf')
+        else:
+            flash_format = self.binary_format
+        download_args += ['--binary-format', flash_format, flash_file]
 
         self.check_call([self.probe_rs, 'download']
                         + self.args + download_args)
 
-        self.check_call([self.probe_rs, 'reset']
-                        + self.args)
+        if self.reset:
+            self.check_call([self.probe_rs, 'reset']
+                            + self.args)
 
     def do_debug_debugserver(self, command, **kwargs):
+        '''Start GDB server or debug session using probe-rs gdb command.'''
         debug_args = ['--gdb-connection-string', f"{self.gdb_host}:{self.gdb_port}"]
         if command == 'debug':
+            if self.gdb_cmd is None:
+                raise ValueError('Cannot debug; gdb is missing')
             debug_args += [self.elf_name]
             debug_args += ['--gdb', self.gdb_cmd]
+        else:
+            # debugserver mode
+            self.logger.info(f'probe-rs GDB server running on port {self.gdb_port}')
 
         self.check_call([self.probe_rs, 'gdb']
                         + self.args + debug_args)
+
+    def do_attach(self, **kwargs):
+        '''Attach to RTT logging using probe-rs attach command.'''
+        attach_cmd = [self.probe_rs, 'attach'] + self.args + [self.elf_name]
+        self.logger.info('Starting RTT session')
+        self.check_call(attach_cmd)