Struct probe_rs::architecture::arm::memory::ADIMemoryInterface

pub struct ADIMemoryInterface<AP> where
    AP: CommunicationInterface + APAccess<MemoryAP, CSW> + APAccess<MemoryAP, TAR> + APAccess<MemoryAP, DRW> + DPAccess,  { /* fields omitted */ }

A struct to give access to a targets memory using a certain DAP.

Implementations

impl<'probe> ADIMemoryInterface<ArmCommunicationInterface<'probe>>

pub fn new(
    interface: ArmCommunicationInterface<'probe>,
    access_port_number: impl Into<MemoryAP>,
    only_32bit_data_size: bool
) -> Result<ADIMemoryInterface<ArmCommunicationInterface<'_>>, AccessPortError>

Creates a new MemoryInterface for given AccessPort.

impl ADIMemoryInterface<MockMemoryAP>

pub fn new(
    mock: MockMemoryAP,
    access_port_number: impl Into<MemoryAP>
) -> ADIMemoryInterface<MockMemoryAP>

Creates a new MemoryInterface for given AccessPort.

pub fn mock_memory(&self) -> &[u8]

impl<AP> ADIMemoryInterface<AP> where
    AP: CommunicationInterface + APAccess<MemoryAP, CSW> + APAccess<MemoryAP, TAR> + APAccess<MemoryAP, DRW> + DPAccess, 

pub fn build_csw_register(data_size: DataSize) -> CSW

Build the correct CSW register for a memory access

Currently, only AMBA AHB Access is supported.

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

Read a 32bit word at addr.

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, AccessPortError>

Read an 8bit word at addr.

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

Read a block of words of the size defined by S at addr.

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<(), AccessPortError>

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

Write a 32bit word at addr.

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<(), AccessPortError>

Write an 8bit word at addr.

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

Write a block of 32bit words at addr.

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<(), AccessPortError>

Write a block of 8bit words at addr.

The number of words written is data.len().

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

Trait Implementations

impl<AP> MemoryInterface for ADIMemoryInterface<AP> where
    AP: CommunicationInterface + APAccess<MemoryAP, CSW> + APAccess<MemoryAP, TAR> + APAccess<MemoryAP, DRW> + DPAccess, 

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

Read a 32bit word of at address.

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

Read an 8bit word of at address.

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

Read a block of 32bit words at address.

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

Read a block of 8bit words at address.

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

Write a 32bit word at address.

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

Write an 8bit word at address.

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

Write a block of 32bit words at address.

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

Write a block of 8bit words at address.

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

Flush any outstanding operations.