pub trait MemoryInterface {
Show 21 methods fn supports_native_64bit_access(&mut self) -> bool; fn read_word_64(&mut self, address: u64) -> Result<u64, Error>; fn read_word_32(&mut self, address: u64) -> Result<u32, Error>; fn read_word_8(&mut self, address: u64) -> Result<u8, Error>; fn read_64(&mut self, address: u64, data: &mut [u64]) -> Result<(), Error>; fn read_32(&mut self, address: u64, data: &mut [u32]) -> Result<(), Error>; fn read_8(&mut self, address: u64, data: &mut [u8]) -> Result<(), Error>; fn write_word_64(&mut self, address: u64, data: u64) -> Result<(), Error>; fn write_word_32(&mut self, address: u64, data: u32) -> Result<(), Error>; fn write_word_8(&mut self, address: u64, data: u8) -> Result<(), Error>; fn write_64(&mut self, address: u64, data: &[u64]) -> Result<(), Error>; fn write_32(&mut self, address: u64, data: &[u32]) -> Result<(), Error>; fn write_8(&mut self, address: u64, data: &[u8]) -> Result<(), Error>; fn supports_8bit_transfers(&self) -> Result<bool, Error>; fn flush(&mut self) -> Result<(), Error>; fn read_mem_64bit(
        &mut self,
        address: u64,
        data: &mut [u8]
    ) -> Result<(), Error> { ... } fn read_mem_32bit(
        &mut self,
        address: u64,
        data: &mut [u8]
    ) -> Result<(), Error> { ... } fn read(&mut self, address: u64, data: &mut [u8]) -> Result<(), Error> { ... } fn write_mem_64bit(&mut self, address: u64, data: &[u8]) -> Result<(), Error> { ... } fn write_mem_32bit(&mut self, address: u64, data: &[u8]) -> Result<(), Error> { ... } fn write(&mut self, address: u64, data: &[u8]) -> Result<(), Error> { ... }
}
Expand description

An interface to be implemented for drivers that allow target memory access.

Required Methods§

Does this interface support native 64-bit wide accesses

If false all 64-bit operations may be split into 32 or 8 bit operations. Most callers will not need to pivot on this but it can be useful for picking the fastest bulk data transfer method.

Read a 64bit word of at address.

The address where the read should be performed at has to be word aligned. Returns AccessPortError::MemoryNotAligned if this does not hold true.

Read a 32bit word of at address.

The address where the read should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Read an 8bit word of at address.

Read a block of 64bit words at address.

The number of words read is data.len(). The address where the read should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Read a block of 32bit words at address.

The number of words read is data.len(). The address where the read should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Read a block of 8bit words at address.

Write a 64bit word at address.

The address where the write should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Write a 32bit word at address.

The address where the write should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Write an 8bit word at address.

Write a block of 64bit words at address.

The number of words written is data.len(). The address where the write should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Write a block of 32bit words at address.

The number of words written is data.len(). The address where the write should be performed at has to be word aligned. Returns Error::MemoryNotAligned if this does not hold true.

Write a block of 8bit words at address.

Returns whether the current platform supports native 8bit transfers.

Flush any outstanding operations.

For performance, debug probe implementations may choose to batch writes; to assure that any such batched writes have in fact been issued, flush can be called. Takes no arguments, but may return failure if a batched operation fails.

Provided Methods§

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

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

Read data from address.

This function tries to use the fastest way of reading data, so there is no guarantee which kind of memory access is used. The function might also read more data than requested, e.g. when the start address is not aligned to a 32-bit boundary.

For more control, the read_x functiongs, e.g. MemoryInterface::read_32(), can be used.

Generally faster than read_8.

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

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

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.

If the target does not support 8-bit aligned access, and address is not aligned on a 32-bit boundary, this function will return a Error::MemoryNotAligned error.

Implementations on Foreign Types§

Implementors§