A GameCube/Wii emulator and debugger written in Rust.
fifo burst
Layledd2e6428348c
diff --git a/crates/gecko/src/flipper/cp.rs b/crates/gecko/src/flipper/cp.rsindex a5f77bd..373a118 100644--- a/crates/gecko/src/flipper/cp.rs+++ b/crates/gecko/src/flipper/cp.rs@@ -1,7 +1,12 @@pub mod regs;+use crate::flipper::pi::InterruptFlag;use crate::system::{System, SystemId};+pub const GP_BURST: u32 = 32;++const GP_PIPE_CAPACITY: usize = 64;+pub struct CommandProcessor {pub status: regs::CpStatus,pub control: regs::CpControl,@@ -19,6 +24,11 @@ pub struct CommandProcessor {pub fifo_write_ptr_hi: regs::FifoWritePtrHi,pub fifo_read_ptr_lo: regs::FifoReadPtrLo,pub fifo_read_ptr_hi: regs::FifoReadPtrHi,+ pub fifo_bp_lo: regs::FifoBpLo,+ pub fifo_bp_hi: regs::FifoBpHi,++ pub gather_pipe: [u8; GP_PIPE_CAPACITY],+ pub gather_pos: u32,}impl CommandProcessor {@@ -40,6 +50,10 @@ impl CommandProcessor {fifo_write_ptr_hi: regs::FifoWritePtrHi::from_raw(0),fifo_read_ptr_lo: regs::FifoReadPtrLo::from_raw(0),fifo_read_ptr_hi: regs::FifoReadPtrHi::from_raw(0),+ fifo_bp_lo: regs::FifoBpLo::from_raw(0),+ fifo_bp_hi: regs::FifoBpHi::from_raw(0),+ gather_pipe: [0; GP_PIPE_CAPACITY],+ gather_pos: 0,}}@@ -49,6 +63,78 @@ impl CommandProcessor {|| (self.status.fifo_overflow() && self.control.fifo_overflow_interrupt_enable())|| (self.status.fifo_underflow() && self.control.fifo_underflow_interrupt_enable())}++ #[inline(always)]+ pub fn fifo_base(&self) -> u32 {+ (((self.fifo_base_hi.raw() as u32) << 16) | (self.fifo_base_lo.raw() as u32)) & !0x1F+ }++ #[inline(always)]+ pub fn fifo_end(&self) -> u32 {+ (((self.fifo_end_hi.raw() as u32) << 16) | (self.fifo_end_lo.raw() as u32)) & !0x1F+ }++ #[inline(always)]+ pub fn fifo_hi_watermark(&self) -> u32 {+ ((self.fifo_hi_watermark_hi.raw() as u32) << 16) | (self.fifo_hi_watermark_lo.raw() as u32)+ }++ #[inline(always)]+ pub fn fifo_lo_watermark(&self) -> u32 {+ ((self.fifo_lo_watermark_hi.raw() as u32) << 16) | (self.fifo_lo_watermark_lo.raw() as u32)+ }++ #[inline(always)]+ pub fn fifo_rw_distance(&self) -> u32 {+ ((self.fifo_rw_distance_hi.raw() as u32) << 16) | (self.fifo_rw_distance_lo.raw() as u32)+ }++ #[inline(always)]+ pub fn fifo_write_ptr(&self) -> u32 {+ (((self.fifo_write_ptr_hi.raw() as u32) << 16) | (self.fifo_write_ptr_lo.raw() as u32)) & !0x1F+ }++ #[inline(always)]+ pub fn fifo_read_ptr(&self) -> u32 {+ (((self.fifo_read_ptr_hi.raw() as u32) << 16) | (self.fifo_read_ptr_lo.raw() as u32)) & !0x1F+ }++ #[inline(always)]+ pub fn fifo_bp(&self) -> u32 {+ (((self.fifo_bp_hi.raw() as u32) << 16) | (self.fifo_bp_lo.raw() as u32)) & !0x1F+ }++ #[inline(always)]+ pub fn set_fifo_rw_distance(&mut self, v: u32) {+ self.fifo_rw_distance_lo = regs::FifoRwDistanceLo::from_raw(v as u16);+ self.fifo_rw_distance_hi = regs::FifoRwDistanceHi::from_raw((v >> 16) as u16);+ }++ #[inline(always)]+ pub fn set_fifo_write_ptr(&mut self, v: u32) {+ self.fifo_write_ptr_lo = regs::FifoWritePtrLo::from_raw(v as u16);+ self.fifo_write_ptr_hi = regs::FifoWritePtrHi::from_raw((v >> 16) as u16);+ }++ #[inline(always)]+ pub fn set_fifo_read_ptr(&mut self, v: u32) {+ self.fifo_read_ptr_lo = regs::FifoReadPtrLo::from_raw(v as u16);+ self.fifo_read_ptr_hi = regs::FifoReadPtrHi::from_raw((v >> 16) as u16);+ }++ pub fn refresh_status(&mut self) {+ let dist = self.fifo_rw_distance();+ let hi = self.fifo_hi_watermark();+ let lo = self.fifo_lo_watermark();+ let read_idle = dist == 0;+ let bp = self.status.bp_interrupt();+ self.status = regs::CpStatus::from_raw(0)+ .with_fifo_overflow(hi != 0 && dist > hi)+ .with_fifo_underflow(lo != 0 && dist < lo)+ .with_read_idle(read_idle)+ .with_cmd_idle(read_idle)+ .with_bp_interrupt(bp);+ }}crate::mmio_device_dispatch! {@@ -72,16 +158,139 @@ crate::mmio_device_dispatch! {regs::FifoWritePtrHi,regs::FifoReadPtrLo,regs::FifoReadPtrHi,+ regs::FifoBpLo,+ regs::FifoBpHi,],}#[inline(always)]pub fn refresh_interrupts<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {- use crate::flipper::pi::InterruptFlag;-if sys.cp.interrupt_active() {sys.pi.assert_interrupt(InterruptFlag::Cp);} else {sys.pi.clear_interrupt(InterruptFlag::Cp);}}++#[inline(always)]+pub fn ack_breakpoint<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ sys.cp.status = sys.cp.status.with_bp_interrupt(false);+ self::refresh_interrupts(sys);+ self::pump_fifo(sys);+}++#[inline(always)]+pub fn gather_pipe_write_u8<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, val: u8) {+ let pos = sys.cp.gather_pos as usize;+ sys.cp.gather_pipe[pos] = val;+ sys.cp.gather_pos += 1;+ if sys.cp.gather_pos >= GP_BURST {+ gather_pipe_bursted(sys);+ }+}++#[inline(always)]+pub fn gather_pipe_write_u16<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, val: u16) {+ let pos = sys.cp.gather_pos as usize;+ sys.cp.gather_pipe[pos..pos + 2].copy_from_slice(&val.to_be_bytes());+ sys.cp.gather_pos += 2;+ if sys.cp.gather_pos >= GP_BURST {+ gather_pipe_bursted(sys);+ }+}++#[inline(always)]+pub fn gather_pipe_write_u32<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, val: u32) {+ let pos = sys.cp.gather_pos as usize;+ sys.cp.gather_pipe[pos..pos + 4].copy_from_slice(&val.to_be_bytes());+ sys.cp.gather_pos += 4;+ if sys.cp.gather_pos >= GP_BURST {+ gather_pipe_bursted(sys);+ }+}++#[cold]+pub fn gather_pipe_bursted<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ let linked = sys.cp.control.gp_link_enable();++ while sys.cp.gather_pos >= GP_BURST {+ if linked {+ let wptr = sys.pi.fifo_wptr;++ let mut burst = [0u8; GP_BURST as usize];+ burst.copy_from_slice(&sys.cp.gather_pipe[..GP_BURST as usize]);++ match sys.mmio.ram_view_mut().slice_mut(wptr as usize, GP_BURST as usize) {+ Some(dst) => dst.copy_from_slice(&burst),+ None => tracing::warn!(+ wptr = format!("{wptr:#010X}"),+ "gather_pipe_bursted: PI fifo_wptr unmapped"+ ),+ }++ let next_wptr = if wptr == sys.pi.fifo_end {+ sys.pi.fifo_base+ } else {+ wptr.wrapping_add(GP_BURST)+ };++ sys.pi.fifo_wptr = next_wptr;+ sys.cp.set_fifo_write_ptr(next_wptr);+ sys.cp+ .set_fifo_rw_distance(sys.cp.fifo_rw_distance().saturating_add(GP_BURST));+ }++ let leftover = sys.cp.gather_pos - GP_BURST;+ if leftover > 0 {+ sys.cp+ .gather_pipe+ .copy_within(GP_BURST as usize..(GP_BURST + leftover) as usize, 0);+ }++ sys.cp.gather_pos = leftover;+ }++ if linked {+ sys.cp.refresh_status();+ refresh_interrupts(sys);+ }++ pump_fifo(sys);+}++pub fn pump_fifo<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ let mut consumed = 0u32;++ while !sys.cp.interrupt_active() && sys.cp.control.gp_fifo_read_enable() && sys.cp.fifo_rw_distance() >= GP_BURST {+ let read_ptr = sys.cp.fifo_read_ptr();+ if sys.cp.control.bp_interrupt_enable() && read_ptr == sys.cp.fifo_bp() {+ sys.cp.status = sys.cp.status.with_bp_interrupt(true);+ refresh_interrupts(sys);+ break;+ }++ let mut burst = [0u8; GP_BURST as usize];+ match sys.mmio.ram_view().slice(read_ptr as usize, GP_BURST as usize) {+ Some(src) => burst.copy_from_slice(src),+ None => unreachable!("pump_fifo: FIFO read pointer unmapped"),+ }+ sys.gx.fifo.extend_from_slice(&burst);++ let next_read_ptr = if read_ptr == sys.cp.fifo_end() {+ sys.cp.fifo_base()+ } else {+ read_ptr.wrapping_add(GP_BURST)+ };+ sys.cp.set_fifo_read_ptr(next_read_ptr);+ sys.cp+ .set_fifo_rw_distance(sys.cp.fifo_rw_distance().saturating_sub(GP_BURST));+ consumed += 1;+ }++ if consumed > 0 {+ sys.gx.drain_fifo(&mut sys.mmio, sys.render_sink.as_mut());+ sys.check_gx_pe_interrupts();+ sys.cp.refresh_status();+ refresh_interrupts(sys);+ }+}diff --git a/crates/gecko/src/flipper/cp/regs.rs b/crates/gecko/src/flipper/cp/regs.rsindex f59da12..f5c6c36 100644--- a/crates/gecko/src/flipper/cp/regs.rs+++ b/crates/gecko/src/flipper/cp/regs.rs@@ -26,13 +26,11 @@ crate::mmio_reg!(CpStatus: u16 @ 0xCC000000);impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for CpStatus {fn read(sys: &mut System<SYSTEM>) -> Self {+ sys.cp.refresh_status();sys.cp.status}- fn write(self, sys: &mut System<SYSTEM>, _: WriteMask) {- sys.cp.status = self;- cp::refresh_interrupts(sys);- }+ fn write(self, _sys: &mut System<SYSTEM>, _: WriteMask) {}}// 0xCC000002 2 R/W CP_CTRL (CP Control Register)@@ -68,6 +66,7 @@ impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for CpControl {fn write(self, sys: &mut System<SYSTEM>, _: WriteMask) {sys.cp.control = self;cp::refresh_interrupts(sys);+ cp::pump_fifo(sys);}}@@ -97,11 +96,11 @@ impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for CpClear {if self.clear_underflow() {sys.cp.status = sys.cp.status.with_fifo_underflow(false);}- cp::refresh_interrupts(sys);+ cp::ack_breakpoint(sys);}}-// 0xCC000020..=0xCC00003B: FIFO pointer registers. All plain 16 bit storage.+// 0xCC000020..=0xCC00003F: FIFO pointer registers. All plain 16 bit storage.#[chapa::bitfield(u16, order = lsb0)]#[derive(Copy, Clone, Debug)]@@ -186,3 +185,37 @@ crate::mmio_default_access!(FifoReadPtrLo => System.cp.fifo_read_ptr_lo);pub struct FifoReadPtrHi {}crate::mmio_reg!(FifoReadPtrHi: u16 @ 0xCC00003A);crate::mmio_default_access!(FifoReadPtrHi => System.cp.fifo_read_ptr_hi);++#[chapa::bitfield(u16, order = lsb0)]+#[derive(Copy, Clone, Debug)]+pub struct FifoBpLo {}+crate::mmio_reg!(FifoBpLo: u16 @ 0xCC00003C);++impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for FifoBpLo {+ fn read(sys: &mut System<SYSTEM>) -> Self {+ sys.cp.fifo_bp_lo+ }+ fn write(self, sys: &mut System<SYSTEM>, _: WriteMask) {+ sys.cp.fifo_bp_lo = self;+ if sys.cp.fifo_bp() != sys.cp.fifo_read_ptr() {+ cp::ack_breakpoint(sys);+ }+ }+}++#[chapa::bitfield(u16, order = lsb0)]+#[derive(Copy, Clone, Debug)]+pub struct FifoBpHi {}+crate::mmio_reg!(FifoBpHi: u16 @ 0xCC00003E);++impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for FifoBpHi {+ fn read(sys: &mut System<SYSTEM>) -> Self {+ sys.cp.fifo_bp_hi+ }+ fn write(self, sys: &mut System<SYSTEM>, _: WriteMask) {+ sys.cp.fifo_bp_hi = self;+ if sys.cp.fifo_bp() != sys.cp.fifo_read_ptr() {+ cp::ack_breakpoint(sys);+ }+ }+}diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex cc9d1f5..7949050 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -136,36 +136,6 @@ impl GraphicsProcessor {}}- pub fn mmio_write_u8<const SYSTEM: SystemId>(- &mut self,- mmio: &mut Mmio<SYSTEM>,- renderer: &mut dyn RenderSink,- val: u8,- ) {- self.push_u8(val);- self.drain_fifo(mmio, renderer);- }-- pub fn mmio_write_u16<const SYSTEM: SystemId>(- &mut self,- mmio: &mut Mmio<SYSTEM>,- renderer: &mut dyn RenderSink,- val: u16,- ) {- self.push_u16(val);- self.drain_fifo(mmio, renderer);- }-- pub fn mmio_write_u32<const SYSTEM: SystemId>(- &mut self,- mmio: &mut Mmio<SYSTEM>,- renderer: &mut dyn RenderSink,- val: u32,- ) {- self.push_u32(val);- self.drain_fifo(mmio, renderer);- }-fn execute_display_list<const SYSTEM: SystemId>(&mut self,mmio: &mut Mmio<SYSTEM>,diff --git a/crates/gecko/src/flipper/gx/fifo.rs b/crates/gecko/src/flipper/gx/fifo.rsindex 5fd39e4..221d467 100644--- a/crates/gecko/src/flipper/gx/fifo.rs+++ b/crates/gecko/src/flipper/gx/fifo.rs@@ -6,18 +6,6 @@ use crate::mmio::Mmio;use crate::system::SystemId;impl GraphicsProcessor {- pub fn push_u8(&mut self, val: u8) {- self.fifo.push(val);- }-- pub fn push_u16(&mut self, val: u16) {- self.fifo.extend_from_slice(&val.to_be_bytes());- }-- pub fn push_u32(&mut self, val: u32) {- self.fifo.extend_from_slice(&val.to_be_bytes());- }-/// Streaming GP FIFO command processor: parses and dispatches each/// command inline so state writes (CP/XF/BP) take effect before the/// next command's parse decisions read them.diff --git a/crates/gecko/src/flipper/pi.rs b/crates/gecko/src/flipper/pi.rsindex 14efb86..044aa10 100644--- a/crates/gecko/src/flipper/pi.rs+++ b/crates/gecko/src/flipper/pi.rs@@ -44,13 +44,6 @@ impl ProcessorInterface {}}- pub fn advance_fifo_wptr(&mut self, nbytes: u32) {- self.fifo_wptr = self.fifo_wptr.wrapping_add(nbytes);- if self.fifo_end != 0 && self.fifo_wptr >= self.fifo_end {- self.fifo_wptr = self.fifo_base;- }- }-pub fn assert_interrupt(&mut self, flag: InterruptFlag) {let raw = self.intsr.raw() | (flag as u32);self.intsr = regs::InterruptCause::from_raw(raw);diff --git a/crates/gecko/src/mmio/bus.rs b/crates/gecko/src/mmio/bus.rsindex b14dd2b..7f4c659 100644--- a/crates/gecko/src/mmio/bus.rs+++ b/crates/gecko/src/mmio/bus.rs@@ -817,13 +817,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {self.mmio.phys_write_u8(phys, val);}GX_FIFO_BASE..=GX_FIFO_END => {- let wptr = self.pi.fifo_wptr;- self.mmio.phys_write_u8(wptr, val);- self.pi.advance_fifo_wptr(1);- if self.cp.control.gp_link_enable() {- self.gx.mmio_write_u8(&mut self.mmio, self.render_sink.as_mut(), val);- self.check_gx_pe_interrupts();- }+ crate::flipper::cp::gather_pipe_write_u8(self, val);}HW_REG_BASE..=HW_REG_END => {tracing::warn!(@@ -993,13 +987,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {self.mmio.phys_write_u16(phys, val);}GX_FIFO_BASE..=GX_FIFO_END => {- let wptr = self.pi.fifo_wptr;- self.mmio.phys_write_u16(wptr, val);- self.pi.advance_fifo_wptr(2);- if self.cp.control.gp_link_enable() {- self.gx.mmio_write_u16(&mut self.mmio, self.render_sink.as_mut(), val);- self.check_gx_pe_interrupts();- }+ crate::flipper::cp::gather_pipe_write_u16(self, val);}HW_REG_BASE..=HW_REG_END => {tracing::warn!(@@ -1168,13 +1156,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {self.mmio.phys_write_u32(phys, val);}GX_FIFO_BASE..=GX_FIFO_END => {- let wptr = self.pi.fifo_wptr;- self.mmio.phys_write_u32(wptr, val);- self.pi.advance_fifo_wptr(4);- if self.cp.control.gp_link_enable() {- self.gx.mmio_write_u32(&mut self.mmio, self.render_sink.as_mut(), val);- self.check_gx_pe_interrupts();- }+ crate::flipper::cp::gather_pipe_write_u32(self, val);}HW_REG_BASE..=HW_REG_END => {tracing::warn!(