A GameCube/Wii emulator and debugger written in Rust.
refactored
Layle4117d863fc81
diff --git a/crates/gekko/src/lib.rs b/crates/gekko/src/lib.rsindex 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 filediff --git a/crates/gekko/src/mmio/traits.rs b/crates/gekko/src/mmio/traits.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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);+}