365 lines
10 KiB
OCaml
365 lines
10 KiB
OCaml
|
(**
|
||
|
* Copyright (c) 2015, Fabien Freling
|
||
|
* All rights reserved.
|
||
|
*
|
||
|
* This source code is licensed under the BSD 2-clause license found in the
|
||
|
* LICENSE file at the top level directory of this source tree.
|
||
|
*)
|
||
|
|
||
|
open Printf
|
||
|
|
||
|
let frequence = 4194304
|
||
|
|
||
|
(** http://bgb.bircd.org/pandocs.htm#cpuregistersandflags
|
||
|
http://gameboy.mongenel.com/dmg/lesson1.html *)
|
||
|
|
||
|
type registers = {
|
||
|
mutable a : char; (* accumulator *)
|
||
|
mutable f : char; (* flags *)
|
||
|
mutable b : char;
|
||
|
mutable c : char;
|
||
|
mutable d : char;
|
||
|
mutable e : char;
|
||
|
mutable h : char;
|
||
|
mutable l : char;
|
||
|
|
||
|
mutable sp : int; (* stack pointer *)
|
||
|
mutable pc : int; (* program counter *)
|
||
|
}
|
||
|
|
||
|
type flags = {
|
||
|
mutable z : bool; (* zero *)
|
||
|
mutable n : bool; (* substraction *)
|
||
|
mutable h : bool; (* half-carry *)
|
||
|
mutable c : bool; (* carry *)
|
||
|
}
|
||
|
|
||
|
type t = {
|
||
|
reg : registers;
|
||
|
flag : flags;
|
||
|
mutable cycles : int;
|
||
|
}
|
||
|
|
||
|
let print_cpu_state cpu =
|
||
|
printf "[Cpu state] Registers:\n";
|
||
|
printf "[Cpu state] \tA: 0x%02X \tF: 0x%02X\n" (int_of_char cpu.reg.a) (int_of_char cpu.reg.f);
|
||
|
printf "[Cpu state] \tB: 0x%02X \tC: 0x%02X\n" (int_of_char cpu.reg.b) (int_of_char cpu.reg.c);
|
||
|
printf "[Cpu state] \tD: 0x%02X \tE: 0x%02X\n" (int_of_char cpu.reg.d) (int_of_char cpu.reg.e);
|
||
|
printf "[Cpu state] \tH: 0x%02X \tL: 0x%02X\n" (int_of_char cpu.reg.h) (int_of_char cpu.reg.l);
|
||
|
printf "[Cpu state] \tPC: 0x%04X\n" cpu.reg.pc;
|
||
|
printf "[Cpu state] \tSP: 0x%04X\n" cpu.reg.sp;
|
||
|
|
||
|
printf "[Cpu state] Flags:\n";
|
||
|
printf "[Cpu state] \t ZNHC\n";
|
||
|
let z = if cpu.flag.z then 1 else 0 in
|
||
|
let n = if cpu.flag.n then 1 else 0 in
|
||
|
let h = if cpu.flag.h then 1 else 0 in
|
||
|
let c = if cpu.flag.c then 1 else 0 in
|
||
|
printf "[Cpu state] \t[%d%d%d%d]\n" z n h c
|
||
|
|
||
|
(** http://bgb.bircd.org/pandocs.htm#powerupsequence *)
|
||
|
let init_registers =
|
||
|
{
|
||
|
a = '\x00';
|
||
|
f = '\x00';
|
||
|
b = '\x00';
|
||
|
c = '\x00';
|
||
|
d = '\x00';
|
||
|
e = '\x00';
|
||
|
h = '\x00';
|
||
|
l = '\x00';
|
||
|
sp = 0xFFFE;
|
||
|
pc = 0x0100;
|
||
|
}
|
||
|
|
||
|
let init_flags =
|
||
|
{
|
||
|
z = false; n = false; h = false; c = false
|
||
|
}
|
||
|
|
||
|
let init_cpu =
|
||
|
{ reg = init_registers; flag = init_flags; cycles = 0 }
|
||
|
|
||
|
let update_flag_reg cpu =
|
||
|
let z = if cpu.flag.z then 0b10000000 else 0 in
|
||
|
let n = if cpu.flag.n then 0b01000000 else 0 in
|
||
|
let h = if cpu.flag.h then 0b00100000 else 0 in
|
||
|
let c = if cpu.flag.c then 0b00010000 else 0 in
|
||
|
cpu.reg.f <- char_of_int @@ z + n + h + c
|
||
|
|
||
|
let inc_pc cpu count =
|
||
|
cpu.reg.pc <- (cpu.reg.pc + count) mod 0xFFFF
|
||
|
|
||
|
let inc_cycles cpu count =
|
||
|
cpu.cycles <- cpu.cycles + count
|
||
|
|
||
|
let merge_bytes low high =
|
||
|
(int_of_char high) * 256 + (int_of_char low)
|
||
|
|
||
|
let split_2B x =
|
||
|
let low = x mod 256 |> char_of_int in
|
||
|
let high = x / 256 |> char_of_int in
|
||
|
(high, low)
|
||
|
|
||
|
let read_2B m addr =
|
||
|
let low = Memory.get m addr in
|
||
|
let high = Memory.get m (addr + 1) in
|
||
|
merge_bytes low high
|
||
|
|
||
|
let inc_BC cpu =
|
||
|
let v = merge_bytes cpu.reg.c cpu.reg.b in
|
||
|
let low, high = split_2B (v + 1) in
|
||
|
cpu.reg.c <- low;
|
||
|
cpu.reg.b <- high
|
||
|
|
||
|
let cmp_A cpu n =
|
||
|
let diff = int_of_char (cpu.reg.a) - n in
|
||
|
cpu.flag.z <- diff = 0;
|
||
|
cpu.flag.n <- true;
|
||
|
cpu.flag.h <- diff > 0x0F || diff < 0;
|
||
|
cpu.flag.c <- diff > 0xFF || diff < 0;
|
||
|
update_flag_reg cpu
|
||
|
|
||
|
let read_pc_byte cpu mem =
|
||
|
let b = Memory.get mem cpu.reg.pc in
|
||
|
inc_pc cpu 1;
|
||
|
int_of_char b
|
||
|
|
||
|
let read_pc_2bytes cpu mem =
|
||
|
let word = read_2B mem cpu.reg.pc in
|
||
|
inc_pc cpu 2;
|
||
|
word
|
||
|
|
||
|
(*************************************************
|
||
|
*
|
||
|
* Stack manipulation
|
||
|
*
|
||
|
************************************************)
|
||
|
let pop_stack cpu mem =
|
||
|
let low = Memory.get mem cpu.reg.sp in
|
||
|
cpu.reg.sp <- (cpu.reg.sp + 1) mod 0xFFFF;
|
||
|
let high = Memory.get mem cpu.reg.sp in
|
||
|
cpu.reg.sp <- (cpu.reg.sp + 1) mod 0xFFFF;
|
||
|
merge_bytes low high
|
||
|
|
||
|
let push_pc_stack cpu mem =
|
||
|
let (high, low) = split_2B cpu.reg.pc in
|
||
|
cpu.reg.sp <- pred cpu.reg.sp;
|
||
|
Memory.set mem cpu.reg.sp high;
|
||
|
cpu.reg.sp <- pred cpu.reg.sp;
|
||
|
Memory.set mem cpu.reg.sp low
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
(*************************************************
|
||
|
*
|
||
|
* CPU instructions
|
||
|
*
|
||
|
************************************************)
|
||
|
(** http://imrannazar.com/GameBoy-Z80-Opcode-Map
|
||
|
https://github.com/sinamas/gambatte/blob/master/libgambatte/src/cpu.cpp *)
|
||
|
let run cpu (mem: Memory.map) =
|
||
|
print_cpu_state cpu;
|
||
|
let opcode = read_pc_byte cpu mem |> char_of_int in
|
||
|
(* Hexa.print_slice cartridge.full_rom cpu.reg.pc (cpu.reg.pc + 7); *)
|
||
|
|
||
|
let inst, cycles = match opcode with
|
||
|
|
||
|
(* 8-bit load *)
|
||
|
(* LD r,(HL) *)
|
||
|
| '\x7E' -> let inst = sprintf "LD \tA, (HL)" in
|
||
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
||
|
cpu.reg.a <- Memory.get mem hl;
|
||
|
inst, 8
|
||
|
|
||
|
| '\x36' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "LD \t(HL) 0x%02X" n in
|
||
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
||
|
Memory.set mem hl (char_of_int n);
|
||
|
inst, 12
|
||
|
|
||
|
|
||
|
(* CPU control *)
|
||
|
| '\x00' -> let inst = sprintf "NOP" in
|
||
|
inst, 4
|
||
|
|
||
|
|
||
|
(* jump *)
|
||
|
| '\x20' -> let n = read_pc_byte cpu mem in
|
||
|
let s = Bit.signed_byte n in
|
||
|
let inst = sprintf "JR \tNZ, 0x%02X (%d)" n s in
|
||
|
if cpu.flag.z = false then begin
|
||
|
inc_pc cpu (s - 2); (* we read 2 bytes from PC, opcode and n *)
|
||
|
inst, 12
|
||
|
end else
|
||
|
inst, 8
|
||
|
|
||
|
| '\xC9' -> let inst = sprintf "RET" in
|
||
|
cpu.reg.pc <- pop_stack cpu mem;
|
||
|
inst, 16
|
||
|
|
||
|
| '\xC0' -> let inst = sprintf "RET \tNZ" in
|
||
|
if cpu.flag.z = false then begin
|
||
|
cpu.reg.pc <- pop_stack cpu mem;
|
||
|
inst, 20
|
||
|
end else
|
||
|
inst, 8
|
||
|
|
||
|
|
||
|
|
||
|
| '\x03' -> let inst = sprintf "INC \tBC" in
|
||
|
inc_BC cpu;
|
||
|
inst, 8
|
||
|
|
||
|
| '\x05' -> let inst = sprintf "DEC \tB" in
|
||
|
let dec = int_of_char(cpu.reg.b) - 1 in
|
||
|
cpu.flag.z <- dec = 0;
|
||
|
cpu.flag.n <- true;
|
||
|
cpu.flag.h <- dec < 0;
|
||
|
cpu.reg.b <- char_of_int @@ if dec >= 0 then dec else 0;
|
||
|
inst, 4
|
||
|
|
||
|
| '\x06' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "LD \tB, 0x%02X" n in
|
||
|
cpu.reg.b <- char_of_int n;
|
||
|
inst, 8
|
||
|
|
||
|
| '\x18' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "JP \t0x%02X" n in
|
||
|
inc_pc cpu (n - 1);
|
||
|
inst, 12
|
||
|
|
||
|
| '\x21' -> let nn = read_pc_2bytes cpu mem in
|
||
|
let inst = sprintf "LD \tHL, 0x%04X" nn in
|
||
|
let high, low = split_2B nn in
|
||
|
cpu.reg.h <- high;
|
||
|
cpu.reg.l <- low;
|
||
|
inst, 12
|
||
|
|
||
|
| '\x22' -> let inst = sprintf "LDI \t(HL), A" in
|
||
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
||
|
Memory.set mem hl cpu.reg.a;
|
||
|
let high, low = split_2B (hl + 1) in
|
||
|
cpu.reg.h <- high;
|
||
|
cpu.reg.l <- low;
|
||
|
inst, 8
|
||
|
|
||
|
|
||
|
| '\x28' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "JR \tZ, 0x%02X" n in
|
||
|
if cpu.flag.z = true then begin
|
||
|
inc_pc cpu (n - 1);
|
||
|
inst, 12
|
||
|
end else
|
||
|
inst, 8
|
||
|
|
||
|
| '\x34' -> let inst = sprintf "INC \t(HL)" in
|
||
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
||
|
let v = Memory.get mem hl |> int_of_char in
|
||
|
cpu.flag.z <- v + 1 = 0;
|
||
|
cpu.flag.n <- false;
|
||
|
cpu.flag.h <- v = 0b00001111;
|
||
|
Memory.set mem hl (char_of_int (v + 1));
|
||
|
inst, 12
|
||
|
|
||
|
|
||
|
| '\x3E' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "LD \tA, 0x%02X" n in
|
||
|
cpu.reg.a <- char_of_int n;
|
||
|
inst, 8
|
||
|
|
||
|
| '\xAF' -> let inst = sprintf "XOR \tA, A" in
|
||
|
let int_A = int_of_char cpu.reg.a in
|
||
|
cpu.reg.a <- char_of_int @@ int_A lxor int_A;
|
||
|
inst, 4
|
||
|
|
||
|
| '\xC3' -> let addr = read_pc_2bytes cpu mem in
|
||
|
let inst = sprintf "JP \t0x%04X" addr in
|
||
|
cpu.reg.pc <- addr;
|
||
|
inst, 16
|
||
|
|
||
|
| '\xE0' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "LDH \t(0xFF%02X), A" n in
|
||
|
Memory.set mem (0xFF00 + n) cpu.reg.a;
|
||
|
inst, 12
|
||
|
|
||
|
| '\xEA' -> let addr = read_pc_2bytes cpu mem in
|
||
|
let inst = sprintf "LD \t(0X%04X), A" addr in
|
||
|
Memory.set mem addr cpu.reg.a;
|
||
|
inst, 16
|
||
|
|
||
|
|
||
|
| '\xF0' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "LDH \tA, (0xFF%02X)" n in
|
||
|
cpu.reg.a <- Memory.get mem (0xFF00 + n);
|
||
|
inst, 12
|
||
|
|
||
|
| '\xF3' -> let inst = sprintf "DI" in
|
||
|
(* fixme *)
|
||
|
inst, 4
|
||
|
|
||
|
| '\xFE' -> let n = read_pc_byte cpu mem in
|
||
|
let inst = sprintf "CP \t0x%02X" n in
|
||
|
cmp_A cpu n;
|
||
|
inst, 8
|
||
|
|
||
|
| '\xFB' -> let inst = sprintf "EI" in
|
||
|
(* enable interrupts *)
|
||
|
Interrupt.gIME := true;
|
||
|
inst, 4
|
||
|
|
||
|
| x -> eprintf "opcode 0x%02X\n" (int_of_char x);
|
||
|
eprintf "#cycles: %d\n" cpu.cycles;
|
||
|
failwith "Unimplemented opcode."
|
||
|
|
||
|
in
|
||
|
inc_cycles cpu cycles;
|
||
|
inst, cycles
|
||
|
|
||
|
|
||
|
(*************************************************
|
||
|
*
|
||
|
* Interrupt handlers
|
||
|
*
|
||
|
************************************************)
|
||
|
let handle_interrupt cpu mmap flag =
|
||
|
let int_vector = match flag with
|
||
|
| Interrupt.V_Blank -> 0x40
|
||
|
| Interrupt.LCD_Stat -> 0x48
|
||
|
| Interrupt.Timer -> 0x50
|
||
|
| Interrupt.Serial -> 0x58
|
||
|
| Interrupt.Joypad -> 0x60 in
|
||
|
|
||
|
Interrupt.reset_IF_flag flag mmap;
|
||
|
Interrupt.gIME := false;
|
||
|
|
||
|
push_pc_stack cpu mmap;
|
||
|
cpu.reg.pc <- int_vector;
|
||
|
|
||
|
(* run cpu until RETI is called *)
|
||
|
let last_inst = ref "" in
|
||
|
while !last_inst <> "RETI" do
|
||
|
let inst, cycles = run cpu mmap in
|
||
|
last_inst := inst
|
||
|
done;
|
||
|
|
||
|
Interrupt.gIME := true
|
||
|
|
||
|
|
||
|
|
||
|
let handle_interrupts cpu mmap =
|
||
|
if not !Interrupt.gIME then
|
||
|
() (* Interrupt Master Enable flag set to false, nothing to do *)
|
||
|
else begin
|
||
|
(* N.B.: flags are precomputed once but an interrupt could be requested
|
||
|
during that time *)
|
||
|
let ie = Interrupt.get_IE mmap in
|
||
|
let if_ = Interrupt.get_IF mmap in
|
||
|
let interrupts = ie land if_ in
|
||
|
let flags = Interrupt.get_flags interrupts in
|
||
|
match flags with
|
||
|
| [] -> () (* No interrupt *)
|
||
|
| _ -> List.iter (fun x -> handle_interrupt cpu mmap x) flags
|
||
|
end
|