m68k-backplane-computer/emu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pass full function code to all memory functions

Browse Source
This commit is contained in:
pjht 2024-03-14 13:29:21 -05:00
parent 2447a98e87
commit 40acac97b5
Signed by: pjht
GPG Key ID: CA239FC6934E6F3A
9 changed files with 141 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/backplane.rs
View File

@ -9,6 +9,7 @@ use anyhow::anyhow;
use itertools::Itertools;
use nullable_result::{GeneralIterExt, NullableResult};
use crate::m68k::FunctionCode;
use crate::InterconnectConfig;
use crate::{
card::{self, Card},
@ -151,102 +152,102 @@ impl Backplane {
.cmd(cmd, self)
}
pub fn read_word(&self, address: u32, supervisor: bool) -> Result<u16, BusError> {
pub fn read_word(&self, address: u32, function: FunctionCode) -> Result<u16, BusError> {
self.mem_helper(
address,
|address, mut card| card.read_word(address),
|address, mut card| card.read_word_io(address as u8),
|address, mut card| card.read_word(address, function),
|address, mut card| card.read_word_io(address as u8, function),
|address| self.read_word_io(address as u8),
false,
false,
supervisor,
function,
)
}
pub fn read_byte(&self, address: u32, supervisor: bool) -> Result<u8, BusError> {
pub fn read_byte(&self, address: u32, function: FunctionCode) -> Result<u8, BusError> {
self.mem_helper(
address,
|address, mut card| card.read_byte(address),
|address, mut card| card.read_byte_io(address as u8),
|address, mut card| card.read_byte(address, function),
|address, mut card| card.read_byte_io(address as u8, function),
|address| self.read_byte_io(address as u8),
false,
false,
supervisor,
function,
)
}
pub fn write_word(&self, address: u32, data: u16, supervisor: bool) -> Result<(), BusError> {
pub fn write_word(&self, address: u32, data: u16, function: FunctionCode) -> Result<(), BusError> {
self.mem_helper(
address,
|address, mut card| card.write_word(address, data),
|address, mut card| card.write_word_io(address as u8, data),
|address, mut card| card.write_word(address, data, function),
|address, mut card| card.write_word_io(address as u8, data, function),
|address| self.write_word_io(address as u8, data),
false,
true,
supervisor,
function,
)
}
pub fn write_byte(&self, address: u32, data: u8, supervisor: bool) -> Result<(), BusError> {
pub fn write_byte(&self, address: u32, data: u8, function: FunctionCode) -> Result<(), BusError> {
self.mem_helper(
address,
|address, mut card| card.write_byte(address, data),
|address, mut card| card.write_byte_io(address as u8, data),
|address, mut card| card.write_byte(address, data, function),
|address, mut card| card.write_byte_io(address as u8, data, function),
|address| self.write_byte_io(address as u8, data),
false,
true,
supervisor,
function,
)
}
pub fn read_word_phys(&self, address: u32) -> Result<u16, BusError> {
pub fn read_word_phys(&self, address: u32, function: FunctionCode) -> Result<u16, BusError> {
self.mem_helper(
address,
|address, mut card| card.read_word(address),
|address, mut card| card.read_word_io(address as u8),
|address, mut card| card.read_word(address, function),
|address, mut card| card.read_word_io(address as u8, function),
|address| self.read_word_io(address as u8),
true,
false,
true,
function,
)
}
#[allow(dead_code)]
pub fn read_byte_phys(&self, address: u32) -> Result<u8, BusError> {
pub fn read_byte_phys(&self, address: u32, function: FunctionCode) -> Result<u8, BusError> {
self.mem_helper(
address,
|address, mut card| card.read_byte(address),
|address, mut card| card.read_byte_io(address as u8),
|address, mut card| card.read_byte(address, function),
|address, mut card| card.read_byte_io(address as u8, function),
|address| self.read_byte_io(address as u8),
true,
false,
true,
function,
)
}
#[allow(dead_code)]
pub fn write_word_phys(&self, address: u32, data: u16) -> Result<(), BusError> {
pub fn write_word_phys(&self, address: u32, data: u16, function: FunctionCode) -> Result<(), BusError> {
self.mem_helper(
address,
|address, mut card| card.write_word(address, data),
|address, mut card| card.write_word_io(address as u8, data),
|address, mut card| card.write_word(address, data, function),
|address, mut card| card.write_word_io(address as u8, data, function),
|address| self.write_word_io(address as u8, data),
true,
true,
true,
function,
)
}
#[allow(dead_code)]
pub fn write_byte_phys(&self, address: u32, data: u8) -> Result<(), BusError> {
pub fn write_byte_phys(&self, address: u32, data: u8, function: FunctionCode) -> Result<(), BusError> {
self.mem_helper(
address,
|address, mut card| card.write_byte(address, data),
|address, mut card| card.write_byte_io(address as u8, data),
|address, mut card| card.write_byte(address, data, function),
|address, mut card| card.write_byte_io(address as u8, data, function),
|address| self.write_byte_io(address as u8, data),
true,
true,
true,
function,
)
}
@ -258,7 +259,7 @@ impl Backplane {
mut backplane_io_func: B,
bypass_mmu: bool,
write: bool,
supervisor: bool,
function: FunctionCode,
) -> Result<T, BusError>
where
M: FnMut(u32, RefMut<'_, dyn Card>) -> NullableResult<T, BusError>,
@ -272,7 +273,7 @@ impl Backplane {
.borrow_mut()
.try_as_mmu()
.unwrap()
.translate_address(self, address, write, supervisor)
.translate_address(self, address, write, function)
{
NullableResult::Ok(address) => address,
NullableResult::Err(e) => return Err(e),

36
src/card.rs
View File

@ -2,7 +2,7 @@
use crate::{
backplane::{Backplane, InterconnectSenderBuilder},
m68k::BusError,
m68k::{BusError, FunctionCode},
};
use anyhow::anyhow;
use mopa::mopafy;
@ -67,47 +67,47 @@ pub trait Card: Debug + Display + mopa::Any {
Ok(Rc::new(RefCell::new(card)))
}
fn read_byte(&mut self, _address: u32) -> NullableResult<u8, BusError> {
fn read_byte(&mut self, _address: u32, _function: FunctionCode) -> NullableResult<u8, BusError> {
NullableResult::Null
}
fn write_byte(&mut self, _address: u32, _data: u8) -> NullableResult<(), BusError> {
fn write_byte(&mut self, _address: u32, _data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
NullableResult::Null
}
fn read_byte_io(&mut self, _address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, _address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
NullableResult::Null
}
fn write_byte_io(&mut self, _address: u8, _data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, _address: u8, _data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
NullableResult::Null
}
fn read_word(&mut self, address: u32) -> NullableResult<u16, BusError> {
fn read_word(&mut self, address: u32, function: FunctionCode) -> NullableResult<u16, BusError> {
assert!((address & 0x1) == 0);
let upper_byte = self.read_byte(address)?;
let lower_byte = self.read_byte(address + 1)?;
let upper_byte = self.read_byte(address, function)?;
let lower_byte = self.read_byte(address + 1, function)?;
NullableResult::Ok((u16::from(upper_byte) << 8) | u16::from(lower_byte))
}
fn write_word(&mut self, address: u32, data: u16) -> NullableResult<(), BusError> {
fn write_word(&mut self, address: u32, data: u16, function: FunctionCode) -> NullableResult<(), BusError> {
assert!((address & 0x1) == 0);
self.write_byte(address, (data >> 8) as u8)?;
self.write_byte(address + 1, data as u8)?;
self.write_byte(address, (data >> 8) as u8, function)?;
self.write_byte(address + 1, data as u8, function)?;
NullableResult::Ok(())
}
fn read_word_io(&mut self, address: u8) -> NullableResult<u16, BusError> {
fn read_word_io(&mut self, address: u8, function: FunctionCode) -> NullableResult<u16, BusError> {
assert!((address & 0x1) == 0);
let upper_byte = self.read_byte_io(address)?;
let lower_byte = self.read_byte_io(address + 1)?;
let upper_byte = self.read_byte_io(address, function)?;
let lower_byte = self.read_byte_io(address + 1, function)?;
NullableResult::Ok((u16::from(upper_byte) << 8) | u16::from(lower_byte))
}
fn write_word_io(&mut self, address: u8, data: u16) -> NullableResult<(), BusError> {
fn write_word_io(&mut self, address: u8, data: u16, function: FunctionCode) -> NullableResult<(), BusError> {
assert!((address & 0x1) == 0);
self.write_byte_io(address, (data >> 8) as u8)?;
self.write_byte_io(address + 1, data as u8)?;
self.write_byte_io(address, (data >> 8) as u8, function)?;
self.write_byte_io(address + 1, data as u8, function)?;
NullableResult::Ok(())
}
@ -145,7 +145,7 @@ pub trait Mmu: Debug {
backplane: &Backplane,
address: u32,
write: bool,
supervisor: bool,
function: FunctionCode
) -> NullableResult<u32, BusError>;
}

72
src/m68k.rs
View File

@ -162,6 +162,33 @@ impl Display for InsExecError {
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FunctionCode {
UserData,
UserProgram,
SupervisorData,
SupervisorProgram,
}
impl FunctionCode {
pub fn new(code: bool, supervisor: bool) -> Self {
match (supervisor, code) {
(false, false) => Self::UserData,
(false, true) => Self::UserProgram,
(true, false) => Self::SupervisorData,
(true, true) => Self::SupervisorProgram,
}
}
pub fn is_code(self) -> bool {
self == Self::UserProgram || self == Self::SupervisorProgram
}
pub fn is_supervisor(self) -> bool {
self == Self::SupervisorData || self == Self::SupervisorProgram
}
}
#[derive(Debug)]
pub struct M68K {
dregs: [u32; 8],
@ -234,11 +261,12 @@ impl M68K {
}
pub fn reset(&mut self) {
let function = FunctionCode::SupervisorProgram;
if let (Ok(ssp_high), Ok(ssp_low), Ok(pc_high), Ok(pc_low)) = (
self.read_word(0),
self.read_word(2),
self.read_word(4),
self.read_word(6),
self.read_word(0, function),
self.read_word(2, function),
self.read_word(4, function),
self.read_word(6, function),
) {
self.ssp = (u32::from(ssp_high) << 16) | u32::from(ssp_low);
self.vbr = 0;
@ -260,7 +288,7 @@ impl M68K {
loc: u32,
) -> Result<(Instruction, u32), DisassemblyError<InsExecError>> {
disas::disasm(loc, &mut |addr| {
self.read_word(addr).map_err(|err| match err {
self.read_word(addr, FunctionCode::new(true, self.is_supervisor())).map_err(|err| match err {
InsExecError::AbnormalTrap => InsExecError::AbnormalTrap,
InsExecError::BusError(err) => InsExecError::BusError(DetailedBusError {
cause: BusErrorCause::ReadingInstruction,
@ -1502,30 +1530,32 @@ impl M68K {
}
fn read_address(&mut self, address: u32, size: Size) -> Result<u32, InsExecError> {
let function = FunctionCode::new(false, self.is_supervisor());
let address = address & 0xFF_FFFF;
match size {
Size::Byte => Ok(u32::from(self.read_byte(address)?)),
Size::Word => Ok(u32::from(self.read_word(address)?)),
Size::Byte => Ok(u32::from(self.read_byte(address, function)?)),
Size::Word => Ok(u32::from(self.read_word(address, function)?)),
Size::Long => {
Ok(u32::from(self.read_word(address)?) << 16
| u32::from(self.read_word(address + 2)?))
Ok(u32::from(self.read_word(address, function)?) << 16
| u32::from(self.read_word(address + 2, function)?))
}
}
}
fn write_address(&mut self, address: u32, data: u32, size: Size) -> Result<(), InsExecError> {
let function = FunctionCode::new(false, self.is_supervisor());
match size {
Size::Byte => self.write_byte(address, data as u8)?,
Size::Word => self.write_word(address, data as u16)?,
Size::Byte => self.write_byte(address, data as u8, function)?,
Size::Word => self.write_word(address, data as u16, function)?,
Size::Long => {
self.write_word(address, (data >> 16) as u16)?;
self.write_word(address + 2, data as u16)?;
self.write_word(address, (data >> 16) as u16, function)?;
self.write_word(address + 2, data as u16, function)?;
}
}
Ok(())
}
fn read_byte(&mut self, address: u32) -> Result<u8, InsExecError> {
fn read_byte(&mut self, address: u32, function: FunctionCode) -> Result<u8, InsExecError> {
let address = address & 0xFF_FFFF;
if self.use_stored_mem_cycles {
let cycle = self.stored_mem_cycles.remove(0);
@ -1543,7 +1573,7 @@ impl M68K {
}
let result = self
.bus
.read_byte(address, self.is_supervisor())
.read_byte(address, function)
.map_err(|_| DetailedBusError {
address,
cause: BusErrorCause::ReadingByte,
@ -1555,7 +1585,7 @@ impl M68K {
Ok(result?)
}
fn write_byte(&mut self, address: u32, data: u8) -> Result<(), InsExecError> {
fn write_byte(&mut self, address: u32, data: u8, function: FunctionCode) -> Result<(), InsExecError> {
let address = address & 0xFF_FFFF;
if self.use_stored_mem_cycles {
let cycle = self.stored_mem_cycles.remove(0);
@ -1579,7 +1609,7 @@ impl M68K {
}
let result = self
.bus
.write_byte(address, data, self.is_supervisor())
.write_byte(address, data, function)
.map_err(|_| DetailedBusError {
address,
cause: BusErrorCause::WritingByte,
@ -1594,7 +1624,7 @@ impl M68K {
Ok(result?)
}
fn read_word(&mut self, address: u32) -> Result<u16, InsExecError> {
fn read_word(&mut self, address: u32, function: FunctionCode) -> Result<u16, InsExecError> {
let address = address & 0xFF_FFFF;
if address & 0x1 != 0 {
self.trap(3)?;
@ -1616,7 +1646,7 @@ impl M68K {
}
let result = self
.bus
.read_word(address, self.is_supervisor())
.read_word(address, function)
.map_err(|_| DetailedBusError {
address,
cause: BusErrorCause::ReadingWord,
@ -1628,7 +1658,7 @@ impl M68K {
Ok(result?)
}
fn write_word(&mut self, address: u32, data: u16) -> Result<(), InsExecError> {
fn write_word(&mut self, address: u32, data: u16, function: FunctionCode) -> Result<(), InsExecError> {
let address = address & 0xFF_FFFF;
if address & 0x1 != 0 {
self.trap(3)?;
@ -1656,7 +1686,7 @@ impl M68K {
}
let result = self
.bus
.write_word(address, data, self.is_supervisor())
.write_word(address, data, function)
.map_err(|_| DetailedBusError {
address,
cause: BusErrorCause::WritingWord,

24
src/main.rs
View File

@ -21,7 +21,7 @@ use clap::Parser;
use disas::DisassemblyError;
use indexmap::IndexSet;
use itertools::Itertools;
use m68k::InsExecError;
use m68k::{FunctionCode, InsExecError};
use parse_int::parse;
use reedline_repl_rs::{
clap::{builder::BoolishValueParser, Arg, ArgAction, Command},
@ -280,25 +280,26 @@ fn main() -> Result<(), anyhow::Error> {
}
let mut data = Vec::new();
let bus = state.cpu.bus_mut();
let function = FunctionCode::SupervisorData;
if args.get_flag("phys") {
for i in 0..count {
match size {
peek::Size::Byte => data.push(u32::from(bus.read_byte_phys(addr + i)?)),
peek::Size::Word => data.push(u32::from(bus.read_word_phys(addr + (i * 2))?)),
peek::Size::Byte => data.push(u32::from(bus.read_byte_phys(addr + i, function)?)),
peek::Size::Word => data.push(u32::from(bus.read_word_phys(addr + (i * 2), function)?)),
peek::Size::LongWord => data.push(
u32::from(bus.read_word_phys(addr + (i * 4))?) << 16
| u32::from(bus.read_word_phys(addr + (i * 4) + 2)?),
u32::from(bus.read_word_phys(addr + (i * 4), function)?) << 16
| u32::from(bus.read_word_phys(addr + (i * 4) + 2, function)?),
),
}
}
} else {
for i in 0..count {
match size {
peek::Size::Byte => data.push(u32::from(bus.read_byte(addr + i, true)?)),
peek::Size::Word => data.push(u32::from(bus.read_word(addr + (i * 2), true)?)),
peek::Size::Byte => data.push(u32::from(bus.read_byte(addr + i, function)?)),
peek::Size::Word => data.push(u32::from(bus.read_word(addr + (i * 2), function)?)),
peek::Size::LongWord => data.push(
u32::from(bus.read_word(addr + (i * 4), true)?) << 16
| u32::from(bus.read_word(addr + (i * 4) + 2, true)?),
u32::from(bus.read_word(addr + (i * 4), function)?) << 16
| u32::from(bus.read_word(addr + (i * 4) + 2, function)?),
),
}
}
@ -330,15 +331,16 @@ fn main() -> Result<(), anyhow::Error> {
.about("Write to a memory address"),
|args, state| {
let address = parse::<u32>(args.get_one::<String>("address").unwrap())?;
let function = FunctionCode::SupervisorData;
if args.get_flag("word") {
if (address & 0x1) != 0 {
return Err(anyhow!("Cannot poke a word to a non-aligned address"));
}
let data = parse::<u16>(args.get_one::<String>("data").unwrap())?;
state.cpu.bus_mut().write_word(address, data, true)?;
state.cpu.bus_mut().write_word(address, data, function)?;
} else {
let data = parse::<u8>(args.get_one::<String>("data").unwrap())?;
state.cpu.bus_mut().write_byte(address, data, true)?;
state.cpu.bus_mut().write_byte(address, data, function)?;
}
Ok(None)
}

14
src/mmu.rs
View File

@ -5,7 +5,7 @@ use nullable_result::NullableResult;
use crate::{
backplane::Backplane,
card::{u16_get_be_byte, u32_get_be_byte, u32_set_be_byte, Card, Mmu},
m68k::BusError,
m68k::{BusError, FunctionCode},
register,
};
@ -39,8 +39,8 @@ impl MmuCard {
if print_debug {
println!("Mapping is at {mapping_address:#x}");
}
let mapping_hi = backplane.read_word_phys(mapping_address)?;
let mapping_lo = backplane.read_word_phys(mapping_address + 2)?;
let mapping_hi = backplane.read_word_phys(mapping_address, FunctionCode::SupervisorData)?;
let mapping_lo = backplane.read_word_phys(mapping_address + 2, FunctionCode::SupervisorData)?;
NullableResult::Ok((u32::from(mapping_hi) << 16 | u32::from(mapping_lo)) | TLB_MAPPING_FLAG_VALID)
}
}
@ -61,7 +61,7 @@ impl Card for MmuCard {
Some(self)
}
fn read_byte_io(&mut self, address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
match address {
(0x0..=0xF) => {
let map_no = (address / 4) as usize;
@ -77,7 +77,7 @@ impl Card for MmuCard {
}
}
fn write_byte_io(&mut self, address: u8, data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, address: u8, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
match address {
(0x0..=0xF) => {
let map_no = (address / 4) as usize;
@ -344,7 +344,7 @@ impl Mmu for MmuCard {
backplane: &Backplane,
address: u32,
write: bool,
supervisor: bool,
function: FunctionCode,
) -> NullableResult<u32, BusError> {
let print_debug = self.print_debug;
if self.enabled {
@ -368,7 +368,7 @@ impl Mmu for MmuCard {
mapping
};
if mapping & MAPPING_FLAG_PRESENT > 0 {
if !supervisor && (mapping & MAPPING_FLAG_USER == 0) {
if !function.is_supervisor() && (mapping & MAPPING_FLAG_USER == 0) {
if print_debug {
println!("Page not user accessible");
}

10
src/ram.rs
View File

@ -7,7 +7,7 @@ use toml::Value;
use crate::{
card::{u16_get_be_byte, u32_get_be_byte, Card},
m68k::BusError,
m68k::{BusError, FunctionCode},
register,
};
@ -34,7 +34,7 @@ impl Card for Ram {
enabled: false,
})
}
fn read_byte(&mut self, address: u32) -> NullableResult<u8, BusError> {
fn read_byte(&mut self, address: u32, _function: FunctionCode) -> NullableResult<u8, BusError> {
if !self.enabled {
return NullableResult::Null;
}
@ -42,7 +42,7 @@ impl Card for Ram {
self.data.get(address as usize).copied().into()
}
fn write_byte(&mut self, address: u32, data: u8) -> NullableResult<(), BusError> {
fn write_byte(&mut self, address: u32, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
if !self.enabled {
return NullableResult::Null;
}
@ -54,7 +54,7 @@ impl Card for Ram {
NullableResult::Ok(())
}
fn write_byte_io(&mut self, address: u8, data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, address: u8, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
match address {
0 => self.start = self.start & !0xFF00_0000 | (u32::from(data) << 24),
1 => self.start = self.start & !0x00FF_0000 | (u32::from(data) << 16),
@ -68,7 +68,7 @@ impl Card for Ram {
NullableResult::Ok(())
}
fn read_byte_io(&mut self, address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
match address {
0 => NullableResult::Ok((self.start >> 24) as u8),
1 => NullableResult::Ok((self.start >> 16) as u8),

10
src/rom.rs
View File

@ -7,7 +7,7 @@ use serde::Deserialize;
use toml::Value;
use crate::{
backplane::Backplane, card::{u16_get_be_byte, u16_set_be_byte, Card}, m68k::BusError, register
backplane::Backplane, card::{u16_get_be_byte, u16_set_be_byte, Card}, m68k::{BusError, FunctionCode}, register
};
const ID: u16 = 1;
@ -47,7 +47,7 @@ impl Card for Rom {
})
}
fn read_byte(&mut self, address: u32) -> NullableResult<u8, BusError> {
fn read_byte(&mut self, address: u32, _function: FunctionCode) -> NullableResult<u8, BusError> {
if !self.enabled | ((address >> 16) as u16 != self.start) {
return NullableResult::Null;
}
@ -59,7 +59,7 @@ impl Card for Rom {
}
}
fn write_byte(&mut self, address: u32, data: u8) -> NullableResult<(), BusError> {
fn write_byte(&mut self, address: u32, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
if !self.enabled | ((address >> 16) as u16 != self.start) {
return NullableResult::Null;
}
@ -71,7 +71,7 @@ impl Card for Rom {
NullableResult::Ok(())
}
fn read_byte_io(&mut self, address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
match address {
(0..=0xEF) => NullableResult::Ok(self.ram[address as usize]),
(0xF0..=0xF1) => NullableResult::Ok(u16_get_be_byte(self.start, address - 0xF0)),
@ -81,7 +81,7 @@ impl Card for Rom {
}
}
fn write_byte_io(&mut self, address: u8, data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, address: u8, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
match address {
(0..=0xEF) => {
self.ram[address as usize] = data;

8
src/storage.rs
View File

@ -1,7 +1,7 @@
use crate::{
backplane::Backplane,
card::{u16_get_be_byte, u32_get_be_byte, u32_set_be_byte, Card},
m68k::BusError,
m68k::{BusError, FunctionCode},
register,
};
use anyhow::anyhow;
@ -72,7 +72,7 @@ impl Card for Storage {
})
}
fn read_byte_io(&mut self, address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
match address {
0x0..=0x3 => NullableResult::Ok(u32_get_be_byte(self.sector, address)),
0x4..=0x7 => NullableResult::Ok(u32_get_be_byte(self.count, address - 0x4)),
@ -89,7 +89,7 @@ impl Card for Storage {
}
}
fn write_byte_io(&mut self, address: u8, data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, address: u8, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
match address {
0x0..=0x3 => {
self.sector = u32_set_be_byte(self.sector, address, data);
@ -156,7 +156,7 @@ impl Card for Storage {
// Closure is used to drop the mutex guard
// between pop calls to prevent deadlock
while let Some(data) = (|| self.read_data.pop_front())() {
backplane.write_byte(address, data, true).unwrap();
backplane.write_byte(address, data, FunctionCode::SupervisorData).unwrap();
address += 1;
}
self.transfer = false;

6
src/term.rs
View File

@ -5,7 +5,7 @@ use toml::Value;
use crate::{
card::{u16_get_be_byte, Card},
m68k::BusError,
m68k::{BusError, FunctionCode},
register,
};
@ -28,14 +28,14 @@ impl Card for Term {
Ok(Self)
}
fn read_byte_io(&mut self, address: u8) -> NullableResult<u8, BusError> {
fn read_byte_io(&mut self, address: u8, _function: FunctionCode) -> NullableResult<u8, BusError> {
match address {
(0xFE..=0xFF) => NullableResult::Ok(u16_get_be_byte(ID, address - 0xFE)),
_ => NullableResult::Null,
}
}
fn write_byte_io(&mut self, address: u8, data: u8) -> NullableResult<(), BusError> {
fn write_byte_io(&mut self, address: u8, data: u8, _function: FunctionCode) -> NullableResult<(), BusError> {
if address == 0 {
print!("{}", data as char);
}