core/GBZ80Core.v

   1 `define REG_A   0
   2 `define REG_B   1
   3 `define REG_C   2
   4 `define REG_D   3
   5 `define REG_E   4
   6 `define REG_F   5
   7 `define REG_H   6
   8 `define REG_L   7
   9 `define REG_SPH 8
  10 `define REG_SPL 9
  11 `define REG_PCH 10
  12 `define REG_PCL 11
  13
  14 `define _A      registers[`REG_A]
  15 `define _B      registers[`REG_B]
  16 `define _C      registers[`REG_C]
  17 `define _D      registers[`REG_D]
  18 `define _E      registers[`REG_E]
  19 `define _F      registers[`REG_F]
  20 `define _H      registers[`REG_H]
  21 `define _L      registers[`REG_L]
  22 `define _SPH    registers[`REG_SPH]
  23 `define _SPL    registers[`REG_SPL]
  24 `define _PCH    registers[`REG_PCH]
  25 `define _PCL    registers[`REG_PCL]
  26 `define _AF     {`_A, `_F}
  27 `define _BC     {`_B, `_C}
  28 `define _DE     {`_D, `_E}
  29 `define _HL     {`_H, `_L}
  30 `define _SP     {`_SPH, `_SPL}
  31 `define _PC     {`_PCH, `_PCL}
  32
  33 `define FLAG_Z  8'b10000000
  34 `define FLAG_N  8'b01000000
  35 `define FLAG_H  8'b00100000
  36 `define FLAG_C  8'b00010000
  37
  38 `define STATE_FETCH             2'h0
  39 `define STATE_DECODE            2'h1
  40 `define STATE_EXECUTE           2'h2
  41 `define STATE_WRITEBACK         2'h3
  42
  43 `define INSN_VOP_INTR           9'b011111100    // 0xFC is grabbed by the fetch if there is an interrupt pending.
  44 `define INSN_RES                9'b110xxxxxx
  45 `define INSN_SET                9'b111xxxxxx
  46
  47 `define INSN_cc_NZ              2'b00
  48 `define INSN_cc_Z               2'b01
  49 `define INSN_cc_NC              2'b10
  50 `define INSN_cc_C               2'b11
  51
  52 `define INSN_reg_A              3'b111
  53 `define INSN_reg_B              3'b000
  54 `define INSN_reg_C              3'b001
  55 `define INSN_reg_D              3'b010
  56 `define INSN_reg_E              3'b011
  57 `define INSN_reg_H              3'b100
  58 `define INSN_reg_L              3'b101
  59 `define INSN_reg_dHL            3'b110
  60 `define INSN_reg16_BC           2'b00
  61 `define INSN_reg16_DE           2'b01
  62 `define INSN_reg16_HL           2'b10
  63 `define INSN_reg16_SP           2'b11
  64 `define INSN_stack_AF           2'b11
  65 `define INSN_stack_BC           2'b00
  66 `define INSN_stack_DE           2'b01
  67 `define INSN_stack_HL           2'b10
  68 `define INSN_alu_ADD            3'b000
  69 `define INSN_alu_ADC            3'b001
  70 `define INSN_alu_SUB            3'b010
  71 `define INSN_alu_SBC            3'b011
  72 `define INSN_alu_AND            3'b100
  73 `define INSN_alu_XOR            3'b101
  74 `define INSN_alu_OR             3'b110
  75 `define INSN_alu_CP             3'b111          // Oh lawd, is dat some CP?
  76 `define INSN_alu_RLC            3'b000
  77 `define INSN_alu_RRC            3'b001
  78 `define INSN_alu_RL             3'b010
  79 `define INSN_alu_RR             3'b011
  80 `define INSN_alu_DA_SLA         3'b100
  81 `define INSN_alu_CPL_SRA        3'b101
  82 `define INSN_alu_SCF_SWAP       3'b110
  83 `define INSN_alu_CCF_SRL        3'b111
  84
  85 `define EXEC_INC_PC             `_PC <= `_PC + 1;
  86 `define EXEC_NEXTADDR_PCINC     address <= `_PC + 1;
  87 `define EXEC_NEWCYCLE           begin newcycle <= 1; rd <= 1; wr <= 0; end
  88 `define EXEC_NEWCYCLE_TWOBYTE   begin newcycle <= 1; rd <= 1; wr <= 0; twobyte <= 1; end
  89 `ifdef isim
  90         `define EXEC_WRITE(ad, da)      begin address <= (ad); wdata <= (da); wr <= 1; end
  91         `define EXEC_READ(ad)           begin address <= (ad); rd <= 1; end
  92 `else
  93         /* Work around XST's retarded bugs :\ */
  94         `define EXEC_WRITE(ad, da)      begin address <= (ad); wdata <= (da); wr <= 1; end end
  95         `define EXEC_READ(ad)           begin address <= (ad); rd <= 1; end end
  96 `endif
  97
  98 module GBZ80Core(
  99         input clk,
 100         inout [15:0] bus0address,       /* BUS_* is latched on STATE_FETCH. */
 101         inout [7:0] bus0data,
 102         inout bus0wr, bus0rd,
 103         inout [15:0] bus1address,       /* BUS_* is latched on STATE_FETCH. */
 104         inout [7:0] bus1data,
 105         inout bus1wr, bus1rd,
 106         input irq, output reg irqack, input [7:0] jaddr,
 107         output reg [1:0] state);
 108
 109 //      reg [1:0] state;                                        /* State within this bus cycle (see STATE_*). */
 110         reg [2:0] cycle;                                        /* Cycle for instructions. */
 111
 112         reg [7:0] registers[11:0];
 113
 114         reg [15:0] address;                             /* Address for the next bus operation. */
 115
 116         reg [8:0] opcode;                               /* Opcode from the current machine cycle. */
 117
 118         reg [7:0] rdata, wdata;         /* Read data from this bus cycle, or write data for the next. */
 119         reg rd, wr, newcycle, twobyte;
 120
 121         reg [7:0] tmp, tmp2;                    /* Generic temporary regs. */
 122
 123         reg [7:0] buswdata;
 124         wire [7:0] busdata;
 125
 126         reg [15:0] busaddress;
 127         reg buswr, busrd;
 128
 129         reg bootstrap_enb;
 130
 131         wire bus = ((busaddress[15:8] == 8'h00) && bootstrap_enb) || ((busaddress[15:7] == 9'b111111111) && (busaddress != 16'hFFFF))   /* 0 or 1 depending on which bus */
 132                 `ifdef isim
 133                         || (busaddress === 16'hxxxx) /* To avoid simulator glomulation. */
 134                 `endif
 135                         ;
 136
 137         assign bus0address = (bus == 0) ? busaddress : 16'bzzzzzzzzzzzzzzz;
 138         assign bus1address = (bus == 1) ? busaddress : 16'bzzzzzzzzzzzzzzz;
 139         assign bus0data = ((bus == 0) && buswr) ? buswdata : 8'bzzzzzzzz;
 140         assign bus1data = ((bus == 1) && buswr) ? buswdata : 8'bzzzzzzzz;
 141         assign busdata = (bus == 0) ? bus0data : bus1data;
 142         assign bus0rd = (bus == 0) ? busrd : 1'b0;
 143         assign bus1rd = (bus == 1) ? busrd : 1'b0;
 144         assign bus0wr = (bus == 0) ? buswr : 1'b0;
 145         assign bus1wr = (bus == 1) ? buswr : 1'b0;
 146
 147         reg ie, iedelay;
 148
 149 `define LOCALWIRES
 150 `include "allinsns.v"
 151 `undef LOCALWIRES
 152
 153         initial begin
 154                 `_A <= 0;
 155                 `_B <= 0;
 156                 `_C <= 0;
 157                 `_D <= 0;
 158                 `_E <= 0;
 159                 `_F <= 0;
 160                 `_H <= 0;
 161                 `_L <= 0;
 162                 `_PCH <= 0;
 163                 `_PCL <= 0;
 164                 `_SPH <= 0;
 165                 `_SPL <= 0;
 166                 rd <= 1;
 167                 wr <= 0;
 168                 newcycle <= 1;
 169                 state <= 0;
 170                 cycle <= 0;
 171                 busrd <= 0;
 172                 buswr <= 0;
 173                 busaddress <= 0;
 174                 ie <= 0;
 175                 iedelay <= 0;
 176                 opcode <= 0;
 177                 state <= `STATE_WRITEBACK;
 178                 cycle <= 0;
 179                 twobyte <= 0;
 180                 bootstrap_enb <= 1;
 181                 irqack <= 0;
 182         end
 183
 184         always @(negedge clk)   /* Set things up at the negedge to prepare for the posedge. */
 185                 case (state)
 186                 `STATE_FETCH: begin
 187                         if (newcycle) begin
 188                                 busaddress <= `_PC;
 189                                 buswr <= 0;
 190                                 busrd <= 1;
 191                         end else begin
 192                                 busaddress <= address;
 193                                 buswr <= wr;
 194                                 busrd <= rd;
 195                                 if (wr) begin
 196                                         buswdata <= wdata;
 197                                         if (address == 16'hFF50)
 198                                                 bootstrap_enb <= 0;
 199                                 end
 200                         end
 201                 end
 202                 `STATE_DECODE: begin    /* Make sure this only happens for one clock. */
 203                         buswr <= 0;
 204                         busrd <= 0;
 205                 end
 206                 endcase
 207
 208         always @(posedge clk)
 209                 case (state)
 210                 `STATE_FETCH: begin
 211                         /* Things are set up in negedge so that something looking on posedge will get his shit. */
 212                         state <= `STATE_DECODE;
 213                 end
 214                 `STATE_DECODE: begin
 215                         if (newcycle) begin
 216                                 if (twobyte) begin
 217                                         opcode <= {1'b1,busdata};
 218                                         twobyte <= 0;
 219                                 end else if (ie && irq)
 220                                         opcode <= `INSN_VOP_INTR;
 221                                 else
 222                                         opcode <= {1'b0,busdata};
 223                                 newcycle <= 0;
 224                                 rdata <= busdata;
 225                                 cycle <= 0;
 226                         end else begin
 227                                 if (rd) rdata <= busdata;       /* Still valid because peripherals are now expected to keep it held valid. */
 228                                 cycle <= cycle + 1;
 229                         end
 230                         if (iedelay) begin
 231                                 ie <= 1;
 232                                 iedelay <= 0;
 233                         end
 234                         wr <= 0;
 235                         rd <= 0;
 236 `ifdef isim
 237                         address <= 16'bxxxxxxxxxxxxxxxx;        // Make it obvious if something of type has happened.
 238                         wdata <= 8'bxxxxxxxx;
 239 `endif
 240                         state <= `STATE_EXECUTE;
 241                 end
 242                 `STATE_EXECUTE: begin
 243                 `ifdef isim
 244                         if (opcode[7:0] === 8'bxxxxxxxx)
 245                                 $stop;
 246                 `endif
 247                         casex (opcode)
 248                         `define EXECUTE
 249                         `include "allinsns.v"
 250                         `undef EXECUTE
 251                         default:
 252                         begin
 253                                 address <= {7'h78,opcode};      // Have the CPU tell you F0xx if something's gone wrong.
 254                                 $stop;
 255                         end
 256                         endcase
 257                         state <= `STATE_WRITEBACK;
 258                 end
 259                 `STATE_WRITEBACK: begin
 260                         casex (opcode)
 261                         `define WRITEBACK
 262                         `include "allinsns.v"
 263                         `undef WRITEBACK
 264                         default:
 265                                 $stop;
 266                         endcase
 267                         state <= `STATE_FETCH;
 268                 end
 269                 endcase
 270 endmodule