load: improve programming of multiple files (#1831)

- fix bug where smart flash was not used for pack targets
- change loading reset mechanism: selected reset and halt before programming and reset using nSRST at the end
- flash algorithm extra symbols are added only if they exist in the binary
- builder: do init and uninit only once for all pages in a sector
- load: handle reset sequence for multi-core devices

Author: TeoMahnic

pyocd/flash/builder.py

@@ -845,20 +845,20 @@ def _sector_erase_program(self, progress_cb=_stub_progress):
 
                 # The sector was erased, so we must program all pages in the sector
                 # regardless of whether they were the same or not.
+                self.flash.init(self.flash.Operation.PROGRAM)
                 for page in sector.page_list:
 
                     progress += page.get_program_weight()
 
-                    self.flash.init(self.flash.Operation.PROGRAM)
                     self.flash.program_page(page.addr, page.data)
-                    self.flash.uninit()
 
                     actual_sector_erase_count += 1
                     actual_sector_erase_weight += page.get_program_weight()
 
                     # Update progress
                     if self.sector_erase_weight > 0:
                         progress_cb(float(progress) / float(self.sector_erase_weight))
+                self.flash.uninit()
 
         progress_cb(1.0)
 

pyocd/flash/flash.py

@@ -199,7 +199,7 @@ def region(self, flashRegion):
         assert flashRegion.is_flash
         self._region = flashRegion
 
-    def init(self, operation, address=None, clock=0, reset=True):
+    def init(self, operation, address=None, clock=0, reset=False):
         """@brief Prepare the flash algorithm for performing operations.
 
         First, the target is prepared to execute flash algo operations, including loading the algo

pyocd/subcommands/load_cmd.py

@@ -22,6 +22,7 @@
 
 from .base import SubcommandBase
 from ..core.helpers import ConnectHelper
+from ..core.target import Target
 from ..flash.file_programmer import FileProgrammer
 from ..utility.cmdline import (
     convert_session_options,
@@ -106,7 +107,21 @@ def invoke(self) -> int:
             programmer = FileProgrammer(session,
                             chip_erase=self._args.erase,
                             trust_crc=self._args.trust_crc,
-                            no_reset=self._args.no_reset)
+                            no_reset=True)  # We handle this reset below
+
+            # Get a list of all secondary cores.
+            secondary_cores = [c for c in session.target.cores.values() if c != session.target.primary_core]
+            try:
+                # Set reset catch for all secondary cores.
+                for core in secondary_cores:
+                    core.set_reset_catch()
+                # Reset and halt the primary core.
+                session.target.reset_and_halt()
+            finally:
+                # Clear reset catch for all secondary cores.
+                for core in secondary_cores:
+                    core.clear_reset_catch()
+
             if not self._args.file and self._args.cbuild_run:
                 # Populate file list from cbuild-run output if not provided explicitly
                 cbuild_files = session.target.get_output()
@@ -148,4 +163,8 @@ def invoke(self) -> int:
                                 skip=self._args.skip,
                                 file_format=file_format)
 
+            # Reset the target after programming unless --no-reset was specified.
+            if not self._args.no_reset:
+                session.target.reset(Target.ResetType.NSRST)
+
         return 0

pyocd/target/pack/flash_algo.py

@@ -103,9 +103,8 @@ def __init__(self, data: Union[str, IO[bytes]]) -> None:
         self.sector_sizes = self.flash_info.sector_info_list
 
         symbols: Dict[str, int] = {}
-        x = self._extract_symbols(self.REQUIRED_SYMBOLS)
-        symbols.update(x)
-        symbols.update(self._extract_symbols(self.EXTRA_SYMBOLS, default=0xFFFFFFFF))
+        symbols.update(self._extract_symbols(self.REQUIRED_SYMBOLS, required=True))
+        symbols.update(self._extract_symbols(self.EXTRA_SYMBOLS))
         self.symbols = symbols
 
         ro_rw_zi = self._find_sections(self.SECTIONS_TO_FIND)
@@ -235,15 +234,21 @@ def get_pyocd_flash_algo(self, blocksize: int, ram_region: "RamRegion") -> Dict[
             )
         # TODO - analyzer support
 
+        # Start of actual code (after the flash blob header) when loaded into RAM.
         code_start = addr_load + self._FLASH_BLOB_HEADER_SIZE
+
+        # Helper to get a symbol address relative to code_start. Returns 0xFFFFFFFF when symbol is not present.
+        def _sym(sym: str) -> int:
+            return (code_start + self.symbols[sym]) if (sym in self.symbols) else 0xFFFFFFFF
+
         flash_algo = {
             "load_address": addr_load,
             "instructions": instructions,
-            "pc_init": code_start + self.symbols["Init"],
-            "pc_unInit": code_start + self.symbols["UnInit"],
-            "pc_eraseAll": code_start + self.symbols["EraseChip"],
-            "pc_erase_sector": code_start + self.symbols["EraseSector"],
-            "pc_program_page": code_start + self.symbols["ProgramPage"],
+            "pc_init": _sym("Init"),
+            "pc_unInit": _sym("UnInit"),
+            "pc_eraseAll": _sym("EraseChip"),
+            "pc_erase_sector": _sym("EraseSector"),
+            "pc_program_page": _sym("ProgramPage"),
             "page_buffers": page_buffers,
             "begin_data": page_buffers[0],
             "begin_stack": addr_stack,
@@ -254,16 +259,15 @@ def get_pyocd_flash_algo(self, blocksize: int, ram_region: "RamRegion") -> Dict[
         }
         return flash_algo
 
-    def _extract_symbols(self, symbols: Set[str], default: Optional[int] = None) -> Dict[str, int]:
-        """@brief Fill 'symbols' field with required flash algo symbols"""
+    def _extract_symbols(self, symbols: Set[str], required: bool = False) -> Dict[str, int]:
+        """@brief Fill 'symbols' field with flash algo symbols"""
         to_ret: Dict[str, int] = {}
         for symbol in symbols:
             symbolInfo = self.elf.symbol_decoder.get_symbol_for_name(symbol)
             if symbolInfo is None:
-                if default is not None:
-                    to_ret[symbol] = default
-                    continue
-                raise FlashAlgoException("Missing symbol %s" % symbol)
+                if required:
+                    raise FlashAlgoException("Missing symbol %s" % symbol)
+                continue
             to_ret[symbol] = symbolInfo.address
         return to_ret
 

test/basic_test.py

@@ -1,5 +1,5 @@
 # pyOCD debugger
-# Copyright (c) 2006-2020 Arm Limited
+# Copyright (c) 2006-2020,2025 Arm Limited
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -248,6 +248,7 @@ def basic_test(board_id, file):
         sectors_to_test = min(rom_region.length // sector_size, 3)
         addr_flash = rom_region.start + rom_region.length - sector_size * sectors_to_test
         fill = [0x55] * page_size
+        target.reset_and_halt()
         for i in range(0, sectors_to_test):
             address = addr_flash + sector_size * i
             # Test only supports a location with 3 aligned
@@ -304,6 +305,7 @@ def basic_test(board_id, file):
             print("TEST FAILED")
 
         print("\n\n----- FLASH NEW BINARY -----")
+        target.reset_and_halt()
         FileProgrammer(session).program(binary_file, base_address=addr_bin)
 
         target.reset()

test/blank_test.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 # pyOCD debugger
-# Copyright (c) 2006-2020 Arm Limited
+# Copyright (c) 2006-2020,2025 Arm Limited
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -36,6 +36,7 @@
         board = session.board
         flash = session.target.memory_map.get_boot_memory().flash
         # Erase and then reset - This locks Kinetis devices
+        board.target.reset_and_halt()
         flash.init(flash.Operation.ERASE)
         flash.erase_all()
         flash.cleanup()
@@ -54,6 +55,7 @@
 with ConnectHelper.session_with_chosen_probe(**get_session_options()) as session:
     board = session.board
     binary_file = get_test_binary_path(board.test_binary)
+    board.target.reset_and_halt()
     FileProgrammer(session).program(binary_file)
 
 print("\n\n------ Testing Attaching to regular board ------")

test/connect_test.py

@@ -1,5 +1,5 @@
 # pyOCD debugger
-# Copyright (c) 2017-2020 Arm Limited
+# Copyright (c) 2017-2020,2025 Arm Limited
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -134,6 +134,7 @@ def test_connect(connect_mode, expected_state, resume):
 
     print("\n\n----- TESTING CONNECT/DISCONNECT -----")
     print("Flashing new binary")
+    live_board.target.reset_and_halt()
     FileProgrammer(live_session).program(binary_file, base_address=rom_start)
     live_board.target.reset()
     test_count += 1

test/cortex_test.py

@@ -133,6 +133,7 @@ def cortex_test(board_id):
         gdbFacade = GDBDebugContextFacade(debugContext)
 
         print("\n\n----- FLASH NEW BINARY BEFORE TEST -----")
+        target.reset_and_halt()
         FileProgrammer(session).program(binary_file, base_address=addr_bin)
         # Let the target run for a bit so it
         # can initialize the watchdog if it needs to

test/debug_context_test.py

@@ -1,5 +1,5 @@
 # pyOCD debugger
-# Copyright (c) 2019-2020 Arm Limited
+# Copyright (c) 2019-2020,2025 Arm Limited
 # Copyright (c) 2021 Chris Reed
 # SPDX-License-Identifier: Apache-2.0
 #
@@ -151,6 +151,7 @@ def debug_context_test(board_id):
 
         # Program the test binary.
         print("Programming test binary to boot memory")
+        target.reset_and_halt()
         FileProgrammer(session).program(binary_file, base_address=boot_region.start)
 
         with mock.patch.object(target.selected_core, 'read_memory_block32') as read_block32_mock:
@@ -200,4 +201,3 @@ def debug_context_test(board_id):
     session = ConnectHelper.session_with_chosen_probe(**get_session_options())
     test = DebugContextTest()
     result = [test.run(session.board)]
-

test/flash_loader_test.py

@@ -1,5 +1,5 @@
 # pyOCD debugger
-# Copyright (c) 2018-2020 Arm Limited
+# Copyright (c) 2018-2020,2025 Arm Limited
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -98,6 +98,7 @@ def flash_loader_test(board_id):
 
         print("\n------ Test Basic Load ------")
         loader = FlashLoader(session, chip_erase="sector")
+        target.reset_and_halt()
         loader.add_data(boot_start_addr, data)
         loader.commit()
         verify_data = target.read_memory_block8(boot_start_addr, data_length)
@@ -117,6 +118,7 @@ def flash_loader_test(board_id):
             orig_data_length = data_length
 
         loader = FlashLoader(session, chip_erase="sector")
+        target.reset_and_halt()
         loader.add_data(addr, test_data)
         loader.add_data(addr + boot_blocksize, test_data)
         loader.commit()
@@ -133,6 +135,7 @@ def flash_loader_test(board_id):
         print("\n------ Test Basic Sector Erase ------")
         addr = (boot_end_addr + 1) - (boot_blocksize * num_test_sectors)
         eraser = FlashEraser(session, FlashEraser.Mode.SECTOR)
+        target.reset_and_halt()
         eraser.erase(["0x%x+0x%x" % (addr, boot_blocksize)])
         verify_data = target.read_memory_block8(addr, boot_blocksize)
         if target.memory_map.get_region_for_address(addr).is_data_erased(verify_data):
@@ -144,6 +147,7 @@ def flash_loader_test(board_id):
 
         print("\n------ Test Load Chip Erase ------")
         loader = FlashLoader(session, chip_erase="chip")
+        target.reset_and_halt()
         loader.add_data(boot_start_addr, data)
         loader.commit()
         verify_data = target.read_memory_block8(boot_start_addr, data_length)
@@ -156,6 +160,7 @@ def flash_loader_test(board_id):
 
         print("\n------ Test Binary File Load ------")
         programmer = FileProgrammer(session)
+        target.reset_and_halt()
         programmer.program(binary_file, file_format='bin', base_address=boot_start_addr)
         verify_data = target.read_memory_block8(boot_start_addr, data_length)
         if same(verify_data, data):
@@ -167,6 +172,7 @@ def flash_loader_test(board_id):
 
         print("\n------ Test Intel Hex File Load ------")
         programmer = FileProgrammer(session)
+        target.reset_and_halt()
         programmer.program(temp_test_hex_name, file_format='hex')
         verify_data = target.read_memory_block8(boot_start_addr, data_length)
         if same(verify_data, data):
@@ -178,6 +184,7 @@ def flash_loader_test(board_id):
 
         print("\n------ Test ELF File Load ------")
         programmer = FileProgrammer(session)
+        target.reset_and_halt()
         programmer.program(temp_test_elf_name, file_format='elf')
         verify_data = target.read_memory_block8(boot_start_addr, data_length)
         if same(verify_data, data):
@@ -211,4 +218,3 @@ def flash_loader_test(board_id):
     session = ConnectHelper.session_with_chosen_probe(**get_session_options())
     test = FlashLoaderTest()
     result = [test.run(session.board)]
-