nickorlow/yayacemu
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

run formatter

Browse source
This commit is contained in:
Nicholas Orlowsky 2024-01-31 21:04:52 -06:00
parent e679a3ce68
commit f715709942
9 changed files with 550 additions and 469 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
beeper.sv
View file

@ -1,10 +1,10 @@
module beeper ( module beeper (
input wire [7:0] sound_timer input wire [7:0] sound_timer
); );
import "DPI-C" function void set_beep(bit beep); import "DPI-C" function void set_beep(bit beep);
always_comb begin always_comb begin
set_beep(sound_timer > 0); set_beep(sound_timer > 0);
end end
endmodule endmodule

166
chip8.sv
View file

@ -1,54 +1,136 @@
module chip8 ( module chip8 (
input wire clk_in input wire clk_in
); );
bit [31:0] vram [0:2047]; bit [31:0] vram[0:2047];
bit [7:0] memory [0:4095]; bit [7:0] memory[0:4095];
bit keyboard [15:0]; bit keyboard[15:0];
bit [7:0] sound_timer; bit [7:0] sound_timer;
bit [15:0] program_counter; bit [15:0] program_counter;
int cycle_counter; int cycle_counter;
bit [7:0] random_number; bit [7:0] random_number;
beeper beeper (sound_timer); beeper beeper (sound_timer);
cpu cpu (memory, clk_in, keyboard, random_number, cycle_counter, program_counter, vram, sound_timer); cpu cpu (
gpu gpu (vram); memory,
keyboard kb (clk_in, keyboard); clk_in,
rng randy (clk_in, program_counter, keyboard, cycle_counter, random_number); keyboard,
rom_loader loader (memory); random_number,
cycle_counter,
program_counter,
vram,
sound_timer
);
gpu gpu (vram);
keyboard kb (
clk_in,
keyboard
);
rng randy (
clk_in,
program_counter,
keyboard,
cycle_counter,
random_number
);
rom_loader loader (memory);
initial begin initial begin
bit [7:0] fontset [79:0] = { bit [7:0] fontset[79:0] = {
8'hF0, 8'h90, 8'h90, 8'h90, 8'hF0, // 0 8'hF0,
8'h20, 8'h60, 8'h20, 8'h20, 8'h70, // 1 8'h90,
8'hF0, 8'h10, 8'hF0, 8'h80, 8'hF0, // 2 8'h90,
8'hF0, 8'h10, 8'hF0, 8'h10, 8'hF0, // 3 8'h90,
8'h90, 8'h90, 8'hF0, 8'h10, 8'h10, // 4 8'hF0, // 0
8'hF0, 8'h80, 8'hF0, 8'h10, 8'hF0, // 5 8'h20,
8'hF0, 8'h80, 8'hF0, 8'h90, 8'hF0, // 6 8'h60,
8'hF0, 8'h10, 8'h20, 8'h40, 8'h40, // 7 8'h20,
8'hF0, 8'h90, 8'hF0, 8'h90, 8'hF0, // 8 8'h20,
8'hF0, 8'h90, 8'hF0, 8'h10, 8'hF0, // 9 8'h70, // 1
8'hF0, 8'h90, 8'hF0, 8'h90, 8'h90, // A 8'hF0,
8'hE0, 8'h90, 8'hE0, 8'h90, 8'hE0, // B 8'h10,
8'hF0, 8'h80, 8'h80, 8'h80, 8'hF0, // C 8'hF0,
8'hE0, 8'h90, 8'h90, 8'h90, 8'hE0, // D 8'h80,
8'hF0, 8'h80, 8'hF0, 8'h80, 8'hF0, // E 8'hF0, // 2
8'hF0, 8'h80, 8'hF0, 8'h80, 8'h80 // F 8'hF0,
}; 8'h10,
8'hF0,
8'h10,
8'hF0, // 3
8'h90,
8'h90,
8'hF0,
8'h10,
8'h10, // 4
8'hF0,
8'h80,
8'hF0,
8'h10,
8'hF0, // 5
8'hF0,
8'h80,
8'hF0,
8'h90,
8'hF0, // 6
8'hF0,
8'h10,
8'h20,
8'h40,
8'h40, // 7
8'hF0,
8'h90,
8'hF0,
8'h90,
8'hF0, // 8
8'hF0,
8'h90,
8'hF0,
8'h10,
8'hF0, // 9
8'hF0,
8'h90,
8'hF0,
8'h90,
8'h90, // A
8'hE0,
8'h90,
8'hE0,
8'h90,
8'hE0, // B
8'hF0,
8'h80,
8'h80,
8'h80,
8'hF0, // C
8'hE0,
8'h90,
8'h90,
8'h90,
8'hE0, // D
8'hF0,
8'h80,
8'hF0,
8'h80,
8'hF0, // E
8'hF0,
8'h80,
8'hF0,
8'h80,
8'h80 // F
};
// Load fontset into memory // Load fontset into memory
for(int i = 0; i < 80; i++) begin for (int i = 0; i < 80; i++) begin
memory[i] = fontset[79-i]; memory[i] = fontset[79-i];
end
// Initialize keyboard bits
for(int i = 0; i < 15; i++) begin
keyboard[i] = 0;
end
end end
// Initialize keyboard bits
for (int i = 0; i < 15; i++) begin
keyboard[i] = 0;
end
end
endmodule endmodule

