WIP

Author: Grarak

src/cartridge_io.rs

@@ -5,29 +5,31 @@ use crate::utils::{rgb5_to_rgb8, HeapMemU8, NoHashMap};
 use static_assertions::const_assert_eq;
 use std::cmp::min;
 use std::fs::File;
+use std::intrinsics::unlikely;
 use std::io::{ErrorKind, Seek};
 use std::ops::{Deref, DerefMut};
 use std::os::unix::fs::FileExt;
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-use std::{io, mem};
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Condvar, Mutex};
+use std::time::{Duration, Instant};
+use std::{io, mem, thread};
 
-#[repr(C, packed)]
+#[repr(C)]
 pub struct ArmValues {
     pub rom_offset: u32,
     pub entry_address: u32,
     pub ram_address: u32,
     pub size: u32,
 }
 
-#[repr(C, packed)]
+#[repr(C)]
 pub struct ArmOverlay {
-    overlay_offset: u32,
-    overlay_size: u32,
+    pub overlay_offset: u32,
+    pub overlay_size: u32,
 }
 
-#[repr(C, packed)]
+#[repr(C)]
 pub struct CartridgeHeader {
     game_title: [u8; 12],
     pub game_code: [u8; 4],
@@ -42,10 +44,8 @@ pub struct CartridgeHeader {
     autostart: u8,
     pub arm9_values: ArmValues,
     pub arm7_values: ArmValues,
-    file_name_table_offset: u32,
-    file_name_table_size: u32,
-    file_allocation_table_offset: u32,
-    file_allocation_table_size: u32,
+    pub file_name_table: ArmOverlay,
+    pub file_allocation_table: ArmOverlay,
     arm9_overlay: ArmOverlay,
     arm7_overlay: ArmOverlay,
     port_setting_normal_commands: u32,
@@ -162,16 +162,46 @@ impl CartridgePreview {
     }
 }
 
+#[derive(Default)]
+struct CartridgeContent {
+    content_pages: NoHashMap<u32, u16>,
+    content_cache: HeapMemU8<MAX_CARTRIDGE_CACHE>,
+}
+
+impl CartridgeContent {
+    fn get_page(&mut self, file: &File, page_addr: u32) -> io::Result<*const [u8; CARTRIDGE_PAGE_SIZE]> {
+        debug_assert_eq!(page_addr & (CARTRIDGE_PAGE_SIZE as u32 - 1), 0);
+        match self.content_pages.get(&page_addr) {
+            None => {
+                if unlikely(self.content_pages.len() >= MAX_CARTRIDGE_CACHE / CARTRIDGE_PAGE_SIZE) {
+                    debug_println!("clear cartridge pages");
+                    self.content_pages.clear();
+                }
+
+                let content_offset = self.content_pages.len() as u16;
+                let start = content_offset as usize * CARTRIDGE_PAGE_SIZE;
+                let buf = &mut self.content_cache[start..start + CARTRIDGE_PAGE_SIZE];
+                file.read_at(buf, page_addr as u64)?;
+                self.content_pages.insert(page_addr, content_offset);
+                Ok(buf.as_ptr() as _)
+            }
+            Some(page) => Ok(self.content_cache[*page as usize * CARTRIDGE_PAGE_SIZE..].as_ptr() as _),
+        }
+    }
+}
+
 pub struct CartridgeIo {
     file: File,
     pub file_name: String,
     pub file_size: u32,
     pub header: CartridgeHeader,
-    content_pages: NoHashMap<u32, u16>,
-    content_cache: HeapMemU8<MAX_CARTRIDGE_CACHE>,
+    content: CartridgeContent,
     save_file_path: PathBuf,
     pub save_file_size: u32,
     save_buf: Mutex<(Vec<u8>, bool)>,
+    async_cmd: Mutex<(u32, u32)>,
+    async_cmd_condvar: Condvar,
+    read_lock: Mutex<()>,
 }
 
 unsafe impl Send for CartridgeIo {}
@@ -209,42 +239,25 @@ impl CartridgeIo {
             file_name: preview.file_name,
             file_size,
             header: preview.header,
-            content_pages: NoHashMap::default(),
-            content_cache: HeapMemU8::new(),
+            content: CartridgeContent::default(),
             save_file_path,
             save_file_size,
             save_buf: Mutex::new((save_buf, false)),
+            async_cmd: Mutex::new((0, 0)),
+            async_cmd_condvar: Condvar::new(),
+            read_lock: Mutex::new(()),
         })
     }
 
