Enum DeviceBackend 

pub enum DeviceBackend<M = FakeMmio, G = FakeGpio, I = FakeI2c, S = FakeSpi, C = FakeClock, R = FakeReset, U = FakeSerial> {
    Mmio(M),
    Gpio(G),
    I2c(I),
    Spi(S),
    Clock(C),
    Reset(R),
    Serial(U),
}

Unified enum backend allowing heterogeneous resources to coexist in one proxy instance.

Variants

Mmio(M)

Gpio(G)

I2c(I)

Spi(S)

Clock(C)

Reset(R)

Serial(U)

Implementations

impl<M, G, I, S, C, R, U> DeviceBackend<M, G, I, S, C, R, U>

pub fn new_mmio(mmio: M) -> Self

pub fn new_gpio(gpio: G) -> Self

pub fn new_i2c(i2c: I) -> Self

pub fn new_spi(spi: S) -> Self

pub fn new_clock(clock: C) -> Self

pub fn new_reset(reset: R) -> Self

pub fn new_serial(serial: U) -> Self

Trait Implementations

impl<M: Clone, G: Clone, I: Clone, S: Clone, C: Clone, R: Clone, U: Clone> Clone for DeviceBackend<M, G, I, S, C, R, U>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M: Debug, G: Debug, I: Debug, S: Debug, C: Debug, R: Debug, U: Debug> Debug for DeviceBackend<M, G, I, S, C, R, U>

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

Formats the value using the given formatter.

impl<M: ResourceBackend, G: ResourceBackend, I: ResourceBackend, S: ResourceBackend, C: ResourceBackend, R: ResourceBackend, U: ResourceBackend> ResourceBackend for DeviceBackend<M, G, I, S, C, R, U>

fn read32(&mut self, offset: u64) -> Result<u32, BackendError>

fn write32(&mut self, offset: u64, value: u32) -> Result<(), BackendError>

fn barrier(&mut self)

fn gpio_read(&mut self) -> Result<bool, BackendError>

fn gpio_write(&mut self, value: bool) -> Result<(), BackendError>

fn i2c_transfer( &mut self, write_data: &[u8], read_length: usize, ) -> Result<Vec<u8>, BackendError>

fn spi_transmit(&mut self, tx_data: &[u8]) -> Result<Vec<u8>, BackendError>

fn clock_enable(&mut self) -> Result<(), BackendError>

fn clock_disable(&mut self) -> Result<(), BackendError>

fn clock_is_enabled(&mut self) -> Result<bool, BackendError>

fn clock_set_rate(&mut self, hz: u64) -> Result<(), BackendError>

fn clock_query_rate(&mut self, hz_in: u64) -> Result<u64, BackendError>

fn clock_get_rate(&mut self) -> Result<u64, BackendError>

fn reset_assert(&mut self) -> Result<(), BackendError>

fn reset_deassert(&mut self) -> Result<(), BackendError>

fn reset_toggle(&mut self) -> Result<(), BackendError>

fn reset_status(&mut self) -> Result<bool, BackendError>

fn serial_read(&mut self) -> Result<Vec<u8>, BackendError>

fn serial_write(&mut self, data: &[u8]) -> Result<(), BackendError>