前回までのあらすじ
- 自作PCを作ろう！
- まずメモリを作ったよ！(動かしてない)
- ISAを作ったよ！(コンパイラはまだ)
- アセンブリ言語を作ったよ！(アセンブラはまだ)
よくある質問
Q. アセンブラを作るのではなかったですか？
A. 面倒だし本題からずれるのでやっぱやめます
前回からの変更
命令ADDIとSUBIを消しました．
符号ありと無しで動作が同じなので．
全体の構成
ブロックデザインはこんな感じです．
mother_boardの中はこんな感じです．
ソース
いっぱいあるんで省略表示で貼りますね．
util.svh
/**
* 特に分類できない共通系
*/
`ifndef UTIL_SVH
`define UTIL_SVH
package util_p;
typedef logic bool_t;
parameter bool_t TRUE = 1'b1;
parameter bool_t FALSE = 1'b1;
endpackage
`endif
machine.svh
/**
* 機械語を生成する関数
*/
`ifndef MACHINE_SVH
`define MACHINE_SVH
// 機械語の構成
//
// 31 29 28 23 22 19 18 13 12 7 6 1 0
// | type | func | mask | rs1 | rs2 | rd |imm| + イミディエイトデータ(32bit)
package machine_p;
typedef logic [63:0] machine_t; // 機械語のサイズ
typedef logic [ 2:0] type_t; // 命令タイプ
typedef logic [ 5:0] func_t; // 命令
typedef logic [ 3:0] mask_t; // マスクサイズ
typedef logic [ 5:0] addr_t; // レジスタのアドレスサイズ
typedef logic [32:0] imm_t; // イミディエイトデータのサイズ．最上位ビットはイミディエイトデータを使用するかのフラグ
// 各機械語
localparam func_t NOP = 6'h00;
localparam func_t AND = 6'h00;
localparam func_t OR = 6'h01;
localparam func_t XOR = 6'h02;
localparam func_t NOT = 6'h03;
localparam func_t NAND = 6'h04;
localparam func_t ADD = 6'h05;
localparam func_t SUB = 6'h06;
localparam func_t SLL = 6'h00;
localparam func_t SRL = 6'h01;
localparam func_t SLA = 6'h02;
localparam func_t SRA = 6'h03;
localparam func_t MOV = 6'h00;
localparam func_t EQ = 6'h00;
localparam func_t NE = 6'h01;
localparam func_t LT = 6'h02;
localparam func_t GT = 6'h03;
localparam func_t ELT = 6'h04;
localparam func_t EGT = 6'h05;
localparam func_t JMP = 6'h00;
localparam func_t RM = 6'h00;
localparam func_t WM = 6'h01;
localparam func_t BRM = 6'h02;
localparam func_t BWM = 6'h03;
// 処理を実行しない(N系)
function machine_t nop(
);
nop = {3'h0, NOP, 4'h0, 6'h00, 6'h00, 6'h00, 33'h000000000};
endfunction
// 演算系(P系)
function machine_t and_(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
and_ = {3'h1, AND, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t or_(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
or_ = {3'h1, OR, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t xor_(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
xor_ = {3'h1, XOR, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t not_(
input addr_t rs1,
input addr_t rd,
input imm_t imm
);
not_ = {3'h1, NOT, 4'h0, rs1, 6'h00, rd, imm};
endfunction
function machine_t nand_(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
nand_ = {3'h1, NAND, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t add(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
add = {3'h1, ADD, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t sub(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
sub = {3'h1, SUB, 4'h0, rs1, rs2, rd, imm};
endfunction
// シフト系(S系)
function machine_t sll(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
sll = {3'h2, SLL, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t srl(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
srl = {3'h2, SRL, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t sla(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
sla = {3'h2, SLA, 4'h0, rs1, rs2, rd, imm};
endfunction
function machine_t sra(
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
sra = {3'h2, SRA, 4'h0, rs1, rs2, rd, imm};
endfunction
// 代入系(A系)
function machine_t mov(
input mask_t mask,
input addr_t rs1,
input addr_t rd,
input imm_t imm
);
mov = {3'h3, MOV, mask, rs1, 6'h00, rd, imm};
endfunction
// 分岐系(F系)
function machine_t eq(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
eq = {3'h4, EQ, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
function machine_t ne(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
ne = {3'h4, NE, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
function machine_t lt(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
lt = {3'h4, LT, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
function machine_t gt(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
gt = {3'h4, GT, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
function machine_t elt(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
elt = {3'h4, ELT, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
function machine_t egt(
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
egt = {3'h4, EGT, 4'h0, rs1, rs2, 6'h00, imm};
endfunction
// ジャンプ系(J系)
function machine_t jmp(
input addr_t rs1,
input imm_t imm
);
jmp = {3'h5, JMP, 4'h0, rs1, 6'h00, 6'h00, imm};
endfunction
// メモリ系(M系)
function machine_t rm(
input mask_t mask,
input addr_t rs1,
input addr_t rd,
input imm_t imm
);
rm = {3'h6, RM, mask, rs1, 6'h00, rd, imm};
endfunction
function machine_t wm(
input mask_t mask,
input addr_t rs1,
input addr_t rs2,
input imm_t imm
);
wm = {3'h6, WM, mask, rs1, rs2, 6'h00, imm};
endfunction
function machine_t brm(
input mask_t mask,
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
brm = {3'h6, BRM, mask, rs1, rs2, rd, imm};
endfunction
function machine_t bwm(
input mask_t mask,
input addr_t rs1,
input addr_t rs2,
input addr_t rd,
input imm_t imm
);
bwm = {3'h6, BWM, mask, rs1, rs2, rd, imm};
endfunction
endpackage
`endif
register.svh
/**
* レジスタに関する定義
*/
`ifndef REGISTER_SVH
`define REGISTER_SVH
`include "machine.svh"
// アドレスの定義
parameter machine_p::func_t SP_ADDR = 6'h10;
parameter machine_p::func_t FLG_ADDR = 6'h1c;
parameter machine_p::func_t RSI_ADDR = 6'h1d;
parameter machine_p::func_t RAX_ADDR = 6'h1e;
parameter machine_p::func_t PC_ADDR = 6'h1f;
parameter machine_p::func_t BTN_ADDR = 6'h20;
parameter machine_p::func_t SW_ADDR = 6'h21;
parameter machine_p::func_t LED_ADDR = 6'h22;
parameter machine_p::func_t RGB_LED_ADDR = 6'h23;
`endif
decorder.svh
/**
* デコーダーに関する関数
*/
`ifndef DECORDER_SV
`define DECORDER_SV
`include "machine.svh"
package decorder_p;
endpackage
// インターフェース定義
interface command_if; // 機械語から各値を取得してくるインターフェース
machine_p::machine_t machine;
machine_p::type_t m_type;
machine_p::func_t func;
machine_p::mask_t mask;
machine_p::addr_t rs1;
machine_p::addr_t rs2;
machine_p::addr_t rd;
machine_p::imm_t imm;
modport slave(
input machine,
output m_type,
output func,
output mask,
output rs1,
output rs2,
output rd,
output imm
);
modport master(
output machine,
input m_type,
input func,
input mask,
input rs1,
input rs2,
input rd,
input imm
);
endinterface
`endif
ram.svh
/**
* メインメモリに関する関数
*/
`ifndef RAM_SVH
`define RAM_SVH
`include "machine.svh"
package ram_p;
// 列挙体
typedef enum logic [1:0] { // メモリ読み出し・書き込み成否
NONE, // 初期状態
SUCCESS // 成功
} code_enum;
typedef enum logic [1:0] { // メモリ読み出し・書き込み状態
IDLE, // 待機状態
EXECUTE, // データ読み出し・書き込みの実行
RESPONSE // データ読み出し・書き込みのレスポンスを返す
} state_enum;
// 変数型
typedef logic [27:0] address_bus_t; // アドレスバス幅
typedef logic [31:0] data_bus_t; // データバス幅
typedef logic [27:0][ 7:0] memory_t; // メモリのデータ全体
endpackage
// インターフェース定義
interface ram_read_if; // メモリ読み込みインターフェース
ram_p::address_bus_t address;
ram_p::data_bus_t data;
machine_p::mask_t mask;
logic valid;
logic ready;
logic last;
ram_p::code_enum code;
modport slave(
input address,
output data,
input mask,
input valid,
output ready,
input last,
output code
);
modport master(
output address,
input data,
output mask,
output valid,
input ready,
output last,
input code
);
endinterface
interface ram_write_if; // メモリ書き込みインターフェース
ram_p::address_bus_t address;
ram_p::data_bus_t data;
machine_p::mask_t mask;
logic valid;
logic ready;
logic last;
ram_p::code_enum code;
modport slave(
input address,
input data,
input mask,
input valid,
output ready,
input last,
output code
);
modport master(
output address,
output data,
output mask,
output valid,
input ready,
output last,
input code
);
endinterface
`endif
rom.svh
/**
* ROMに関する関数
*/
`ifndef ROM_SVH
`define ROM_SVH
`include "ram.svh"
`include "machine.svh"
package rom_p;
typedef ram_p::address_bus_t pc_bus_t; // プログラムカウンタ
endpackage
// インターフェース定義
interface rom_read_if; // ROM読み込みインターフェース
rom_p::pc_bus_t pc;
machine_p::machine_t machine;
modport slave(
input pc,
output machine
);
modport master(
output pc,
input machine
);
endinterface
`endif
alu.svh
/**
* aluに関する関数など
*/
`ifndef ALU_SVH
`define ALU_SVH
`include "util.svh"
`include "decorder.svh"
package alu_p;
import machine_p::*;
// 列挙体
typedef enum type_t { // 機械語の命令タイプ
N_TYPE, // 処理を実行しない
P_TYPE, // 演算系
S_TYPE, // シフト系
A_TYPE, // 代入系
F_TYPE, // 分岐系
J_TYPE, // ジャンプ系
M_TYPE // メモリ系
} type_enum;
// 定数
localparam integer PC_ADDR = 6'h1f; // PCのアドレス
// 変数型
typedef logic [31:0] register_t; // レジスタサイズ
// 関数
function util_p::bool_t is_readable( // そのアドレスのレジスタが読み込み可能か
machine_p::addr_t addr
);
// CPU内のレジスタ
if (6'h00 <= addr && addr <= 6'h0f)
is_readable = util_p::TRUE;
// スタックポインタ
else if (addr == 6'h10)
is_readable = util_p::TRUE;
// 呼び出し関数の戻り先
else if (6'h11 <= addr && addr <= 6'h1a)
is_readable = util_p::TRUE;
// フラグ
else if (addr == 6'h1c)
is_readable = util_p::TRUE;
// 引数が格納されているレジスタの一つ目の番地
else if (addr == 6'h1d)
is_readable = util_p::TRUE;
// 演算結果
else if (addr == 6'h1e)
is_readable = util_p::TRUE;
// プログラムカウンタ
else if (addr == 6'h1f)
is_readable = util_p::TRUE;
// タクトスイッチ
else if (addr == 6'h20)
is_readable = util_p::TRUE;
// DIPスイッチ
else if (addr == 6'h21)
is_readable = util_p::TRUE;
// LED
else if (addr == 6'h22)
is_readable = util_p::FALSE;
// RGB LED
else if (addr == 6'h23)
is_readable = util_p::FALSE;
// Pmod A
else if (addr == 6'h24)
is_readable = util_p::TRUE;
// Pmod B
else if (addr == 6'h25)
is_readable = util_p::TRUE;
// AR
else if (addr == 6'h26 || addr == 6'h28)
is_readable = util_p::TRUE;
// I2C
else if (addr == 6'h27)
is_readable = util_p::TRUE;
// AR_RST
else if (addr == 6'h29)
is_readable = util_p::TRUE;
// SPI
else if (addr == 6'h2a)
is_readable = util_p::TRUE;
// アナログピン
else if (addr == 6'h2b)
is_readable = util_p::FALSE; // オミット
// XADC
else if (addr == 6'h2c)
is_readable = util_p::FALSE; // オミット
// GPIO
else if (6'h2d <= addr || addr <= 6'h30)
is_readable = util_p::TRUE;
// 定義されていない
else
is_readable = util_p::FALSE;
endfunction
function util_p::bool_t is_writable( // そのアドレスのレジスタが書き込み可能か
machine_p::addr_t addr
);
// CPU内のレジスタ
if (6'h00 <= addr && addr <= 6'h0f)
is_writable = util_p::TRUE;
// スタックポインタ
else if (addr == 6'h10)
is_writable = util_p::FALSE;
// 呼び出し関数の戻り先
else if (6'h11 <= addr && addr <= 6'h1a)
is_writable = util_p::FALSE;
// フラグ
else if (addr == 6'h1c)
is_writable = util_p::FALSE;
// 引数が格納されているレジスタの一つ目の番地
else if (addr == 6'h1d)
is_writable = util_p::FALSE;
// 演算結果
else if (addr == 6'h1e)
is_writable = util_p::FALSE;
// プログラムカウンタ
else if (addr == 6'h1f)
is_writable = util_p::FALSE;
// タクトスイッチ
else if (addr == 6'h20)
is_writable = util_p::FALSE;
// DIPスイッチ
else if (addr == 6'h21)
is_writable = util_p::FALSE;
// LED
else if (addr == 6'h22)
is_writable = util_p::TRUE;
// RGB LED
else if (addr == 6'h23)
is_writable = util_p::TRUE;
// Pmod A
else if (addr == 6'h24)
is_writable = util_p::TRUE;
// Pmod B
else if (addr == 6'h25)
is_writable = util_p::TRUE;
// AR
else if (addr == 6'h26 || addr == 6'h28)
is_writable = util_p::TRUE;
// I2C
else if (addr == 6'h27)
is_writable = util_p::TRUE;
// AR_RST
else if (addr == 6'h29)
is_writable = util_p::FALSE;
// SPI
else if (addr == 6'h2a)
is_writable = util_p::TRUE;
// アナログピン
else if (addr == 6'h2b)
is_writable = util_p::FALSE; // オミット
// XADC
else if (addr == 6'h2c)
is_writable = util_p::FALSE; // オミット
// GPIO
else if (6'h2d <= addr || addr <= 6'h30)
is_writable = util_p::TRUE;
// 定義されていない
else
is_writable = util_p::FALSE;
endfunction
endpackage
// インターフェース定義
`endif
mother_board.v
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2024/07/06 13:34:58
// Design Name:
// Module Name: mother_board
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module mother_board(
input wire clk,
input wire resetn,
input wire [3:0] btn,
input wire [1:0] sw,
output wire [3:0] led,
output wire [5:0] rgb_led
);
mother_board_sv mother_board_sv_0 (
.clk(clk), .resetn(resetn),
.btn(btn),
.sw(sw),
.led(led),
.rgb_led(rgb_led)
);
endmodule
mother_board_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2024/07/06 13:34:58
// Design Name:
// Module Name: mother_board_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "ram.svh"
`include "rom.svh"
module mother_board_sv(
input logic clk,
input logic resetn,
input logic [3:0] btn,
input logic [1:0] sw,
output logic [3:0] led,
output logic [5:0] rgb_led
);
// メインメモリ読み込み・書き込みインターフェース
ram_read_if ram_read();
ram_write_if ram_write();
// メモリ読み込みインターフェース
rom_read_if rom_read();
// メインメモリ
ram_sv ram_sv_0 (
.clk(clk), .resetn(resetn),
// メインメモリデータ読み込み
.ram_read(ram_read),
// メインメモリデータ書き込み
.ram_write(ram_write)
);
// CPU
cpu_sv cpu_sv_0 (
.clk(clk), .resetn(resetn),
// プログラムデータ読み込み
.rom_read(rom_read),
// メモリデータ読み書き
.ram_read(ram_read),
.ram_write(ram_write),
// IO
.btn(btn),
.sw(sw),
.led(led),
.rgb_led(rgb_led)
);
// プログラムメモリ
rom_sv rom_sv_0 (
// プログラムデータ読み込み
.rom_read(rom_read)
);
endmodule
ram_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2024/07/02 20:50:34
// Design Name:
// Module Name: ram_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "ram.svh"
module ram_sv import ram_p::*; (
input logic clk,
input logic resetn,
// メモリデータ読み出し
ram_read_if.slave ram_read,
// メモリデータ書き込み
ram_write_if.slave ram_write
);
// メモリに保存されるデータ
memory_t memory_data = 0;
// メモリ読み出し・書き込み状態
state_enum ram_read_state = IDLE;
state_enum ram_write_state = IDLE;
always_ff @(posedge clk) begin
// リセット
if (!resetn) begin
// IO
ram_read.data <= 32'b0;
ram_read.ready <= 1'b0;
ram_read.code <= NONE;
ram_write.ready <= 1'b0;
ram_write.code <= NONE;
// 内部変数
memory_data <= 0;
ram_read_state <= IDLE;
ram_write_state <= IDLE;
end
// メモリ実行
else begin
// メモリデータ読み出し
unique case (ram_read_state)
// 待機
IDLE: begin
ram_read.code <= NONE;
// 読み出し命令を検知
if (ram_read.valid) begin
ram_read_state <= EXECUTE;
end
end
// メモリ読み込み実行
EXECUTE: begin
if (ram_read.valid) begin
ram_read.ready <= 1'b1;
// マスクに応じて読み込み
foreach (ram_read.mask[i]) begin
if (ram_read.mask[i])
// 32ビットのうち，8ビット分を出力
ram_read.data[i*8 + 7:i*8] <= memory_data[ram_read.address + i];
else
ram_read.data[i*8 + 7:i*8] <= 8'h00;
end
// 読み込みラスト？
if (ram_read.last) begin
ram_read_state <= RESPONSE;
end
end else begin
ram_read.ready <= 1'b0;
end
end
// メモリ読み込みの実行結果を返す
RESPONSE: begin
ram_read.ready <= 1'b0;
ram_read.code <= SUCCESS;
ram_read_state <= IDLE;
end
endcase
// メモリデータ書き込み
unique case (ram_write_state)
// 待機
IDLE: begin
ram_write.code <= NONE;
// 書き込み命令を検知
if (ram_write.valid) begin
ram_write_state <= EXECUTE;
end
end
// メモリ書き込み実行
EXECUTE: begin
if (ram_write.valid) begin
ram_write.ready <= 1'b1;
// マスクに応じて書き込み
foreach (ram_write.mask[i]) begin
if (ram_write.mask[i])
// 32ビットのうち，8ビット分を入力
memory_data[ram_write.address + i] <= ram_write.data[i*8 + 7:i*8];
else
memory_data[ram_write.address + i] <= 8'h00;
end
// 書き込みラスト？
if (ram_write.last) begin
ram_write_state <= RESPONSE;
end
end else begin
ram_write.ready <= 1'b0;
end
end
// メモリ書き込みの実行結果を返す
RESPONSE: begin
ram_write.ready <= 1'b0;
ram_write.code <= SUCCESS;
ram_write_state <= IDLE;
end
endcase
end
end
endmodule
cpu_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2025/04/19 20:35:14
// Design Name:
// Module Name: cpu_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "machine.svh"
`include "rom.svh"
`include "decorder.svh"
module cpu_sv import machine_p::*; (
input logic clk,
input logic resetn,
rom_read_if.master rom_read,
ram_read_if.master ram_read,
ram_write_if.master ram_write,
input logic [3:0] btn,
input logic [1:0] sw,
output logic [3:0] led,
output logic [5:0] rgb_led
);
// デコーダーとのインターフェース
command_if command();
// デコーダー
decorder_sv decorder_sv_0(
.resetn(resetn),
.command(command)
);
// ALU
alu_sv alu_sv_0(
.clk(clk), .resetn(resetn),
.rom_read(rom_read),
.command(command),
.ram_read(ram_read),
.ram_write(ram_write),
.btn(btn),
.sw(sw),
.led(led),
.rgb_led(rgb_led)
);
endmodule
rom_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2025/04/19 20:51:41
// Design Name:
// Module Name: rom_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "rom.svh"
`include "machine.svh"
`include "register.svh"
module rom_sv import machine_p::*; (
// メモリデータ読み出し
rom_read_if.slave rom_read
);
localparam integer ROM_SIZE = 2;
// ボタンの状態をLEDに出力するだけのプログラム
machine_t machines[0:ROM_SIZE - 1] = {
// ボタンの状態をメインメモリに書き込む
wm(4'h1, 0, BTN_ADDR, {1'b1, 0}),
// メインメモリからボタンの状態をLEDに出力
rm(4'h1, 0, LED_ADDR, {1'b1, 0}),
// pcを先頭に戻す
jmp(0, {1'b1, 32'b0})
};
// メモリデータの読み出し
always_comb begin
if (rom_read.pc >= ROM_SIZE) begin
rom_read.machine = nop();
end else begin
rom_read.machine = machines[rom_read.pc];
end
end
endmodule
decorder_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2025/04/20 16:22:23
// Design Name:
// Module Name: decorder_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "decorder.svh"
module decorder_sv (
input logic resetn,
command_if.slave command
);
// 組み合わせ回路
always_comb begin
// リセット
if (!resetn) begin
command.m_type = 0;
command.func = 0;
command.mask = 0;
command.rs1 = 0;
command.rs2 = 0;
command.rd = 0;
command.imm = 0;
end
// 機械語を展開
else begin
command.m_type = command.machine[31 + 32:29 + 32];
command.func = command.machine[28 + 32:23 + 32];
command.mask = command.machine[22 + 32:19 + 32];
command.rs1 = command.machine[18 + 32:13 + 32];
command.rs2 = command.machine[12 + 32: 7 + 32];
command.rd = command.machine[ 6 + 32: 1 + 32];
command.imm = command.machine[31:0];
end
end
endmodule
alu_sv.sv
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2025/04/20 16:41:07
// Design Name:
// Module Name: alu_sv
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
`include "rom.svh"
`include "decorder.svh"
`include "alu.svh"
`include "ram.svh"
`include "machine.svh"
module alu_sv import alu_p::*, ram_p::*, machine_p::*; (
input logic clk,
input logic resetn,
rom_read_if.master rom_read,
command_if.master command,
// メモリ読み込みインターフェース
ram_read_if.master ram_read,
// メモリ書き込みインターフェース
ram_write_if.master ram_write,
input logic [3:0] btn,
input logic [1:0] sw,
output logic [3:0] led,
output logic [5:0] rgb_led
);
// 内部レジスタ
register_t register[6'h30:0] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
// メモリ読み込み・書き出し状態
ram_p::state_enum ram_read_state = IDLE;
ram_p::state_enum ram_write_state = IDLE;
// 強制リセット
logic force_reset = 1'b0;
// デバッグ用
type_t m_type = 0;
func_t func = 0;
mask_t mask = 0;
addr_t rs1 = 0;
addr_t rs2 = 0;
addr_t rd = 0;
imm_t imm = 0;
// 組み合わせ回路
always_comb begin
// 機械語を分解してもらう
command.machine = rom_read.machine;
// メモリのバースト転送はオミットする
ram_read.last = 1'b1;
ram_write.last = 1'b1;
// IOにレジスタの値を出力する
led = register[6'h22][3:0];
rgb_led = register[6'h23][5:0];
// pcを出力する
rom_read.pc = register[PC_ADDR];
// デバッグ用
m_type = command.m_type;
func = command.func;
mask = command.mask;
rs1 = command.rs1;
rs2 = command.rs2;
rd = command.rd;
imm = command.imm;
end
// 順序回路
always_ff @(posedge clk) begin
// リセット
if (!resetn || force_reset) begin
// メモリの読み込み・書き出し状態をリセット
ram_read_state <= IDLE;
ram_write_state <= IDLE;
// メモリ読み書き
ram_read.address = 0;
ram_read.mask = 0;
ram_read.valid = 0;
ram_write.address = 0;
ram_write.data = 0;
ram_write.mask = 0;
ram_write.valid = 0;
// レジスタ
for (logic [5:0] i = 0; i <= 6'h31; i++) begin
register[i] = 0;
end
end
// 命令実行
else begin
// IOからレジスタに値を格納する
register[6'h20] = {4'b0, btn};
register[6'h21] = {6'b0, sw};
// 関数タイプごとに実行
unique case (command.m_type)
// 処理を実行しない(N系)
N_TYPE: begin
// pcをカウントアップ
register[PC_ADDR] <= register[PC_ADDR] + 1;
// 不正な値が入っても全て無視する
end
// 演算系(P系)
P_TYPE: begin
// 演算系はどの命令でもpcをカウントアップする
register[PC_ADDR] <= register[PC_ADDR] + 1;
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (
is_readable(command.rs1)
&& is_readable(command.rs2)
&& is_writable(command.rd)
) begin
unique case (command.func)
AND: register[command.rd] <= register[command.rs1] & register[command.rs2];
OR: register[command.rd] <= register[command.rs1] | register[command.rs2];
XOR: register[command.rd] <= register[command.rs1] ^ register[command.rs2];
NOT: register[command.rd] <= ~register[command.rs1];
NAND: register[command.rd] <= ~(register[command.rs1] & register[command.rs2]);
ADD: register[command.rd] <= register[command.rs1] + register[command.rs2];
SUB: register[command.rd] <= register[command.rs1] - register[command.rs2];
default: force_reset <= 1'b1;
endcase
end
else begin
force_reset <= 1'b1;
end
end
// シフト系
S_TYPE: begin
// シフト系はどの命令でもpcをカウントアップする
register[PC_ADDR] <= register[PC_ADDR] + 1;
// イミディエイトデータを使用する？
if (command.imm[32]) begin
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (
is_readable(command.rs1)
&& is_writable(command.rd)
) begin
unique case (command.func)
SLL: register[command.rd] <= register[command.rs1] << command.imm[31:0];
SRL: register[command.rd] <= register[command.rs1] >> command.imm[31:0];
SLA: register[command.rd] <= register[command.rs1] <<< command.imm[31:0];
SRA: register[command.rd] <= register[command.rs1] >>> command.imm[31:0];
default: force_reset <= 1'b1;
endcase
end
else begin
force_reset <= 1'b1;
end
end else begin
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (
is_readable(command.rs1)
&& is_readable(command.rs2)
&& is_writable(command.rd)
) begin
unique case (command.func)
SLL: register[command.rd] <= register[command.rs1] << register[command.rs2];
SRL: register[command.rd] <= register[command.rs1] >> register[command.rs2];
SLA: register[command.rd] <= register[command.rs1] <<< register[command.rs2];
SRA: register[command.rd] <= register[command.rs1] >>> register[command.rs2];
default: force_reset <= 1'b1;
endcase
end
else begin
force_reset <= 1'b1;
end
end
end
// 代入系
A_TYPE: begin
// 代入系はどの命令でもpcをカウントアップする
register[PC_ADDR] <= register[PC_ADDR] + 1;
// 命令がMOVの時だけ実行
if (command.func == MOV) begin
// イミディエイトデータを使用する？
if (command.imm[32]) begin
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (is_writable(command.rd)) begin
register[command.rd] <= command.imm[31:0];
end
else begin
force_reset <= 1'b1;
end
end else begin
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (is_readable(command.rs1) && is_writable(command.rd)) begin
register[command.rd] <= register[command.rs1];
end
else begin
force_reset <= 1'b1;
end
end
end
else begin
force_reset <= 1'b1;
end
end
// 分岐系
F_TYPE: begin
// 指定されているアドレスが全て使用可能
// かつイミディエイトデータを使用する設定の時だけ，処理を実行する
if (
is_readable(command.rs1)
&& is_readable(command.rs2)
&& is_writable(command.rd)
&& command.imm[32]
) begin
unique case (command.func)
EQ: begin
if (register[command.rs1] == register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
NE: begin
if (register[command.rs1] != register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
LT: begin
if (register[command.rs1] < register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
GT: begin
if (register[command.rs1] > register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
ELT: begin
if (register[command.rs1] <= register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
EGT: begin
if (register[command.rs1] >= register[command.rs2])
register[PC_ADDR] <= register[PC_ADDR] + command.imm[31:0];
else
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
default: begin
force_reset <= 1'b1;
end
endcase
end
else begin
force_reset <= 1'b1;
end
end
// ジャンプ系
J_TYPE: begin
// 命令がジャンプの時だけ実行
if (command.func == JMP) begin
// イミディエイトデータを使用する？
if (command.imm[32]) begin
register[PC_ADDR] <= command.imm[31:0];
end else begin
// 指定されているアドレスが全て使用可能な場合のみ，処理を実行する
if (is_readable(command.rs1)) begin
register[PC_ADDR] <= register[command.rs1];
end
else begin
force_reset <= 1'b1;
end
end
end
else begin
force_reset <= 1'b1;
end
end
// メモリ系
M_TYPE: begin
unique case (command.func)
// メモリ読み込み
RM: begin
unique case (ram_read_state)
// 待機
IDLE: begin
// 実行を指示
ram_read_state <= EXECUTE;
// 実行状態であることを送る
ram_read.valid <= 1'b1;
// マスク情報を送る
ram_read.mask <= command.mask;
// アドレス情報を送る
if (command.imm[32]) begin
// イミディエイトデータを使用する指定なら，それを送る
ram_read.address <= command.imm[31:0];
end
else begin
// rs1を使用するなら，書き込み可能であることを確認して送る
if (is_writable(command.rs1)) begin
ram_read.address <= register[command.rs1];
end
else begin
// 強制リセット
force_reset <= 1'b1;
end
end
end
// メモリ読み込み実行
EXECUTE: begin
// 読み込みが完了したなら
if (ram_read.ready) begin
// 待機状態に遷移
ram_read_state <= IDLE;
// 実行状態をオフ
ram_read.valid <= 1'b0;
// データを受け取る
if (is_writable(command.rd)) begin
register[command.rd] <= ram_read.data;
end
else begin
force_reset <= 1'b1;
end
// プログラムカウンタをインクリメント
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
end
// その他
default: begin
force_reset <= 1'b1;
end
endcase
end
// メモリ書き込み
WM: begin
unique case(ram_write_state)
// 待機
IDLE: begin
// 実行を指示
ram_write_state <= EXECUTE;
// 実行状態であることを送る
ram_write.valid <= 1'b1;
// マスク情報を送る
ram_write.mask <= command.mask;
// アドレス情報を送る
if (command.imm[32]) begin
// イミディエイトデータを使用する指定なら，それを送る
ram_write.address <= command.imm[31:0];
end
else begin
// rs1を使用するなら，書き込み可能であることを確認して送る
if (is_writable(command.rs1)) begin
ram_write.address <= register[command.rs1];
end
else begin
// 強制リセット
force_reset <= 1'b1;
end
end
// データを送る
if (is_readable(command.rs2)) begin
ram_write.data <= register[command.rs2];
end
else begin
// 強制リセット
force_reset <= 1'b1;
end
end
// メモリ書き込み実行
EXECUTE: begin
// 書き込みが完了したなら
if (ram_write.ready) begin
// 待機状態に遷移
ram_write_state <= IDLE;
// 実行状態をオフ
ram_write.valid <= 1'b0;
// プログラムカウンタをインクリメント
register[PC_ADDR] <= register[PC_ADDR] + 1;
end
end
// その他
default: begin
force_reset <= 1'b1;
end
endcase
end
// バーストはオミット
// メモリ読み込み(バースト)
BRM: begin
force_reset <= 1'b1;
end
// メモリ書き込み(バースト)
BWM: begin
force_reset <= 1'b1;
end
default: begin
force_reset <= 1'b1;
end
endcase
end
default: begin
force_reset <= 1'b1;
end
endcase
end
end
endmodule
テストコード
大したテストはしてないですが一応．
top_sim.v
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 2025/08/24 20:10:28
// Design Name:
// Module Name: top_sim
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module top_sim();
// クロック関係
reg clk = 1'b0, resetn = 1'b1;
always #(10/2) begin
clk <= !clk;
end
// 入力
reg [3:0] btn = 0;
reg [1:0] sw = 0;
// 出力
wire [3:0] led;
wire [5:0] rgb_led;
// モジュール
mother_board mother_board_0(
.clk(clk), .resetn(resetn),
.btn(btn), .sw(sw),
.led(led), .rgb_led(rgb_led)
);
initial begin
// ボタンに値を入れる
btn[0] = 1'b1;
$finish();
end
endmodule
実行結果
次回の目標
最終的にはCUIで何かコントロールしたいので，その途中になるものを何か考えておきます．