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.rsindex 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 {// Registerspub 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_dmapub 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 DMAif 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.rsnew file mode 100644index 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.rsindex 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>, // st3pub 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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 {