[−][src]Trait probe_rs::MemoryInterface

pub trait MemoryInterface {
    pub fn read_word_32(&mut self, address: u32) -> Result<u32, Error>;

    pub fn read_word_8(&mut self, address: u32) -> Result<u8, Error>;

    pub fn read_32(
        &mut self, 
        address: u32, 
        data: &mut [u32]
    ) -> Result<(), Error>;

    pub fn read_8(&mut self, address: u32, data: &mut [u8]) -> Result<(), Error>;

    pub fn write_word_32(
        &mut self, 
        address: u32, 
        data: u32
    ) -> Result<(), Error>;

    pub fn write_word_8(&mut self, address: u32, data: u8) -> Result<(), Error>;

    pub fn write_32(&mut self, address: u32, data: &[u32]) -> Result<(), Error>;

    pub fn write_8(&mut self, address: u32, data: &[u8]) -> Result<(), Error>;

    pub fn flush(&mut self) -> Result<(), Error>;
}

Required methods

pub fn read_word_32(&mut self, address: u32) -> Result<u32, Error>

Read a 32bit 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.

pub fn read_word_8(&mut self, address: u32) -> Result<u8, Error>

Read an 8bit word of at address.

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

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 AccessPortError::MemoryNotAligned if this does not hold true.

pub fn read_8(&mut self, address: u32, data: &mut [u8]) -> Result<(), Error>

Read a block of 8bit words at address.

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

Write a 32bit word at address.

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

pub fn write_word_8(&mut self, address: u32, data: u8) -> Result<(), Error>

Write an 8bit word at address.

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

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 AccessPortError::MemoryNotAligned if this does not hold true.

pub fn write_8(&mut self, address: u32, data: &[u8]) -> Result<(), Error>

Write a block of 8bit words at address.

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

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.

Loading content...

Implementations on Foreign Types

impl<T, '_> MemoryInterface for &'_ mut T where
    T: MemoryInterface, [src]

Loading content...

Implementors

impl MemoryInterface for RiscvCommunicationInterface[src]

pub fn read_8(&mut self, address: u32, data: &mut [u8]) -> Result<(), Error>[src]

Read 8-bit values from target memory.

impl<'probe> MemoryInterface for M0<'probe>[src]

impl<'probe> MemoryInterface for M4<'probe>[src]

impl<'probe> MemoryInterface for M33<'probe>[src]

impl<'probe> MemoryInterface for Riscv32<'probe>[src]

impl<'probe> MemoryInterface for Core<'probe>[src]

Loading content...