Struct moa_core::Bus

pub struct Bus {
    blocks: Vec<Block>,
    ignore_unmapped: bool,
    watchers: Vec<Address>,
    watcher_modified: bool,
}

A bus-like collection of Addressable Devices mapped to different address ranges

This is the fundamental means of connecting devices together to a CPU implementation.

Fields

blocks: Vec<Block>

ignore_unmapped: bool

watchers: Vec<Address>

watcher_modified: bool

Implementations

impl Bus

pub fn set_ignore_unmapped(&mut self, ignore_unmapped: bool)

pub fn clear_all_bus_devices(&mut self)

pub fn insert(&mut self, base: Address, dev: Device)

pub fn get_device_at( &self, addr: Address, count: usize ) -> Result<(Device, Address), Error>

pub fn dump_memory(&mut self, clock: Instant, addr: Address, count: Address)

pub fn add_watcher(&mut self, addr: Address)

pub fn remove_watcher(&mut self, addr: Address)

pub fn check_and_reset_watcher_modified(&mut self) -> bool

Trait Implementations

impl Addressable for Bus

fn size(&self) -> usize

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

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

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

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

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

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

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

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

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

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

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

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

impl BusAccess<u64> for Bus

type Instant = Instant

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

type Error = Error

The type of an error returned by this bus

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

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

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

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

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

impl Clone for Bus

fn clone(&self) -> Bus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Bus

fn default() -> Bus

Returns the “default value” for a type.