-    fn get_page(&mut self, page_addr: u32) -> io::Result<*const [u8; CARTRIDGE_PAGE_SIZE]> {
-        debug_assert_eq!(page_addr & (CARTRIDGE_PAGE_SIZE as u32 - 1), 0);
-        match self.content_pages.get(&page_addr) {
-            None => {
-                if self.content_pages.len() >= MAX_CARTRIDGE_CACHE / CARTRIDGE_PAGE_SIZE {
-                    debug_println!("clear cartridge pages");
-                    self.content_pages.clear();
-                }
-
-                let content_offset = self.content_pages.len() as u16;
-                let start = content_offset as usize * CARTRIDGE_PAGE_SIZE;
-                let buf = &mut self.content_cache[start..start + CARTRIDGE_PAGE_SIZE];
-                self.file.read_at(buf, page_addr as u64)?;
-                self.content_pages.insert(page_addr, content_offset);
-                Ok(buf.as_ptr() as _)
-            }
-            Some(page) => Ok(self.content_cache[*page as usize * CARTRIDGE_PAGE_SIZE..].as_ptr() as _),
-        }
-    }
-
     pub fn read_slice(&mut self, offset: u32, slice: &mut [u8]) -> io::Result<()> {
         let mut remaining = slice.len();
         while remaining > 0 {
             let slice_start = slice.len() - remaining;
 
             let page_addr = (offset + slice_start as u32) & !(CARTRIDGE_PAGE_SIZE as u32 - 1);
             let page_offset = offset + slice_start as u32 - page_addr;
-            let page = self.get_page(page_addr)?;
+            let _read_lock = self.read_lock.lock().unwrap();
+            let page = self.content.get_page(&self.file, page_addr)?;
             let page = unsafe { page.as_ref_unchecked() };
             let page_slice = &page[page_offset as usize..];
 
@@ -324,6 +337,33 @@ impl CartridgeIo {
             *dirty = false;
         }
     }
+
+    pub fn async_cmd(&self, addr: u32, len: u32) {
+        let mut async_cmd = self.async_cmd.lock().unwrap();
+        *async_cmd = (addr, len);
+        self.async_cmd_condvar.notify_one();
+    }
+
+    pub fn async_read_rom(&mut self) {
+        let async_cmd = self.async_cmd.lock().unwrap();
+        let (mut async_cmd, timeout_result) = self
+            .async_cmd_condvar
+            .wait_timeout_while(async_cmd, Duration::from_millis(500), |(addr, offset)| *addr == 0 && *offset == 0)
+            .unwrap();
+        if timeout_result.timed_out() {
+            return;
+        }
+
+        let (addr, len) = *async_cmd;
+        *async_cmd = (0, 0);
+
+        let aligned_addr = addr & !(CARTRIDGE_PAGE_SIZE as u32 - 1);
+        let aligned_addr_end = (addr + len + CARTRIDGE_PAGE_SIZE as u32 - 1) & !(CARTRIDGE_PAGE_SIZE as u32 - 1);
+        for addr in (aligned_addr..aligned_addr_end).step_by(CARTRIDGE_PAGE_SIZE) {
+            let _read_lock = self.read_lock.lock().unwrap();
+            self.content.get_page(&self.file, addr).unwrap();
+        }
+    }
 }
 
 const KEY1_BUF_SIZE: usize = 0x412;

src/core/emu.rs

@@ -63,6 +63,9 @@ pub struct Emu {
     pub jit: JitMemory,
     pub settings: Settings,
     pub nitro_sdk_version: NitroSdkVersion,
+    pub nitro_read_rom_addr: u32,
+    pub nitro_read_rom_last_src: u32,
+    pub nitro_read_rom_hook_usable: bool,
     pub breakout_imm: bool,
     initialized: bool,
 }
@@ -89,6 +92,9 @@ impl Emu {
             jit,
             settings: DEFAULT_SETTINGS.clone(),
             nitro_sdk_version: NitroSdkVersion::default(),
+            nitro_read_rom_addr: 0,
+            nitro_read_rom_last_src: u32::MAX,
+            nitro_read_rom_hook_usable: false,
             breakout_imm: false,
             initialized: true,
         }
