diff --git a/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.cpp b/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.cpp index 023d1298c..ff5220a09 100644 --- a/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.cpp +++ b/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.cpp @@ -4,9 +4,10 @@ namespace mesh { namespace spistartup { extern "C" { volatile Capture mesh_hil_spi_startup = { - 0x4d435353, 1, sizeof(Capture), Idle, + 0x4d435353, 2, sizeof(Capture), Idle, 0, UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX, - 0, 0, 0, UINT32_MAX, 0}; + 0, 0, 0, UINT32_MAX, 0, UINT32_MAX, 0, 0, + {UINT32_MAX, UINT32_MAX, UINT32_MAX}}; } } } #endif diff --git a/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.h b/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.h index 1eb477b7b..998e2f23d 100644 --- a/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.h +++ b/src/helpers/radiolib/NrfRadioSpiStartupDiagHal.h @@ -6,6 +6,20 @@ #if MESH_HIL_SPI_STARTUP_DIAG != 0 && MESH_HIL_SPI_STARTUP_DIAG != 1 #error "SPI startup diagnostic flag must be 0 or 1" #endif +#ifndef MESH_HIL_SPI3_RX_DELAY +#define MESH_HIL_SPI3_RX_DELAY -1 +#endif +#if MESH_HIL_SPI3_RX_DELAY < -1 || MESH_HIL_SPI3_RX_DELAY > 7 +#error "SPI3 sample delay must be -1 (unchanged) or 0..7" +#endif +#if MESH_HIL_SPI3_RX_DELAY >= 0 +#if !MESH_HIL_SPI_STARTUP_DIAG || !defined(NRF52_PLATFORM) +#error "SPI3 sample delay requires the nRF52 SPI startup diagnostic" +#endif +#if !defined(SPI_32MHZ_INTERFACE) || SPI_32MHZ_INTERFACE != 1 +#error "SPI3 sample delay requires the diagnostic SPI1/SPIM3 mapping" +#endif +#endif #if MESH_HIL_SPI_STARTUP_DIAG #if !defined(NRF52_PLATFORM) @@ -22,16 +36,19 @@ namespace mesh { namespace spistartup { enum Phase : uint32_t { Idle = 0, Query = 1, Transfer = 2, Completed = 3, Refused = 4 }; -// Fixed 14-word ABI for private SWD reads, including before USB is usable. +// Fixed 20-word ABI for private SWD reads, including before USB is usable. // Each word is independently observable; this is not an atomic snapshot. struct Capture { uint32_t magic, version, size_bytes, phase; uint32_t queries, first_query_result, first_query_enabled; uint32_t last_query_result, last_query_enabled; uint32_t begun, completed, refused, last_opcode, last_length; + uint32_t actual_rx_delay; + uint32_t packet_type_frames, packet_type_length, packet_type_rx[3]; }; -static_assert(sizeof(Capture) == 56 && offsetof(Capture, begun) == 36 - && offsetof(Capture, last_length) == 52, "SPI startup capture ABI changed"); +static_assert(sizeof(Capture) == 80 && offsetof(Capture, begun) == 36 + && offsetof(Capture, actual_rx_delay) == 56 + && offsetof(Capture, packet_type_rx) == 68, "SPI startup capture ABI changed"); extern "C" { extern volatile Capture mesh_hil_spi_startup; } @@ -46,6 +63,22 @@ public: explicit NrfRadioSpiStartupDiagHal(SPIClass& bus, uint32_t hz) : Nrf52BufferedRadioHal(bus, hz) {} + void spiBeginTransaction() override { +#if defined(SPI_32MHZ_INTERFACE) && SPI_32MHZ_INTERFACE == 1 +#if MESH_HIL_SPI3_RX_DELAY >= 0 + // The previous frame is complete and CS has not been selected. Configure + // only the diagnostic SPIM3 while disabled; the normal base transaction + // still owns mode/clock setup, enable, and its optional HIL guards. + NRF_SPIM3->ENABLE = 0; + NRF_SPIM3->IFTIMING.RXDELAY = MESH_HIL_SPI3_RX_DELAY; +#endif +#endif + Nrf52BufferedRadioHal::spiBeginTransaction(); +#if defined(SPI_32MHZ_INTERFACE) && SPI_32MHZ_INTERFACE == 1 + mesh::spistartup::mesh_hil_spi_startup.actual_rx_delay = NRF_SPIM3->IFTIMING.RXDELAY; +#endif + } + void spiTransfer(uint8_t* out, size_t len, uint8_t* in) override { if (!len) return; auto& capture = mesh::spistartup::mesh_hil_spi_startup; @@ -70,6 +103,14 @@ public: ++capture.begun; capture.phase = mesh::spistartup::Transfer; Nrf52BufferedRadioHal::spiTransfer(out, len, in); + // Preserve real wire evidence for GetPacketType's opcode/status/data + // bytes. Refused frames do not overwrite the last completed response. + if (capture.last_opcode == 0x11) { + ++capture.packet_type_frames; + capture.packet_type_length = static_cast(len); + for (unsigned i = 0; i < 3; ++i) + capture.packet_type_rx[i] = in && i < len ? in[i] : UINT32_MAX; + } ++capture.completed; capture.phase = mesh::spistartup::Completed; } diff --git a/test/test_nrf_radio_spi_startup_diag.py b/test/test_nrf_radio_spi_startup_diag.py index 9a112ae60..ec4988e59 100644 --- a/test/test_nrf_radio_spi_startup_diag.py +++ b/test/test_nrf_radio_spi_startup_diag.py @@ -19,12 +19,38 @@ extern uint8_t test_sd_enabled; uint32_t sd_softdevice_is_enabled(uint8_t* state); ''' +MOCK_ARDUINO = r''' +#pragma once +#include +#include +extern bool spim_disabled; +extern unsigned delay_writes,transaction_starts; +struct EnableRegister { + uint32_t value=7; + operator uint32_t() const { return value; } + EnableRegister& operator=(uint32_t next) { value=next;spim_disabled=next==0;return *this; } +}; +struct DelayRegister { + uint32_t value=2; + operator uint32_t() const { return value; } + DelayRegister& operator=(uint32_t next) { + assert(spim_disabled);++delay_writes;value=next;return *this; + } +}; +struct SpimMock { EnableRegister ENABLE;struct { DelayRegister RXDELAY; } IFTIMING; }; +extern SpimMock spim3; +#define NRF_SPIM3 (&spim3) +''' + HARNESS = r''' #include #include #include #include #include +bool spim_disabled=false; +unsigned delay_writes=0,transaction_starts=0; +SpimMock spim3; uint32_t test_sd_result=0,test_sd_queries=0; uint8_t test_sd_enabled=0; using namespace mesh::spistartup; @@ -42,14 +68,24 @@ int main() { SPIClass bus;NrfRadioSpiStartupDiagHal concrete(bus,16000000); ArduinoHal& hal=concrete; auto& capture=mesh_hil_spi_startup; - assert(capture.magic==0x4d435353&&capture.version==1&&capture.size_bytes==56); + assert(capture.magic==0x4d435353&&capture.version==2&&capture.size_bytes==80); assert(capture.phase==Idle&&capture.queries==0&&capture.begun==0&&capture.completed==0&&capture.refused==0); assert(capture.first_query_result==UINT32_MAX&&capture.first_query_enabled==UINT32_MAX); + assert(capture.actual_rx_delay==UINT32_MAX && capture.packet_type_frames==0); assert(concrete.spiSettings.hz==16000000&&concrete.spiSettings.order==MSBFIRST&&concrete.spiSettings.mode==SPI_MODE0); Capture initial;memcpy(&initial,(const void*)&capture,sizeof(initial)); // A zero-size call must not touch capture, query the supervisor, or use SPI. hal.spiTransfer(nullptr,0,nullptr); assert(memcmp(&initial,(const void*)&capture,sizeof(initial))==0&&test_sd_queries==0&&bus.bursts==0); + hal.spiBeginTransaction(); + assert(transaction_starts==1 && !spim_disabled); +#if defined(SPI_32MHZ_INTERFACE) && SPI_32MHZ_INTERFACE == 1 + const unsigned expected=MESH_HIL_SPI3_RX_DELAY<0?2:MESH_HIL_SPI3_RX_DELAY; + assert(capture.actual_rx_delay==expected && uint32_t(spim3.IFTIMING.RXDELAY)==expected); + assert(delay_writes==unsigned(MESH_HIL_SPI3_RX_DELAY>=0)); +#else + assert(capture.actual_rx_delay==UINT32_MAX && delay_writes==0); +#endif std::array out={0x83,0x11,0x22,0x33},in{}; const auto original=out; // Positively disabled permits exactly one buffered full-duplex frame. @@ -87,25 +123,52 @@ int main() { Capture final;memcpy(&final,(const void*)&capture,sizeof(final)); hal.spiTransfer(nullptr,0,nullptr); assert(memcmp(&final,(const void*)&capture,sizeof(final))==0&&test_sd_queries==5); + // Record the first three wire bytes only for completed GetPacketType. + out[0]=0x11; + hal.spiTransfer(out.data(),3,in.data()); + assert(capture.packet_type_frames==1 && capture.packet_type_length==3); + for(unsigned i=0;i<3;++i) assert(capture.packet_type_rx[i]==uint8_t(out[i]^0xa5)); + test_sd_enabled=1;hal.spiTransfer(out.data(),3,in.data()); + assert(capture.packet_type_frames==1); // Refused bytes are not wire evidence. + test_sd_enabled=0;hal.spiTransfer(out.data(),1,in.data()); + assert(capture.packet_type_frames==2 && capture.packet_type_length==1); + assert(capture.packet_type_rx[0]==uint8_t(0x11^0xa5)); + assert(capture.packet_type_rx[1]==UINT32_MAX && capture.packet_type_rx[2]==UINT32_MAX); + hal.spiTransfer(out.data(),3,nullptr); + assert(capture.packet_type_frames==3 && capture.packet_type_length==3); + for(unsigned i=0;i<3;++i) assert(capture.packet_type_rx[i]==UINT32_MAX); } ''' class NrfRadioSpiStartupDiagTests(unittest.TestCase): def test_actual_helper_queries_before_frames_and_refuses_unsafe_workaround(self): + for flags in ([],['-DSPI_32MHZ_INTERFACE=1'],*[['-DSPI_32MHZ_INTERFACE=1', + f'-DMESH_HIL_SPI3_RX_DELAY={delay}'] for delay in range(8)]): + with self.subTest(flags=flags): self.compile_and_run(flags) + + def compile_and_run(self,flags): with tempfile.TemporaryDirectory(prefix="nrf-spi-startup-") as directory: folder=Path(directory);(folder/"hal/Arduino").mkdir(parents=True) - mock=MOCK_HAL.replace("constexpr unsigned MSBFIRST", "void before_test_spi_transfer();\nconstexpr unsigned MSBFIRST") + mock=MOCK_HAL.replace('#include ','#include \n#include ') + mock=mock.replace("constexpr unsigned MSBFIRST", "void before_test_spi_transfer();\nconstexpr unsigned MSBFIRST") mock=mock.replace(" ++bursts;", " before_test_spi_transfer();\n ++bursts;") + mock=mock.replace('rx[i] = tx[i] ^ 0xa5;', 'if(rx) rx[i] = tx[i] ^ 0xa5;') + mock=mock.replace('virtual ~ArduinoHal() = default;',r''' + virtual ~ArduinoHal() = default; + virtual void spiBeginTransaction() { ++transaction_starts;spim3.ENABLE=7; } +''') (folder/"hal/Arduino/ArduinoHal.h").write_text(mock,encoding="ascii") (folder/"nrf_sdm.h").write_text(MOCK_SDM,encoding="ascii") + (folder/"Arduino.h").write_text(MOCK_ARDUINO,encoding="ascii") source=folder/"test.cpp";source.write_text(HARNESS,encoding="ascii") binary=folder/"test" command=[os.environ.get("CXX","c++"),"-std=c++17","-Wall","-Wextra","-Werror", "-fsanitize=address,undefined","-fno-sanitize-recover=all","-fno-pie","-no-pie", "-DNRF52_PLATFORM=1","-DMESH_HIL_SPI_STARTUP_DIAG=1", + *flags, "-I",str(folder),"-I",str(ROOT/"src"),str(source),str(HELPER),"-o",str(binary)] - built=subprocess.run(command,capture_output=True,text=True) + built=subprocess.run(command,capture_output=True,text=True,env={**os.environ,'TMPDIR':str(folder)}) self.assertEqual(built.returncode,0,built.stderr) ran=subprocess.run([str(binary)],capture_output=True,text=True) self.assertEqual(ran.returncode,0,ran.stdout+ran.stderr) @@ -121,5 +184,20 @@ class NrfRadioSpiStartupDiagTests(unittest.TestCase): self.assertEqual(symbols.returncode,0,symbols.stderr) self.assertEqual(symbols.stdout.strip(),"") + def test_delay_dial_rejects_non_hil_or_wrong_controller_and_invalid_range(self): + for flags,diagnostic in ((['-DMESH_HIL_SPI3_RX_DELAY=0'],'requires the nRF52 SPI startup diagnostic'), + (['-DMESH_HIL_SPI3_RX_DELAY=1','-DMESH_HIL_SPI_STARTUP_DIAG=1', + '-DNRF52_PLATFORM=1'],'requires the diagnostic SPI1/SPIM3 mapping'), + (['-DMESH_HIL_SPI3_RX_DELAY=2','-DMESH_HIL_SPI_STARTUP_DIAG=1', + '-DNRF52_PLATFORM=1','-DSPI_32MHZ_INTERFACE=0'],'requires the diagnostic SPI1/SPIM3 mapping'), + (['-DMESH_HIL_SPI3_RX_DELAY=-2'],'SPI3 sample delay must be'), + (['-DMESH_HIL_SPI3_RX_DELAY=8'],'SPI3 sample delay must be')): + with self.subTest(flags=flags): + result=subprocess.run([os.environ.get('CXX','c++'),'-E','-x','c++', + *flags,'-I',str(ROOT/'src'),'-'],input='#include \n', + capture_output=True,text=True) + self.assertNotEqual(result.returncode,0) + self.assertIn(diagnostic,result.stderr) + if __name__=="__main__":unittest.main(verbosity=2) diff --git a/test/test_rak3401_buffered_radio_hal.py b/test/test_rak3401_buffered_radio_hal.py index be58d506a..618d87c89 100644 --- a/test/test_rak3401_buffered_radio_hal.py +++ b/test/test_rak3401_buffered_radio_hal.py @@ -18,6 +18,12 @@ MOCK_HAL = r''' #include #include constexpr unsigned MSBFIRST = 1, SPI_MODE0 = 0; +struct MockSpim { + uint32_t ENABLE = 0; + struct { uint32_t RXDELAY = 2; } IFTIMING; +}; +inline MockSpim mockSpim3; +inline MockSpim* NRF_SPIM3 = &mockSpim3; struct SPISettings { unsigned hz, order, mode; SPISettings(unsigned h, unsigned o, unsigned m) : hz(h), order(o), mode(m) {} @@ -42,6 +48,7 @@ struct ArduinoHal { explicit ArduinoHal(SPIClass& bus, SPISettings settings) : spi(&bus), spiSettings(settings) {} virtual ~ArduinoHal() = default; + virtual void spiBeginTransaction() {} virtual void spiTransfer(uint8_t* out, size_t length, uint8_t* in) { for (size_t i = 0; i < length; ++i) in[i] = spi->transfer(out[i]); }