Struct FieldSafeMemory 

pub struct FieldSafeMemory<'a> {
    arm: &'a mut FieldSafeArm,
    ap: FullyQualifiedApAddress,
}

AP0 memory through the base’s 32-bit memory commands.

Every access width is carried by 32-bit transfers: 64-bit as word pairs, 8- and 16-bit through FieldSafeArm’s byte helpers (read-modify-write for writes). Addresses above 4 GB are refused with [ArmError::OutOfBounds].

Fields

arm: &'a mut FieldSafeArm

The interface whose link carries the transfers.

ap: FullyQualifiedApAddress

The access port this interface was opened for (always AP0).

Trait Implementations

impl ArmMemoryInterface for FieldSafeMemory<'_>

fn base_address(&mut self) -> Result<u64, ArmError>

Returns the ROM table address from the DapTable’s AP0 BASE, with its format/present bits masked off.

fn fully_qualified_address(&self) -> FullyQualifiedApAddress

Returns the access port this interface was opened for (AP0).

fn get_arm_debug_interface( &mut self, ) -> Result<&mut dyn ArmDebugInterface, DebugProbeError>

Returns the FieldSafeArm this memory interface belongs to.

fn generic_status(&mut self) -> Result<CSW, ArmError>

Returns AP0’s CSW from the DapTable, as the part resets it.

fn update_core_status(&mut self, _state: CoreStatus)

Inform the probe of the [CoreStatus] of the chip/core attached to the probe.

impl<'a> Debug for FieldSafeMemory<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MemoryInterface<ArmError> for FieldSafeMemory<'_>

fn supports_native_64bit_access(&mut self) -> bool

Returns false: 64-bit accesses are split into word pairs.

fn read_64(&mut self, address: u64, data: &mut [u64]) -> Result<(), ArmError>

Reads double words as pairs of little-endian words.

fn read_32(&mut self, address: u64, data: &mut [u32]) -> Result<(), ArmError>

Reads words directly with READMEM_32BIT.

fn read_16(&mut self, address: u64, data: &mut [u16]) -> Result<(), ArmError>

Reads half-words through whole-word reads.

fn read_8(&mut self, address: u64, data: &mut [u8]) -> Result<(), ArmError>

Reads bytes through whole-word reads, never READMEM_8BIT.

fn write_64(&mut self, address: u64, data: &[u64]) -> Result<(), ArmError>

Writes double words as pairs of little-endian words.

fn write_32(&mut self, address: u64, data: &[u32]) -> Result<(), ArmError>

Writes words directly with WRITEMEM_32BIT.

fn write_16(&mut self, address: u64, data: &[u16]) -> Result<(), ArmError>

Writes half-words by read-modify-write of whole words; see FieldSafeArm’s byte-write caveats.

fn write_8(&mut self, address: u64, data: &[u8]) -> Result<(), ArmError>

Writes bytes by read-modify-write of whole words; see FieldSafeArm’s byte-write caveats.

fn supports_8bit_transfers(&self) -> Result<bool, ArmError>

Returns true: byte transfers are emulated, so probe-rs may use them.

fn flush(&mut self) -> Result<(), ArmError>

Does nothing: every transfer completes before its call returns.

fn read_word_64(&mut self, address: u64) -> Result<u64, ERR>

Read a 64bit word of at address.

fn read_word_32(&mut self, address: u64) -> Result<u32, ERR>

Read a 32bit word of at address.

fn read_word_16(&mut self, address: u64) -> Result<u16, ERR>

Read a 16bit word of at address.

fn read_word_8(&mut self, address: u64) -> Result<u8, ERR>

Read an 8bit word of at address.

fn read_mem_64bit(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Reads bytes using 64 bit memory access.

fn read_mem_32bit(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Reads bytes using 32 bit memory access.

fn read(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Read data from address.

fn write_word_64(&mut self, address: u64, data: u64) -> Result<(), ERR>

Write a 64bit word at address.

fn write_word_32(&mut self, address: u64, data: u32) -> Result<(), ERR>

Write a 32bit word at address.

fn write_word_16(&mut self, address: u64, data: u16) -> Result<(), ERR>

Write a 16bit word at address.

fn write_word_8(&mut self, address: u64, data: u8) -> Result<(), ERR>

Write an 8bit word at address.

fn write_mem_64bit(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Writes bytes using 64 bit memory access. Address must be 64 bit aligned and data must be an exact multiple of 8.

fn write_mem_32bit(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Writes bytes using 32 bit memory access. Address must be 32 bit aligned and data must be an exact multiple of 8.

fn write(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Write a block of 8bit words at address. May use 64 bit memory access, so should only be used if reading memory locations that don’t have side effects. Generally faster than [MemoryInterface::write_8].

fn execute_single_memory_operation( &mut self, operation: Operation<'_>, ) -> Result<(), Error>

where Error: From<ERR>,

Execute a single memory operation.

fn execute_memory_operations(&mut self, operations: &mut [Operation<'_>])

where Error: From<ERR>,

Execute a batch of operations.

impl SwdSequence for FieldSafeMemory<'_>

fn swj_sequence( &mut self, bit_len: u8, bits: u64, ) -> Result<(), DebugProbeError>

Forwards to FieldSafeArm, which refuses it.

fn swj_pins( &mut self, pin_out: u32, pin_select: u32, pin_wait: u32, ) -> Result<u32, DebugProbeError>

Forwards to FieldSafeArm: drives nRST only.