Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

PANDA DOL RENDERS LETS GOOOO

Laylee59d5f0ada19
diff --git a/Cargo.lock b/Cargo.lock
index 0807e11..a236b9c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -61,6 +61,12 @@ dependencies = [
"windows-sys",
]
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
[[package]]
name = "bitflags"
version = "2.11.0"
@@ -76,6 +82,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
[[package]]
name = "chapa"
version = "0.1.0"
+source = "git+http://github.com/ioncodes/chapa#ef09ed9685421632f87fd851f6d5de1866d6c026"
dependencies = [
"chapa-macros",
]
@@ -83,6 +90,7 @@ dependencies = [
[[package]]
name = "chapa-macros"
version = "0.1.0"
+source = "git+http://github.com/ioncodes/chapa#ef09ed9685421632f87fd851f6d5de1866d6c026"
dependencies = [
"proc-macro2",
"quote",
@@ -103,9 +111,9 @@ checksum = "804b48113bfcabe42a604d0db98786210fe860c0b7ced8b9bb85aa7c74f86b85"
[[package]]
name = "clap"
-version = "4.5.59"
+version = "4.5.60"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5caf74d17c3aec5495110c34cc3f78644bfa89af6c8993ed4de2790e49b6499"
+checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a"
dependencies = [
"clap_builder",
"clap_derive",
@@ -113,9 +121,9 @@ dependencies = [
[[package]]
name = "clap_builder"
-version = "4.5.59"
+version = "4.5.60"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "370daa45065b80218950227371916a1633217ae42b2715b2287b606dcd618e24"
+checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876"
dependencies = [
"anstream",
"anstyle",
@@ -352,9 +360,9 @@ dependencies = [
[[package]]
name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
[[package]]
name = "proc-macro2"
@@ -385,9 +393,9 @@ dependencies = [
[[package]]
name = "regex-automata"
-version = "0.4.13"
+version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
dependencies = [
"aho-corasick",
"memchr",
@@ -396,9 +404,9 @@ dependencies = [
[[package]]
name = "regex-syntax"
-version = "0.8.8"
+version = "0.8.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
[[package]]
name = "rustix"
@@ -442,9 +450,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
[[package]]
name = "syn"
-version = "2.0.116"
+version = "2.0.117"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df424c70518695237746f84cede799c9c58fcb37450d7b23716568cc8bc69cb"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
dependencies = [
"proc-macro2",
"quote",
@@ -464,6 +472,7 @@ dependencies = [
name = "tinyemu"
version = "0.1.0"
dependencies = [
+ "base64",
"colored",
"disasm",
"gekko",
diff --git a/crates/gekko/Cargo.toml b/crates/gekko/Cargo.toml
index fe4c320..39e1a25 100644
--- a/crates/gekko/Cargo.toml
+++ b/crates/gekko/Cargo.toml
@@ -7,6 +7,6 @@ edition = "2024"
chipi = "0.5.1"
[dependencies]
-chapa = { path = "../../../chapa/chapa" }
+chapa = { git = "http://github.com/ioncodes/chapa" }
tracing = "0.1.44"
dol = { path = "../dol" }
\ No newline at end of file
diff --git a/crates/gekko/src/cpu/interpreter.rs b/crates/gekko/src/cpu/interpreter.rs
index e8b0bc5..7f93e66 100644
--- a/crates/gekko/src/cpu/interpreter.rs
+++ b/crates/gekko/src/cpu/interpreter.rs
@@ -178,7 +178,7 @@ pub fn store_load<const OP: u32>(
.cpu
.read_gpr(instr.ra())
.wrapping_add_signed(instr.disp());
- ctx.mmu.virt_write_u32(addr, ctx.cpu.read_gpr(instr.rs()));
+ ctx.mmio.virt_write_u32(addr, ctx.cpu.read_gpr(instr.rs()));
if OP == crate::cpu::lut::OP_STWU {
ctx.cpu.write_gpr(instr.ra(), addr);
}
@@ -188,7 +188,7 @@ pub fn store_load<const OP: u32>(
.cpu
.read_gpr(instr.ra())
.wrapping_add_signed(instr.disp());
- ctx.mmu
+ ctx.mmio
.virt_write_u16(addr, (ctx.cpu.read_gpr(instr.rs()) & 0xffff) as u16);
if OP == crate::cpu::lut::OP_STHU {
ctx.cpu.write_gpr(instr.ra(), addr);
@@ -199,7 +199,7 @@ pub fn store_load<const OP: u32>(
.cpu
.read_gpr(instr.ra())
.wrapping_add_signed(instr.disp());
- ctx.cpu.write_gpr(instr.rd(), ctx.mmu.virt_read_u32(addr));
+ ctx.cpu.write_gpr(instr.rd(), ctx.mmio.virt_read_u32(addr));
if OP == crate::cpu::lut::OP_LWZU {
ctx.cpu.write_gpr(instr.ra(), addr);
}
diff --git a/crates/gekko/src/gekko.rs b/crates/gekko/src/gekko.rs
index 9ba075f..cbd678e 100644
--- a/crates/gekko/src/gekko.rs
+++ b/crates/gekko/src/gekko.rs
@@ -1,17 +1,17 @@
use crate::{
cpu::{self, semantics::Instruction},
- mmu, scheduler,
+ mmio, scheduler,
};
pub struct Gekko {
pub cpu: cpu::Cpu,
pub scheduler: scheduler::Scheduler,
- pub mmu: mmu::Mmu,
+ pub mmio: mmio::Mmio,
}
impl Gekko {
pub fn new(path: &str) -> Self {
- let mut mmu = mmu::Mmu::new();
+ let mut mmio = mmio::Mmio::new();
let data = std::fs::read(path).expect("failed to read ROM");
let dol = dol::Dol::parse(&data);
@@ -20,7 +20,7 @@ impl Gekko {
for i in 0..section.size {
let addr = section.vaddr + i;
let value = data[(section.offset + i) as usize];
- mmu.virt_write_u8(addr, value);
+ mmio.virt_write_u8(addr, value);
}
}
@@ -29,20 +29,20 @@ impl Gekko {
for i in 0..section.size {
let addr = section.vaddr + i;
let value = data[(section.offset + i) as usize];
- mmu.virt_write_u8(addr, value);
+ mmio.virt_write_u8(addr, value);
}
}
// Zero out the BSS section
for i in 0..dol.bss_size {
let addr = dol.bss_start + i;
- mmu.virt_write_u8(addr, 0);
+ mmio.virt_write_u8(addr, 0);
}
Gekko {
cpu: cpu::Cpu::new(dol.entry_point),
scheduler: scheduler::Scheduler { cycles: 0 },
- mmu,
+ mmio,
}
}
@@ -50,7 +50,7 @@ impl Gekko {
self.cpu.cia = self.cpu.pc;
self.cpu.nia = self.cpu.cia.wrapping_add(4);
- let instr = Instruction(self.mmu.virt_read_u32(self.cpu.cia));
+ let instr = Instruction(self.mmio.virt_read_u32(self.cpu.cia));
cpu::lut::dispatch(self, instr);
self.scheduler.cycles += 1;
diff --git a/crates/gekko/src/lib.rs b/crates/gekko/src/lib.rs
index db0b7a3..c634bca 100644
--- a/crates/gekko/src/lib.rs
+++ b/crates/gekko/src/lib.rs
@@ -1,4 +1,5 @@
pub mod cpu;
pub mod scheduler;
pub mod gekko;
-pub mod mmu;
\ No newline at end of file
+pub mod mmio;
+pub mod vi;
\ No newline at end of file
diff --git a/crates/gekko/src/mmu.rs b/crates/gekko/src/mmio.rs
similarity index 82%
rename from crates/gekko/src/mmu.rs
rename to crates/gekko/src/mmio.rs
index 67bfc5b..ff619b4 100644
--- a/crates/gekko/src/mmu.rs
+++ b/crates/gekko/src/mmio.rs
@@ -2,17 +2,19 @@
mod tests;
pub mod constants;
+pub mod traits;
+
use constants::*;
-pub struct Mmu {
+pub struct Mmio {
pub ram: Vec<u8>,
pub efb: Vec<u8>,
pub hwr: Vec<u8>,
}
-impl Mmu {
+impl Mmio {
pub fn new() -> Self {
- Mmu {
+ Mmio {
ram: vec![0; RAM_SIZE],
efb: vec![0; EFB_SIZE],
hwr: vec![0; HW_REG_SIZE],
@@ -24,7 +26,9 @@ impl Mmu {
fn resolve(&self, phys: u32) -> (&[u8], usize) {
match phys {
RAM_BASE..=RAM_END => (&self.ram, phys as usize),
- EFB_BASE..=EFB_END => (&self.efb, (phys - EFB_BASE) as usize),
+ EFB_BASE..=EFB_END => {
+ (&self.efb, (phys - EFB_BASE) as usize)
+ },
HW_REG_BASE..=HW_REG_END => {
tracing::warn!(phys_addr = format!("{:08X}", phys), "read from mmio");
(&self.hwr, (phys - HW_REG_BASE) as usize)
@@ -161,9 +165,30 @@ impl Mmu {
self.phys_slice(Self::virt_to_phys(addr), len)
}
- // Simple virtual to physical translation that ignores caching and other MMU features
- pub fn virt_to_phys(addr: u32) -> u32 {
- tracing::trace!(virt_addr = format!("{:08X}", addr), "virt_to_phys");
+ /// Read a typed MMIO register from its physical address
+ pub fn read_register<T: traits::MmioRegister>(&self) -> T {
+ let raw = match T::SIZE {
+ 1 => self.phys_read_u8(T::ADDR) as u32,
+ 2 => self.phys_read_u16(T::ADDR) as u32,
+ 4 => self.phys_read_u32(T::ADDR),
+ _ => panic!("unsupported register size {}", T::SIZE),
+ };
+ T::from_raw(raw)
+ }
+
+ /// Write a typed MMIO register to its physical address
+ pub fn write_register<T: traits::MmioRegister>(&mut self, value: T) {
+ let raw = value.to_raw();
+ match T::SIZE {
+ 1 => self.phys_write_u8(T::ADDR, raw as u8),
+ 2 => self.phys_write_u16(T::ADDR, raw as u16),
+ 4 => self.phys_write_u32(T::ADDR, raw),
+ _ => panic!("unsupported register size {}", T::SIZE),
+ }
+ }
+
+ // Simple virtual to physical translation that ignores caching and other MMIO features
+ pub const fn virt_to_phys(addr: u32) -> u32 {
addr & 0x3FFFFFFF
}
}
diff --git a/crates/gekko/src/mmu/constants.rs b/crates/gekko/src/mmio/constants.rs
similarity index 100%
rename from crates/gekko/src/mmu/constants.rs
rename to crates/gekko/src/mmio/constants.rs
diff --git a/crates/gekko/src/mmio/tests.rs b/crates/gekko/src/mmio/tests.rs
new file mode 100644
index 0000000..9503c6b
--- /dev/null
+++ b/crates/gekko/src/mmio/tests.rs
@@ -0,0 +1,68 @@
+#[cfg(test)]
+mod tests {
+ use crate::mmio::Mmio;
+
+ #[test]
+ fn ram_phys_read_write_roundtrip() {
+ let mut mmio = Mmio::new();
+ mmio.phys_write_u32(0x100, 0xDEAD_BEEF);
+ assert_eq!(mmio.phys_read_u32(0x100), 0xDEAD_BEEF);
+ assert_eq!(mmio.phys_read_u16(0x100), 0xDEAD);
+ assert_eq!(mmio.phys_read_u8(0x100), 0xDE);
+ }
+
+ #[test]
+ fn cached_virtual_maps_to_physical() {
+ let mut mmio = Mmio::new();
+ mmio.virt_write_u32(0x8000_0100, 0x1234_5678);
+ assert_eq!(mmio.phys_read_u32(0x100), 0x1234_5678);
+ }
+
+ #[test]
+ fn uncached_virtual_maps_to_physical() {
+ let mut mmio = Mmio::new();
+ mmio.virt_write_u32(0xC000_0100, 0xAAAA_BBBB);
+ assert_eq!(mmio.phys_read_u32(0x100), 0xAAAA_BBBB);
+ }
+
+ #[test]
+ fn efb_virtual_maps_to_efb_storage() {
+ let mut mmio = Mmio::new();
+ // 0xC8000000 virtual -> phys 0x08000000 (EFB)
+ mmio.virt_write_u32(0xC800_0000, 0xFB_FB_FB_FB);
+ assert_eq!(mmio.phys_read_u32(0x0800_0000), 0xFB_FB_FB_FB);
+ // Confirm it did NOT touch RAM
+ assert_eq!(mmio.phys_read_u32(0x0), 0);
+ }
+
+ #[test]
+ fn efb_address_does_not_alias_ram() {
+ let mut mmio = Mmio::new();
+ mmio.phys_write_u32(0x0, 0x1111_1111);
+ mmio.phys_write_u32(0x0800_0000, 0x2222_2222);
+ assert_eq!(mmio.phys_read_u32(0x0), 0x1111_1111);
+ assert_eq!(mmio.phys_read_u32(0x0800_0000), 0x2222_2222);
+ }
+
+ #[test]
+ #[should_panic(expected = "unmapped physical")]
+ fn unmapped_address_panics() {
+ let mmio = Mmio::new();
+ mmio.phys_read_u8(0x1000_0000);
+ }
+
+ #[test]
+ #[should_panic(expected = "unimplemented HW register")]
+ fn hw_register_panics() {
+ let mmio = Mmio::new();
+ mmio.phys_read_u8(0x0C00_0000);
+ }
+
+ #[test]
+ fn phys_slice_returns_correct_data() {
+ let mut mmio = Mmio::new();
+ mmio.phys_write_u32(0x200, 0xCAFE_BABE);
+ let slice = mmio.phys_slice(0x200, 4);
+ assert_eq!(slice, &[0xCA, 0xFE, 0xBA, 0xBE]);
+ }
+}
diff --git a/crates/gekko/src/mmio/traits.rs b/crates/gekko/src/mmio/traits.rs
new file mode 100644
index 0000000..682b090
--- /dev/null
+++ b/crates/gekko/src/mmio/traits.rs
@@ -0,0 +1,7 @@
+pub trait MmioRegister: Sized {
+ const ADDR: u32;
+ const SIZE: usize;
+
+ fn from_raw(raw: u32) -> Self;
+ fn to_raw(self) -> u32;
+}
\ No newline at end of file
diff --git a/crates/gekko/src/mmu/tests.rs b/crates/gekko/src/mmu/tests.rs
deleted file mode 100644
index 08eb0a3..0000000
--- a/crates/gekko/src/mmu/tests.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#[cfg(test)]
-mod tests {
- use crate::mmu::Mmu;
-
- #[test]
- fn ram_phys_read_write_roundtrip() {
- let mut mmu = Mmu::new();
- mmu.phys_write_u32(0x100, 0xDEAD_BEEF);
- assert_eq!(mmu.phys_read_u32(0x100), 0xDEAD_BEEF);
- assert_eq!(mmu.phys_read_u16(0x100), 0xDEAD);
- assert_eq!(mmu.phys_read_u8(0x100), 0xDE);
- }
-
- #[test]
- fn cached_virtual_maps_to_physical() {
- let mut mmu = Mmu::new();
- mmu.virt_write_u32(0x8000_0100, 0x1234_5678);
- assert_eq!(mmu.phys_read_u32(0x100), 0x1234_5678);
- }
-
- #[test]
- fn uncached_virtual_maps_to_physical() {
- let mut mmu = Mmu::new();
- mmu.virt_write_u32(0xC000_0100, 0xAAAA_BBBB);
- assert_eq!(mmu.phys_read_u32(0x100), 0xAAAA_BBBB);
- }
-
- #[test]
- fn efb_virtual_maps_to_efb_storage() {
- let mut mmu = Mmu::new();
- // 0xC8000000 virtual -> phys 0x08000000 (EFB)
- mmu.virt_write_u32(0xC800_0000, 0xFB_FB_FB_FB);
- assert_eq!(mmu.phys_read_u32(0x0800_0000), 0xFB_FB_FB_FB);
- // Confirm it did NOT touch RAM
- assert_eq!(mmu.phys_read_u32(0x0), 0);
- }
-
- #[test]
- fn efb_address_does_not_alias_ram() {
- let mut mmu = Mmu::new();
- mmu.phys_write_u32(0x0, 0x1111_1111);
- mmu.phys_write_u32(0x0800_0000, 0x2222_2222);
- assert_eq!(mmu.phys_read_u32(0x0), 0x1111_1111);
- assert_eq!(mmu.phys_read_u32(0x0800_0000), 0x2222_2222);
- }
-
- #[test]
- #[should_panic(expected = "unmapped physical")]
- fn unmapped_address_panics() {
- let mmu = Mmu::new();
- mmu.phys_read_u8(0x1000_0000);
- }
-
- #[test]
- #[should_panic(expected = "unimplemented HW register")]
- fn hw_register_panics() {
- let mmu = Mmu::new();
- mmu.phys_read_u8(0x0C00_0000);
- }
-
- #[test]
- fn phys_slice_returns_correct_data() {
- let mut mmu = Mmu::new();
- mmu.phys_write_u32(0x200, 0xCAFE_BABE);
- let slice = mmu.phys_slice(0x200, 4);
- assert_eq!(slice, &[0xCA, 0xFE, 0xBA, 0xBE]);
- }
-}
diff --git a/crates/gekko/src/vi.rs b/crates/gekko/src/vi.rs
new file mode 100644
index 0000000..3ce4b03
--- /dev/null
+++ b/crates/gekko/src/vi.rs
@@ -0,0 +1,38 @@
+pub mod regs;
+
+use crate::mmio::Mmio;
+
+pub fn xfb_addr(mmio: &Mmio) -> u32 {
+ let top = mmio.read_register::<regs::TopFieldBase>();
+ let addr = (top.xfb_addr() << 9) | ((top.page_offset() as u32) << 24);
+ addr
+}
+
+pub const XFB_WIDTH: usize = 640;
+pub const XFB_HEIGHT: usize = 574;
+
+#[rustfmt::skip]
+pub fn render_xfb(mmio: &mut Mmio) -> Vec<u32> {
+ let mut pixels = vec![0u32; XFB_WIDTH * XFB_HEIGHT];
+ let xfb_addr = xfb_addr(mmio);
+
+ // XFB is YUY2 (YCbCr 4:2:2): each 32-bit word = [Y0][Cb][Y1][Cr] (big-endian)
+ // One word -> two adjacent pixels sharing Cb and Cr.
+ let ycbcr_to_rgb = |y: f32, cb: f32, cr: f32| -> u32 {
+ let r = (1.164 * y + 1.596 * cr).clamp(0.0, 255.0) as u8;
+ let g = (1.164 * y - 0.813 * cr - 0.391 * cb).clamp(0.0, 255.0) as u8;
+ let b = (1.164 * y + 2.018 * cb).clamp(0.0, 255.0) as u8;
+ ((r as u32) << 16) | ((g as u32) << 8) | (b as u32)
+ };
+
+ for i in 0..(XFB_WIDTH * XFB_HEIGHT / 2) {
+ let word = mmio.phys_read_u32(xfb_addr + (i as u32) * 4);
+ let y0 = ((word >> 24) & 0xFF) as f32 - 16.0;
+ let cb = ((word >> 16) & 0xFF) as f32 - 128.0;
+ let y1 = ((word >> 8) & 0xFF) as f32 - 16.0;
+ let cr = ( word & 0xFF) as f32 - 128.0;
+ pixels[i * 2] = ycbcr_to_rgb(y0, cb, cr);
+ pixels[i * 2 + 1] = ycbcr_to_rgb(y1, cb, cr);
+ }
+ pixels
+}
\ No newline at end of file
diff --git a/crates/gekko/src/vi/regs.rs b/crates/gekko/src/vi/regs.rs
new file mode 100644
index 0000000..b05ed63
--- /dev/null
+++ b/crates/gekko/src/vi/regs.rs
@@ -0,0 +1,74 @@
+use crate::mmio::{Mmio, traits::MmioRegister};
+use chapa::BitEnum;
+
+#[derive(Debug, BitEnum)]
+pub enum VideoFormat {
+ Ntsc = 0,
+ Pal = 1,
+ Mpal = 2,
+ Debug = 3,
+}
+
+#[rustfmt::skip]
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Copy, Clone, Debug)]
+pub struct DisplayConfiguration {
+ #[bits(0, alias = "enb")] pub enable: bool,
+ #[bits(1, alias = "rst")] pub reset: bool,
+ #[bits(2, alias = "nin")] pub interlace_selector: bool,
+ #[bits(3, alias = "dlr")] pub display_mode_3d: bool,
+ #[bits(4..=5, alias = "le0")] pub display_latch0: u8,
+ #[bits(6..=7, alias = "le1")] pub display_latch1: u8,
+ #[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 }
+}
+
+#[chapa::bitfield(u32, order = lsb0)]
+#[derive(Copy, Clone, Debug)]
+pub struct TopFieldBase {
+ #[bits(9..=23, alias = "fbb")]
+ pub xfb_addr: u32,
+
+ #[bits(24..=27, alias = "xof")]
+ pub horizontal_offset: u8,
+
+ #[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 (?))
+}
+
+#[chapa::bitfield(u32, order = lsb0)]
+#[derive(Copy, Clone, Debug)]
+pub struct BottomFieldBase {
+ #[bits(9..=23, alias = "fbb")]
+ pub xfb_addr: u32,
+
+ #[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() }
+}
+
+#[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() }
+}
\ No newline at end of file
diff --git a/crates/tinyemu/Cargo.toml b/crates/tinyemu/Cargo.toml
index 8f71890..31079dd 100644
--- a/crates/tinyemu/Cargo.toml
+++ b/crates/tinyemu/Cargo.toml
@@ -9,3 +9,4 @@ colored = "3.1.1"
disasm = { path = "../disasm" }
tracing = "0.1"
tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+base64 = "0.22"
diff --git a/crates/tinyemu/src/main.rs b/crates/tinyemu/src/main.rs
index c592d61..ff4a4e6 100644
--- a/crates/tinyemu/src/main.rs
+++ b/crates/tinyemu/src/main.rs
@@ -1,15 +1,24 @@
mod fmt;
mod snaptshot;
+use base64::Engine as _;
use colored::Colorize;
use disasm::gekko::GekkoInstruction;
+use gekko::vi;
use snaptshot::CpuSnapshot;
fn main() {
- let path = std::env::args()
- .nth(1)
- .expect("Usage: debugger <path_to_rom>");
- let is_debug = std::env::args().any(|arg| arg == "--debug");
+ let args: Vec<String> = std::env::args().collect();
+ let path = args.get(1).expect("Usage: debugger <path_to_rom>").clone();
+ let is_debug = args.iter().any(|arg| arg == "--debug");
+ let until_addr: Option<u32> = args
+ .iter()
+ .position(|arg| arg == "--until")
+ .and_then(|i| args.get(i + 1))
+ .map(|s| {
+ u32::from_str_radix(s.trim_start_matches("0x"), 16)
+ .expect("--until: invalid hex address")
+ });
tracing_subscriber::fmt()
.without_time()
@@ -26,10 +35,10 @@ fn main() {
loop {
if !is_busyloop {
- let instr = GekkoInstruction::decode(gekko.mmu.virt_slice(gekko.cpu.pc, 4))
+ let instr = GekkoInstruction::decode(gekko.mmio.virt_slice(gekko.cpu.pc, 4))
.unwrap_or_else(|| {
dump_registers(&prev_snapshot, &prev_snapshot);
- dump_memory(&gekko.mmu, gekko.cpu.read_gpr(1));
+ dump_memory(&gekko.mmio, gekko.cpu.read_gpr(1));
panic!("Failed to decode instruction at {:08X}", gekko.cpu.pc)
})
@@ -72,12 +81,23 @@ fn main() {
current_addr = gekko.cpu.pc;
+ if let Some(until) = until_addr {
+ if gekko.cpu.pc == until {
+ break;
+ }
+ }
+
if is_debug && !is_busyloop {
dump_registers(&curr_snapshot, &prev_snapshot);
}
prev_snapshot = curr_snapshot;
}
+
+ dump_mmio(&gekko.mmio);
+
+ let pixels = vi::render_xfb(&mut gekko.mmio);
+ render_kitty(&pixels, vi::XFB_WIDTH, vi::XFB_HEIGHT);
}
fn dump_registers(curr: &CpuSnapshot, prev: &CpuSnapshot) {
@@ -148,10 +168,10 @@ fn dump_registers(curr: &CpuSnapshot, prev: &CpuSnapshot) {
println!();
}
-fn dump_memory(mmu: &gekko::mmu::Mmu, addr: u32) {
+fn dump_memory(mmio: &gekko::mmio::Mmio, addr: u32) {
let aligned_addr = addr & !0xF;
let start = aligned_addr.wrapping_sub(0x40);
- let data = mmu.virt_slice(start, 0x80);
+ let data = mmio.virt_slice(start, 0x80);
for (i, line) in data.chunks(16).enumerate() {
let line_addr = start.wrapping_add((i as u32) * 16);
@@ -167,3 +187,64 @@ fn dump_memory(mmu: &gekko::mmu::Mmu, addr: u32) {
println!("{} {}", format!("{:08X}:", line_addr).blue().bold(), hex);
}
}
+
+fn dump_mmio(mmio: &gekko::mmio::Mmio) {
+ let dcr = mmio.read_register::<vi::regs::DisplayConfiguration>();
+ println!("Display Configuration: {:?}", dcr);
+ let tfbl = mmio.read_register::<vi::regs::BottomFieldBase>();
+ println!("Bottom Field Base: {:08X?}", tfbl);
+ let tfbr = mmio.read_register::<vi::regs::TopFieldBase>();
+ println!("Top Field Base: {:08X?}", tfbr);
+ println!("XFB Address: {:08X}", vi::xfb_addr(mmio));
+}
+
+/// Render pixels (packed 0x00RRGGBB u32s) to the terminal via the Kitty
+/// graphics protocol
+///
+/// Protocol: APC escape \x1b_G<key=value,...>;<base64-payload>\x1b\\
+/// a=T – transmit + display immediately
+/// f=32 – 32-bit RGBA pixels
+/// s=W,v=H – dimensions
+/// m=1 – more chunks follow; m=0 – last (or only) chunk
+fn render_kitty(pixels: &[u32], width: usize, height: usize) {
+ use std::io::Write as _;
+
+ // Convert packed RGB to RGBA (alpha = 0xFF).
+ let mut rgba: Vec<u8> = Vec::with_capacity(width * height * 4);
+ for &px in pixels {
+ rgba.push(((px >> 16) & 0xFF) as u8); // R
+ rgba.push(((px >> 8) & 0xFF) as u8); // G
+ rgba.push(( px & 0xFF) as u8); // B
+ rgba.push(0xFF); // A
+ }
+
+ let encoded = base64::engine::general_purpose::STANDARD.encode(&rgba);
+
+ // Kitty protocol requires chunks of at most 4096 base64 characters
+ const CHUNK: usize = 4096;
+ let chunks: Vec<&str> = encoded
+ .as_bytes()
+ .chunks(CHUNK)
+ .map(|c| std::str::from_utf8(c).unwrap())
+ .collect();
+
+ let stdout = std::io::stdout();
+ let mut out = stdout.lock();
+
+ for (idx, chunk) in chunks.iter().enumerate() {
+ let more = if idx + 1 < chunks.len() { 1 } else { 0 };
+ if idx == 0 {
+ // First chunk: include image metadata
+ write!(
+ out,
+ "\x1b_Ga=T,f=32,s={},v={},m={};{}\x1b\\",
+ width, height, more, chunk
+ )
+ .unwrap();
+ } else {
+ write!(out, "\x1b_Gm={};{}\x1b\\", more, chunk).unwrap();
+ }
+ }
+
+ writeln!(out).unwrap();
+}
diff --git a/rsrc/roms/panda.dol.i64 b/rsrc/roms/panda.dol.i64
index ae98d8f..899cf85 100644
Binary files a/rsrc/roms/panda.dol.i64 and b/rsrc/roms/panda.dol.i64 differ