Trait emulator_hal::BusAccess

pub trait BusAccess<Address>
where
    Address: Copy,
{
    type Instant: Instant;
    type Error: ErrorType;

    // Required methods
    fn read(
        &mut self,
        now: Self::Instant,
        addr: Address,
        data: &mut [u8]
    ) -> Result<usize, Self::Error>;
    fn write(
        &mut self,
        now: Self::Instant,
        addr: Address,
        data: &[u8]
    ) -> Result<usize, Self::Error>;

    // Provided methods
    fn read_u8(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u8, Self::Error> { ... }
    fn read_beu16(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u16, Self::Error> { ... }
    fn read_leu16(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u16, Self::Error> { ... }
    fn read_u16(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address
    ) -> Result<u16, Self::Error> { ... }
    fn read_beu32(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u32, Self::Error> { ... }
    fn read_leu32(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u32, Self::Error> { ... }
    fn read_u32(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address
    ) -> Result<u32, Self::Error> { ... }
    fn read_beu64(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u64, Self::Error> { ... }
    fn read_leu64(
        &mut self,
        now: Self::Instant,
        addr: Address
    ) -> Result<u64, Self::Error> { ... }
    fn read_u64(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address
    ) -> Result<u64, Self::Error> { ... }
    fn write_u8(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u8
    ) -> Result<(), Self::Error> { ... }
    fn write_beu16(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u16
    ) -> Result<(), Self::Error> { ... }
    fn write_leu16(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u16
    ) -> Result<(), Self::Error> { ... }
    fn write_u16(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address,
        value: u16
    ) -> Result<(), Self::Error> { ... }
    fn write_beu32(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u32
    ) -> Result<(), Self::Error> { ... }
    fn write_leu32(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u32
    ) -> Result<(), Self::Error> { ... }
    fn write_u32(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address,
        value: u32
    ) -> Result<(), Self::Error> { ... }
    fn write_beu64(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u64
    ) -> Result<(), Self::Error> { ... }
    fn write_leu64(
        &mut self,
        now: Self::Instant,
        addr: Address,
        value: u64
    ) -> Result<(), Self::Error> { ... }
    fn write_u64(
        &mut self,
        order: ByteOrder,
        now: Self::Instant,
        addr: Address,
        value: u64
    ) -> Result<(), Self::Error> { ... }
}

A device that can be addressed to read data from or write data to the device.

This represents access to a peripheral device or a bus of multiple devices, which can be used by a controller (eg. CPU). The address can either be a single number or a tuple to represent different address spaces, such as memory vs I/O spaces as in the Z80 CPUs, or supervisor vs user access as in the Function Code present on 68k CPUs.

Required Associated Types

type Instant: Instant

The type of an instant in simulated time that the bus access is meant to occur at

type Error: ErrorType

The type of an error returned by this bus

Required Methods

fn read( &mut self, now: Self::Instant, addr: Address, data: &mut [u8] ) -> Result<usize, Self::Error>

Read an arbitrary length of bytes from this device, at time now

Returns the number of bytes read, which would normally be the same as data.len() but could be less or zero if no data is returned

fn write( &mut self, now: Self::Instant, addr: Address, data: &[u8] ) -> Result<usize, Self::Error>

Write an arbitrary length of bytes into this device, at time now

Returns the number of bytes written, which would normally be the same as data.len() but could be less or zero if no data was written or the memory was read-only

Provided Methods

fn read_u8( &mut self, now: Self::Instant, addr: Address ) -> Result<u8, Self::Error>

Read a single u8 value at the given address

fn read_beu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in big endian byte order at the given address

fn read_leu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in little endian byte order at the given address

fn read_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in the given byte order at the given address

fn read_beu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in big endian byte order at the given address

fn read_leu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in little endian byte order at the given address

fn read_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in the given byte order at the given address

fn read_beu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in big endian byte order at the given address

fn read_leu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in little endian byte order at the given address

fn read_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in the given byte order at the given address

fn write_u8( &mut self, now: Self::Instant, addr: Address, value: u8 ) -> Result<(), Self::Error>

Write a single u8 value to the given address

fn write_beu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in big endian byte order to the given address

fn write_leu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in little endian byte order to the given address

fn write_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in the given byte order to the given address

fn write_beu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in big endian byte order to the given address

fn write_leu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in little endian byte order to the given address

fn write_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in the given byte order to the given address

fn write_beu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in big endian byte order to the given address

fn write_leu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in little endian byte order to the given address

fn write_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in the given byte order to the given address

Implementations on Foreign Types

impl<Address, T> BusAccess<Address> for &mut T

where Address: Copy, T: BusAccess<Address> + ?Sized,

type Instant = <T as BusAccess<Address>>::Instant

type Error = <T as BusAccess<Address>>::Error

fn read( &mut self, now: Self::Instant, addr: Address, data: &mut [u8] ) -> Result<usize, T::Error>

fn write( &mut self, now: Self::Instant, addr: Address, data: &[u8] ) -> Result<usize, T::Error>

impl<Address, T> BusAccess<Address> for Box<T>

where Address: Copy, T: BusAccess<Address> + ?Sized,

type Instant = <T as BusAccess<Address>>::Instant

type Error = <T as BusAccess<Address>>::Error

fn read( &mut self, now: Self::Instant, addr: Address, data: &mut [u8] ) -> Result<usize, T::Error>

fn write( &mut self, now: Self::Instant, addr: Address, data: &[u8] ) -> Result<usize, T::Error>

Implementors

impl<Address, Instant> BusAccess<Address> for NoBus<Instant>

where Address: Copy, Instant: EmuInstant,

type Instant = Instant

type Error = BasicBusError

impl<AddressIn, AddressOut, Bus, ErrorOut> BusAccess<AddressIn> for AutoBusAdapter<AddressIn, AddressOut, Bus, ErrorOut>

where AddressIn: Copy, AddressOut: FromAddress<AddressIn> + Copy, Bus: BusAccess<AddressOut>, ErrorOut: ErrorType + From<Bus::Error>,

type Instant = <Bus as BusAccess<AddressOut>>::Instant

type Error = ErrorOut

impl<AddressIn, AddressOut, Bus, ErrorOut> BusAccess<AddressIn> for BusAdapter<AddressIn, AddressOut, Bus, ErrorOut>

where AddressIn: Copy, AddressOut: Copy, Bus: BusAccess<AddressOut>, ErrorOut: ErrorType + From<Bus::Error>,

type Instant = <Bus as BusAccess<AddressOut>>::Instant

type Error = ErrorOut