From 4ead0218d98f042994f495751fabaa23eb77cc4a Mon Sep 17 00:00:00 2001
From: Logan McNaughton <848146+loganmc10@users.noreply.github.com>
Date: Sat, 18 Jan 2025 19:58:23 +0100
Subject: [PATCH] remove pub keyword where it isn't needed (#161)

* remove pub keyword where it isn't needed

* more

* Update main.rs

* more
---
 src/compat/aarch64.rs             | 18 ++++++++--------
 src/device/ai.rs                  | 12 +++++------
 src/device/cache.rs               |  2 +-
 src/device/cart.rs                | 14 ++++++-------
 src/device/cart_rom.rs            |  4 ++--
 src/device/controller.rs          |  8 ++++----
 src/device/controller/mempak.rs   |  2 +-
 src/device/controller/vru.rs      |  6 +++---
 src/device/cop0.rs                | 28 ++++++++++++-------------
 src/device/cop1.rs                | 32 ++++++++++++++---------------
 src/device/cop2.rs                | 14 ++++++-------
 src/device/cpu_instructions.rs    | 14 ++++++-------
 src/device/events.rs              |  2 +-
 src/device/exceptions.rs          |  2 +-
 src/device/fpu_instructions.rs    |  2 +-
 src/device/mi.rs                  |  4 ++--
 src/device/pi.rs                  |  8 ++++----
 src/device/pif.rs                 | 12 +++++------
 src/device/rdp.rs                 |  6 +++---
 src/device/rsp_interface.rs       | 12 +++++------
 src/device/rsp_su_instructions.rs | 34 +++++++++++++++----------------
 src/device/rsp_vu_instructions.rs | 18 ++++++++--------
 src/device/si.rs                  |  6 +++---
 src/device/sram.rs                | 27 ++++++++++--------------
 src/device/tlb.rs                 |  4 ++--
 src/device/vi.rs                  | 10 ++++-----
 src/main.rs                       |  1 +
 src/ui/input.rs                   | 14 ++++++-------
 src/ui/storage.rs                 |  6 +++---
 29 files changed, 159 insertions(+), 163 deletions(-)

