oboy/src/cpu.ml

(**
 * 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

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


(**
  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 begin
                inst, 8
              end

  | '\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 begin
                inst, 8
              end



  | '\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 begin
                inst, 8
              end

  | '\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, IME=1 *)
              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