Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

refactored

Layle4117d863fc81
diff --git a/crates/gekko/src/lib.rs b/crates/gekko/src/lib.rs
index c634bca..32b1cd7 100644
--- a/crates/gekko/src/lib.rs
+++ b/crates/gekko/src/lib.rs
@@ -2,4 +2,27 @@ pub mod cpu;
pub mod scheduler;
pub mod gekko;
pub mod mmio;
-pub mod vi;
\ No newline at end of file
+pub mod vi;
+
+/// Generate `read_raw` and `write_raw` dispatch methods for a list of MMIO register types
+#[macro_export]
+macro_rules! impl_mmio_dispatch {
+ ($($reg:ty),* $(,)?) => {
+ #[inline]
+ fn read_raw(&self, addr: u32, access_size: u32) -> Option<u32> {
+ $(if <$reg>::fits(addr, access_size) {
+ return Some(<$reg>::read_at(self, addr, access_size));
+ })*
+ None
+ }
+
+ #[inline]
+ fn write_raw(&mut self, addr: u32, access_size: u32, val: u32) -> bool {
+ $(if <$reg>::fits(addr, access_size) {
+ <$reg>::write_at(self, addr, access_size, val);
+ return true;
+ })*
+ false
+ }
+ };
+}
\ No newline at end of file
diff --git a/crates/gekko/src/mmio/traits.rs b/crates/gekko/src/mmio/traits.rs
index e2782a4..893d7f7 100644
--- a/crates/gekko/src/mmio/traits.rs
+++ b/crates/gekko/src/mmio/traits.rs
@@ -4,9 +4,45 @@ pub trait MmioRegister: Sized {
fn from_raw(raw: u32) -> Self;
fn to_raw(self) -> u32;
+
+ fn contains(addr: u32) -> bool {
+ addr >= Self::ADDR && addr < Self::ADDR + Self::SIZE as u32
+ }
+
+ fn fits(addr: u32, access_size: u32) -> bool {
+ addr >= Self::ADDR && addr + access_size <= Self::ADDR + Self::SIZE as u32
+ }
+
+ /// Extract `access_size` bytes at `addr` from `raw` (big-endian register of `SIZE` bytes)
+ fn read_sub(raw: u32, addr: u32, access_size: u32) -> u32 {
+ let sub_offset = addr - Self::ADDR;
+ let shift = (Self::SIZE as u32 - sub_offset - access_size) * 8;
+ let mask = ((1u64 << (access_size * 8)) - 1) as u32;
+ (raw >> shift) & mask
+ }
+
+ /// Return `full` with `access_size` bytes at `addr` replaced by `val` (big-endian)
+ fn write_sub(full: u32, addr: u32, access_size: u32, val: u32) -> u32 {
+ let sub_offset = addr - Self::ADDR;
+ let shift = (Self::SIZE as u32 - sub_offset - access_size) * 8;
+ let mask = ((1u64 << (access_size * 8)) - 1) as u32;
+ (full & !(mask << shift)) | ((val & mask) << shift)
+ }
}
pub trait MmioAccess<C>: MmioRegister {
fn read(component: &C) -> Self;
fn write(self, component: &mut C);
-}
\ No newline at end of file
+
+ /// Read `access_size` bytes from this register in `component` at physical address `addr`
+ fn read_at(component: &C, addr: u32, access_size: u32) -> u32 {
+ Self::read_sub(Self::read(component).to_raw(), addr, access_size)
+ }
+
+ /// Write `access_size` bytes at `addr` into this register in `component`
+ /// Unaffected bytes in the register are preserved
+ fn write_at(component: &mut C, addr: u32, access_size: u32, val: u32) {
+ let merged = Self::write_sub(Self::read(component).to_raw(), addr, access_size, val);
+ Self::from_raw(merged).write(component);
+ }
+}
diff --git a/crates/gekko/src/vi.rs b/crates/gekko/src/vi.rs
index b61ce98..5edc40a 100644
--- a/crates/gekko/src/vi.rs
+++ b/crates/gekko/src/vi.rs
@@ -1,3 +1,6 @@
+#[cfg(test)]
+mod tests;
+
pub mod regs;
use crate::{
@@ -21,61 +24,53 @@ impl Vi {
}
}
+ crate::impl_mmio_dispatch!(
+ regs::DisplayConfiguration,
+ regs::TopFieldBase,
+ regs::BottomFieldBase,
+ );
+
pub fn xfb_addr(&self) -> u32 {
let top = self.top_field_base;
(top.xfb_addr() << 9) | ((top.page_offset() as u32) << 24)
}
pub fn mmio_read_u8(&self, offset: u32) -> u8 {
- tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI read_u8");
- 0
+ self.read_raw(VI_BASE + offset, 1).unwrap_or_else(|| {
+ tracing::warn!(offset = format!("{offset:08X}"), "unhandled VI read_u8");
+ 0
+ }) as u8
}
- pub fn mmio_write_u8(&mut self, offset: u32, _val: u8) {
- tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI write_u8");
+ pub fn mmio_write_u8(&mut self, offset: u32, val: u8) {
+ if !self.write_raw(VI_BASE + offset, 1, val as u32) {
+ tracing::warn!(offset = format!("{offset:#08X}"), "unhandled VI write_u8");
+ }
}
pub fn mmio_read_u16(&self, offset: u32) -> u16 {
- match VI_BASE + offset {
- regs::DisplayConfiguration::ADDR => {
- regs::DisplayConfiguration::read(self).to_raw() as u16
- }
- _ => {
- tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI read_u16");
- 0
- }
- }
+ self.read_raw(VI_BASE + offset, 2).unwrap_or_else(|| {
+ tracing::warn!(offset = format!("{offset:#08X}"), "unhandled VI read_u16");
+ 0
+ }) as u16
}
pub fn mmio_write_u16(&mut self, offset: u32, val: u16) {
- match VI_BASE + offset {
- regs::DisplayConfiguration::ADDR => {
- <regs::DisplayConfiguration as MmioRegister>::from_raw(val as u32).write(self)
- }
- _ => tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI write_u16"),
+ if !self.write_raw(VI_BASE + offset, 2, val as u32) {
+ tracing::warn!(offset = format!("{offset:#08X}"), "unhandled VI write_u16");
}
}
pub fn mmio_read_u32(&self, offset: u32) -> u32 {
- match VI_BASE + offset {
- regs::TopFieldBase::ADDR => regs::TopFieldBase::read(self).to_raw(),
- regs::BottomFieldBase::ADDR => regs::BottomFieldBase::read(self).to_raw(),
- _ => {
- tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI read_u32");
- 0
- }
- }
+ self.read_raw(VI_BASE + offset, 4).unwrap_or_else(|| {
+ tracing::warn!(offset = format!("{offset:#08X}"), "unhandled VI read_u32");
+ 0
+ })
}
pub fn mmio_write_u32(&mut self, offset: u32, val: u32) {
- match VI_BASE + offset {
- regs::TopFieldBase::ADDR => {
- <regs::TopFieldBase as MmioRegister>::from_raw(val).write(self)
- }
- regs::BottomFieldBase::ADDR => {
- <regs::BottomFieldBase as MmioRegister>::from_raw(val).write(self)
- }
- _ => tracing::warn!(offset = format!("{offset:#06X}"), "unhandled VI write_u32"),
+ if !self.write_raw(VI_BASE + offset, 4, val) {
+ tracing::warn!(offset = format!("{offset:#08X}"), "unhandled VI write_u32");
}
}
}
diff --git a/crates/gekko/src/vi/regs.rs b/crates/gekko/src/vi/regs.rs
index e098d9f..be19c96 100644
--- a/crates/gekko/src/vi/regs.rs
+++ b/crates/gekko/src/vi/regs.rs
@@ -1,16 +1,9 @@
-use crate::mmio::{Mmio, traits::{MmioAccess, MmioRegister}};
-use chapa::BitEnum;
-
use super::Vi;
-
-macro_rules! impl_mmio_access {
- ($reg:ty, $owner:ty, $field:ident) => {
- impl MmioAccess<$owner> for $reg {
- fn read(dev: &$owner) -> Self { dev.$field }
- fn write(self, dev: &mut $owner) { dev.$field = self; }
- }
- };
-}
+use crate::mmio::{
+ Mmio,
+ traits::{MmioAccess, MmioRegister},
+};
+use chapa::BitEnum;
#[derive(Debug, BitEnum)]
pub enum VideoFormat {
@@ -33,14 +26,6 @@ pub struct DisplayConfiguration {
#[bits(8..=9, alias = "fmt")] pub video_format: VideoFormat,
}
-#[rustfmt::skip]
-impl MmioRegister for DisplayConfiguration {
- const ADDR: u32 = Mmio::virt_to_phys(0xCC002002);
- const SIZE: usize = 2;
- fn from_raw(raw: u32) -> Self { (raw as u16).into() }
- fn to_raw(self) -> u32 { self.raw() as u32 }
-}
-
impl MmioAccess<Vi> for DisplayConfiguration {
fn read(vi: &Vi) -> Self {
vi.dcr
@@ -67,7 +52,6 @@ pub struct TopFieldBase {
#[bits(28)]
pub page_offset: bool,
-
// TODO: 29-31 y always zero (maybe some write only control register stuff?, setting bit 31 clears bits 31-28 (?))
}
@@ -79,25 +63,41 @@ pub struct BottomFieldBase {
#[bits(28)]
pub page_offset: bool,
-
// TODO: y always zero (maybe some write-only control register stuff?)
}
#[rustfmt::skip]
-impl MmioRegister for TopFieldBase {
- const ADDR: u32 = Mmio::virt_to_phys(0xCC00201c);
- const SIZE: usize = 4;
- fn from_raw(raw: u32) -> Self { raw.into() }
- fn to_raw(self) -> u32 { self.raw() }
+macro_rules! impl_mmio_access {
+ ($reg:ty, $owner:ty, $field:ident) => {
+ impl MmioAccess<$owner> for $reg {
+ fn read(dev: &$owner) -> Self { dev.$field }
+ fn write(self, dev: &mut $owner) { dev.$field = self; }
+ }
+ };
}
#[rustfmt::skip]
-impl MmioRegister for BottomFieldBase {
- const ADDR: u32 = Mmio::virt_to_phys(0xCC002024);
- const SIZE: usize = 4;
- fn from_raw(raw: u32) -> Self { raw.into() }
- fn to_raw(self) -> u32 { self.raw() }
+macro_rules! size_to_raw_type {
+ (1, $raw:expr) => { $raw as u8 };
+ (2, $raw:expr) => { $raw as u16 };
+ (4, $raw:expr) => { $raw };
}
+#[rustfmt::skip]
+macro_rules! impl_mmio_register {
+ ($reg:ty, $addr:expr, $size:tt) => {
+ impl MmioRegister for $reg {
+ const ADDR: u32 = Mmio::virt_to_phys($addr);
+ const SIZE: usize = $size;
+ fn from_raw(raw: u32) -> Self { size_to_raw_type!($size, raw).into() }
+ fn to_raw(self) -> u32 { self.raw() as u32 }
+ }
+ };
+}
+
+impl_mmio_register!(DisplayConfiguration, 0xCC002002, 2);
+impl_mmio_register!(TopFieldBase, 0xCC00201C, 4);
+impl_mmio_register!(BottomFieldBase, 0xCC002024, 4);
+
impl_mmio_access!(TopFieldBase, Vi, top_field_base);
impl_mmio_access!(BottomFieldBase, Vi, bottom_field_base);
diff --git a/crates/gekko/src/vi/tests.rs b/crates/gekko/src/vi/tests.rs
new file mode 100644
index 0000000..613a111
--- /dev/null
+++ b/crates/gekko/src/vi/tests.rs
@@ -0,0 +1,74 @@
+use super::*;
+use crate::mmio::traits::MmioRegister;
+
+fn vi_with_top(raw: u32) -> Vi {
+ let mut vi = Vi::new();
+ vi.top_field_base = regs::TopFieldBase::from_raw(raw);
+ vi
+}
+
+fn vi_with_dcr(raw: u16) -> Vi {
+ let mut vi = Vi::new();
+ vi.dcr = regs::DisplayConfiguration::from_raw(raw);
+ vi
+}
+
+const TOP_OFF: u32 = regs::TopFieldBase::ADDR - VI_BASE;
+const DCR_OFF: u32 = regs::DisplayConfiguration::ADDR - VI_BASE;
+
+#[test]
+fn u16_write_upper_half_of_u32_register() {
+ let mut vi = vi_with_top(0xAABBCCDD);
+ vi.mmio_write_u16(TOP_OFF, 0x1234);
+ assert_eq!(vi.top_field_base.to_raw(), 0x1234CCDD);
+}
+
+#[test]
+fn u16_write_lower_half_of_u32_register() {
+ let mut vi = vi_with_top(0xAABBCCDD);
+ vi.mmio_write_u16(TOP_OFF + 2, 0x5678);
+ assert_eq!(vi.top_field_base.to_raw(), 0xAABB5678);
+}
+
+#[test]
+fn u16_read_upper_half_of_u32_register() {
+ let vi = vi_with_top(0xAABBCCDD);
+ assert_eq!(vi.mmio_read_u16(TOP_OFF), 0xAABB);
+}
+
+#[test]
+fn u16_read_lower_half_of_u32_register() {
+ let vi = vi_with_top(0xAABBCCDD);
+ assert_eq!(vi.mmio_read_u16(TOP_OFF + 2), 0xCCDD);
+}
+
+#[test]
+fn u8_write_each_byte_of_u32_register() {
+ let mut vi = vi_with_top(0x00000000);
+ vi.mmio_write_u8(TOP_OFF + 0, 0xAA);
+ vi.mmio_write_u8(TOP_OFF + 1, 0xBB);
+ vi.mmio_write_u8(TOP_OFF + 2, 0xCC);
+ vi.mmio_write_u8(TOP_OFF + 3, 0xDD);
+ assert_eq!(vi.top_field_base.to_raw(), 0xAABBCCDD);
+}
+
+#[test]
+fn u8_write_does_not_disturb_other_bytes_in_u32() {
+ let mut vi = vi_with_top(0xAABBCCDD);
+ vi.mmio_write_u8(TOP_OFF + 1, 0xFF);
+ assert_eq!(vi.top_field_base.to_raw(), 0xAAFFCCDD);
+}
+
+#[test]
+fn u8_write_upper_byte_of_u16_register() {
+ let mut vi = vi_with_dcr(0x00FF);
+ vi.mmio_write_u8(DCR_OFF, 0xAB);
+ assert_eq!(vi.dcr.to_raw(), 0xABFF);
+}
+
+#[test]
+fn u8_write_lower_byte_of_u16_register() {
+ let mut vi = vi_with_dcr(0xFF00);
+ vi.mmio_write_u8(DCR_OFF + 1, 0xCD);
+ assert_eq!(vi.dcr.to_raw(), 0xFFCD);
+}