use self::mmio::{Apu, Gpu, Joypad, Serial}; pub use self::rom::Rom; use crate::{processor::SplitRegister, util::set_bit, verbose_println, Cpu}; use gilrs::Gilrs; use minifb::{Key, Window}; pub mod mmio; pub(crate) mod rom; pub(crate) type Address = u16; #[allow(dead_code)] pub struct Memory { bootrom: Option>, rom: Rom, ram: [u8; 8192], switchable_ram: [u8; 8192], cpu_ram: [u8; 128], interrupts: u8, pub(super) ime: bool, pub(super) ime_scheduled: u8, io: [u8; 76], pub(super) user_mode: bool, joypad: Joypad, gpu: Gpu, apu: Apu, serial: Serial, } impl Memory { pub fn init( bootrom: Option>, rom: Rom, window: Window, connect_serial: bool, enable_tile_window: bool, ) -> Self { let serial = if connect_serial { Serial::default().connected() } else { Serial::default() }; Self { bootrom, rom, ram: [0x0; 8192], switchable_ram: [0x0; 8192], cpu_ram: [0x0; 128], interrupts: 0x0, ime: false, ime_scheduled: 0x0, io: [0xFF; 76], user_mode: false, joypad: Joypad::default(), gpu: Gpu::new(window, enable_tile_window), apu: Apu::init_default(), serial, } } pub fn get(&self, address: Address) -> u8 { match address { 0x0..0x8000 => { // rom access // todo - switchable rom banks if let Some(bootrom) = &self.bootrom && (address as usize) < bootrom.len() { bootrom[address as usize] } else { self.rom.get(address) } } 0x8000..0xA000 => self.gpu.vram.get(address), 0xA000..0xC000 => { // cart ram self.rom.get_ram(address) } 0xC000..0xE000 => self.ram[(address - 0xC000) as usize], 0xE000..0xFE00 => self.ram[(address - 0xE000) as usize], 0xFE00..0xFEA0 => self.gpu.oam.get(address), 0xFEA0..0xFF00 => 0xFF, 0xFF00..0xFF4C => self.get_io(address), 0xFF4C..0xFF80 => 0xFF, 0xFF80..0xFFFF => self.cpu_ram[(address - 0xFF80) as usize], 0xFFFF => self.interrupts, } } pub fn set(&mut self, address: Address, data: u8) { match address { 0x0..0x8000 => { // change this with MBC code... self.rom.set(address, data); } 0x8000..0xA000 => self.gpu.vram.set(address, data), 0xA000..0xC000 => self.rom.set_ram(address, data), 0xC000..0xE000 => self.ram[(address - 0xC000) as usize] = data, 0xE000..0xFE00 => self.ram[(address - 0xE000) as usize] = data, 0xFE00..0xFEA0 => self.gpu.oam.set(address, data), 0xFEA0..0xFF00 => {} 0xFF00..0xFF4C => self.set_io(address, data), 0xFF50 => self.bootrom = None, 0xFF4C..0xFF50 | 0xFF51..0xFF80 => {} 0xFF80..0xFFFF => self.cpu_ram[(address - 0xFF80) as usize] = data, 0xFFFF => { verbose_println!("interrupts set to {:#b}", data); verbose_println!(" / {:#X}", data); self.interrupts = data; } } } fn get_io(&self, address: Address) -> u8 { // range: 0xFF00 - 0xFF4B inclusive match address { 0xFF00 => self.joypad.as_register(), 0xFF01 => self.serial.get_queued(), 0xFF02 => self.serial.get_control(), 0xFF10..0xFF40 => self.apu.get_register(address), 0xFF40 => self.gpu.get_lcdc(), 0xFF41 => self.gpu.get_lcd_status(), 0xFF42 => self.gpu.get_scy(), 0xFF43 => self.gpu.get_scx(), 0xFF44 => self.gpu.get_ly(), 0xFF45 => self.gpu.get_lyc(), 0xFF47 => self.gpu.get_bg_palette(), 0xFF48 => self.gpu.get_obj_palette_0(), 0xFF49 => self.gpu.get_obj_palette_1(), 0xFF4A => self.gpu.get_wy(), 0xFF4B => self.gpu.get_wx(), _ => self.io[(address - 0xFF00) as usize], } } fn set_io(&mut self, address: Address, data: u8) { // range: 0xFF00 - 0xFF4B inclusive let addr_l = (address - 0xFF00) as usize; if !self.user_mode { self.io[addr_l] = data; } else { match address { 0xFF00 => { // joypad self.joypad.mmio_write(data); } 0xFF01 => self.serial.update_queued(data), 0xFF02 => self.serial.update_control(data), 0xFF04 => self.io[addr_l] = 0, 0xFF07 => self.masked_io(addr_l, data, 0b111), 0xFF0F => self.masked_io(addr_l, data, 0b11111), 0xFF10..0xFF40 => self.apu.mmio_write(address, data), 0xFF40 => self.gpu.update_lcdc(data), 0xFF41 => self.gpu.update_lcd_status(data), 0xFF42 => self.gpu.update_scy(data), 0xFF43 => self.gpu.update_scx(data), 0xFF45 => self.gpu.update_lyc(data), 0xFF46 => { if data > 0xDF { panic!("dma transfer out of bounds: {data:#X}"); } self.io[addr_l] = data; let mut addr: u16 = 0x0; addr.set_high(data); for l in 0x0..0xA0 { addr.set_low(l); self.gpu.oam.data[l as usize] = self.get(addr); } } 0xFF47 => self.gpu.update_bg_palette(data), 0xFF48 => self.gpu.update_obj_palette_0(data), 0xFF49 => self.gpu.update_obj_palette_1(data), 0xFF4A => self.gpu.update_wy(data), 0xFF4B => self.gpu.update_wx(data), 0xFF03 | 0xFF08..0xFF0F | 0xFF44 => { // read-only addresses println!("BANNED write: {data:#X} to {address:#X}"); } 0x0..0xFF00 | 0xFF4C..=u16::MAX => panic!("passed wrong address to set_io"), _ => self.io[addr_l] = data, } } } fn masked_io(&mut self, addr_l: usize, data: u8, mask: u8) { self.io[addr_l] = masked_update(self.io[addr_l], data, mask); } pub fn update_pressed_keys(&mut self, keys: Vec, gamepads: &mut Gilrs) -> bool { self.joypad.update_pressed_keys(keys, gamepads) } pub fn div_apu_tick(&mut self) { self.apu.div_apu_tick(); } pub(super) fn cpu_ram_init(&mut self) { self.set(0xFF04, 0xAD); self.set(0xFF10, 0x80); self.set(0xFF11, 0xBF); self.set(0xFF12, 0xF3); self.set(0xFF14, 0xBF); self.set(0xFF16, 0x3F); self.set(0xFF19, 0xBF); self.set(0xFF1A, 0x7F); self.set(0xFF1B, 0xFF); self.set(0xFF1C, 0x9F); self.set(0xFF1E, 0xBF); self.set(0xFF20, 0xFF); self.set(0xFF23, 0xBF); self.set(0xFF24, 0x77); self.set(0xFF25, 0xF3); self.set(0xFF26, 0xF1); self.set(0xFF40, 0x91); self.set(0xFF47, 0xFC); self.set(0xFF48, 0xFF); self.set(0xFF49, 0xFF); for i in 0xC000..0xE000 { self.set(i, if rand::random() { 0xFF } else { 0x00 }); } } } impl Cpu { pub fn advance_mmio_clocks(&mut self, steps: usize) { self.memory.apu.tick(steps); if self.memory.serial.tick(steps) { self.memory.set(0xFF0F, set_bit(self.memory.get(0xFF0F), 3)); } let gpu_interrupts = self.memory.gpu.tick(steps); if gpu_interrupts.vblank { self.memory.set(0xFF0F, set_bit(self.memory.get(0xFF0F), 0)); if self .memory .update_pressed_keys(self.memory.gpu.window.get_keys(), &mut self.gamepad_handler) { self.memory.set(0xFF0F, set_bit(self.memory.get(0xFF0F), 4)); } } if gpu_interrupts.lcd_stat { self.memory.set(0xFF0F, set_bit(self.memory.get(0xFF0F), 1)); } } } pub fn masked_update(current: u8, data: u8, mask: u8) -> u8 { (current & (!mask)) | (data & mask) }