Skip to content

armgit / gecko

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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!(