Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

lesson 12 works, implement PI regs for fifo

Laylee2ab52e52fee
diff --git a/crates/backend-wgpu/src/helpers.rs b/crates/backend-wgpu/src/helpers.rs
index 3c7d352..33b8d8c 100644
--- a/crates/backend-wgpu/src/helpers.rs
+++ b/crates/backend-wgpu/src/helpers.rs
@@ -17,7 +17,9 @@ pub fn map_mag_filter(filter: MagFilter) -> wgpu::FilterMode {
pub fn map_min_filter(filter: MinFilter) -> wgpu::FilterMode {
match filter {
- MinFilter::Nearest | MinFilter::NearestMipmapNearest | MinFilter::NearestMipmapLinear => wgpu::FilterMode::Nearest,
+ MinFilter::Nearest | MinFilter::NearestMipmapNearest | MinFilter::NearestMipmapLinear => {
+ wgpu::FilterMode::Nearest
+ }
MinFilter::Linear | MinFilter::LinearMipmapNearest | MinFilter::LinearMipmapLinear => wgpu::FilterMode::Linear,
}
}
diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rs
index 7edcbdc..93c9f8b 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -106,10 +106,7 @@ impl GxRenderer {
height: u32,
) -> Self {
let uniform_size = std::mem::size_of::<Uniforms>() as u64;
- let uniform_stride = align_up(
- uniform_size,
- device.limits().min_uniform_buffer_offset_alignment as u64,
- );
+ let uniform_stride = align_up(uniform_size, device.limits().min_uniform_buffer_offset_alignment as u64);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("gx_shader"),
@@ -462,8 +459,7 @@ impl GxRenderer {
};
let start = self.scratch_draws.len() * stride;
self.scratch_uniform_bytes.resize(start + stride, 0);
- self.scratch_uniform_bytes[start..start + uniform_size]
- .copy_from_slice(bytemuck::bytes_of(&uniform));
+ self.scratch_uniform_bytes[start..start + uniform_size].copy_from_slice(bytemuck::bytes_of(&uniform));
self.scratch_draws.push((prev_len as u32, added as u32));
}
diff --git a/crates/gekko/src/flipper/gx.rs b/crates/gekko/src/flipper/gx.rs
index 85c9173..866b857 100644
--- a/crates/gekko/src/flipper/gx.rs
+++ b/crates/gekko/src/flipper/gx.rs
@@ -71,11 +71,23 @@ impl Gx {
FifoCmd::Cp(data) => self.load_cp(&data),
FifoCmd::Xf(data) => self.load_xf(&data),
FifoCmd::Bp(data) => self.load_bp(&data),
+ FifoCmd::CallDisplayList { phys_addr, nbytes } => {
+ let addr = phys_addr as usize;
+ let len = nbytes as usize;
+ self.execute_display_list(mmio, &mmio.ram[addr..addr + len].to_vec());
+ }
FifoCmd::DrawCall(cmd, data) => self.create_draw_call(mmio, cmd, data),
}
}
}
+ fn execute_display_list(&mut self, mmio: &mut Mmio, data: &[u8]) {
+ let saved = std::mem::take(&mut self.fifo);
+ self.fifo = data.to_vec();
+ self.drain_fifo(mmio);
+ self.fifo = saved;
+ }
+
fn create_draw_call(&mut self, mmio: &mut Mmio, cmd: u8, data: Vec<u8>) {
let Some(primitive) = draw::Primitive::from_cmd(cmd) else {
tracing::error!(cmd, "goofy draw command");
diff --git a/crates/gekko/src/flipper/gx/constants.rs b/crates/gekko/src/flipper/gx/constants.rs
index fb05e02..15a42ba 100644
--- a/crates/gekko/src/flipper/gx/constants.rs
+++ b/crates/gekko/src/flipper/gx/constants.rs
@@ -1,5 +1,8 @@
+pub const NOP_CMD: u8 = 0x00;
pub const CP_CMD: u8 = 0x08;
pub const XF_CMD: u8 = 0x10;
+pub const CALL_DL_CMD: u8 = 0x40;
+pub const INV_VTX_CACHE_CMD: u8 = 0x48;
pub const BP_CMD: u8 = 0x61;
pub const DRAW_COMMANDS_START: u8 = 0x80;
diff --git a/crates/gekko/src/flipper/gx/fifo.rs b/crates/gekko/src/flipper/gx/fifo.rs
index 46d6746..35950b8 100644
--- a/crates/gekko/src/flipper/gx/fifo.rs
+++ b/crates/gekko/src/flipper/gx/fifo.rs
@@ -1,4 +1,4 @@
-use super::constants::{BP_CMD, CP_CMD, XF_CMD};
+use super::constants::{BP_CMD, CALL_DL_CMD, CP_CMD, INV_VTX_CACHE_CMD, NOP_CMD, XF_CMD};
use crate::flipper::gx::{
Gx,
constants::{DRAW_COMMANDS_END, DRAW_COMMANDS_START, VATA_REG, VCD_HI_REG, VCD_LO_REG},
@@ -36,6 +36,23 @@ impl Gx {
let cmd = cmd_buf[0];
match cmd {
+ NOP_CMD | INV_VTX_CACHE_CMD => {
+ // NOP / vertex cache invalidate, skip
+ }
+ CALL_DL_CMD => {
+ // 4-byte physical address + 4-byte size = 8 bytes payload
+ if remaining < 9 {
+ cur.set_position(pos as u64);
+ break;
+ }
+ let mut addr_buf = [0u8; 4];
+ let mut size_buf = [0u8; 4];
+ cur.read_exact(&mut addr_buf).unwrap();
+ cur.read_exact(&mut size_buf).unwrap();
+ let phys_addr = u32::from_be_bytes(addr_buf);
+ let nbytes = u32::from_be_bytes(size_buf);
+ cmds.push(FifoCmd::CallDisplayList { phys_addr, nbytes });
+ }
CP_CMD => {
// 1 addr + 4 data = 5 bytes
if remaining < 6 {
@@ -152,5 +169,6 @@ pub enum FifoCmd {
Cp([u8; 5]),
Xf(Vec<u8>),
Bp([u8; 4]),
+ CallDisplayList { phys_addr: u32, nbytes: u32 },
DrawCall(u8, Vec<u8>),
}
diff --git a/crates/gekko/src/flipper/pi.rs b/crates/gekko/src/flipper/pi.rs
index 5bc0237..d74cd06 100644
--- a/crates/gekko/src/flipper/pi.rs
+++ b/crates/gekko/src/flipper/pi.rs
@@ -3,9 +3,22 @@ pub mod regs;
use crate::mmio::constants::PI_BASE;
use crate::mmio::traits::{MmioAccess, MmioRegister};
+// PI FIFO register offsets (from PI_BASE 0xCC003000)
+const PI_FIFO_BASE_OFFSET: u32 = 0x0C;
+const PI_FIFO_END_OFFSET: u32 = 0x10;
+const PI_FIFO_WPTR_OFFSET: u32 = 0x14;
+
pub struct Pi {
pub intsr: regs::InterruptCause,
pub intmr: regs::InterruptMask,
+ /// CPU FIFO base address in physical memory
+ pub fifo_base: u32,
+ /// CPU FIFO end address in physical memory
+ pub fifo_end: u32,
+ /// CPU FIFO write pointer (32-byte aligned)
+ pub fifo_wptr: u32,
+ /// The initial FIFO base set by GX_Init (0 = not yet set)
+ initial_fifo_base: u32,
}
/// Bitmask constants for each PI interrupt source
@@ -32,9 +45,18 @@ impl Pi {
Pi {
intsr: regs::InterruptCause::default(),
intmr: regs::InterruptMask::from_raw(0),
+ fifo_base: 0,
+ fifo_end: 0,
+ fifo_wptr: 0,
+ initial_fifo_base: 0,
}
}
+ /// Returns true when the CPU FIFO is redirected to a display list buffer
+ pub fn is_fifo_redirected(&self) -> bool {
+ self.initial_fifo_base != 0 && self.fifo_base != self.initial_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);
@@ -85,8 +107,25 @@ impl Pi {
}
pub fn mmio_write_u32(&mut self, offset: u32, val: u32) {
- if !self.write_raw(PI_BASE + offset, 4, val) {
- tracing::error!(offset = format!("{offset:08X}"), "unhandled PI write_u32");
+ match offset {
+ PI_FIFO_BASE_OFFSET => {
+ self.fifo_base = val;
+ // Record the first FIFO base as the "normal" GX FIFO
+ if self.initial_fifo_base == 0 {
+ self.initial_fifo_base = val;
+ }
+ }
+ PI_FIFO_END_OFFSET => {
+ self.fifo_end = val;
+ }
+ PI_FIFO_WPTR_OFFSET => {
+ self.fifo_wptr = val & 0x1FFF_FFE0; // 32-byte aligned
+ }
+ _ => {
+ if !self.write_raw(PI_BASE + offset, 4, val) {
+ tracing::error!(offset = format!("{offset:08X}"), "unhandled PI write_u32");
+ }
+ }
}
}
}
diff --git a/crates/gekko/src/mmio/bus.rs b/crates/gekko/src/mmio/bus.rs
index d485414..5856f1a 100644
--- a/crates/gekko/src/mmio/bus.rs
+++ b/crates/gekko/src/mmio/bus.rs
@@ -93,8 +93,14 @@ impl Gekko {
self.exi.process_dma_transfers(&mut self.mmio);
}
BusTarget::Gx => {
- self.gx.mmio_write_u8(&mut self.mmio, val);
- self.check_gx_pe_finish();
+ if self.pi.is_fifo_redirected() {
+ let wptr = self.pi.fifo_wptr as usize;
+ self.mmio.ram[wptr] = val;
+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(1);
+ } else {
+ self.gx.mmio_write_u8(&mut self.mmio, val);
+ self.check_gx_pe_finish();
+ }
}
BusTarget::Fallback => self.mmio.phys_write_u8(offset, val),
}
@@ -115,8 +121,15 @@ impl Gekko {
self.exi.process_dma_transfers(&mut self.mmio);
}
BusTarget::Gx => {
- self.gx.mmio_write_u16(&mut self.mmio, val);
- self.check_gx_pe_finish();
+ if self.pi.is_fifo_redirected() {
+ let wptr = self.pi.fifo_wptr as usize;
+ let bytes = val.to_be_bytes();
+ self.mmio.ram[wptr..wptr + 2].copy_from_slice(&bytes);
+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(2);
+ } else {
+ self.gx.mmio_write_u16(&mut self.mmio, val);
+ self.check_gx_pe_finish();
+ }
}
BusTarget::Fallback => self.mmio.phys_write_u16(offset, val),
}
@@ -137,8 +150,15 @@ impl Gekko {
self.exi.process_dma_transfers(&mut self.mmio);
}
BusTarget::Gx => {
- self.gx.mmio_write_u32(&mut self.mmio, val);
- self.check_gx_pe_finish();
+ if self.pi.is_fifo_redirected() {
+ let wptr = self.pi.fifo_wptr as usize;
+ let bytes = val.to_be_bytes();
+ self.mmio.ram[wptr..wptr + 4].copy_from_slice(&bytes);
+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(4);
+ } else {
+ self.gx.mmio_write_u32(&mut self.mmio, val);
+ self.check_gx_pe_finish();
+ }
}
BusTarget::Fallback => self.mmio.phys_write_u32(offset, val),
}