diff --git a/src/compat/aarch64.rs b/src/compat/aarch64.rs
index e00d66db..9b9ab41e 100644
--- a/src/compat/aarch64.rs
+++ b/src/compat/aarch64.rs
@@ -1,46 +1,46 @@
 unsafe extern "C" {
     #[link_name = "_mm_srli_epi16__extern"]
-    pub fn _mm_srli_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> __m128i;
+    fn _mm_srli_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> __m128i;
 
     #[link_name = "_mm_insert_epi8__extern"]
-    pub fn _mm_insert_epi8(
+    fn _mm_insert_epi8(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi8__extern"]
-    pub fn _mm_extract_epi8(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi8(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi16__extern"]
-    pub fn _mm_insert_epi16(
+    fn _mm_insert_epi16(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi16__extern"]
-    pub fn _mm_extract_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi32__extern"]
-    pub fn _mm_insert_epi32(
+    fn _mm_insert_epi32(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi32__extern"]
-    pub fn _mm_extract_epi32(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi32(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi64__extern"]
-    pub fn _mm_insert_epi64(
+    fn _mm_insert_epi64(
         __a: __m128i,
         __i: ::std::os::raw::c_longlong,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi64__extern"]
-    pub fn _mm_extract_epi64(
+    fn _mm_extract_epi64(
         __a: __m128i,
         __imm8: ::std::os::raw::c_int,
     ) -> ::std::os::raw::c_longlong;
diff --git a/src/device/ai.rs b/src/device/ai.rs
index cb52742a..08bb3980 100644
--- a/src/device/ai.rs
+++ b/src/device/ai.rs
@@ -26,7 +26,7 @@ pub struct AiDma {
     pub duration: u64,
 }
 
-pub fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
+fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
     if device.ai.fifo[0].duration == 0 {
         return 0;
     }
@@ -43,7 +43,7 @@ pub fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
     dma_length & !7
 }
 
-pub fn get_dma_duration(device: &device::Device) -> u64 {
+fn get_dma_duration(device: &device::Device) -> u64 {
     let samples_per_sec = device.vi.clock / (1 + device.ai.regs[AI_DACRATE_REG as usize]) as u64;
     let bytes_per_sample = 4; /* XXX: assume 16bit stereo - should depends on bitrate instead */
     let length = (device.ai.regs[AI_LEN_REG as usize] & !7) as u64;
@@ -51,7 +51,7 @@ pub fn get_dma_duration(device: &device::Device) -> u64 {
     length * (device.cpu.clock_rate / (bytes_per_sample * samples_per_sec))
 }
 
-pub fn do_dma(device: &mut device::Device) {
+fn do_dma(device: &mut device::Device) {
     device.ai.last_read = device.ai.fifo[0].length;
 
     if device.ai.delayed_carry {
@@ -71,7 +71,7 @@ pub fn do_dma(device: &mut device::Device) {
     device::mi::schedule_rcp_interrupt(device, device::mi::MI_INTR_AI);
 }
 
-pub fn fifo_push(device: &mut device::Device) {
+fn fifo_push(device: &mut device::Device) {
     let duration = get_dma_duration(device);
 
     if (device.ai.regs[AI_STATUS_REG as usize] & AI_STATUS_BUSY) != 0 {
@@ -91,7 +91,7 @@ pub fn fifo_push(device: &mut device::Device) {
     }
 }
 
-pub fn fifo_pop(device: &mut device::Device) {
+fn fifo_pop(device: &mut device::Device) {
     if device.ai.regs[AI_STATUS_REG as usize] & AI_STATUS_FULL != 0 {
         device.ai.fifo[0].address = device.ai.fifo[1].address;
         device.ai.fifo[0].length = device.ai.fifo[1].length;
@@ -152,7 +152,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     }
 }
 
-pub fn dma_event(device: &mut device::Device) {
+fn dma_event(device: &mut device::Device) {
     if device.ai.last_read != 0 {
         let diff = device.ai.fifo[0].length - device.ai.last_read;
         ui::audio::play_audio(
diff --git a/src/device/cache.rs b/src/device/cache.rs
index 3ea3558f..1b2e1da4 100644
--- a/src/device/cache.rs
+++ b/src/device/cache.rs
@@ -205,7 +205,7 @@ pub fn dcache_writeback(device: &mut device::Device, line_index: usize) {
     );
 }
 
-pub fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
+fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
     device::cop0::add_cycles(device, 7);
 
     device.memory.dcache[line_index].valid = true;
diff --git a/src/device/cart.rs b/src/device/cart.rs
index e2a688d0..41f986cd 100644
--- a/src/device/cart.rs
+++ b/src/device/cart.rs
@@ -22,7 +22,7 @@ pub struct AfRtc {
     pub control: u16,
 }
 
-pub fn byte2bcd(mut n: u32) -> u8 {
+fn byte2bcd(mut n: u32) -> u8 {
     n %= 100;
     (((n / 10) << 4) | (n % 10)) as u8
 }
@@ -95,13 +95,13 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn format_eeprom(device: &mut device::Device) {
+fn format_eeprom(device: &mut device::Device) {
     if device.ui.saves.eeprom.0.len() < EEPROM_MAX_SIZE {
         device.ui.saves.eeprom.0.resize(EEPROM_MAX_SIZE, 0xFF)
     }
 }
 
-pub fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
+fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
     format_eeprom(device);
@@ -110,7 +110,7 @@ pub fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usiz
         .copy_from_slice(&device.ui.saves.eeprom.0[address..address + EEPROM_BLOCK_SIZE]);
 }
 
-pub fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
     format_eeprom(device);
@@ -123,7 +123,7 @@ pub fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usi
     device.ui.saves.eeprom.1 = true
 }
 
-pub fn time2data(device: &mut device::Device, offset: usize) {
+fn time2data(device: &mut device::Device, offset: usize) {
     let now: chrono::DateTime<chrono::Local> = chrono::Local::now();
 
     device.pif.ram[offset] = byte2bcd(now.second());
@@ -136,7 +136,7 @@ pub fn time2data(device: &mut device::Device, offset: usize) {
     device.pif.ram[offset + 7] = byte2bcd((now.year() as u32 - 1900) / 100);
 }
 
-pub fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     match device.pif.ram[block] {
         0 => {
             device.pif.ram[offset] = device.cart.rtc.control as u8;
@@ -155,7 +155,7 @@ pub fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usiz
         }
     }
 }
-pub fn af_rtc_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn af_rtc_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     match device.pif.ram[block] {
         0 => {
             device.cart.rtc.control =
diff --git a/src/device/cart_rom.rs b/src/device/cart_rom.rs
index 2358255b..2a4756a6 100644
--- a/src/device/cart_rom.rs
+++ b/src/device/cart_rom.rs
@@ -144,7 +144,7 @@ pub fn load_rom_save(device: &mut device::Device) {
     }
 }
 
-pub fn set_system_region(device: &mut device::Device, country: u8) {
+fn set_system_region(device: &mut device::Device, country: u8) {
     let pal_codes: [u8; 8] = [b'D', b'F', b'I', b'P', b'S', b'U', b'X', b'Y'];
     for i in pal_codes {
         if country == i {
@@ -153,7 +153,7 @@ pub fn set_system_region(device: &mut device::Device, country: u8) {
     }
 }
 
-pub fn set_cic(device: &mut device::Device) {
+fn set_cic(device: &mut device::Device) {
     let hash = calculate_hash(&device.cart.rom[0x40..0x1000]);
     match hash.as_str() {
         "B99F06C4802C2377E31E388435955EF3E99C618A6D55D24699D828EB1075F1EB" => {
diff --git a/src/device/controller.rs b/src/device/controller.rs
index 965d425a..d5af0463 100644
--- a/src/device/controller.rs
+++ b/src/device/controller.rs
@@ -89,7 +89,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn pak_read_block(
+fn pak_read_block(
     device: &mut device::Device,
     addr_acrc: usize,
     data: usize,
@@ -108,7 +108,7 @@ pub fn pak_read_block(
     }
 }
 
-pub fn pak_write_block(
+fn pak_write_block(
     device: &mut device::Device,
     addr_acrc: usize,
     data: usize,
@@ -127,7 +127,7 @@ pub fn pak_write_block(
     }
 }
 
-pub fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
+fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
     let mut i = 0;
     let mut crc = 0;
 
@@ -147,7 +147,7 @@ pub fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8
     crc
 }
 
-pub fn pak_switch_event(device: &mut device::Device) {
+fn pak_switch_event(device: &mut device::Device) {
     for (i, channel) in device.pif.channels.iter_mut().enumerate() {
         if channel.change_pak != PakType::None {
             if channel.change_pak == PakType::RumblePak {
diff --git a/src/device/controller/mempak.rs b/src/device/controller/mempak.rs
index c8bd7efe..48dc9be8 100644
--- a/src/device/controller/mempak.rs
+++ b/src/device/controller/mempak.rs
@@ -3,7 +3,7 @@ use crate::device;
 const MEMPAK_SIZE: usize = 0x8000;
 const MPK_PAGE_SIZE: usize = 256;
 
-pub fn format_mempak(device: &mut device::Device) {
+fn format_mempak(device: &mut device::Device) {
     if device.ui.saves.mempak.0.len() < MEMPAK_SIZE * 4 {
         device.ui.saves.mempak.0.resize(MEMPAK_SIZE * 4, 0);
 
diff --git a/src/device/controller/vru.rs b/src/device/controller/vru.rs
index 5f738a03..e300fdac 100644
--- a/src/device/controller/vru.rs
+++ b/src/device/controller/vru.rs
@@ -36,7 +36,7 @@ pub fn init(device: &mut device::Device) {
     create_word_mappings(device);
 }
 
-pub fn reset_vru(device: &mut device::Device) {
+fn reset_vru(device: &mut device::Device) {
     device.vru.status = 0x00;
     if device.cart.rom[0x3E] == /* Japan */ 0x4A || device.cart.rom[0x3E] == /* Demo */ 0x00 {
         device.vru.voice_state = VOICE_STATUS_READY;
@@ -250,11 +250,11 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn vru_talking_event(device: &mut device::Device) {
+fn vru_talking_event(device: &mut device::Device) {
     device.vru.talking = false
 }
 
-pub fn create_word_mappings(device: &mut device::Device) {
+fn create_word_mappings(device: &mut device::Device) {
     device.vru.word_mappings = HashMap::from([
         (
             String::from("03A50024000303CF00A80003036000EA"),
diff --git a/src/device/cop0.rs b/src/device/cop0.rs
index f414e8bd..0a4e7bb7 100644
--- a/src/device/cop0.rs
+++ b/src/device/cop0.rs
@@ -99,18 +99,18 @@ pub struct Cop0 {
     pub tlb_entries: [device::tlb::TlbEntry; 32],
 }
 
-pub fn mfc0(device: &mut device::Device, opcode: u32) {
+fn mfc0(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] = device::cpu_instructions::se32(
         (get_control_registers(device, device::cpu_instructions::rd(opcode))) as u32 as i32,
     )
 }
 
-pub fn dmfc0(device: &mut device::Device, opcode: u32) {
+fn dmfc0(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] =
         get_control_registers(device, device::cpu_instructions::rd(opcode))
 }
 
-pub fn mtc0(device: &mut device::Device, opcode: u32) {
+fn mtc0(device: &mut device::Device, opcode: u32) {
     device::cop0::set_control_registers(
         device,
         device::cpu_instructions::rd(opcode),
@@ -120,7 +120,7 @@ pub fn mtc0(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dmtc0(device: &mut device::Device, opcode: u32) {
+fn dmtc0(device: &mut device::Device, opcode: u32) {
     device::cop0::set_control_registers(
         device,
         device::cpu_instructions::rd(opcode),
@@ -128,24 +128,24 @@ pub fn dmtc0(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn tlbr(device: &mut device::Device, _opcode: u32) {
+fn tlbr(device: &mut device::Device, _opcode: u32) {
     device::tlb::read(device, device.cpu.cop0.regs[COP0_INDEX_REG as usize])
 }
 
-pub fn tlbwi(device: &mut device::Device, _opcode: u32) {
+fn tlbwi(device: &mut device::Device, _opcode: u32) {
     device::tlb::write(device, device.cpu.cop0.regs[COP0_INDEX_REG as usize])
 }
 
-pub fn tlbwr(device: &mut device::Device, _opcode: u32) {
+fn tlbwr(device: &mut device::Device, _opcode: u32) {
     let random = set_random_register(device);
     device::tlb::write(device, random)
 }
 
-pub fn tlbp(device: &mut device::Device, _opcode: u32) {
+fn tlbp(device: &mut device::Device, _opcode: u32) {
     device::tlb::probe(device)
 }
 
-pub fn eret(device: &mut device::Device, _opcode: u32) {
+fn eret(device: &mut device::Device, _opcode: u32) {
     if device.cpu.cop0.regs[COP0_STATUS_REG as usize] & COP0_STATUS_ERL != 0 {
         device.cpu.pc = device.cpu.cop0.regs[COP0_ERROREPC_REG as usize];
         device.cpu.cop0.regs[COP0_STATUS_REG as usize] &= !COP0_STATUS_ERL
@@ -158,7 +158,7 @@ pub fn eret(device: &mut device::Device, _opcode: u32) {
     device::exceptions::check_pending_interrupts(device)
 }
 
-pub fn execute_cp0(device: &mut device::Device, opcode: u32) {
+fn execute_cp0(device: &mut device::Device, opcode: u32) {
     device.cpu.cop0.instrs2[(opcode & 0x3F) as usize](device, opcode)
 }
 
@@ -174,7 +174,7 @@ pub fn reserved(device: &mut device::Device, _opcode: u32) {
     device::exceptions::reserved_exception(device, 0);
 }
 
-pub fn get_control_registers(device: &device::Device, index: u32) -> u64 {
+fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     match index {
         COP0_COUNT_REG => device.cpu.cop0.regs[index as usize] >> 1,
         COP0_RANDOM_REG => set_random_register(device),
@@ -183,7 +183,7 @@ pub fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     }
 }
 
-pub fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64) {
+fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64) {
     device.cpu.cop0.reg_latch = data;
     match index {
         COP0_COUNT_REG => {
@@ -230,7 +230,7 @@ pub fn set_control_registers(device: &mut device::Device, index: u32, mut data:
     device::exceptions::check_pending_interrupts(device);
 }
 
-pub fn compare_event(device: &mut device::Device) {
+fn compare_event(device: &mut device::Device) {
     device.cpu.cop0.regs[COP0_CAUSE_REG as usize] &= !COP0_CAUSE_EXCCODE_MASK;
     device.cpu.cop0.regs[COP0_CAUSE_REG as usize] |= COP0_CAUSE_IP7;
 
@@ -243,7 +243,7 @@ pub fn compare_event(device: &mut device::Device) {
     device::exceptions::check_pending_interrupts(device);
 }
 
-pub fn set_random_register(device: &device::Device) -> u64 {
+fn set_random_register(device: &device::Device) -> u64 {
     if device.cpu.cop0.regs[COP0_WIRED_REG as usize] > 31 {
         (u64::MAX - device.cpu.cop0.regs[COP0_COUNT_REG as usize]) & 0x3F
     } else {
diff --git a/src/device/cop1.rs b/src/device/cop1.rs
index 01239eaf..8a4ee8ac 100644
--- a/src/device/cop1.rs
+++ b/src/device/cop1.rs
@@ -173,7 +173,7 @@ pub fn sdc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn mfc1(device: &mut device::Device, opcode: u32) {
+fn mfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -185,7 +185,7 @@ pub fn mfc1(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32(u32::from_ne_bytes(value.to_ne_bytes()) as i32);
 }
 
-pub fn dmfc1(device: &mut device::Device, opcode: u32) {
+fn dmfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -197,7 +197,7 @@ pub fn dmfc1(device: &mut device::Device, opcode: u32) {
         u64::from_ne_bytes(value.to_ne_bytes());
 }
 
-pub fn cfc1(device: &mut device::Device, opcode: u32) {
+fn cfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -209,7 +209,7 @@ pub fn cfc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dcfc1(device: &mut device::Device, opcode: u32) {
+fn dcfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -221,7 +221,7 @@ pub fn dcfc1(device: &mut device::Device, opcode: u32) {
     device::exceptions::floating_point_exception(device)
 }
 
-pub fn mtc1(device: &mut device::Device, opcode: u32) {
+fn mtc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -239,7 +239,7 @@ pub fn mtc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dmtc1(device: &mut device::Device, opcode: u32) {
+fn dmtc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -252,7 +252,7 @@ pub fn dmtc1(device: &mut device::Device, opcode: u32) {
     set_fpr_double(device, device::fpu_instructions::fs(opcode) as usize, value)
 }
 
-pub fn ctc1(device: &mut device::Device, opcode: u32) {
+fn ctc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -266,7 +266,7 @@ pub fn ctc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dctc1(device: &mut device::Device, opcode: u32) {
+fn dctc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -278,7 +278,7 @@ pub fn dctc1(device: &mut device::Device, opcode: u32) {
     device::exceptions::floating_point_exception(device)
 }
 
-pub fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -288,7 +288,7 @@ pub fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.b_instrs[((opcode >> 16) & 0x3) as usize](device, opcode)
 }
 
-pub fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -298,7 +298,7 @@ pub fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.s_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -308,7 +308,7 @@ pub fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.d_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -318,7 +318,7 @@ pub fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.l_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -328,7 +328,7 @@ pub fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.w_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn unusable(device: &mut device::Device, _opcode: u32) {
+fn unusable(device: &mut device::Device, _opcode: u32) {
     device::exceptions::cop_unusable_exception(device, device::cop0::COP0_CAUSE_CE1)
 }
 
@@ -342,7 +342,7 @@ pub fn reserved(device: &mut device::Device, opcode: u32) {
     device::exceptions::reserved_exception(device, device::cop0::COP0_CAUSE_CE1);
 }
 
-pub fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
+fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
     match index {
         0 => device.cpu.cop1.fcr0,
         31 => device.cpu.cop1.fcr31,
@@ -352,7 +352,7 @@ pub fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
     }
 }
 
-pub fn set_control_registers_fpu(device: &mut device::Device, index: u32, data: u32) {
+fn set_control_registers_fpu(device: &mut device::Device, index: u32, data: u32) {
     match index {
         0 => { // read only
         }
diff --git a/src/device/cop2.rs b/src/device/cop2.rs
index be7a8517..ddf5763a 100644
--- a/src/device/cop2.rs
+++ b/src/device/cop2.rs
@@ -5,7 +5,7 @@ pub struct Cop2 {
     pub reg_latch: u64,
 }
 
-pub fn mfc2(device: &mut device::Device, opcode: u32) {
+fn mfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -15,7 +15,7 @@ pub fn mfc2(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32((device.cpu.cop2.reg_latch) as u32 as i32)
 }
 
-pub fn dmfc2(device: &mut device::Device, opcode: u32) {
+fn dmfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -24,7 +24,7 @@ pub fn dmfc2(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] = device.cpu.cop2.reg_latch
 }
 
-pub fn cfc2(device: &mut device::Device, opcode: u32) {
+fn cfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -34,7 +34,7 @@ pub fn cfc2(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32((device.cpu.cop2.reg_latch) as u32 as i32)
 }
 
-pub fn mtc2(device: &mut device::Device, opcode: u32) {
+fn mtc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -43,7 +43,7 @@ pub fn mtc2(device: &mut device::Device, opcode: u32) {
     device.cpu.cop2.reg_latch = device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize]
 }
 
-pub fn dmtc2(device: &mut device::Device, opcode: u32) {
+fn dmtc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -52,7 +52,7 @@ pub fn dmtc2(device: &mut device::Device, opcode: u32) {
     device.cpu.cop2.reg_latch = device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize]
 }
 
-pub fn ctc2(device: &mut device::Device, opcode: u32) {
+fn ctc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -72,7 +72,7 @@ pub fn reserved(device: &mut device::Device, opcode: u32) {
     device::exceptions::reserved_exception(device, device::cop0::COP0_CAUSE_CE2);
 }
 
-pub fn unusable(device: &mut device::Device, _opcode: u32) {
+fn unusable(device: &mut device::Device, _opcode: u32) {
     device::exceptions::cop_unusable_exception(device, device::cop0::COP0_CAUSE_CE2)
 }
 
diff --git a/src/device/cpu_instructions.rs b/src/device/cpu_instructions.rs
index e452a26f..4843f2b5 100644
--- a/src/device/cpu_instructions.rs
+++ b/src/device/cpu_instructions.rs
@@ -12,7 +12,7 @@ pub fn rt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn sa(opcode: u32) -> u32 {
+fn sa(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
@@ -28,23 +28,23 @@ pub fn se16(value: i16) -> u64 {
     value as i64 as u64
 }
 
-pub fn se8(value: i8) -> u64 {
+fn se8(value: i8) -> u64 {
     value as i64 as u64
 }
 
-pub fn bshift<T: Into<u64>>(address: T) -> u64 {
+fn bshift<T: Into<u64>>(address: T) -> u64 {
     ((address.into() & 3) ^ 3) << 3
 }
 
-pub fn hshift<T: Into<u64>>(address: T) -> u64 {
+fn hshift<T: Into<u64>>(address: T) -> u64 {
     ((address.into() & 2) ^ 2) << 3
 }
 
-pub fn bits_below_mask<T: Into<u64>>(x: T) -> u64 {
+fn bits_below_mask<T: Into<u64>>(x: T) -> u64 {
     (1 << x.into()) - 1
 }
 
-pub fn bits_above_mask<T: Into<u64>>(x: T) -> u64 {
+fn bits_above_mask<T: Into<u64>>(x: T) -> u64 {
     !bits_below_mask(x)
 }
 
@@ -60,7 +60,7 @@ pub fn check_relative_idle_loop(device: &mut device::Device, opcode: u32) {
     }
 }
 
-pub fn check_absolute_idle_loop(device: &mut device::Device, target: u64) {
+fn check_absolute_idle_loop(device: &mut device::Device, target: u64) {
     if device.cpu.pc == target
         && device.memory.fast_read[(device.cpu.pc_phys >> 16) as usize](
             device,
diff --git a/src/device/events.rs b/src/device/events.rs
index d527f3d5..ee7c2837 100644
--- a/src/device/events.rs
+++ b/src/device/events.rs
@@ -57,7 +57,7 @@ pub fn trigger_event(device: &mut device::Device) {
     set_next_event(device);
 }
 
-pub fn set_next_event(device: &mut device::Device) {
+fn set_next_event(device: &mut device::Device) {
     device.cpu.next_event_count = u64::MAX;
     for (pos, i) in device.cpu.events.iter().enumerate() {
         if i.enabled && i.count < device.cpu.next_event_count {
diff --git a/src/device/exceptions.rs b/src/device/exceptions.rs
index 42008f72..4558b714 100644
--- a/src/device/exceptions.rs
+++ b/src/device/exceptions.rs
@@ -133,7 +133,7 @@ pub fn tlb_miss_exception(
     exception_general(device, vector_offset)
 }
 
-pub fn exception_general(device: &mut device::Device, vector_offset: u32) {
+fn exception_general(device: &mut device::Device, vector_offset: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_EXL
         == 0
     {
diff --git a/src/device/fpu_instructions.rs b/src/device/fpu_instructions.rs
index 007a18c1..0b4824f3 100644
--- a/src/device/fpu_instructions.rs
+++ b/src/device/fpu_instructions.rs
@@ -8,7 +8,7 @@ pub fn ft(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn fd(opcode: u32) -> u32 {
+fn fd(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
diff --git a/src/device/mi.rs b/src/device/mi.rs
index 6ca54e74..595dd12d 100644
--- a/src/device/mi.rs
+++ b/src/device/mi.rs
@@ -75,7 +75,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     device::exceptions::check_pending_interrupts(device)
 }
 
-pub fn update_init_mode(device: &mut device::Device, w: u32) {
+fn update_init_mode(device: &mut device::Device, w: u32) {
     device.mi.regs[MI_INIT_MODE_REG as usize] &= !MI_INIT_LENGTH_MASK;
     device.mi.regs[MI_INIT_MODE_REG as usize] |= w & MI_INIT_LENGTH_MASK;
 
@@ -103,7 +103,7 @@ pub fn update_init_mode(device: &mut device::Device, w: u32) {
     }
 }
 
-pub fn update_intr_mask(device: &mut device::Device, w: u32) {
+fn update_intr_mask(device: &mut device::Device, w: u32) {
     if w & MI_CLR_SP != 0 {
         device.mi.regs[MI_INTR_MASK_REG as usize] &= !MI_INTR_SP
     }
diff --git a/src/device/pi.rs b/src/device/pi.rs
index f3dc7132..54a82e16 100644
--- a/src/device/pi.rs
+++ b/src/device/pi.rs
@@ -30,7 +30,7 @@ pub struct Pi {
     pub regs: [u32; PI_REGS_COUNT as usize],
 }
 
-pub struct PiHandler {
+struct PiHandler {
     read: fn(&mut device::Device, u32, u32, u32) -> u64,
     write: fn(&mut device::Device, u32, u32, u32) -> u64,
 }
@@ -49,7 +49,7 @@ pub fn read_regs(
     }
 }
 
-pub fn dma_read(device: &mut device::Device) {
+fn dma_read(device: &mut device::Device) {
     let handler = get_handler(device.pi.regs[PI_CART_ADDR_REG as usize]);
 
     let cart_addr = device.pi.regs[PI_CART_ADDR_REG as usize] & !1;
@@ -79,7 +79,7 @@ pub fn dma_read(device: &mut device::Device) {
     device.pi.regs[PI_STATUS_REG as usize] |= PI_STATUS_DMA_BUSY
 }
 
-pub fn dma_write(device: &mut device::Device) {
+fn dma_write(device: &mut device::Device) {
     let handler = get_handler(device.pi.regs[PI_CART_ADDR_REG as usize]);
 
     let cart_addr = device.pi.regs[PI_CART_ADDR_REG as usize] & !1;
@@ -112,7 +112,7 @@ pub fn dma_write(device: &mut device::Device) {
     device.pi.regs[PI_STATUS_REG as usize] |= PI_STATUS_DMA_BUSY
 }
 
-pub fn get_handler(address: u32) -> PiHandler {
+fn get_handler(address: u32) -> PiHandler {
     let mut handler = PiHandler {
         read: device::cart_rom::dma_read,
         write: device::cart_rom::dma_write,
diff --git a/src/device/pif.rs b/src/device/pif.rs
index f3f1ad79..d94765fe 100644
--- a/src/device/pif.rs
+++ b/src/device/pif.rs
@@ -73,7 +73,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         device::si::SI_STATUS_DMA_BUSY | device::si::SI_STATUS_IO_BUSY
 }
 
-pub fn process_channel(device: &mut device::Device, channel: usize) -> usize {
+fn process_channel(device: &mut device::Device, channel: usize) -> usize {
     /* don't process channel if it has been disabled */
     if device.pif.channels[channel].tx.is_none() {
         return 0;
@@ -103,14 +103,14 @@ pub fn update_pif_ram(device: &mut device::Device) -> u64 {
     (24000 + (active_channels * 30000)) as u64
 }
 
-pub fn disable_pif_channel(channel: &mut PifChannel) {
+fn disable_pif_channel(channel: &mut PifChannel) {
     channel.tx = None;
     channel.rx = None;
     channel.tx_buf = None;
     channel.rx_buf = None;
 }
 
-pub fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize) -> usize {
+fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize) -> usize {
     let tx = device.pif.ram[buf] & 0x3f;
     let rx = device.pif.ram[buf + 1] & 0x3f;
 
@@ -124,7 +124,7 @@ pub fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize
     (2 + tx + rx) as usize
 }
 
-pub fn setup_channels_format(device: &mut device::Device) {
+fn setup_channels_format(device: &mut device::Device) {
     let mut i: usize = 0;
     let mut k: usize = 0;
     while i < PIF_RAM_SIZE && k < PIF_CHANNELS_COUNT {
@@ -244,7 +244,7 @@ pub fn init(device: &mut device::Device) {
     device.pif.channels[4].process = Some(device::cart::process)
 }
 
-pub fn process_cic_challenge(device: &mut device::Device) {
+fn process_cic_challenge(device: &mut device::Device) {
     let mut challenge: [u8; 30] = [0; 30];
     let mut response: [u8; 30] = [0; 30];
 
@@ -265,7 +265,7 @@ pub fn process_cic_challenge(device: &mut device::Device) {
     }
 }
 
-pub fn n64_cic_nus_6105(chl: [u8; 30], rsp: &mut [u8; 30], len: usize) {
+fn n64_cic_nus_6105(chl: [u8; 30], rsp: &mut [u8; 30], len: usize) {
     let lut0: [u8; 0x10] = [
         0x4, 0x7, 0xA, 0x7, 0xE, 0x5, 0xE, 0x1, 0xC, 0xF, 0x8, 0xF, 0x6, 0x3, 0x6, 0x9,
     ];
diff --git a/src/device/rdp.rs b/src/device/rdp.rs
index 2b323cac..973a7d2b 100644
--- a/src/device/rdp.rs
+++ b/src/device/rdp.rs
@@ -91,7 +91,7 @@ pub fn write_regs_dpc(device: &mut device::Device, address: u64, value: u32, mas
     }
 }
 
-pub fn run_rdp(device: &mut device::Device) {
+fn run_rdp(device: &mut device::Device) {
     let timer = ui::video::process_rdp_list();
 
     if timer != 0 {
@@ -120,7 +120,7 @@ pub fn write_regs_dps(device: &mut device::Device, address: u64, value: u32, mas
     )
 }
 
-pub fn update_dpc_status(device: &mut device::Device, w: u32) {
+fn update_dpc_status(device: &mut device::Device, w: u32) {
     /* clear / set xbus_dmem_dma */
     if w & DPC_CLR_XBUS_DMEM_DMA != 0 {
         device.rdp.regs_dpc[DPC_STATUS_REG as usize] &= !DPC_STATUS_XBUS_DMEM_DMA
@@ -173,7 +173,7 @@ pub fn init(device: &mut device::Device) {
         DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY | DPC_STATUS_CBUF_READY;
 }
 
-pub fn rdp_interrupt_event(device: &mut device::Device) {
+fn rdp_interrupt_event(device: &mut device::Device) {
     ui::video::full_sync();
 
     device::mi::set_rcp_interrupt(device, device::mi::MI_INTR_DP)
diff --git a/src/device/rsp_interface.rs b/src/device/rsp_interface.rs
index 275c0899..2fbb4048 100644
--- a/src/device/rsp_interface.rs
+++ b/src/device/rsp_interface.rs
@@ -129,7 +129,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, _mask: u
     // SH/SB are broken: They overwrite the whole 32 bit, filling everything that isn't written with zeroes
 }
 
-pub fn do_dma(device: &mut device::Device, dma: RspDma) {
+fn do_dma(device: &mut device::Device, dma: RspDma) {
     let l = dma.length;
 
     let length = ((l & 0xfff) | 7) + 1;
@@ -205,7 +205,7 @@ pub fn do_dma(device: &mut device::Device, dma: RspDma) {
     );
 }
 
-pub fn fifo_push(device: &mut device::Device, dir: DmaDir) {
+fn fifo_push(device: &mut device::Device, dir: DmaDir) {
     if device.rsp.regs[SP_DMA_FULL_REG as usize] != 0 {
         panic!("RSP DMA already full")
     }
@@ -237,7 +237,7 @@ pub fn fifo_push(device: &mut device::Device, dir: DmaDir) {
     }
 }
 
-pub fn fifo_pop(device: &mut device::Device) {
+fn fifo_pop(device: &mut device::Device) {
     if device.rsp.regs[SP_DMA_FULL_REG as usize] != 0 {
         device.rsp.fifo[0].dir = device.rsp.fifo[1].dir;
         device.rsp.fifo[0].length = device.rsp.fifo[1].length;
@@ -312,7 +312,7 @@ pub fn write_regs2(device: &mut device::Device, address: u64, value: u32, mask:
     }
 }
 
-pub fn update_sp_status(device: &mut device::Device, w: u32) {
+fn update_sp_status(device: &mut device::Device, w: u32) {
     let was_halted = device.rsp.regs[SP_STATUS_REG as usize] & SP_STATUS_HALT != 0;
 
     /* clear / set halt */
@@ -426,7 +426,7 @@ pub fn update_sp_status(device: &mut device::Device, w: u32) {
     }
 }
 
-pub fn do_task(device: &mut device::Device) {
+fn do_task(device: &mut device::Device) {
     let timer = device::rsp_cpu::run(device);
 
     device::events::create_event(
@@ -437,7 +437,7 @@ pub fn do_task(device: &mut device::Device) {
     )
 }
 
-pub fn rsp_event(device: &mut device::Device) {
+fn rsp_event(device: &mut device::Device) {
     if device.rsp.cpu.broken {
         device.rsp.regs[SP_STATUS_REG as usize] |= SP_STATUS_HALT | SP_STATUS_BROKE;
 
diff --git a/src/device/rsp_su_instructions.rs b/src/device/rsp_su_instructions.rs
index 0081c49c..6bbc0fd2 100644
--- a/src/device/rsp_su_instructions.rs
+++ b/src/device/rsp_su_instructions.rs
@@ -8,45 +8,45 @@ use crate::device;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-pub fn rd(opcode: u32) -> u32 {
+fn rd(opcode: u32) -> u32 {
     (opcode >> 11) & 0x1F
 }
 
-pub fn rs(opcode: u32) -> u32 {
+fn rs(opcode: u32) -> u32 {
     (opcode >> 21) & 0x1F
 }
 
-pub fn rt(opcode: u32) -> u32 {
+fn rt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn sa(opcode: u32) -> u32 {
+fn sa(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
-pub fn imm(opcode: u32) -> u16 {
+fn imm(opcode: u32) -> u16 {
     opcode as u16
 }
 
-pub fn se16(value: i16) -> u32 {
+fn se16(value: i16) -> u32 {
     value as i32 as u32
 }
 
-pub fn voffset(opcode: u32) -> u8 {
+fn voffset(opcode: u32) -> u8 {
     (opcode & 0x7F) as u8
 }
 
-pub fn velement(opcode: u32) -> u8 {
+fn velement(opcode: u32) -> u8 {
     ((opcode >> 7) & 0xF) as u8
 }
 
-pub fn sign_extend_7bit_offset(offset: u8, shift_amount: u32) -> u32 {
+fn sign_extend_7bit_offset(offset: u8, shift_amount: u32) -> u32 {
     let soffset = (((offset << 1) & 0x80) | offset) as i8;
 
     (((soffset) as i32) as u32) << shift_amount
 }
 
-pub fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
+fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
     unsafe {
         *vpr = match element & 15 {
             0 => _mm_insert_epi8(*vpr, value as i32, 15),
@@ -70,7 +70,7 @@ pub fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
     }
 }
 
-pub fn get_vpr8(vpr: __m128i, element: u8) -> u8 {
+fn get_vpr8(vpr: __m128i, element: u8) -> u8 {
     unsafe {
         match element & 15 {
             0 => _mm_extract_epi8(vpr, 15) as u8,
@@ -126,7 +126,7 @@ pub fn get_vpr16(vpr: __m128i, element: u8) -> u16 {
     }
 }
 
-pub fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
+fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
     unsafe {
         *vpr = match element & 3 {
             0 => _mm_insert_epi32(*vpr, value as i32, 3),
@@ -138,7 +138,7 @@ pub fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
     }
 }
 
-pub fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
+fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
     unsafe {
         match element & 3 {
             0 => _mm_extract_epi32(vpr, 3) as u32,
@@ -150,7 +150,7 @@ pub fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
     }
 }
 
-pub fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
+fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
     unsafe {
         *vpr = match element & 1 {
             0 => _mm_insert_epi64(*vpr, value as i64, 1),
@@ -160,7 +160,7 @@ pub fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
     }
 }
 
-pub fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
+fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
     unsafe {
         match element & 1 {
             0 => _mm_extract_epi64(vpr, 1) as u64,
@@ -170,11 +170,11 @@ pub fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
     }
 }
 
-pub fn modify_vpr128(vpr: &mut __m128i, value: u128) {
+fn modify_vpr128(vpr: &mut __m128i, value: u128) {
     unsafe { *vpr = std::mem::transmute::<u128, __m128i>(value) }
 }
 
-pub fn get_vpr128(vpr: __m128i) -> u128 {
+fn get_vpr128(vpr: __m128i) -> u128 {
     unsafe { std::mem::transmute::<__m128i, u128>(vpr) }
 }
 
diff --git a/src/device/rsp_vu_instructions.rs b/src/device/rsp_vu_instructions.rs
index e9f0833b..15de7e4b 100644
--- a/src/device/rsp_vu_instructions.rs
+++ b/src/device/rsp_vu_instructions.rs
@@ -9,41 +9,41 @@ use crate::device::rsp_su_instructions::{get_vpr16, modify_vpr16};
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-pub fn vt(opcode: u32) -> u32 {
+fn vt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn ve(opcode: u32) -> u32 {
+fn ve(opcode: u32) -> u32 {
     (opcode >> 21) & 0xF
 }
 
-pub fn vs(opcode: u32) -> u32 {
+fn vs(opcode: u32) -> u32 {
     (opcode >> 11) & 0x1F
 }
 
-pub fn vd(opcode: u32) -> u32 {
+fn vd(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
-pub fn de(opcode: u32) -> u32 {
+fn de(opcode: u32) -> u32 {
     (opcode >> 11) & 0x7
 }
 
-pub fn clamp_signed_32(value: i32) -> i16 {
+fn clamp_signed_32(value: i32) -> i16 {
     value.clamp(-32768, 32767) as i16
 }
 
-pub fn clamp_signed_64(value: i64) -> i16 {
+fn clamp_signed_64(value: i64) -> i16 {
     value.clamp(-32768, 32767) as i16
 }
 
-pub fn s_clip(x: i64, bits: u32) -> i64 {
+fn s_clip(x: i64, bits: u32) -> i64 {
     let b = 1_u64 << (bits - 1);
     let m = b * 2 - 1;
     ((((x as u64) & m) ^ b).wrapping_sub(b)) as i64
 }
 
-pub fn vte(device: &device::Device, vt: u32, index: usize) -> __m128i {
+fn vte(device: &device::Device, vt: u32, index: usize) -> __m128i {
     unsafe {
         _mm_shuffle_epi8(
             device.rsp.cpu.vpr[vt as usize],
diff --git a/src/device/si.rs b/src/device/si.rs
index 11adf447..df1e6442 100644
--- a/src/device/si.rs
+++ b/src/device/si.rs
@@ -34,7 +34,7 @@ pub fn read_regs(
     device.si.regs[((address & 0xFFFF) >> 2) as usize]
 }
 
-pub fn dma_read(device: &mut device::Device) {
+fn dma_read(device: &mut device::Device) {
     device.si.dma_dir = DmaDir::Read;
 
     let duration = device::pif::update_pif_ram(device);
@@ -49,7 +49,7 @@ pub fn dma_read(device: &mut device::Device) {
     )
 }
 
-pub fn dma_write(device: &mut device::Device) {
+fn dma_write(device: &mut device::Device) {
     device.si.dma_dir = DmaDir::Write;
 
     copy_pif_rdram(device);
@@ -78,7 +78,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
 }
 
 //rdram is in native endian format, and pif memory is in big endian format
-pub fn copy_pif_rdram(device: &mut device::Device) {
+fn copy_pif_rdram(device: &mut device::Device) {
     let dram_addr = device.si.regs[SI_DRAM_ADDR_REG as usize] as usize & device::rdram::RDRAM_MASK;
     if device.si.dma_dir == DmaDir::Write {
         let mut i = 0;
diff --git a/src/device/sram.rs b/src/device/sram.rs
index e40e941d..9ece9087 100644
--- a/src/device/sram.rs
+++ b/src/device/sram.rs
@@ -27,19 +27,19 @@ pub struct Flashram {
     pub silicon_id: [u32; 2],
 }
 
-pub fn format_sram(device: &mut device::Device) {
+fn format_sram(device: &mut device::Device) {
     if device.ui.saves.sram.0.len() < SRAM_SIZE {
         device.ui.saves.sram.0.resize(SRAM_SIZE, 0xFF)
     }
 }
 
-pub fn format_flash(device: &mut device::Device) {
+fn format_flash(device: &mut device::Device) {
     if device.ui.saves.flash.0.len() < FLASHRAM_SIZE {
         device.ui.saves.flash.0.resize(FLASHRAM_SIZE, 0xFF)
     }
 }
 
-pub fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
+fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     let masked_address = address as usize & SRAM_MASK;
 
     format_sram(device);
@@ -51,7 +51,7 @@ pub fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     )
 }
 
-pub fn read_mem_flash(device: &device::Device, address: u64) -> u32 {
+fn read_mem_flash(device: &device::Device, address: u64) -> u32 {
     if (address & 0x1ffff) == 0x00000 && device.flashram.mode == FlashramMode::Status {
         /* read Status register */
         device.flashram.status
@@ -80,7 +80,7 @@ pub fn read_mem(
     }
 }
 
-pub fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     let masked_address = address as usize & SRAM_MASK;
 
     format_sram(device);
@@ -96,7 +96,7 @@ pub fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mas
     device.ui.saves.sram.1 = true
 }
 
-pub fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     if (address & 0x1ffff) == 0x00000 && device.flashram.mode == FlashramMode::Status {
         /* clear/set Status register */
         device.flashram.status = (value & mask) & 0xff;
@@ -128,12 +128,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
     );
 }
 
-pub fn dma_read_sram(
-    device: &mut device::Device,
-    mut cart_addr: u32,
-    mut dram_addr: u32,
-    length: u32,
-) {
+fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_addr: u32, length: u32) {
     dram_addr &= device::rdram::RDRAM_MASK as u32;
     cart_addr &= SRAM_MASK as u32;
     let mut i = dram_addr;
@@ -150,7 +145,7 @@ pub fn dma_read_sram(
     device.ui.saves.sram.1 = true
 }
 
-pub fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
+fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
     format_flash(device);
 
     if (cart_addr & 0x1ffff) == 0x00000
@@ -178,7 +173,7 @@ pub fn dma_read(device: &mut device::Device, cart_addr: u32, dram_addr: u32, len
     device::pi::calculate_cycles(device, 2, length)
 }
 
-pub fn dma_write_sram(
+fn dma_write_sram(
     device: &mut device::Device,
     mut cart_addr: u32,
     mut dram_addr: u32,
@@ -198,7 +193,7 @@ pub fn dma_write_sram(
     }
 }
 
-pub fn dma_write_flash(
+fn dma_write_flash(
     device: &mut device::Device,
     mut cart_addr: u32,
     mut dram_addr: u32,
@@ -251,7 +246,7 @@ pub fn dma_write(device: &mut device::Device, cart_addr: u32, dram_addr: u32, le
     device::pi::calculate_cycles(device, 2, length)
 }
 
-pub fn flashram_command(device: &mut device::Device, command: u32) {
+fn flashram_command(device: &mut device::Device, command: u32) {
     match command & 0xff000000 {
         0x3c000000 => {
             /* set chip erase mode */
diff --git a/src/device/tlb.rs b/src/device/tlb.rs
index d32bfbb9..e966684e 100644
--- a/src/device/tlb.rs
+++ b/src/device/tlb.rs
@@ -145,7 +145,7 @@ pub fn probe(device: &mut device::Device) {
     }
 }
 
-pub fn tlb_unmap(device: &mut device::Device, index: u64) {
+fn tlb_unmap(device: &mut device::Device, index: u64) {
     let e = &mut device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0 {
@@ -183,7 +183,7 @@ pub fn tlb_unmap(device: &mut device::Device, index: u64) {
     }
 }
 
-pub fn tlb_map(device: &mut device::Device, index: u64) {
+fn tlb_map(device: &mut device::Device, index: u64) {
     let e = &mut device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0
diff --git a/src/device/vi.rs b/src/device/vi.rs
index f29c1d7b..ccb7964f 100644
--- a/src/device/vi.rs
+++ b/src/device/vi.rs
@@ -32,7 +32,7 @@ pub struct Vi {
 
 const LIMIT_BUFFER: u64 = 3;
 
-pub fn set_expected_refresh_rate(device: &mut device::Device) {
+fn set_expected_refresh_rate(device: &mut device::Device) {
     let expected_refresh_rate = device.vi.clock as f64
         / (device.vi.regs[VI_V_SYNC_REG as usize] + 1) as f64
         / ((device.vi.regs[VI_H_SYNC_REG as usize] & 0xFFF) + 1) as f64
@@ -48,7 +48,7 @@ pub fn set_expected_refresh_rate(device: &mut device::Device) {
     device.vi.limiter = Some(governor::RateLimiter::direct(quota))
 }
 
-pub fn set_vertical_interrupt(device: &mut device::Device) {
+fn set_vertical_interrupt(device: &mut device::Device) {
     if device::events::get_event(device, device::events::EventType::VI).is_none() {
         device::events::create_event(
             device,
@@ -59,7 +59,7 @@ pub fn set_vertical_interrupt(device: &mut device::Device) {
     }
 }
 
-pub fn set_current_line(device: &mut device::Device) {
+fn set_current_line(device: &mut device::Device) {
     let delay = device.vi.delay;
     let next_vi = device::events::get_event(device, device::events::EventType::VI);
     if next_vi.is_some() {
@@ -115,7 +115,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     ui::video::set_register(reg as u32, device.vi.regs[reg as usize])
 }
 
-pub fn vertical_interrupt_event(device: &mut device::Device) {
+fn vertical_interrupt_event(device: &mut device::Device) {
     device.cpu.running = ui::video::update_screen();
 
     /*
@@ -162,7 +162,7 @@ pub fn init(device: &mut device::Device) {
     */
 }
 
-pub fn speed_limiter(device: &device::Device) {
+fn speed_limiter(device: &device::Device) {
     let result = device.vi.limiter.as_ref().unwrap().check();
     if result.is_err() {
         let outcome = result.unwrap_err();
diff --git a/src/main.rs b/src/main.rs
index feab3e59..3ab6f2cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,4 @@
+#![deny(warnings)]
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
diff --git a/src/ui/input.rs b/src/ui/input.rs
index 14f94502..a01064d6 100644
--- a/src/ui/input.rs
+++ b/src/ui/input.rs
@@ -34,7 +34,7 @@ pub struct Controllers {
     pub joystick: Option<sdl2::joystick::Joystick>,
 }
 
-pub fn bound_axis(x: &mut f64, y: &mut f64) {
+fn bound_axis(x: &mut f64, y: &mut f64) {
     let radius = 95.0; // this is roughly the maxium diagonal distance of the controller
 
     // Calculate the distance from the origin (0, 0)
@@ -48,7 +48,7 @@ pub fn bound_axis(x: &mut f64, y: &mut f64) {
     }
 }
 
-pub fn set_axis_from_joystick(
+fn set_axis_from_joystick(
     profile: &ui::config::InputProfile,
     joystick: &sdl2::joystick::Joystick,
 ) -> (f64, f64) {
@@ -114,7 +114,7 @@ fn get_button_from_i32(button: i32) -> sdl2::controller::Button {
     }
 }
 
-pub fn set_axis_from_controller(
+fn set_axis_from_controller(
     profile: &ui::config::InputProfile,
     controller: &sdl2::controller::GameController,
 ) -> (f64, f64) {
@@ -150,7 +150,7 @@ pub fn set_axis_from_controller(
     (x, y)
 }
 
-pub fn set_axis_from_keys(
+fn set_axis_from_keys(
     profile: &ui::config::InputProfile,
     keyboard_state: &sdl2::keyboard::KeyboardState,
 ) -> (f64, f64) {
@@ -187,7 +187,7 @@ pub fn set_axis_from_keys(
     (x, y)
 }
 
-pub fn set_buttons_from_joystick(
+fn set_buttons_from_joystick(
     profile: &ui::config::InputProfile,
     i: usize,
     joystick: &sdl2::joystick::Joystick,
@@ -217,7 +217,7 @@ pub fn set_buttons_from_joystick(
     }
 }
 
-pub fn set_buttons_from_controller(
+fn set_buttons_from_controller(
     profile: &ui::config::InputProfile,
     i: usize,
     controller: &sdl2::controller::GameController,
@@ -268,7 +268,7 @@ pub fn set_rumble(ui: &mut ui::Ui, channel: usize, rumble: u8) {
     }
 }
 
-pub fn change_paks(
+fn change_paks(
     profile: &ui::config::InputProfile,
     joystick: &Option<sdl2::joystick::Joystick>,
     controller: &Option<sdl2::controller::GameController>,
diff --git a/src/ui/storage.rs b/src/ui/storage.rs
index fadb2ca6..afcb7a71 100644
--- a/src/ui/storage.rs
+++ b/src/ui/storage.rs
@@ -28,7 +28,7 @@ pub struct Saves {
     pub romsave: (serde_json::Map<String, serde_json::Value>, bool),
 }
 
-pub fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
+fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
     match game_id {
         "NB7" | // Banjo-Tooie [Banjo to Kazooie no Daiboken 2 (J)]
         "NGT" | // City Tour GrandPrix - Zen Nihon GT Senshuken
@@ -141,7 +141,7 @@ pub fn load_saves(ui: &mut ui::Ui) {
     }
 }
 
-pub fn write_rom_save(ui: &ui::Ui) {
+fn write_rom_save(ui: &ui::Ui) {
     let f = std::fs::File::create(ui.paths.romsave_file_path.clone()).unwrap();
     serde_json::to_writer(f, &ui.saves.romsave.0).unwrap();
 }
@@ -164,7 +164,7 @@ pub fn write_saves(ui: &ui::Ui) {
     }
 }
 
-pub fn write_save(ui: &ui::Ui, save_type: SaveTypes) {
+fn write_save(ui: &ui::Ui, save_type: SaveTypes) {
     let path: &std::path::Path;
     let data: &Vec<u8>;
     match save_type {