Initial memory mapping implementation

Author: Grarak

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "vitaGL"]
 	path = vitaGL
 	url = https://github.com/Rinnegatamante/vitaGL.git
+[submodule "kubridge"]
+	path = kubridge
+	url = https://github.com/bythos14/kubridge.git

Cargo.lock

@@ -18,7 +18,6 @@ chrono = "0.4.38"
 dsvita_macros = { path = "macros" }
 gl = { git = "https://github.com/bjz/gl-rs" }
 glyph_brush = "0.7.9"
-lazy_static = "1.5.0"
 rust-ini = "0.21.1"
 static_assertions = "1.1.0"
 paste = "1.0.15"
@@ -32,6 +31,7 @@ affinity = "0.1.2"
 [build-dependencies]
 bindgen = "0.70.0"
 cc = "1.0.100"
+cmake = "0.1"
 
 [target.armv7-sony-vita-newlibeabihf.dependencies]
 vitasdk-sys = { version = "0.3.2", features = [
@@ -50,6 +50,7 @@ vitasdk-sys = { version = "0.3.2", features = [
     "SceKernelDmacMgr_stub",
     "SceShaccCg_stub",
     "ScePower_stub",
+    "SceSysrootForKernel_stub"
     #    "SceRazorCapture_stub",
 ] }
 

Cargo.toml

@@ -16,56 +16,98 @@ fn main() {
     if target != "armv7-sony-vita-newlibeabihf" {
         // Running IDE on anything other than linux will fail, so ignore compile error
         let _ = cc::Build::new().file("builtins/cache.c").try_compile("cache").ok();
-        return;
     }
 
     let num_jobs = env::var("NUM_JOBS").unwrap();
 
-    let vitasdk_path = PathBuf::from(env::var("VITASDK").unwrap());
+    let vitasdk_path = env::var("VITASDK").map(PathBuf::from);
+    if vitasdk_path.is_err() {
+        return;
+    }
+    let vitasdk_path = vitasdk_path.unwrap();
     let vitasdk_include_path = vitasdk_path.join("arm-vita-eabi").join("include");
     let vitasdk_lib_path = vitasdk_path.join("arm-vita-eabi").join("lib");
 
-    let bindings_file = out_path.join("imgui_bindings.rs");
-
-    const IMGUI_HEADERS: [&str; 3] = ["imgui.h", "imgui_internal.h", "imgui_impl_vitagl.h"];
-    let mut bindings = bindgen::Builder::default()
-        .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
-        .clang_args(["-x", "c++"])
-        .clang_args(["-std=c++17"])
-        .clang_args(["-target", "armv7a-none-eabihf"])
-        .formatter(Formatter::Prettyplease);
-    for header in IMGUI_HEADERS {
-        let header_path = vitasdk_include_path.join(header);
-        println!("cargo:rerun-if-changed={header_path:?}");
-        bindings = bindings.header(header_path.to_str().unwrap());
+    let kubridge_path = PathBuf::from("kubridge");
+
+    {
+        let bindings_file = out_path.join("imgui_bindings.rs");
+
+        const IMGUI_HEADERS: [&str; 3] = ["imgui.h", "imgui_internal.h", "imgui_impl_vitagl.h"];
+        let mut bindings = bindgen::Builder::default()
+            .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
+            .clang_args(["-x", "c++"])
+            .clang_args(["-std=c++17"])
+            .clang_args(["-target", "armv7a-none-eabihf"])
+            .formatter(Formatter::Prettyplease);
+        for header in IMGUI_HEADERS {
+            let header_path = vitasdk_include_path.join(header);
+            println!("cargo:rerun-if-changed={header_path:?}");
+            bindings = bindings.header(header_path.to_str().unwrap());
+        }
+        bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
+
+        println!("cargo:rustc-link-search=native={vitasdk_lib_path:?}");
+        println!("cargo:rustc-link-lib=static=imgui");
+    }
+
+    {
+        let bindings_file = out_path.join("kubridge_bindings.rs");
+
+        const KUBRIDGE_HEADERS: [&str; 1] = ["kubridge.h"];
+        let mut bindings = bindgen::Builder::default()
+            .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
+            .clang_args(["-I", kubridge_path.to_str().unwrap()])
+            .clang_args(["-x", "c++"])
+            .clang_args(["-std=c++17"])
+            .clang_args(["-target", "armv7a-none-eabihf"])
+            .formatter(Formatter::Prettyplease);
+        for header in KUBRIDGE_HEADERS {
+            let header_path = kubridge_path.join(header);
+            println!("cargo:rerun-if-changed={header_path:?}");
+            bindings = bindings.header(header_path.to_str().unwrap());
+        }
+        bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
+    }
+
+    if target != "armv7-sony-vita-newlibeabihf" {
+        return;
+    }
+
+    {
+        let vita_gl_path = PathBuf::from("vitaGL");
+        let vita_gl_lib_path = vita_gl_path.join("libvitaGL.a");
+        let vita_gl_lib_new_path = vita_gl_path.join("libvitaGL_dsvita.a");
+
+        Command::new("make")
+            .current_dir("vitaGL")
+            .args(["-j", &num_jobs])
+            .envs([
+                ("HAVE_UNFLIPPED_FBOS", "1"),
+                ("NO_TEX_COMBINER", "1"),
+                ("NO_DEBUG", "1"),
+                ("SHADER_COMPILER_SPEEDHACK", "1"),
+                ("MATH_SPEEDHACK", "1"),
+                ("HAVE_SHADER_CACHE", "1"),
+                // ("HAVE_SHARK_LOG", "1"),
+                // ("LOG_ERRORS", "1"),
+                // ("HAVE_RAZOR", "1"),
+            ])
+            .status()
+            .unwrap();
+
+        fs::rename(vita_gl_lib_path, vita_gl_lib_new_path).unwrap();
+        println!("cargo:rustc-link-search=native={}", fs::canonicalize(vita_gl_path).unwrap().to_str().unwrap());
+        println!("cargo:rustc-link-lib=static=vitaGL_dsvita");
+    }
+
+    {
+        let kubridge_dst_path = cmake::Config::new(&kubridge_path).build_target("libkubridge_stub.a").build().join("build");
+        let kubridge_lib_path = kubridge_dst_path.join("libkubridge_stub.a");
+        let kubridge_lib_new_path = kubridge_dst_path.join("libkubridge_stub_dsvita.a");
+        fs::rename(kubridge_lib_path, kubridge_lib_new_path).unwrap();
+
+        println!("cargo:rustc-link-search=native={}", fs::canonicalize(kubridge_dst_path).unwrap().to_str().unwrap());
+        println!("cargo:rustc-link-lib=static=kubridge_stub_dsvita");
     }
-    bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
-
-    println!("cargo:rustc-link-search=native={vitasdk_lib_path:?}");
-    println!("cargo:rustc-link-lib=static=imgui");
-
-    let vita_gl_path = PathBuf::from("vitaGL");
-    let vita_gl_lib_path = vita_gl_path.join("libvitaGL.a");
-    let vita_gl_lib_new_path = vita_gl_path.join("libvitaGL_dsvita.a");
-
-    Command::new("make")
-        .current_dir("vitaGL")
-        .args(["-j", &num_jobs])
-        .envs([
-            ("HAVE_UNFLIPPED_FBOS", "1"),
-            ("NO_TEX_COMBINER", "1"),
-            ("NO_DEBUG", "1"),
-            ("SHADER_COMPILER_SPEEDHACK", "1"),
-            ("MATH_SPEEDHACK", "1"),
-            ("HAVE_SHADER_CACHE", "1"),
-            // ("HAVE_SHARK_LOG", "1"),
-            // ("LOG_ERRORS", "1"),
-            // ("HAVE_RAZOR", "1"),
-        ])
-        .status()
-        .unwrap();
-
-    fs::rename(vita_gl_lib_path, vita_gl_lib_new_path).unwrap();
-    println!("cargo:rustc-link-search=native={}", fs::canonicalize(vita_gl_path).unwrap().to_str().unwrap());
-    println!("cargo:rustc-link-lib=static=vitaGL_dsvita");
 }

build.rs

@@ -1,5 +1,6 @@
 use crate::cartridge_metadata::get_cartridge_metadata;
 use crate::logging::debug_println;
+use crate::mmap::PAGE_SIZE;
 use crate::utils;
 use crate::utils::{rgb5_to_rgb8, NoHashMap};
 use static_assertions::const_assert_eq;
@@ -73,8 +74,6 @@ pub struct CartridgeHeader {
     reserved5: [u8; 0x90],
 }
 
-const PAGE_SIZE: u32 = 4096;
-
 const HEADER_SIZE: usize = size_of::<CartridgeHeader>();
 pub const HEADER_IN_RAM_SIZE: usize = 0x170;
 const_assert_eq!(HEADER_SIZE, HEADER_IN_RAM_SIZE + 0x90);
@@ -86,7 +85,7 @@ pub struct CartridgeIo {
     pub file_name: String,
     pub file_size: u32,
     pub header: CartridgeHeader,
-    content_pages: RefCell<NoHashMap<u32, Rc<[u8; PAGE_SIZE as usize]>>>,
+    content_pages: RefCell<NoHashMap<u32, Rc<[u8; PAGE_SIZE]>>>,
     save_file_path: PathBuf,
     pub save_file_size: u32,
     save_buf: Mutex<(Vec<u8>, bool)>,
@@ -138,8 +137,8 @@ impl CartridgeIo {
         })
     }
 
-    fn get_page(&self, page_addr: u32) -> io::Result<Rc<[u8; PAGE_SIZE as usize]>> {
-        debug_assert_eq!(page_addr & (PAGE_SIZE - 1), 0);
+    fn get_page(&self, page_addr: u32) -> io::Result<Rc<[u8; PAGE_SIZE]>> {
+        debug_assert_eq!(page_addr & (PAGE_SIZE as u32 - 1), 0);
         let mut pages = self.content_pages.borrow_mut();
         match pages.get(&page_addr) {
             None => {
@@ -149,7 +148,7 @@ impl CartridgeIo {
                     pages.clear();
                 }
 
-                let mut buf = [0u8; PAGE_SIZE as usize];
+                let mut buf = [0u8; PAGE_SIZE];
                 self.file.read_at(&mut buf, page_addr as u64)?;
                 let buf = Rc::new(buf);
                 pages.insert(page_addr, buf.clone());
@@ -164,7 +163,7 @@ impl CartridgeIo {
         while remaining > 0 {
             let slice_start = slice.len() - remaining;
 
-            let page_addr = (offset + slice_start as u32) & !(PAGE_SIZE - 1);
+            let page_addr = (offset + slice_start as u32) & !(PAGE_SIZE as u32 - 1);
             let page_offset = offset + slice_start as u32 - page_addr;
             let page = match self.get_page(page_addr) {
                 Ok(page) => page,

kubridge

@@ -284,8 +284,8 @@ impl Emu {
         unsafe { (*self.mem.get()).read_no_tcm::<CPU, T>(addr, self) }
     }
 
-    pub fn mem_read_with_options<const CPU: CpuType, const TCM: bool, const MMU: bool, T: Convert>(&mut self, addr: u32) -> T {
-        unsafe { (*self.mem.get()).read_with_options::<CPU, TCM, MMU, T>(addr, self) }
+    pub fn mem_read_with_options<const CPU: CpuType, const TCM: bool, T: Convert>(&mut self, addr: u32) -> T {
+        unsafe { (*self.mem.get()).read_with_options::<CPU, TCM, T>(addr, self) }
     }
 
     pub fn mem_write<const CPU: CpuType, T: Convert>(&mut self, addr: u32, value: T) {

src/cartridge_io.rs

@@ -4,7 +4,7 @@ use crate::utils::{Convert, HeapMemU8};
 use std::ops::{Deref, DerefMut};
 
 pub struct Main {
-    main: HeapMemU8<{ regions::MAIN_MEMORY_SIZE as usize }>,
+    main: HeapMemU8<{ regions::MAIN_SIZE as usize }>,
 }
 
 impl Main {
@@ -13,18 +13,18 @@ impl Main {
     }
 
     pub fn get_ptr(&self, addr: u32) -> *const u8 {
-        unsafe { self.main.as_ptr().add((addr & (regions::MAIN_MEMORY_SIZE - 1)) as usize) }
+        unsafe { self.main.as_ptr().add((addr & (regions::MAIN_SIZE - 1)) as usize) }
     }
 
     pub fn read<T: Convert>(&self, addr_offset: u32) -> T {
-        utils::read_from_mem(self.main.deref(), addr_offset & (regions::MAIN_MEMORY_SIZE - 1))
+        utils::read_from_mem(self.main.deref(), addr_offset & (regions::MAIN_SIZE - 1))
     }
 
     pub fn write<T: Convert>(&mut self, addr_offset: u32, value: T) {
-        utils::write_to_mem(self.main.deref_mut(), addr_offset & (regions::MAIN_MEMORY_SIZE - 1), value);
+        utils::write_to_mem(self.main.deref_mut(), addr_offset & (regions::MAIN_SIZE - 1), value);
     }
 
     pub fn write_slice<T: Convert>(&mut self, addr_offset: u32, slice: &[T]) {
-        utils::write_to_mem_slice(self.main.deref_mut(), (addr_offset & (regions::MAIN_MEMORY_SIZE - 1)) as usize, slice);
+        utils::write_to_mem_slice(self.main.deref_mut(), (addr_offset & (regions::MAIN_SIZE - 1)) as usize, slice);
     }
 }