552
cpu.sv
View file

@ -1,301 +1,299 @@
module cpu( module cpu (
output bit [7:0] memory [0:4095], output bit [7:0] memory[0:4095],
input wire clk_in, input wire clk_in,
input wire keyboard [15:0], input wire keyboard[15:0],
input wire [7:0] random_number, input wire [7:0] random_number,
output int cycle_counter, output int cycle_counter,
output wire [15:0] program_counter, output wire [15:0] program_counter,
output wire [31:0] vram [0:2047], output wire [31:0] vram[0:2047],
output wire [7:0] sound_timer output wire [7:0] sound_timer
); );
bit halt; bit halt;
int watch_key; int watch_key;
logic [15:0] stack [0:15]; logic [15:0] stack[0:15];
logic [15:0] index_reg; logic [15:0] index_reg;
logic [3:0] stack_pointer; logic [3:0] stack_pointer;
logic [7:0] registers [0:15]; logic [7:0] registers[0:15];
logic [15:0] opcode; logic [15:0] opcode;
logic [7:0] delay_timer; logic [7:0] delay_timer;
logic [15:0] scratch; logic [15:0] scratch;
logic [15:0] scratch2; logic [15:0] scratch2;
logic [7:0] scratch_8; logic [7:0] scratch_8;
logic [7:0] scratch_82; logic [7:0] scratch_82;
logic [31:0] x_cord; logic [31:0] x_cord;
logic [31:0] y_cord; logic [31:0] y_cord;
logic [7:0] size; logic [7:0] size;
logic [31:0] screen_pixel; logic [31:0] screen_pixel;
logic [7:0] sprite_pixel; logic [7:0] sprite_pixel;
// Initialize CPU // Initialize CPU
initial begin initial begin
halt = 0; halt = 0;
watch_key = 255; watch_key = 255;
sound_timer = 0; sound_timer = 0;
delay_timer = 0; delay_timer = 0;
cycle_counter = 0; cycle_counter = 0;
program_counter = 'h200; program_counter = 'h200;
stack_pointer = 4'b0000; stack_pointer = 4'b0000;
end
always_ff @(posedge clk_in) begin
opcode = {memory[program_counter+0], memory[program_counter+1]};
$display("HW : opcode is 0x%h (%b)", opcode, opcode);
$display("HW : PC %0d 0x%h", program_counter, program_counter);
if (cycle_counter % 20 == 0) begin
if (delay_timer > 0) delay_timer--;
if (sound_timer > 0) sound_timer--;
end end
always_ff @(posedge clk_in) begin casez (opcode)
opcode = {memory[program_counter+0], memory[program_counter+1]}; 'h00E0: begin
$display("HW : opcode is 0x%h (%b)", opcode, opcode); $display("HW : INSTR CLS");
$display("HW : PC %0d 0x%h", program_counter, program_counter); for (int i = 0; i < 2048; i++) begin
vram[i] = 0;
if (cycle_counter % 20 == 0) begin
if (delay_timer > 0)
delay_timer--;
if (sound_timer > 0)
sound_timer--;
end end
end
'h00EE: begin
$display("HW : INSTR RET");
stack_pointer--;
program_counter = stack[stack_pointer];
end
'h0???: $display("HW : INSTR SYS addr (Treating as NOP)");
'h1???: begin
$display("HW : INSTR JP addr");
program_counter = (opcode & 'h0FFF) - 2;
end
'h2???: begin
$display("HW : INSTR CALL addr");
stack[stack_pointer] = program_counter;
stack_pointer++;
program_counter = (opcode & 'h0FFF) - 2;
end
'h3???: begin
$display("HW : INSTR SE Vx, byte");
scratch = (opcode & 'h00FF);
if (scratch[7:0] == registers[(opcode&'h0F00)>>8]) begin
program_counter += 2;
end
end
'h4???: begin
$display("HW : INSTR SNE Vx, byte");
scratch = (opcode & 'h00FF);
if (scratch[7:0] != registers[(opcode&'h0F00)>>8]) begin
program_counter += 2;
end
end
'h5??0: begin
$display("HW : INSTR SE Vx, Vy");
if (registers[(opcode&'h00F0)>>4] == registers[(opcode&'h0F00)>>8]) begin
program_counter += 2;
end
end
'h6???: begin
$display("HW : INSTR LD Vx, byte");
scratch = (opcode & 'h00FF);
registers[(opcode&'h0F00)>>8] = scratch[7:0];
end
'h7???: begin
$display("HW : INSTR ADD Vx, byte");
scratch = (opcode & 'h00FF);
registers[(opcode&'h0F00)>>8] += scratch[7:0];
end
'h8??0: begin
$display("HW : INSTR LD Vx, Vy");
registers[(opcode&'h0F00)>>8] = registers[(opcode&'h00F0)>>4];
end
'h8??1: begin
$display("HW : INSTR OR Vx, Vy");
registers[(opcode&'h0F00)>>8] |= registers[(opcode&'h00F0)>>4];
registers[15] = 0;
end
'h8??2: begin
$display("HW : INSTR AND Vx, Vy");
registers[(opcode&'h0F00)>>8] &= registers[(opcode&'h00F0)>>4];
registers[15] = 0;
end
'h8??3: begin
$display("HW : INSTR XOR Vx, Vy");
registers[(opcode&'h0F00)>>8] ^= registers[(opcode&'h00F0)>>4];
registers[15] = 0;
end
'h8??4: begin
$display("HW : INSTR ADD Vx, Vy");
scratch_8 = registers[(opcode&'h0F00)>>8];
registers[(opcode&'h0F00)>>8] += registers[(opcode&'h00F0)>>4];
registers[15] = {7'b0000000, scratch_8 > registers[(opcode&'h0F00)>>8]};
end
'h8??5: begin
$display("HW : INSTR SUB Vx, Vy");
scratch_8 = registers[(opcode&'h0F00)>>8];
registers[(opcode&'h0F00)>>8] -= registers[(opcode&'h00F0)>>4];
registers[15] = {7'b0000000, scratch_8 >= registers[(opcode&'h0F00)>>8]};
end
'h8??6: begin
$display("HW : INSTR SHR Vx {, Vy}");
scratch_8 = registers[(opcode&'h0F00)>>8];
registers[(opcode&'h0F00)>>8] = registers[(opcode&'h00F0)>>4] >> 1;
registers[15] = {7'b0000000, ((scratch_8 & 8'h01) == 8'h01)};
end
'h8??7: begin
$display("HW : INSTR SUBN Vx, Vy");
scratch_8 = registers[(opcode&'h00F0)>>4];
scratch_82 = registers[(opcode&'h0F00)>>8];
registers[(opcode & 'h0F00) >> 8] = registers[(opcode & 'h00F0) >> 4] - registers[(opcode & 'h0F00) >> 8];
registers[15] = {7'b0000000, (scratch_8 >= scratch_82)};
end
'h8??E: begin
$display("HW : INSTR SHL Vx {, Vy}");
scratch_8 = registers[(opcode&'h0F00)>>8];
registers[(opcode&'h0F00)>>8] = registers[(opcode&'h00F0)>>4] << 1;
casez(opcode) registers[15] = {7'b0000000, (scratch_8[7])};
'h00E0: begin end
$display("HW : INSTR CLS"); 'h9??0: begin
for(int i = 0; i < 2048; i++) begin $display("HW : INSTR SNE Vx, Vy");
vram[i] = 0; if (registers[(opcode&'h00F0)>>4] != registers[(opcode&'h0F00)>>8]) begin
end program_counter += 2;
end end
'h00EE: begin end
$display("HW : INSTR RET"); 'hA???: begin
stack_pointer--; $display("HW : INSTR LD I, addr");
program_counter = stack[stack_pointer]; index_reg = (opcode & 'h0FFF);
end end
'h0???: $display("HW : INSTR SYS addr (Treating as NOP)"); 'hb???: begin
'h1???: begin $display("HW : INSTR JP V0, addr");
$display("HW : INSTR JP addr"); program_counter = {8'h00, registers[0]} + (opcode & 'h0FFF) - 2;
program_counter = (opcode & 'h0FFF) - 2; end
end 'hc???: begin
'h2???: begin $display("HW : RND Vx, addr");
$display("HW : INSTR CALL addr"); // TODO: use a real RNG module, this is not synthesizeable
stack[stack_pointer] = program_counter; scratch = {8'h00, random_number} % 16'h0100;
stack_pointer++; scratch2 = (opcode & 'h00FF);
program_counter = (opcode & 'h0FFF) - 2; registers[(opcode&'h0F00)>>8] = scratch[7:0] & scratch2[7:0];
end end
'h3???: begin 'hD???: begin
$display("HW : INSTR SE Vx, byte"); $display("HW : INSTR DRW Vx, Vy, nibble");
scratch = (opcode & 'h00FF); if (cycle_counter % 20 != 0) begin
if (scratch[7:0] == registers[(opcode & 'h0F00) >> 8]) begin halt = 1;
program_counter += 2; end else begin
end halt = 0;
end x_cord = {24'h000000, registers[(opcode&'h0F00)>>8]};
'h4???: begin y_cord = {24'h000000, registers[(opcode&'h00F0)>>4]};
$display("HW : INSTR SNE Vx, byte");
scratch = (opcode & 'h00FF);
if (scratch[7:0] != registers[(opcode & 'h0F00) >> 8]) begin
program_counter += 2;
end
end
'h5??0: begin
$display("HW : INSTR SE Vx, Vy");
if (registers[(opcode & 'h00F0) >> 4] == registers[(opcode & 'h0F00) >> 8]) begin
program_counter += 2;
end
end
'h6???: begin
$display("HW : INSTR LD Vx, byte");
scratch = (opcode & 'h00FF);
registers[(opcode & 'h0F00) >> 8] = scratch[7:0];
end
'h7???: begin
$display("HW : INSTR ADD Vx, byte");
scratch = (opcode & 'h00FF);
registers[(opcode & 'h0F00) >> 8] += scratch[7:0];
end
'h8??0: begin
$display("HW : INSTR LD Vx, Vy");
registers[(opcode & 'h0F00) >> 8] = registers[(opcode & 'h00F0) >> 4];
end
'h8??1: begin
$display("HW : INSTR OR Vx, Vy");
registers[(opcode & 'h0F00) >> 8] |= registers[(opcode & 'h00F0) >> 4];
registers[15] = 0;
end
'h8??2: begin
$display("HW : INSTR AND Vx, Vy");
registers[(opcode & 'h0F00) >> 8] &= registers[(opcode & 'h00F0) >> 4];
registers[15] = 0;
end
'h8??3: begin
$display("HW : INSTR XOR Vx, Vy");
registers[(opcode & 'h0F00) >> 8] ^= registers[(opcode & 'h00F0) >> 4];
registers[15] = 0;
end
'h8??4: begin
$display("HW : INSTR ADD Vx, Vy");
scratch_8 = registers[(opcode & 'h0F00) >> 8];
registers[(opcode & 'h0F00) >> 8] += registers[(opcode & 'h00F0) >> 4];
registers[15] = {7'b0000000, scratch_8 > registers[(opcode & 'h0F00) >> 8]};
end
'h8??5: begin
$display("HW : INSTR SUB Vx, Vy");
scratch_8 = registers[(opcode & 'h0F00) >> 8];
registers[(opcode & 'h0F00) >> 8] -= registers[(opcode & 'h00F0) >> 4];
registers[15] = {7'b0000000, scratch_8 >= registers[(opcode & 'h0F00) >> 8]};
end
'h8??6: begin
$display("HW : INSTR SHR Vx {, Vy}");
scratch_8 = registers[(opcode & 'h0F00) >> 8];
registers[(opcode & 'h0F00) >> 8] = registers[(opcode & 'h00F0) >> 4]>> 1;
registers[15] = {7'b0000000, ((scratch_8 & 8'h01) == 8'h01)};
end
'h8??7: begin
$display("HW : INSTR SUBN Vx, Vy");
scratch_8 = registers[(opcode & 'h00F0) >> 4];
scratch_82 = registers[(opcode & 'h0F00) >> 8];
registers[(opcode & 'h0F00) >> 8] = registers[(opcode & 'h00F0) >> 4] - registers[(opcode & 'h0F00) >> 8];
registers[15] = {7'b0000000, (scratch_8 >= scratch_82)};
end
'h8??E: begin
$display("HW : INSTR SHL Vx {, Vy}");
scratch_8 = registers[(opcode & 'h0F00) >> 8];
registers[(opcode & 'h0F00) >> 8] = registers[(opcode & 'h00F0) >> 4]<< 1;
registers[15] = {7'b0000000, (scratch_8[7]) }; x_cord %= 64;
end y_cord %= 32;
'h9??0: begin
$display("HW : INSTR SNE Vx, Vy");
if (registers[(opcode & 'h00F0) >> 4] != registers[(opcode & 'h0F00) >> 8]) begin
program_counter += 2;
end
end
'hA???: begin
$display("HW : INSTR LD I, addr");
index_reg = (opcode & 'h0FFF);
end
'hb???: begin
$display("HW : INSTR JP V0, addr");
program_counter = {8'h00, registers[0]} + (opcode & 'h0FFF) - 2;
end
'hc???: begin
$display("HW : RND Vx, addr");
// TODO: use a real RNG module, this is not synthesizeable
scratch = {8'h00, random_number} % 16'h0100;
scratch2 = (opcode & 'h00FF);
registers[(opcode & 'h0F00) >> 8] = scratch[7:0] & scratch2[7:0];
end
'hD???: begin
$display("HW : INSTR DRW Vx, Vy, nibble");
if (cycle_counter % 20 != 0) begin
halt = 1;
end else begin
halt = 0;
x_cord = {24'h000000, registers[(opcode & 'h0F00) >> 8]};
y_cord = {24'h000000, registers[(opcode & 'h00F0) >> 4]};
x_cord %= 64; scratch = (opcode & 'h000F);
y_cord %= 32; size = scratch[7:0];
registers[15] = 0;
scratch = (opcode & 'h000F); for (int r = 0; r < size; r++) begin
size = scratch[7:0]; for (int c = 0; c < 8; c++) begin
registers[15] = 0; if (r + y_cord >= 32 || x_cord + c >= 64) continue;
screen_pixel = vram[((r+y_cord)*64)+(x_cord+c)];
sprite_pixel = memory[{16'h0000, index_reg}+r] & ('h80 >> c);
for (int r = 0; r < size; r++) begin if (|sprite_pixel) begin
for (int c = 0; c < 8; c++) begin if (screen_pixel == 32'hFFFFFFFF) begin
if (r + y_cord >= 32 || x_cord + c >= 64) registers[15] = 1;
continue;
screen_pixel = vram[((r + y_cord) * 64) + (x_cord + c)];
sprite_pixel = memory[{16'h0000, index_reg} + r] & ('h80 >> c);
if (|sprite_pixel) begin
if (screen_pixel == 32'hFFFFFFFF) begin
registers[15] = 1;
end
vram[((r + y_cord) * 64) + (x_cord + c)] ^= 32'hFFFFFFFF;
end
end
end
end end
vram[((r+y_cord)*64)+(x_cord+c)] ^= 32'hFFFFFFFF;
end
end end
'hE?9E: begin end
$display("HW : INSTR SKP Vx"); end
if (keyboard[{registers[(opcode & 'h0F00) >> 8]}[3:0]] == 1) begin end
program_counter += 2; 'hE?9E: begin
end $display("HW : INSTR SKP Vx");
scratch_8 = registers[(opcode&'h0F00)>>8];
if (keyboard[scratch_8[3:0]] == 1) begin
program_counter += 2;
end
end
'hE?A1: begin
$display("HW : INSTR SNE Vx");
scratch_8 = registers[(opcode&'h0F00)>>8];
if (keyboard[scratch_8[3:0]] != 1) begin
program_counter += 2;
end
end
'hF?07: begin
$display("HW : INSTR LD Vx, DT");
registers[(opcode&'h0F00)>>8] = delay_timer;
end
'hF?0A: begin
$display("HW : INSTR LD Vx, K");
halt = 1;
for (int i = 0; i < 16; i++) begin
if (watch_key == 255) begin
if (keyboard[i]) begin
watch_key = i;
end end
'hE?A1: begin end else begin
$display("HW : INSTR SNE Vx"); if (!keyboard[watch_key]) begin
if (keyboard[{registers[(opcode & 'h0F00) >> 8]}[3:0]] != 1) begin halt = 0;
program_counter += 2; watch_key = 255;
end
end end
'hF?07: begin end
$display("HW : INSTR LD Vx, DT"); end
registers[(opcode & 'h0F00) >> 8] = delay_timer; end
end 'hF?15: begin
'hF?0A: begin $display("HW : INSTR LD DT, Vx");
$display("HW : INSTR LD Vx, K"); delay_timer = registers[(opcode&'h0F00)>>8];
halt = 1; end
for(int i = 0; i < 16; i++) begin 'hF?18: begin
if (watch_key == 255) begin $display("HW : INSTR LD ST, Vx");
if (keyboard[i]) begin sound_timer = registers[(opcode&'h0F00)>>8];
watch_key = i; end
end 'hF?1E: begin
end else begin $display("HW : INSTR ADD I, Vx");
if (!keyboard[watch_key]) begin index_reg = index_reg + {8'h00, registers[(opcode&'h0F00)>>8]};
halt = 0; end
watch_key = 255; 'hF?29: begin
end $display("HW : INSTR LDL F, Vx");
end index_reg = registers[(opcode&'h0F00)>>8] * 5;
end end
end 'hF?33: begin
'hF?15: begin $display("HW : INSTR LD B, Vx");
$display("HW : INSTR LD DT, Vx"); scratch = {8'h00, registers[(opcode&'h0F00)>>8]};
delay_timer = registers[(opcode & 'h0F00) >> 8]; scratch2 = scratch % 10;
end memory[index_reg+2] = scratch2[7:0];
'hF?18: begin scratch /= 10;
$display("HW : INSTR LD ST, Vx"); scratch2 = scratch % 10;
sound_timer = registers[(opcode & 'h0F00) >> 8]; memory[index_reg+1] = scratch2[7:0];
end scratch /= 10;
'hF?1E: begin scratch2 = scratch % 10;
$display("HW : INSTR ADD I, Vx"); memory[index_reg+0] = scratch2[7:0];
index_reg = index_reg + {8'h00, registers[(opcode & 'h0F00) >> 8]}; end
end 'hF?55: begin
'hF?29: begin $display("HW : INSTR LD [I], Vx");
$display("HW : INSTR LDL F, Vx"); scratch = (opcode & 'h0F00) >> 8;
index_reg = registers[(opcode & 'h0F00) >> 8] * 5; for (bit [7:0] i8 = 0; i8 <= scratch[7:0]; i8++) begin
end scratch2 = index_reg + {8'h00, i8};
'hF?33: begin memory[scratch2[11:0]] = registers[i8[3:0]];
$display("HW : INSTR LD B, Vx"); end
scratch = {8'h00, registers[(opcode & 'h0F00) >> 8]}; index_reg++;
scratch2 = scratch % 10; end
memory[index_reg + 2] = scratch2[7:0]; 'hF?65: begin
scratch /= 10; $display("HW : INSTR LD Vx, [I]");
scratch2 = scratch % 10; scratch = (opcode & 'h0F00) >> 8;
memory[index_reg + 1] = scratch2[7:0]; for (bit [7:0] i8 = 0; i8 <= scratch[7:0]; i8++) begin
scratch /= 10; scratch2 = index_reg + {8'h00, i8};
scratch2 = scratch % 10; registers[i8[3:0]] = memory[scratch2[11:0]];
memory[index_reg + 0] = scratch2[7:0]; end
end index_reg++;
'hF?55: begin end
$display("HW : INSTR LD [I], Vx"); default: $display("HW : ILLEGAL INSTRUCTION");
scratch = (opcode & 'h0F00) >> 8; endcase
for (bit [7:0] i8 = 0; i8 <= scratch[7:0]; i8++) begin
scratch2 = index_reg + {8'h00, i8};
memory[scratch2[11:0]] = registers[i8[3:0]];
end
index_reg++;
end
'hF?65: begin
$display("HW : INSTR LD Vx, [I]");
scratch = (opcode & 'h0F00) >> 8;
for (bit [7:0] i8 = 0; i8 <= scratch[7:0]; i8++) begin
scratch2 = index_reg + {8'h00, i8};
registers[i8[3:0]] = memory[scratch2[11:0]];
end
index_reg++;
end
default: $display("HW : ILLEGAL INSTRUCTION");
endcase
if (!halt) if (!halt) program_counter += 2;
program_counter += 2;
cycle_counter++; cycle_counter++;
end end
endmodule endmodule

20
gpu.sv
View file

@ -1,15 +1,15 @@
module gpu ( module gpu (
input wire [31:0] vram [0:2047] input wire [31:0] vram[0:2047]
); );
import "DPI-C" function void init_screen(); import "DPI-C" function void init_screen();
import "DPI-C" function void draw_screen(logic [31:0] vram [0:2047]); import "DPI-C" function void draw_screen(logic [31:0] vram[0:2047]);
initial begin initial begin
init_screen(); init_screen();
end end
always_comb begin always_comb begin
draw_screen(vram); draw_screen(vram);
end end
endmodule endmodule

18
keyboard.sv
View file

@ -1,15 +1,15 @@
module keyboard ( module keyboard (
input wire clk_in, input wire clk_in,
output bit keyboard [15:0] output bit keyboard[15:0]
); );
import "DPI-C" function bit [7:0] get_key(); import "DPI-C" function bit [7:0] get_key();
always_ff @(posedge clk_in) begin always_ff @(posedge clk_in) begin
bit[7:0] keyval = get_key(); bit [7:0] keyval = get_key();
if (&keyval != 1) begin if (&keyval != 1) begin
keyboard[keyval[3:0]] = keyval[7]; keyboard[keyval[3:0]] = keyval[7];
end
end end
end
endmodule endmodule

6
makefile
View file

@ -1,3 +1,5 @@
.PHONY: run clean format
SDL_CFLAGS = `sdl2-config --cflags` SDL_CFLAGS = `sdl2-config --cflags`
SDL_LDFLAGS = `sdl2-config --libs` SDL_LDFLAGS = `sdl2-config --libs`
@ -13,4 +15,8 @@ run: build
clean: clean:
rm -rf obj_dir rm -rf obj_dir
format:
verible-verilog-format *.sv --inplace && clang-format *.cpp -i

22
rng.sv
View file

@ -1,19 +1,19 @@
module rng ( module rng (
input wire clk_in, input wire clk_in,
input wire [15:0] pc, input wire [15:0] pc,
input bit keyboard [15:0], input bit keyboard[15:0],
input int cycle_counter, input int cycle_counter,
output bit [7:0] rand_bit output bit [7:0] rand_bit
); );
bit [7:0] last; bit [7:0] last;
always_ff @(posedge clk_in) begin always_ff @(posedge clk_in) begin
for (int i = 0; i < 8; i++) begin for (int i = 0; i < 8; i++) begin
rand_bit[i] ^= ~keyboard[i] ? cycle_counter[i] : cycle_counter[7-i]; rand_bit[i] ^= ~keyboard[i] ? cycle_counter[i] : cycle_counter[7-i];
rand_bit[i] ^= (cycle_counter % 7) == 0 ? pc[i] : ~pc[i]; rand_bit[i] ^= (cycle_counter % 7) == 0 ? pc[i] : ~pc[i];
rand_bit[i] ^= keyboard[i+7] ? ~last[i] : last[i]; rand_bit[i] ^= keyboard[i+7] ? ~last[i] : last[i];
end
last = rand_bit;
end end
last = rand_bit;
end
endmodule endmodule

27
rom_loader.sv
View file

@ -1,18 +1,19 @@
module rom_loader ( module rom_loader (
output bit [7:0] memory [0:4095] output bit [7:0] memory[0:4095]
); );
import "DPI-C" function int load_rom(); import "DPI-C" function int load_rom();
import "DPI-C" function bit [7:0] get_next_instr(); import "DPI-C" function bit [7:0] get_next_instr();
import "DPI-C" function void close_rom(); import "DPI-C" function void close_rom();
initial begin initial begin
int rom_size = load_rom(); int rom_size = load_rom();
$display("HW : ROM size is %0d bytes (%0d bits) (%0d instructions)", rom_size, rom_size * 8, rom_size / 2); $display("HW : ROM size is %0d bytes (%0d bits) (%0d instructions)", rom_size,
for (int i = 0; i < rom_size; i++) begin rom_size * 8, rom_size / 2);
memory['h200 + i] = get_next_instr(); for (int i = 0; i < rom_size; i++) begin
end memory['h200+i] = get_next_instr();
close_rom();
$display("HW : ROM loaded successfully");
end end
close_rom();
$display("HW : ROM loaded successfully");
end
endmodule endmodule

198
yayacemu.cpp
View file

@ -1,14 +1,14 @@
#include "svdpi.h"
#include "Vchip8__Dpi.h"
#include <iostream>
#include <memory.h>
#include "Vchip8.h" #include "Vchip8.h"
#include "Vchip8__Dpi.h"
#include "svdpi.h"
#include "verilated.h" #include "verilated.h"
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <SDL2/SDL_image.h> #include <SDL2/SDL_image.h>
#include <SDL2/SDL_quit.h> #include <SDL2/SDL_quit.h>
#include <SDL2/SDL_timer.h> #include <SDL2/SDL_timer.h>
#include <inttypes.h> #include <inttypes.h>
#include <iostream>
#include <memory.h>
#define SCREEN_WIDTH 64 #define SCREEN_WIDTH 64
#define SCREEN_HEIGHT 32 #define SCREEN_HEIGHT 32
@ -18,34 +18,33 @@ FILE *rom_file;
SDL_Window *window; SDL_Window *window;
SDL_Renderer *renderer; SDL_Renderer *renderer;
SDL_Texture *texture; SDL_Texture *texture;
char* rom_name; char *rom_name;
void init_screen() { void init_screen() {
SDL_Init(SDL_INIT_EVERYTHING); SDL_Init(SDL_INIT_EVERYTHING);
window = window = SDL_CreateWindow(
SDL_CreateWindow("Yet Another Yet Another Chip-8 Emulator", // creates a window "Yet Another Yet Another Chip-8 Emulator", // creates a window
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH * 10,
SCREEN_WIDTH * 10, SCREEN_HEIGHT * 10, 0); SCREEN_HEIGHT * 10, 0);
renderer = renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888,
SDL_TEXTUREACCESS_STREAMING, SDL_TEXTUREACCESS_STREAMING, SCREEN_WIDTH,
SCREEN_WIDTH, SCREEN_HEIGHT); SCREEN_HEIGHT);
std::cout << "INF_EMU: Screen initialized" << '\n'; std::cout << "INF_EMU: Screen initialized" << '\n';
} }
void set_beep(const svBit beep) { void set_beep(const svBit beep) {
if (beep == 1) if (beep == 1)
SDL_SetTextureColorMod(texture, 255, 0, 0); SDL_SetTextureColorMod(texture, 255, 0, 0);
else else
SDL_SetTextureColorMod(texture, 255, 255, 255); SDL_SetTextureColorMod(texture, 255, 255, 255);
} }
void draw_screen(const svLogicVecVal* vram) { void draw_screen(const svLogicVecVal *vram) {
uint32_t *screen = (uint32_t*) malloc(SCREEN_WIDTH*SCREEN_HEIGHT*32); uint32_t *screen = (uint32_t *)malloc(SCREEN_WIDTH * SCREEN_HEIGHT * 32);
for(int i = 0; i < SCREEN_WIDTH * SCREEN_HEIGHT; i++) { for (int i = 0; i < SCREEN_WIDTH * SCREEN_HEIGHT; i++) {
screen[i] = vram[i].aval; screen[i] = vram[i].aval;
} }
SDL_UpdateTexture(texture, NULL, screen, sizeof(screen[0]) * SCREEN_WIDTH); SDL_UpdateTexture(texture, NULL, screen, sizeof(screen[0]) * SCREEN_WIDTH);
SDL_RenderClear(renderer); SDL_RenderClear(renderer);
@ -56,12 +55,12 @@ void draw_screen(const svLogicVecVal* vram) {
} }
int load_rom() { int load_rom() {
std::cout << "INF_EMU: Loading ROM " << rom_name << '\n'; std::cout << "INF_EMU: Loading ROM " << rom_name << '\n';
rom_file = fopen(rom_name, "r"); rom_file = fopen(rom_name, "r");
if (rom_file == NULL) { if (rom_file == NULL) {
std::cout << "INF_EMU: Error reading ROM file. Panicing." << '\n'; std::cout << "INF_EMU: Error reading ROM file. Panicing." << '\n';
exit(1); exit(1);
} }
fseek(rom_file, 0L, SEEK_END); fseek(rom_file, 0L, SEEK_END);
@ -72,93 +71,88 @@ int load_rom() {
return rom_size; return rom_size;
} }
svBitVecVal get_next_instr() { svBitVecVal get_next_instr() { return (uint8_t)fgetc(rom_file); }
return (uint8_t) fgetc(rom_file);
}
void close_rom() { void close_rom() { fclose(rom_file); }
fclose(rom_file);
}
svBitVecVal get_key() { svBitVecVal get_key() {
SDL_Event event; SDL_Event event;
uint8_t down = 0; uint8_t down = 0;
while(SDL_PollEvent(&event)) { while (SDL_PollEvent(&event)) {
switch(event.type) { switch (event.type) {
case SDL_KEYDOWN: case SDL_KEYDOWN:
down = 128; down = 128;
case SDL_KEYUP: case SDL_KEYUP:
switch(event.key.keysym.sym) { switch (event.key.keysym.sym) {
case SDLK_0: case SDLK_0:
return down | (uint8_t) 0; return down | (uint8_t)0;
case SDLK_1: case SDLK_1:
return down | (uint8_t) 1; return down | (uint8_t)1;
case SDLK_2: case SDLK_2:
return down | (uint8_t) 2; return down | (uint8_t)2;
case SDLK_3: case SDLK_3:
return down | (uint8_t) 3; return down | (uint8_t)3;
case SDLK_4: case SDLK_4:
return down | (uint8_t) 4; return down | (uint8_t)4;
case SDLK_5: case SDLK_5:
return down | (uint8_t) 5; return down | (uint8_t)5;
case SDLK_6: case SDLK_6:
return down | (uint8_t) 6; return down | (uint8_t)6;
case SDLK_7: case SDLK_7:
return down | (uint8_t) 7; return down | (uint8_t)7;
case SDLK_8: case SDLK_8:
return down | (uint8_t) 8; return down | (uint8_t)8;
case SDLK_9: case SDLK_9:
return down | (uint8_t) 9; return down | (uint8_t)9;
case SDLK_a: case SDLK_a:
return down | (uint8_t) 10; return down | (uint8_t)10;
case SDLK_b: case SDLK_b:
return down | (uint8_t) 11; return down | (uint8_t)11;
case SDLK_c: case SDLK_c:
return down | (uint8_t) 12; return down | (uint8_t)12;
case SDLK_d: case SDLK_d:
return down | (uint8_t) 13; return down | (uint8_t)13;
case SDLK_e: case SDLK_e:
return down | (uint8_t) 14; return down | (uint8_t)14;
case SDLK_f: case SDLK_f:
return down | (uint8_t) 15; return down | (uint8_t)15;
default: default:
return 255; return 255;
} }
default:
default: return 255;
return 255;
}
} }
return 255; }
return 255;
} }
int main(int argc, char** argv) { int main(int argc, char **argv) {
if (argc < 2) { if (argc < 2) {
std::cout << "Use: yayacemu [ROM_NAME]" << '\n'; std::cout << "Use: yayacemu [ROM_NAME]" << '\n';
exit(1); exit(1);
}
rom_name = argv[1];
VerilatedContext *contextp = new VerilatedContext;
contextp->commandArgs(argc, argv);
Vchip8 *dut = new Vchip8{contextp};
while (true) {
dut->clk_in ^= 1;
dut->eval();
usleep(1000000 / EMULATION_HZ);
if (SDL_QuitRequested()) {
std::cout << "INF_EMU: Received Quit from SDL. Goodbye!" << '\n';
break;
} }
}
rom_name = argv[1]; fflush(stdout);
delete dut;
VerilatedContext* contextp = new VerilatedContext; delete contextp;
contextp->commandArgs(argc, argv); return 0;
Vchip8* dut = new Vchip8{contextp};
while (true) {
dut->clk_in ^= 1;
dut->eval();
usleep(1000000/EMULATION_HZ);
if (SDL_QuitRequested()) {
std::cout << "INF_EMU: Received Quit from SDL. Goodbye!" << '\n';
break;
}
}
fflush(stdout);
delete dut;
delete contextp;
return 0;
} }