Add private SPIM3 sample-delay dial and packet-type readback

This commit is contained in:
mikecarper committed 2026-10-23 03:11:30 -07:00
1 parent 4e513b19d5
commit 5c18f086da
4 files changed
+135 -8

No files matched your search

@@ -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
@@ -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<uint32_t>(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;
}
+81 -3
View File
@@ -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 <cassert>
#include <cstdint>
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 <array>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <helpers/radiolib/NrfRadioSpiStartupDiagHal.h>
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<uint8_t,4> 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 <cassert>','#include <Arduino.h>\n#include <cassert>')
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 <helpers/radiolib/NrfRadioSpiStartupDiagHal.h>\n',
capture_output=True,text=True)
self.assertNotEqual(result.returncode,0)
self.assertIn(diagnostic,result.stderr)
if __name__=="__main__":unittest.main(verbosity=2)
+7
View File
@@ -18,6 +18,12 @@ MOCK_HAL = r'''
#include <cstdint>
#include <cstring>
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]);
}