Struct probe_rs::architecture::arm::ArmCommunicationInterface

pub struct ArmCommunicationInterface<'probe> { /* fields omitted */ }

Implementations

impl<'probe> ArmCommunicationInterface<'probe>

pub fn new(
    probe: &'probe mut Probe,
    state: &'probe mut ArmCommunicationInterfaceState
) -> Result<Option<Self>, DebugProbeError>

pub fn reborrow(&mut self) -> ArmCommunicationInterface

Reborrows the ArmCommunicationInterface at hand. This borrows the references inside the interface and hands them out with a new interface. This method replaces the normally called ::clone() method which consumes the object, which is not what we want.

pub fn dedicated_memory_interface(
    &self
) -> Result<Option<Memory>, DebugProbeError>

pub fn write_ap_register<AP, R>(
    &mut self,
    port: AP,
    register: R
) -> Result<(), DebugProbeError> where
    AP: AccessPort,
    R: APRegister<AP>, 

Write the given register R of the given AP, where the to be written register value is wrapped in the given register parameter.

pub fn write_ap_register_repeated<AP, R>(
    &mut self,
    port: AP,
    _register: R,
    values: &[u32]
) -> Result<(), DebugProbeError> where
    AP: AccessPort,
    R: APRegister<AP>, 

Write the given register R of the given AP repeatedly, where the to be written register values are stored in the values array. The values are written in the exact order they are stored in the array.

pub fn read_ap_register<AP, R>(
    &mut self,
    port: AP,
    _register: R
) -> Result<R, DebugProbeError> where
    AP: AccessPort,
    R: APRegister<AP>, 

Read the given register R of the given AP, where the read register value is wrapped in the given register parameter.

pub fn read_ap_register_repeated<AP, R>(
    &mut self,
    port: AP,
    _register: R,
    values: &mut [u32]
) -> Result<(), DebugProbeError> where
    AP: AccessPort,
    R: APRegister<AP>, 

Read the given register R of the given AP repeatedly, where the read register values are stored in the values array. The values are read in the exact order they are stored in the array.

Trait Implementations

impl<'probe, R> APAccess<GenericAP, R> for ArmCommunicationInterface<'probe> where
    R: APRegister<GenericAP>, 

type Error = DebugProbeError

fn read_ap_register(
    &mut self,
    port: GenericAP,
    register: R
) -> Result<R, Self::Error>

fn write_ap_register(
    &mut self,
    port: GenericAP,
    register: R
) -> Result<(), Self::Error>

fn write_ap_register_repeated(
    &mut self,
    port: GenericAP,
    register: R,
    values: &[u32]
) -> Result<(), Self::Error>

Write a register using a block transfer. This can be used to write multiple values to the same register.

fn read_ap_register_repeated(
    &mut self,
    port: GenericAP,
    register: R,
    values: &mut [u32]
) -> Result<(), Self::Error>

Read a register using a block transfer. This can be used to read multiple values from the same register.

impl<'probe, R> APAccess<MemoryAP, R> for ArmCommunicationInterface<'probe> where
    R: APRegister<MemoryAP>, 

type Error = DebugProbeError

fn read_ap_register(
    &mut self,
    port: MemoryAP,
    register: R
) -> Result<R, Self::Error>

fn write_ap_register(
    &mut self,
    port: MemoryAP,
    register: R
) -> Result<(), Self::Error>

fn write_ap_register_repeated(
    &mut self,
    port: MemoryAP,
    register: R,
    values: &[u32]
) -> Result<(), Self::Error>

Write a register using a block transfer. This can be used to write multiple values to the same register.

fn read_ap_register_repeated(
    &mut self,
    port: MemoryAP,
    register: R,
    values: &mut [u32]
) -> Result<(), Self::Error>

Read a register using a block transfer. This can be used to read multiple values from the same register.

impl<'probe> CommunicationInterface for ArmCommunicationInterface<'probe>

fn probe_for_chip_info(self) -> Result<Option<ChipInfo>, ProbeRsError>

impl<'probe> DPAccess for ArmCommunicationInterface<'probe>

fn read_dp_register<R: DPRegister>(&mut self) -> Result<R, DebugPortError>

fn write_dp_register<R: DPRegister>(
    &mut self,
    register: R
) -> Result<(), DebugPortError>

impl<'probe> Debug for ArmCommunicationInterface<'probe>

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

Formats the value using the given formatter.