Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

dsp dma

Laylefc9dddf6471a
diff --git a/crates/gecko/src/flipper/dsp.rs b/crates/gecko/src/flipper/dsp.rs
index d1c1dce..2ed582d 100644
--- a/crates/gecko/src/flipper/dsp.rs
+++ b/crates/gecko/src/flipper/dsp.rs
@@ -1,3 +1,4 @@
+pub mod addr;
pub mod condition;
pub mod core;
pub mod instruction;
@@ -15,8 +16,6 @@ use crate::mmio::Mmio;
use crate::mmio::constants::DSP_BASE;
use crate::mmio::traits::{MmioAccess, MmioRegister, MmioRw};
-pub const DSP_MAIL_SLICE: u32 = 72;
-
pub struct Dsp {
// Registers
pub registers: core::Registers,
@@ -46,8 +45,16 @@ pub struct Dsp {
pub aram_dma_aram_addr: regs::AramDmaAramAddr,
pub aram_dma_control: regs::AramDmaControl,
+ // IFX Registers
+ pub dma_control: core::regs::DspDmaControl,
+ pub dma_length: u16,
+ pub dma_dsp_addr: u16,
+ pub dma_ram_addr_hi: u16,
+ pub dma_ram_addr_lo: u16,
+
// Flags set by register write handlers, consumed by process_pending_dma
pub pending_aram_dma: bool,
+ pub pending_dsp_dma: bool,
pub pending_ucode_upload: bool,
}
@@ -79,68 +86,104 @@ impl Dsp {
aram_dma_mmio_addr: regs::AramDmaMmioAddr::from_raw(0),
aram_dma_aram_addr: regs::AramDmaAramAddr::from_raw(0),
aram_dma_control: regs::AramDmaControl::from_raw(0),
+ dma_control: core::regs::DspDmaControl::new(),
+ dma_length: 0,
+ dma_dsp_addr: 0,
+ dma_ram_addr_hi: 0,
+ dma_ram_addr_lo: 0,
pending_aram_dma: false,
+ pending_dsp_dma: false,
pending_ucode_upload: false,
}
}
- /// Called by the bus after every DSP MMIO write
- ///
- /// - If an ARAM DMA was triggered (write to DmaControl), execute the transfer and
- /// assert ARINT in the CSR
- /// - If ucode upload was triggered (CSR bit 11 falling edge), DMA 1024 bytes from
- /// main RAM into IRAM (we LLE, but we could HLE the mailbox response)
#[inline]
pub fn process_pending_dma(&mut self, mmio: &mut Mmio) {
- // Handle ARAM DMA
if self.pending_aram_dma {
self.pending_aram_dma = false;
+ self.process_aram_dma(mmio);
+ }
- let mmio_addr = (self.aram_dma_mmio_addr.raw() & 0x3FFFFFFF) as usize;
- let aram_addr = self.aram_dma_aram_addr.raw() as usize;
- let count = self.aram_dma_control.count() as usize * 4;
+ if self.pending_ucode_upload {
+ self.pending_ucode_upload = false;
+ self.process_ucode_upload(mmio);
+ }
- if self.aram_dma_control.direction() == regs::DmaDirection::AramToRam {
- // ARAM -> main RAM
- let src = self.aram[aram_addr..aram_addr + count].to_vec();
- mmio.ram[mmio_addr..mmio_addr + count].copy_from_slice(&src);
- } else {
- // main RAM -> ARAM
- let src = mmio.ram[mmio_addr..mmio_addr + count].to_vec();
- self.aram[aram_addr..aram_addr + count].copy_from_slice(&src);
- }
+ if self.pending_dsp_dma {
+ self.pending_dsp_dma = false;
+ self.process_dsp_dma(mmio);
+ }
+ }
- tracing::debug!(
- mmio_addr = format!("{mmio_addr:08X}"),
- aram_addr = format!("{aram_addr:08X}"),
- count,
- direction = ?self.aram_dma_control.direction(),
- "ARAM DMA complete"
- );
+ fn process_aram_dma(&mut self, mmio: &mut Mmio) {
+ let mmio_addr = (self.aram_dma_mmio_addr.raw() & 0x3FFFFFFF) as usize;
+ let aram_addr = self.aram_dma_aram_addr.raw() as usize;
+ let count = self.aram_dma_control.count() as usize * 4;
- // Assert ARAM DMA complete interrupt in CSR
- self.csr = self.csr.with_ar_interrupt(true);
+ if self.aram_dma_control.direction() == regs::DmaDirection::AramToRam {
+ let src = &self.aram[aram_addr..aram_addr + count];
+ let dst = mmio.virt_slice_mut(mmio_addr as u32, count);
+ dst.copy_from_slice(src);
+ } else {
+ let src = mmio.virt_slice(mmio_addr as u32, count);
+ self.aram[aram_addr..aram_addr + count].copy_from_slice(&src);
}
- // Handle DSP ucode upload
- if self.pending_ucode_upload {
- self.pending_ucode_upload = false;
+ tracing::debug!(
+ mmio_addr = format!("{mmio_addr:08X}"),
+ aram_addr = format!("{aram_addr:08X}"),
+ count,
+ direction = ?self.aram_dma_control.direction(),
+ "ARAM DMA complete"
+ );
- const UCODE_ADDR: usize = 0x8100_0000;
- const UCODE_SIZE: usize = 1024;
- let src = mmio.virt_slice(UCODE_ADDR as u32, UCODE_SIZE);
- self.iram[..UCODE_SIZE].copy_from_slice(&src);
+ self.csr = self.csr.with_ar_interrupt(true);
+ }
- tracing::info!(
- mmio_addr = format!("{UCODE_ADDR:08X}"),
- count = UCODE_SIZE,
- "DSP stub uploaded from RAM to IRAM, executing IRAM"
- );
+ fn process_ucode_upload(&mut self, mmio: &mut Mmio) {
+ const UCODE_ADDR: usize = 0x8100_0000;
+ const UCODE_SIZE: usize = 1024;
+ let src = mmio.virt_slice(UCODE_ADDR as u32, UCODE_SIZE);
+ self.iram[..UCODE_SIZE].copy_from_slice(&src);
+
+ tracing::info!(
+ mmio_addr = format!("{UCODE_ADDR:08X}"),
+ count = UCODE_SIZE,
+ "DSP stub uploaded from RAM to IRAM, executing IRAM"
+ );
+ }
- // HLE: Write expected response to mailbox
- // self.mailbox_to_cpu_hi = regs::MailboxToCpuHi::from_raw(0x8071);
- // self.mailbox_to_cpu_lo = regs::MailboxToCpuLo::from_raw(0xFEED);
+ fn process_dsp_dma(&mut self, mmio: &mut Mmio) {
+ let ram_addr = ((self.dma_ram_addr_hi as u32) << 16) | self.dma_ram_addr_lo as u32;
+ let dsp_addr = (self.dma_dsp_addr as usize) * 2; // word address -> byte offset
+ let len = self.dma_length as usize;
+
+ tracing::debug!(
+ ram_addr = format!("{ram_addr:08X}"),
+ dsp_addr = format!("{dsp_addr:04X}"),
+ len,
+ dscr = format!("{:04X}", self.dma_control.raw()),
+ "DSP DMA"
+ );
+
+ let memory = match self.dma_control.memory_type() {
+ core::regs::DspMemoryType::Data => &mut *self.dram,
+ core::regs::DspMemoryType::Instruction => &mut *self.iram,
+ };
+
+ match self.dma_control.direction() {
+ core::regs::DspDmaDirection::MainToDsp => {
+ let src = mmio.virt_slice(ram_addr, len);
+ memory[dsp_addr..dsp_addr + len].copy_from_slice(&src);
+ }
+ core::regs::DspDmaDirection::DspToMain => {
+ let src = &memory[dsp_addr..dsp_addr + len];
+ let dst = mmio.virt_slice_mut(ram_addr, len);
+ dst.copy_from_slice(src);
+ }
}
+
+ self.dma_length = 0;
}
}
@@ -233,18 +276,27 @@ impl Dsp {
pub fn read_ifx(&mut self, addr: u16) -> u16 {
match addr {
// CMBH (CPU Mailbox High): reading returns data + M bit.
- // M is only cleared when CMBL is read (0xFFFF).
- 0xFFFE => self.mailbox_to_dsp_hi.raw(),
+ // M is only cleared when CMBL is read.
+ addr::IFX_CMBH => self.mailbox_to_dsp_hi.raw(),
// CMBL (CPU Mailbox Low): reading clears CMBH.M (busy)
- 0xFFFF => {
+ addr::IFX_CMBL => {
self.mailbox_to_dsp_hi.set_busy(false);
self.mailbox_to_dsp_lo.raw()
}
// DMBH (DSP Mailbox High): DSP reads back what it wrote
- 0xFFFC => self.mailbox_to_cpu_hi.raw(),
+ addr::IFX_DMBH => self.mailbox_to_cpu_hi.raw(),
// DMBL (DSP Mailbox Low): DSP reads back what it wrote (no side effects)
- 0xFFFD => self.mailbox_to_cpu_lo.raw(),
- _ => read_word(&*self.ifx, addr - 0xFF00),
+ addr::IFX_DMBL => self.mailbox_to_cpu_lo.raw(),
+ // DSP DMA registers
+ addr::IFX_DSCR => self.dma_control.raw(),
+ addr::IFX_DSBL => self.dma_length,
+ addr::IFX_DSPA => self.dma_dsp_addr,
+ addr::IFX_DSMAH => self.dma_ram_addr_hi,
+ addr::IFX_DSMAL => self.dma_ram_addr_lo,
+ _ => {
+ tracing::warn!(addr = format!("{:04X}", addr), "Read from unknown DSP IFX register");
+ read_word(&*self.ifx, addr - 0xFF00)
+ }
}
}
@@ -252,26 +304,41 @@ impl Dsp {
pub fn write_ifx(&mut self, addr: u16, value: u16) {
match addr {
// DMBH (DSP Mailbox High): store data bits (14:0), busy is preserved
- 0xFFFC => {
+ addr::IFX_DMBH => {
let busy = self.mailbox_to_cpu_hi.busy();
self.mailbox_to_cpu_hi = regs::MailboxToCpuHi::from_raw(value & 0x7FFF).with_busy(busy);
}
// DMBL (DSP Mailbox Low): writing sets DMBH.M
- // Interrupt is NOT raised here; the ucode must explicitly write DIRQ (0xFFFB)
- 0xFFFD => {
+ addr::IFX_DMBL => {
self.mailbox_to_cpu_lo = regs::MailboxToCpuLo::from_raw(value);
self.mailbox_to_cpu_hi.set_busy(true);
}
// DIRQ: DSP explicitly raises interrupt to CPU
- 0xFFFB => {
+ addr::IFX_DIRQ => {
if value & 1 != 0 {
tracing::debug!("DSP DIRQ: requesting CPU interrupt");
self.csr.set_dsp_interrupt(true);
}
}
// CMBH/CMBL are read-only from DSP side
- 0xFFFE | 0xFFFF => {}
- _ => write_word(&mut *self.ifx, addr - 0xFF00, value),
+ addr::IFX_CMBH | addr::IFX_CMBL => {}
+ // DSP DMA: writing DSBL triggers the transfer
+ addr::IFX_DSBL => {
+ self.dma_length = value;
+ self.pending_dsp_dma = true;
+ }
+ addr::IFX_DSCR => self.dma_control = core::regs::DspDmaControl::from_raw(value),
+ addr::IFX_DSPA => self.dma_dsp_addr = value,
+ addr::IFX_DSMAH => self.dma_ram_addr_hi = value,
+ addr::IFX_DSMAL => self.dma_ram_addr_lo = value,
+ _ => {
+ tracing::warn!(
+ addr = format!("{:04X}", addr),
+ value = format!("{:04X}", value),
+ "Write to unknown DSP IFX register"
+ );
+ write_word(&mut *self.ifx, addr - 0xFF00, value);
+ }
}
}
diff --git a/crates/gecko/src/flipper/dsp/addr.rs b/crates/gecko/src/flipper/dsp/addr.rs
new file mode 100644
index 0000000..8b0370e
--- /dev/null
+++ b/crates/gecko/src/flipper/dsp/addr.rs
@@ -0,0 +1,24 @@
+// DSP DMA registers
+pub const IFX_DSCR: u16 = 0xFFC9;
+pub const IFX_DSBL: u16 = 0xFFCB;
+pub const IFX_DSPA: u16 = 0xFFCD;
+pub const IFX_DSMAH: u16 = 0xFFCE;
+pub const IFX_DSMAL: u16 = 0xFFCF;
+
+// Accelerator registers
+pub const IFX_ACSAH: u16 = 0xFFD4;
+pub const IFX_ACSAL: u16 = 0xFFD5;
+pub const IFX_ACEAH: u16 = 0xFFD6;
+pub const IFX_ACEAL: u16 = 0xFFD7;
+pub const IFX_ACCAH: u16 = 0xFFD8;
+pub const IFX_ACCAL: u16 = 0xFFD9;
+
+// ARAM DMA request mask
+pub const IFX_AMDM: u16 = 0xFFEF;
+
+// Mailbox registers
+pub const IFX_DIRQ: u16 = 0xFFFB;
+pub const IFX_DMBH: u16 = 0xFFFC;
+pub const IFX_DMBL: u16 = 0xFFFD;
+pub const IFX_CMBH: u16 = 0xFFFE;
+pub const IFX_CMBL: u16 = 0xFFFF;
diff --git a/crates/gecko/src/flipper/dsp/core.rs b/crates/gecko/src/flipper/dsp/core.rs
index 9c0b8ed..60ee009 100644
--- a/crates/gecko/src/flipper/dsp/core.rs
+++ b/crates/gecko/src/flipper/dsp/core.rs
@@ -1,4 +1,7 @@
-use chapa::BitEnum;
+pub mod regs;
+pub mod stack;
+
+use crate::flipper::dsp::core::regs::{SignExtensionMode, StatusRegister};
/// DSP register indices for `Registers::read` / `Registers::write`.
pub mod reg {
@@ -36,47 +39,6 @@ pub mod reg {
pub const AC1M: u8 = 31;
}
-pub struct DspStack<const N: usize> {
- data: [u16; N],
- ptr: u8,
-}
-
-impl<const N: usize> Default for DspStack<N> {
- fn default() -> Self {
- Self { data: [0; N], ptr: 0 }
- }
-}
-
-impl<const N: usize> DspStack<N> {
- #[inline(always)]
- pub fn top(&self) -> u16 {
- self.data[self.ptr as usize]
- }
-
- #[inline(always)]
- pub fn set_top(&mut self, value: u16) {
- self.data[self.ptr as usize] = value;
- }
-
- #[inline(always)]
- pub fn push(&mut self, value: u16) {
- self.ptr += 1;
- self.data[self.ptr as usize] = value;
- }
-
- #[inline(always)]
- pub fn pop(&mut self) -> u16 {
- let value = self.data[self.ptr as usize];
- self.ptr -= 1;
- value
- }
-
- #[inline(always)]
- pub fn is_empty(&self) -> bool {
- self.ptr == 0
- }
-}
-
#[derive(Default)]
pub struct Registers {
pub pc: u16,
@@ -85,10 +47,10 @@ pub struct Registers {
pub ar: [u16; 4],
pub ix: [u16; 4],
pub wr: [u16; 4],
- pub call_stack: DspStack<8>, // st0
- pub data_stack: DspStack<4>, // st1
- pub loop_addr: DspStack<4>, // st2
- pub loop_counter: DspStack<4>, // st3
+ pub call_stack: stack::DspStack<32>, // st0
+ pub data_stack: stack::DspStack<32>, // st1
+ pub loop_addr: stack::DspStack<32>, // st2
+ pub loop_counter: stack::DspStack<32>, // st3
pub ac0_high: u16,
pub ac1_high: u16,
pub config: u16,
@@ -284,40 +246,3 @@ impl Registers {
}
}
}
-
-#[derive(BitEnum, PartialEq, PartialOrd)]
-pub enum SignExtensionMode {
- Bits16,
- Bits40,
-}
-
-#[chapa::bitfield(u16, order = lsb0)]
-#[derive(Clone, Copy, Default)]
-pub struct StatusRegister {
- #[bits(0, alias = "c")]
- pub carry: bool,
- #[bits(1, alias = "o")]
- pub overflow: bool,
- #[bits(2, alias = "z")]
- pub arithmetic_zero: bool,
- #[bits(3, alias = "s")]
- pub sign: bool,
- #[bits(4, alias = "as32")]
- pub above_s32: bool,
- #[bits(5, alias = "tb")]
- pub top_two_bits_equal: bool,
- #[bits(6, alias = "lz")]
- pub logical_zero: bool,
- #[bits(7, alias = "os")]
- pub overflow_sticky: bool,
- #[bits(9, alias = "ie")]
- pub interrupt_enable: bool,
- #[bits(11, alias = "eie")]
- pub external_interrupt_enable: bool,
- #[bits(13, alias = "am")]
- pub product_multiply_result_by_2: bool, // when AM = 0
- #[bits(14, alias = "sxm")]
- pub sign_extension_mode: SignExtensionMode,
- #[bits(15, alias = "su")]
- pub multiplication_operands_are_signed: bool,
-}
diff --git a/crates/gecko/src/flipper/dsp/core/regs.rs b/crates/gecko/src/flipper/dsp/core/regs.rs
new file mode 100644
index 0000000..724ec88
--- /dev/null
+++ b/crates/gecko/src/flipper/dsp/core/regs.rs
@@ -0,0 +1,159 @@
+use chapa::BitEnum;
+
+#[derive(BitEnum, PartialEq, PartialOrd)]
+pub enum SignExtensionMode {
+ Bits16,
+ Bits40,
+}
+
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct StatusRegister {
+ #[bits(0, alias = "c")]
+ pub carry: bool,
+ #[bits(1, alias = "o")]
+ pub overflow: bool,
+ #[bits(2, alias = "z")]
+ pub arithmetic_zero: bool,
+ #[bits(3, alias = "s")]
+ pub sign: bool,
+ #[bits(4, alias = "as32")]
+ pub above_s32: bool,
+ #[bits(5, alias = "tb")]
+ pub top_two_bits_equal: bool,
+ #[bits(6, alias = "lz")]
+ pub logical_zero: bool,
+ #[bits(7, alias = "os")]
+ pub overflow_sticky: bool,
+ #[bits(9, alias = "ie")]
+ pub interrupt_enable: bool,
+ #[bits(11, alias = "eie")]
+ pub external_interrupt_enable: bool,
+ #[bits(13, alias = "am")]
+ pub product_multiply_result_by_2: bool, // when AM = 0
+ #[bits(14, alias = "sxm")]
+ pub sign_extension_mode: SignExtensionMode,
+ #[bits(15, alias = "su")]
+ pub multiplication_operands_are_signed: bool,
+}
+
+/// DSP DMA transfer direction
+#[derive(BitEnum, Debug, PartialEq, Eq)]
+pub enum DspDmaDirection {
+ MainToDsp = 0,
+ DspToMain = 1,
+}
+
+/// DSP memory type involved in DMA
+#[derive(BitEnum, Debug, PartialEq, Eq)]
+pub enum DspMemoryType {
+ Data = 0,
+ Instruction = 1,
+}
+
+/// Accelerator ARAM access direction
+#[derive(BitEnum, Debug, PartialEq, Eq)]
+pub enum AcceleratorDirection {
+ Read = 0,
+ Write = 1,
+}
+
+/// ARAM DMA request mask state.
+#[derive(BitEnum, Debug, PartialEq, Eq)]
+pub enum AramDmaMask {
+ Unmasked = 0,
+ Masked = 1,
+}
+
+/// 0xFFC9 - DSCR - DSP DMA Control Register
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct DspDmaControl {
+ #[bits(0)]
+ pub direction: DspDmaDirection,
+
+ #[bits(1)]
+ pub memory_type: DspMemoryType,
+
+ #[bits(2, readonly)]
+ pub busy: bool,
+}
+
+/// 0xFFCB - DSBL - DSP DMA Block Length
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct DspDmaBlockLength {
+ #[bits(0..=1, readonly)]
+ pub lsb: u8,
+
+ #[bits(2..=15)]
+ pub length: u16,
+}
+
+/// 0xFFCD - DSPA - DSP DMA DSP Memory Address
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct DspDmaDspAddr {
+ #[bits(0, readonly)]
+ pub lsb: bool,
+
+ #[bits(1..=15)]
+ pub address: u16,
+}
+
+/// 0xFFCE - DSMAH - DSP DMA Main Memory Address High
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct DspDmaMainAddrHigh {
+ #[bits(0..=9)]
+ pub address: u16,
+
+ #[bits(10..=15, readonly)]
+ pub _reserved: u8,
+}
+
+/// 0xFFCF - DSMAL - DSP DMA Main Memory Address Low
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct DspDmaMainAddrLow {
+ #[bits(0..=1, readonly)]
+ pub lsb: u8,
+
+ #[bits(2..=15)]
+ pub address: u16,
+}
+
+/// 0xFFD4 - ACSAH - Accelerator ARAM Starting Address High
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct AccStartAddrHigh {
+ #[bits(0..=10)]
+ pub address: u16,
+}
+
+/// 0xFFD6 - ACEAH - Accelerator ARAM Ending Address High
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct AccEndAddrHigh {
+ #[bits(0..=10)]
+ pub address: u16,
+}
+
+/// 0xFFD8 - ACCAH - Accelerator ARAM Current Address High
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct AccCurrentAddrHigh {
+ #[bits(0..=10)]
+ pub address: u16,
+
+ #[bits(15)]
+ pub direction: AcceleratorDirection,
+}
+
+/// 0xFFEF - AMDM - ARAM DMA Request Mask
+#[chapa::bitfield(u16, order = lsb0)]
+#[derive(Clone, Copy, Default)]
+pub struct AramDmaRequestMask {
+ #[bits(0)]
+ pub mask: AramDmaMask,
+}
diff --git a/crates/gecko/src/flipper/dsp/core/stack.rs b/crates/gecko/src/flipper/dsp/core/stack.rs
new file mode 100644
index 0000000..356794b
--- /dev/null
+++ b/crates/gecko/src/flipper/dsp/core/stack.rs
@@ -0,0 +1,42 @@
+pub struct DspStack<const N: usize> {
+ data: [u16; N],
+ ptr: u8,
+}
+
+impl<const N: usize> Default for DspStack<N> {
+ fn default() -> Self {
+ Self { data: [0; N], ptr: 0 }
+ }
+}
+
+impl<const N: usize> DspStack<N> {
+ const MASK: u8 = (N - 1) as u8;
+
+ #[inline(always)]
+ pub fn top(&self) -> u16 {
+ self.data[self.ptr as usize]
+ }
+
+ #[inline(always)]
+ pub fn set_top(&mut self, value: u16) {
+ self.data[self.ptr as usize] = value;
+ }
+
+ #[inline(always)]
+ pub fn push(&mut self, value: u16) {
+ self.ptr = (self.ptr + 1) & Self::MASK;
+ self.data[self.ptr as usize] = value;
+ }
+
+ #[inline(always)]
+ pub fn pop(&mut self) -> u16 {
+ let value = self.data[self.ptr as usize];
+ self.ptr = (self.ptr.wrapping_sub(1)) & Self::MASK;
+ value
+ }
+
+ #[inline(always)]
+ pub fn is_empty(&self) -> bool {
+ self.ptr == 0
+ }
+}
diff --git a/crates/gecko/src/flipper/dsp/interpreter.rs b/crates/gecko/src/flipper/dsp/interpreter.rs
index 9420d1d..04f74ed 100644
--- a/crates/gecko/src/flipper/dsp/interpreter.rs
+++ b/crates/gecko/src/flipper/dsp/interpreter.rs
@@ -1,5 +1,6 @@
use crate::flipper::dsp::condition::BranchControl;
-use crate::flipper::dsp::core::{SignExtensionMode, StatusRegister, reg};
+use crate::flipper::dsp::core::reg;
+use crate::flipper::dsp::core::regs::{SignExtensionMode, StatusRegister};
use crate::flipper::dsp::lut::*;
#[inline(always)]
diff --git a/crates/gecko/src/gamecube.rs b/crates/gecko/src/gamecube.rs
index 679f079..2578b39 100644
--- a/crates/gecko/src/gamecube.rs
+++ b/crates/gecko/src/gamecube.rs
@@ -15,7 +15,7 @@ use crate::flipper::vi::VideoInterface;
#[cfg(feature = "idle-skip")]
use crate::idle::{IDLE_LOOP_MAX_INSTRS, IdleCheck, IdleDetector};
use crate::mmio::Mmio;
-use crate::scheduler::{CYCLES_PER_VSYNC, CPU_CYCLES_PER_DSP_TICK, EventKind, Scheduler};
+use crate::scheduler::{CPU_CYCLES_PER_DSP_TICK, CYCLES_PER_VSYNC, EventKind, Scheduler};
#[cfg(feature = "scripting")]
use crate::scripting::{HookFlags, ScriptHookFilters, ScriptHookState, ScriptHost};
use image::Executable;
diff --git a/crates/gecko/src/mmio.rs b/crates/gecko/src/mmio.rs
index 71077bc..bd7aecc 100644
--- a/crates/gecko/src/mmio.rs
+++ b/crates/gecko/src/mmio.rs
@@ -183,6 +183,11 @@ impl Mmio {
self.phys_slice(Self::virt_to_phys(addr), len)
}
+ #[inline(always)]
+ pub fn virt_slice_mut(&mut self, addr: u32, len: usize) -> &mut [u8] {
+ self.phys_slice_mut(Self::virt_to_phys(addr), len)
+ }
+
/// Read a typed MMIO register from its physical address
#[inline(always)]
pub fn read_register<T: traits::MmioRegister>(&self) -> T {