Use open-source ipl3 (#68)

* Use open source ipl3-prod

* Remove emux instruction at boot

* Change comment

* Update physical_cart_address to reflect what the new ipl3 does

* Clear MI Interrupt mask at boot

The new ipl3 keeps the mask at non-0, which causes an interrupt to be
signalled in Cause. Clear it at boot to ensure things are all as expected.

* Bump version number

* Read ramsize from ipl3 instead of auto-detecting

* Remove emux in boot.s

* Completely remove boot.asm - with the new ipl3, the bootup can be done in 100% Rust

* Remove boot.asm; determine rom offset; update build instructions

- boot.asm isn't need anymore - the little hardware we still need we can do in Rust.
- rom offset: ipl3 puts the value we need into SPMEM. Use that instead of hardcoding

Author: lemmy-64

.cargo/config.toml

@@ -8,7 +8,5 @@ build-std = ["core", "alloc"]
 rustflags = ["-Clinker-plugin-lto"]
 
 # runner specifies a program that cargo automatically executes after compiling (using the 'cargo run' command).
-# nust64 is used by default, to convert the generated ELF file into an N64 ROM, including the provided IPL3 binary.
-# If you wish to use a different IPL3 file, just provide its path here, in place of the mini-ipl3.
 # Cargo will append this command with the path to the ELF file, so make sure the command ends with '--elf'.
-runner = "nust64 --ipl3 mini-ipl3/mini-ipl3.bin --elf"
+runner = "nust64 --elf"

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "n64-systemtest"
-version = "2.0.5"
+version = "2.1.0"
 edition = "2021"
 
 [features]
@@ -30,7 +30,7 @@ cop0hazard = ["quick"]
 
 # Tests that show something weird about the hardware where the pattern isn't fully understood. These tests aren't enough
 # to implement in an emulator yet. As more tests for a certain quirk are being written (and the understanding grows),
-# they'd move out of this category. Therefore it is disabled by default and not even reported as disabled.
+# they'd move out of this category. Therefore, it is disabled by default and not even reported as disabled.
 poorly_understood_quirk = ["quick"]
 
 vmulf_stress_test = []

Cargo.toml

@@ -31,10 +31,6 @@ cargo install nust64
 ```
 4. Run `cargo run --release` to build the test rom.
 
-**Please note:** N64 roms require a bootcode called IPL3. This bootcode is expected to setup hardware and copy the rom into memory. n64-systemtest comes with its own IPL3, which will **NOT** run on hardware. Once there is a community built open-source IPL3, we'll switch to that.
-
-If you'd like to use your own IPL3: Reconfigure the IPL3 path used by the runner (nust64) in `.cargo/config.toml`.
-
 # Expanded test-set
 In addition to the regular set of tests, n64-systemtest has a few additional sets which can
 be enabled individually: timing, cycle and cop0hazard. Refer to cargo.toml for a detailed description.

README.md

@@ -1,4 +1,4 @@
-ENTRY(_start)
+ENTRY(entrypoint)
 
 SECTIONS {
     . = 0x80000400;

linker.ld

@@ -19,13 +19,14 @@
 
 extern crate alloc;
 
-use core::arch::global_asm;
-
+use crate::cop1::FCSR;
 use spinning_top::Spinlock;
+use crate::cop1::set_fcsr;
 use crate::graphics::framebuffer_console::FramebufferConsole;
 
 use crate::graphics::vi::Video;
 use crate::memory_map::MemoryMap;
+use crate::rsp::spmem::SPMEM;
 
 mod allocator;
 mod assembler;
@@ -45,13 +46,20 @@ mod rsp;
 mod tests;
 mod uncached_memory;
 
-global_asm!(include_str!("boot.s"));
-
 static VIDEO: Spinlock<Video> = Spinlock::new(Video::new());
 
 #[no_mangle]
-unsafe extern "C" fn rust_entrypoint() -> ! {
-    MemoryMap::init();
+unsafe extern "C" fn entrypoint() -> ! {
+    // IPL3 (the bootloader) write the memory size to DMEM. We can read it from there
+    let memory_size = SPMEM::read(0) as usize;
+    let elf_header_offset = ((SPMEM::read(12) >> 16) << 8) as usize;
+    MemoryMap::init(memory_size, elf_header_offset);
+
+    // fcsr isn't reset on boot. Use a good default for the main loop - some tests will change and
+    // restore this
+    set_fcsr(FCSR::new().with_flush_denorm_to_zero(true).with_enable_invalid_operation(true));
+
+    mi::clear_interrupt_mask();
     allocator::init_allocator();
     main();
 

mini-ipl3/mini-ipl3.bin

@@ -4,6 +4,7 @@
 // growing down from the end: stack
 
 static mut MEMORY_SIZE: usize = 0;
+static mut ELF_HEADER_OFFSET: usize = 0;
 
 pub struct MemoryMap {
 
@@ -17,11 +18,11 @@ impl MemoryMap {
     pub const PHYSICAL_PIFRAM_BASE: usize = 0x1FC0_07C0;
 
     /// Call very early (before setting up exception handlers) during boot to set memory size
-    pub(super) fn init() {
+    pub(super) fn init(memory_size: usize, elf_header_offset: usize) {
         assert_eq!(Self::memory_size(), 0);
         unsafe {
-            let value = *(0x8000_0318 as *mut usize);
-            MEMORY_SIZE = value;
+            MEMORY_SIZE = memory_size;
+            ELF_HEADER_OFFSET = elf_header_offset;
         };
     }
 
@@ -31,6 +32,12 @@ impl MemoryMap {
         unsafe { MEMORY_SIZE }
     }
 
+    /// Returns the number of bytes that the elf header is offset RAM vs ROM
+    pub fn elf_header_offset() -> usize {
+        // MEMORY_SIZE is only set during early boot and then never again, so this should be safe
+        unsafe { ELF_HEADER_OFFSET }
+    }
+
     /// Returns an uncached pointer of the given pointer (e.g. 0xA000_1234 is returned for 0x8000_1234
     pub fn uncached<T>(p: *const T) -> *const T {
         let memory_address = p as usize;
@@ -46,13 +53,13 @@ impl MemoryMap {
 
     /// Returns the cartridge (rom) address of a given constant
     pub fn physical_cart_address<T>(p: *const T) -> usize {
-        // The bootcode copies from 0x10001000 to 0x8000_0400. If we have some other pointer,
+        // The bootcode copies from ROM to 0x8000_0400. If we have some other pointer,
         // it doesn't come from the cart
         let memory_address = p as usize;
         assert!(memory_address >= 0x8000_0400);
         assert!(memory_address < 0x8000_0400 + 3 * 1024 * 1024);
 
-        memory_address - 0x8000_0000 + 0x10001000 - 0x400
+        memory_address - 0x8000_0000 + 0x10000000 + MemoryMap::elf_header_offset()
     }
 
     pub fn uncached_cart_address<T>(p: *const T) -> *const T {