@@ -113,8 +119,11 @@ impl Emu {
             self.dma = [Dma::new(), Dma::new()];
             self.timers = [Timers::new(), Timers::new()];
             self.wifi = Wifi::new();
+            self.nitro_sdk_version = NitroSdkVersion::default();
+            self.nitro_read_rom_addr = 0;
+            self.nitro_read_rom_last_src = u32::MAX;
+            self.nitro_read_rom_hook_usable = false;
         }
-        self.nitro_sdk_version = NitroSdkVersion::default();
         self.initialized = false;
     }
 }

src/core/graphics/gpu_renderer.rs

@@ -19,7 +19,7 @@ use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
 use std::thread::Thread;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 pub struct GpuRendererCommon {
     pub mem_buf: GpuMemBuf,
@@ -330,10 +330,6 @@ impl GpuRenderer {
     pub fn unpause(&mut self, cpu_thread: &Thread) {
         self.pause = false;
         cpu_thread.unpark();
-
-        if self.quit {
-            self.read_vram_condvar.notify_one();
-        }
     }
 
     pub fn blit_main_framebuffer(&self) {
@@ -356,13 +352,12 @@ impl GpuRenderer {
     }
 
     pub fn read_vram(&mut self, vram: &[u8; vram::TOTAL_SIZE]) {
-        if self.quit {
+        let read_vram = self.read_vram.lock().unwrap();
+        let (_read_vram, timeout_result) = self.read_vram_condvar.wait_timeout(read_vram, Duration::from_millis(500)).unwrap();
+        if timeout_result.timed_out() {
             return;
         }
 
-        let read_vram = self.read_vram.lock().unwrap();
-        let _read_vram = self.read_vram_condvar.wait(read_vram).unwrap();
-
         self.common.mem_buf.read_vram(vram);
     }
 }

src/core/memory/cartridge.rs

@@ -100,6 +100,8 @@ pub struct Cartridge {
     cmd_mode: CmdMode,
     inner: [CartridgeInner; 2],
     read_buf: HeapMemU8<{ 16 * 1024 }>,
+    pub last_read_addr: u32,
+    need_read: bool,
 }
 
 impl Cartridge {
@@ -109,6 +111,8 @@ impl Cartridge {
             inner: [CartridgeInner::default(), CartridgeInner::default()],
             cmd_mode: CmdMode::None,
             read_buf: HeapMemU8::new(),
+            last_read_addr: 0,
+            need_read: false,
         }
     }
 
@@ -171,6 +175,7 @@ impl Emu {
             CmdMode::Data => {
                 let offset = inner.read_count as u32 - 4;
                 if offset + 3 < inner.block_size as u32 {
+                    self.cartridge_read_rom(cpu);
                     utils::read_from_mem(self.cartridge.read_buf.deref(), offset)
                 } else {
                     0xFFFFFFFF
@@ -365,7 +370,8 @@ impl Emu {
             if read_addr < 0x8000 {
                 read_addr = 0x8000 + (read_addr & 0x1FF);
             }
-            self.cartridge.io.read_slice(read_addr, &mut self.cartridge.read_buf[..inner.block_size as usize]).unwrap();
+            self.cartridge.need_read = true;
+            self.cartridge.last_read_addr = read_addr;
         } else if cmd != 0x9F00000000000000 {
             debug_println!("Unknown rom transfer command {:x}", cmd);
         }
@@ -382,8 +388,19 @@ impl Emu {
         }
     }
 
+    fn cartridge_read_rom(&mut self, cpu: CpuType) {
+        if self.cartridge.need_read {
+            self.cartridge
+                .io
+                .read_slice(self.cartridge.last_read_addr, &mut self.cartridge.read_buf[..self.cartridge.inner[cpu].block_size as usize])
+                .unwrap();
+            self.cartridge.need_read = false;
+        }
+    }
+
     pub fn cartridge_on_word_read_event<const CPU: CpuType>(&mut self) {
         self.cartridge.inner[CPU].rom_ctrl.set_data_word_status(true);
+        self.cartridge_read_rom(CPU);
         self.dma_trigger_imm(CPU, DmaTransferMode::DsCartSlot, 0xF);
     }
 }