devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CPU设计实战：Loongarch版 lab7：不考虑相关冲突处理的简单流水线CPU_cpu设计实战loongarch版 lab

作者：码创造者 | 2024-08-07 09:49:45

赞

踩

cpu设计实战loongarch版 lab

首先上来看到了这两句话，那么直接起手改变一下接口

  1.     // inst sram interface
  2.     output wire         inst_sram_en,
  3.     output wire [ 3:0] inst_sram_we,
  4.     output wire [31:0] inst_sram_addr,
  5.     output wire [31:0] inst_sram_wdata,
  6.     input  wire [31:0] inst_sram_rdata,
  7.     // data sram interface
  8.     output wire         data_sram_en,
  9.     output wire [ 3:0] data_sram_we,
  10.     output wire [31:0] data_sram_addr,
  11.     output wire [31:0] data_sram_wdata,
  12.     input  wire [31:0] data_sram_rdata,

ok，添加完成后先进行运行，看看报错在什么地方（舔舌）。

直接出来这个了，我滴妈，难道，我滴任务完成辣？nonono，一看输出全为0，显然不是的，再查下去发现指令ram使能信号一直高阻态，好嘛，那大致明白要干什么了，那就要把mycpu的单周期改为流水线再来看看怎么事吧。这里借用了龙芯团队胡伟武老师等人编写的计算机体系结构基础的一些图。

然后流水线的设计参考汪文祥工程师等人攥写的CPU设计实战，引入了同步ram，所以考虑采用nextpc作为指令ram的读地址（视作pre-IF），并且要注意设置好各级流水线之间的握手信号。

或者还有一种方案是在IF阶段请求读指令ram，然后在ID阶段获取到指令，我第一次分割时候是这样做的，但是实现完之后一直会有一些小bug，改起来比较头疼，于是换了上面的方案。

我在一开始将每个需要传递到下一个阶段的信号都写在输入输出那里，发现这在我后面连线时会变得异常麻烦，参考了openla500后发现可以简化一下，于是就设置了每级流水之间的bus，会让连线变得简单一点。

我认为在了解了怎么将单周期分割成流水线之后最主要就是要细心了，将mycpu分成5个module之后，有时候会出现丢掉几个赋值语句（在ctrl+C和ctrl+V时）或者是数据位宽的问题，比如我就忘掉了数据ram的使能信号和读出数据的赋值，导致我卡了很久，而且在复制的时候我认为要给不同阶段之间传递的需要保持的信号附上不同的名字，这样就可以知道是哪个阶段出了问题。不过最终也是解决了问题，通过测试。

IF stage

  1.  
  2. module IF_stage(
  3. 	input  clk,
  4. 	input  reset,
  5. 	input  ID_allow_in,
  6. 	input  [32:0] br_bus,
  7. 	output        inst_sram_en,
  8.     output [ 3:0] inst_sram_we,
  9.     output [31:0] inst_sram_addr,
  10.     output [31:0] inst_sram_wdata,
  11.     input  [31:0] inst_sram_rdata,
  12. 	output [63:0] IF_ID_bus,
  13. 	output IF_to_ID_valid
  14.  
  15.     );
  16. wire br_taken;
  17. wire [31:0] br_target;
  18. wire [31:0] IF_inst;
  19. reg  [31:0] IF_pc;
  20. wire [31:0] seq_pc;
  21. wire [31:0] nextpc;
  22. wire IF_ready_go;
  23. wire IF_allow_in;
  24. wire to_IF_valid;
  25. wire IF_to_ID_valid;
  26. reg  IF_valid;
  27.  
  28. assign to_IF_valid = ~reset;
  29. assign IF_ready_go = 1'b1;
  30. assign IF_allow_in = !IF_valid || IF_ready_go && ID_allow_in;
  31. assign IF_to_ID_valid =  IF_valid && IF_ready_go;   
  32. assign IF_ID_bus = {IF_pc, IF_inst};
  33. assign {br_taken, br_target} = br_bus;
  35. 	always @(posedge clk) begin
  36. 	    if (reset) begin
  37. 	        IF_valid <= 1'b0;
  38. 	    end
  39. 	    else if (IF_allow_in) begin
  40. 	        IF_valid <= to_IF_valid;
  41. 	    end
  42. 	end
  43.  
  44. 	always @(posedge clk) begin 
  45. 		if(reset) begin
  46. 			 IF_pc <= 32'h1bfffffc;
  47. 		end else begin
  48. 			 IF_pc <= nextpc;			
  49. 		end
  50. 	end
  51.                        
  53. assign seq_pc       = IF_pc + 3'h4;
  54. assign nextpc       = br_taken ? br_target : seq_pc;
  55. assign inst_sram_en    = to_IF_valid && IF_allow_in;
  56. assign inst_sram_addr = nextpc;
  57. assign IF_inst = inst_sram_rdata;
  58. assign inst_sram_we = 4'b0;
  59. assign inst_sram_wdata = 32'b0;
  60.  
  61.  
  62. endmodule

ID stage

  1. `timescale 1ns / 1ps
  2. //
  3. // Company: 
  4. // Engineer: 
  5. // 
  6. // Create Date: 2024/05/29 10:44:41
  7. // Design Name: 
  8. // Module Name: ID_stage
  9. // Project Name: 
  10. // Target Devices: 
  11. // Tool Versions: 
  12. // Description: 
  13. // 
  14. // Dependencies: 
  15. // 
  16. // Revision:
  17. // Revision 0.01 - File Created
  18. // Additional Comments:
  19. // 
  20. //
  21.  
  22.  
  23. module ID_stage(
  24.   input  clk,
  25.   input  reset,
  26.   input  EX_allow_in,
  27.   input  IF_to_ID_valid,
  28.   input  [63:0]IF_ID_bus,
  29.   input  [37:0]WB_rf_bus,
  30.   output ID_allow_in,
  31.   output [32:0]br_bus,
  32.   output [150:0]ID_EX_bus,
  33.   output ID_to_EX_valid,
  34.   output to_EX_inst_bl
  35.  
  36.     );
  37. reg  [31:0] ID_pc;
  38. reg  [31:0] ID_inst;
  39. reg  ID_valid;
  40. wire ID_ready_go;
  41. reg delay_slot; 
  42.  
  43. wire [31:0] br_offs;
  44. wire [31:0] jirl_offs;
  45. wire        src_reg_is_rd;
  46. wire        dst_is_r1;
  47. wire [ 5:0] op_31_26;
  48. wire [ 3:0] op_25_22;
  49. wire [ 1:0] op_21_20;
  50. wire [ 4:0] op_19_15;
  51. wire [ 4:0] rd;
  52. wire [ 4:0] rj;
  53. wire [ 4:0] rk;
  54. wire [11:0] i12;
  55. wire [19:0] i20;
  56. wire [15:0] i16;
  57. wire [25:0] i26;
  58.  
  59. wire rf_we  ;
  60. wire [4:0]rf_waddr;
  61. wire [31:0]rf_wdata;
  62. wire [4:0]rf_raddr1;
  63. wire [31:0]rf_rdata1;
  64. wire [4:0]rf_raddr2;
  65. wire [31:0]rf_rdata2;
  66.  
  67. wire [11:0] alu_op;
  68. wire        src1_is_pc;
  69. wire        src2_is_imm;
  70. wire        src2_is_4;
  71. wire        res_from_mem;
  72. wire        gr_we;
  73. wire        mem_we;
  74. wire [4: 0] dest;
  75. wire [31:0] rj_value;
  76. wire [31:0] rkd_value;
  77. wire [31:0] imm;
  78.  
  79. wire br_taken;
  80. wire [31:0]br_target;
  81.  
  82. wire [63:0] op_31_26_d;
  83. wire [15:0] op_25_22_d;
  84. wire [ 3:0] op_21_20_d;
  85. wire [31:0] op_19_15_d;
  86.  
  87. wire        inst_add_w;
  88. wire        inst_sub_w;
  89. wire        inst_slt;
  90. wire        inst_sltu;
  91. wire        inst_nor;
  92. wire        inst_and;
  93. wire        inst_or;
  94. wire        inst_xor;
  95. wire        inst_slli_w;
  96. wire        inst_srli_w;
  97. wire        inst_srai_w;
  98. wire        inst_addi_w;
  99. wire        inst_ld_w;
  100. wire        inst_st_w;
  101. wire        inst_jirl;
  102. wire        inst_b;
  103. wire        inst_bl;
  104. wire        inst_beq;
  105. wire        inst_bne;
  106. wire        inst_lu12i_w;
  107.  
  108. wire        need_ui5;
  109. wire        need_si12;
  110. wire        need_si16;
  111. wire        need_si20;
  112. wire        need_si26;
  113.  
  114. wire [31:0]alu_src1;
  115. wire [31:0]alu_src2;
  116.  
  117. assign op_31_26  = ID_inst[31:26];
  118. assign op_25_22  = ID_inst[25:22];
  119. assign op_21_20  = ID_inst[21:20];
  120. assign op_19_15  = ID_inst[19:15];
  121.  
  122. assign rd   = ID_inst[ 4: 0];
  123. assign rj   = ID_inst[ 9: 5];
  124. assign rk   = ID_inst[14:10];
  125.  
  126. assign i12  = ID_inst[21:10];
  127. assign i20  = ID_inst[24: 5];
  128. assign i16  = ID_inst[25:10];
  129. assign i26  = {ID_inst[ 9: 0], ID_inst[25:10]};
  130.  
  131.  
  132. decoder_6_64 u_dec0(.in(op_31_26 ), .out(op_31_26_d ));
  133. decoder_4_16 u_dec1(.in(op_25_22 ), .out(op_25_22_d ));
  134. decoder_2_4  u_dec2(.in(op_21_20 ), .out(op_21_20_d ));
  135. decoder_5_32 u_dec3(.in(op_19_15 ), .out(op_19_15_d ));
  136.  
  137. assign inst_add_w  = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h00];
  138. assign inst_sub_w  = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h02];
  139. assign inst_slt    = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h04];
  140. assign inst_sltu   = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h05];
  141. assign inst_nor    = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h08];
  142. assign inst_and    = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h09];
  143. assign inst_or     = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h0a];
  144. assign inst_xor    = op_31_26_d[6'h00] & op_25_22_d[4'h0] & op_21_20_d[2'h1] & op_19_15_d[5'h0b];
  145. assign inst_slli_w = op_31_26_d[6'h00] & op_25_22_d[4'h1] & op_21_20_d[2'h0] & op_19_15_d[5'h01];
  146. assign inst_srli_w = op_31_26_d[6'h00] & op_25_22_d[4'h1] & op_21_20_d[2'h0] & op_19_15_d[5'h09];
  147. assign inst_srai_w = op_31_26_d[6'h00] & op_25_22_d[4'h1] & op_21_20_d[2'h0] & op_19_15_d[5'h11];
  148. assign inst_addi_w = op_31_26_d[6'h00] & op_25_22_d[4'ha];
  149. assign inst_ld_w   = op_31_26_d[6'h0a] & op_25_22_d[4'h2];
  150. assign inst_st_w   = op_31_26_d[6'h0a] & op_25_22_d[4'h6];
  151. assign inst_jirl   = op_31_26_d[6'h13];
  152. assign inst_b      = op_31_26_d[6'h14];
  153. assign inst_bl     = op_31_26_d[6'h15];
  154. assign inst_beq    = op_31_26_d[6'h16];
  155. assign inst_bne    = op_31_26_d[6'h17];
  156. assign inst_lu12i_w= op_31_26_d[6'h05] & ~ID_inst[25];
  157.  
  158. assign to_EX_inst_bl = inst_bl;
  159.  
  160. assign alu_op[ 0] = inst_add_w | inst_addi_w | inst_ld_w | inst_st_w
  161.                     | inst_jirl | inst_bl;
  162. assign alu_op[ 1] = inst_sub_w;
  163. assign alu_op[ 2] = inst_slt;
  164. assign alu_op[ 3] = inst_sltu;
  165. assign alu_op[ 4] = inst_and;
  166. assign alu_op[ 5] = inst_nor;
  167. assign alu_op[ 6] = inst_or;
  168. assign alu_op[ 7] = inst_xor;
  169. assign alu_op[ 8] = inst_slli_w;
  170. assign alu_op[ 9] = inst_srli_w;
  171. assign alu_op[10] = inst_srai_w;
  172. assign alu_op[11] = inst_lu12i_w;
  173.  
  174. assign need_ui5   =  inst_slli_w | inst_srli_w | inst_srai_w;
  175. assign need_si12  =  inst_addi_w | inst_ld_w | inst_st_w;
  176. assign need_si16  =  inst_jirl | inst_beq | inst_bne;
  177. assign need_si20  =  inst_lu12i_w;
  178. assign need_si26  =  inst_b | inst_bl;
  179. assign src2_is_4  =  inst_jirl | inst_bl;
  180. assign imm = src2_is_4 ? 32'h4                      :
  181.              need_si20 ? {i20[19:0], 12'b0}         :
  182. /*need_ui5 || need_si12*/{{20{i12[11]}}, i12[11:0]} ;
  183.  
  184. assign br_offs = need_si26 ? {{ 4{i26[25]}}, i26[25:0], 2'b0} :
  185.                              {{14{i16[15]}}, i16[15:0], 2'b0} ;
  186.  
  187. assign jirl_offs = {{14{i16[15]}}, i16[15:0], 2'b0};
  188. assign src_reg_is_rd = inst_beq | inst_bne | inst_st_w;
  189. assign src1_is_pc    = inst_jirl | inst_bl;
  190. assign src2_is_imm   = inst_slli_w |
  191.                        inst_srli_w |
  192.                        inst_srai_w |
  193.                        inst_addi_w |
  194.                        inst_ld_w   |
  195.                        inst_st_w   |
  196.                        inst_lu12i_w|
  197.                        inst_jirl   |
  198.                        inst_bl     ;
  199. assign res_from_mem  = inst_ld_w;
  200. assign dst_is_r1     = inst_bl;
  201. assign gr_we         = ~inst_st_w & ~inst_beq & ~inst_bne & ~inst_b;
  202. assign mem_we        = inst_st_w;
  203. assign dest          = dst_is_r1 ? 5'd1 : rd;
  204.  
  205. assign rf_raddr1 = rj;
  206. assign rf_raddr2 = src_reg_is_rd ? rd :rk;
  207.  
  208. assign {rf_we, rf_waddr, rf_wdata} = WB_rf_bus;
  209.  
  210. regfile u_regfile(
  211.     .clk    (clk      ),
  212.     .raddr1 (rf_raddr1),
  213.     .rdata1 (rf_rdata1),
  214.     .raddr2 (rf_raddr2),
  215.     .rdata2 (rf_rdata2),
  216.     .we     (rf_we    ),
  217.     .waddr  (rf_waddr ),
  218.     .wdata  (rf_wdata )
  219.     );
  220.  
  221. assign rj_value  = rf_rdata1;
  222. assign rkd_value = rf_rdata2;
  223.  
  224. assign ID_EX_bus = {
  225.                     ID_pc,//150:119
  226.                     alu_op,//118:107
  227.                     src2_is_4,//106
  228.                     src1_is_pc,//105
  229.                     src2_is_imm,//104
  230.                     gr_we,//103
  231.                     mem_we,//102
  232.                     dest,//101:97
  233.                     imm,//96:65
  234.                     rj_value,//64:33
  235.                     rkd_value,//32:1
  236.                     res_from_mem //0:0
  237. };
  238. assign rj_eq_rd = (rj_value == rkd_value);
  239. assign br_taken = (   inst_beq  &&  rj_eq_rd
  240.                    || inst_bne  && !rj_eq_rd
  241.                    || inst_jirl
  242.                    || inst_bl
  243.                    || inst_b
  244.                   ) && ID_valid;
  245. assign br_target = (inst_beq || inst_bne || inst_bl || inst_b) ? (ID_pc + br_offs) :
  246.                                                    /*inst_jirl*/ (rj_value + jirl_offs);
  247. assign br_bus = {br_taken,//32
  248.                 br_target //31:0
  249.                 };
  250.  
  251. assign ID_ready_go    = 1'b1;
  252. assign ID_allow_in     = !ID_valid || ID_ready_go && EX_allow_in;
  253. assign ID_to_EX_valid = ID_valid && ID_ready_go && !delay_slot;
  254. always @(posedge clk) begin
  255.     if (reset) begin
  256.         ID_valid <= 1'b0;
  257.         delay_slot <= 1'b0;
  258.     end
  259.     else if (ID_allow_in) begin
  260.         ID_valid <= IF_to_ID_valid;
  261.     end
  262.  
  263.     if (IF_to_ID_valid && ID_allow_in) begin
  264.         {ID_pc,ID_inst} <= IF_ID_bus;
  265.          if (br_taken) begin
  266.           delay_slot <= 1'b1;
  267.           end else begin
  268.             delay_slot <=1'b0;
  269.           end
  270.     end
  271.     
  272. end
  273.  
  274. endmodule

EX stage

  1. module EX_stage(
  2. 	input         clk,
  3.     input         reset,
  4.     input  MEM_allow_in,
  5.     input  ID_to_EX_valid,
  6. 	output EX_allow_in,
  7. 	input  [150:0]ID_EX_bus,
  8.  	input  	inst_bl,
  9.  	output [70:0]EX_MEM_bus,
  10.  	output  EX_to_MEM_valid,
  11.  	output        data_sram_en,
  12.     output [ 3:0] data_sram_we,
  13.     output [31:0] data_sram_addr,
  14.     output [31:0] data_sram_wdata
  15.  
  16. 	);
  17.  
  18. 	reg  [31:0] EX_pc;
  19.  
  20. 	reg EX_valid;
  21. 	wire EX_ready_go;
  22. 	reg  [11:0] EX_alu_op;
  23. 	reg         EX_src1_is_pc;
  24. 	reg         EX_src2_is_imm;
  25. 	reg         EX_src2_is_4;
  26. 	reg         EX_res_from_mem;
  27. 	reg         EX_gr_we;
  28. 	reg         EX_mem_we;
  29. 	reg  [4: 0] EX_dest;
  30. 	reg  [31:0] EX_rj_value;
  31. 	reg  [31:0] EX_rkd_value;
  32. 	reg  [31:0] EX_imm;
  33. 	wire [31:0] alu_result;
  34. 	reg EX_inst_bl;
  35. 	wire [31:0] alu_src1;
  36. 	wire [31:0] alu_src2;
  37. 	assign EX_ready_go    = 1'b1;
  38. 	assign EX_allow_in     = !EX_valid || EX_ready_go && MEM_allow_in;
  39. 	assign EX_to_MEM_valid =  EX_valid && EX_ready_go;
  40. 	assign EX_MEM_bus = {
  41. 						EX_pc,//70:39
  42. 						EX_gr_we,//38
  43. 						EX_dest,//37:33
  44. 						alu_result,//32:1
  45. 						EX_res_from_mem//0
  46. 	};
  48. always @(posedge clk) begin
  49.     if (reset) begin
  50.         EX_valid <= 1'b0;
  51.     end
  52.     else if (EX_allow_in) begin
  53.         EX_valid <= ID_to_EX_valid;
  54.     end
  55.  
  56.     if (ID_to_EX_valid && EX_allow_in) begin
  57.     	{EX_pc ,
  58.     	EX_alu_op ,
  59.     	EX_src2_is_4,
  60.     	EX_src1_is_pc,
  61.     	EX_src2_is_imm,
  62.     	EX_gr_we,
  63.     	EX_mem_we,
  64.     	EX_dest,
  65.     	EX_imm,
  66.     	EX_rj_value,
  67.     	EX_rkd_value,
  68.     	EX_res_from_mem} <= ID_EX_bus;
  69.     	EX_inst_bl <= inst_bl;
  70.     end
  71. end
  72.  
  73. alu u_alu(
  74.     .alu_op     (EX_alu_op ),
  75.     .alu_src1   (alu_src1  ),
  76.     .alu_src2   (alu_src2  ),
  77.     .alu_result (alu_result)
  78.     );
  79. assign alu_src1 = EX_src1_is_pc  ? EX_pc : EX_rj_value;
  80. assign alu_src2 = EX_src2_is_imm ? EX_imm : (EX_inst_bl ? 32'd4 : EX_rkd_value);
  81. assign data_sram_en = 1'b1;
  82. assign data_sram_we    = EX_mem_we && EX_valid ? 4'b1111 : 4'b0000;
  83. assign data_sram_addr  = alu_result;
  84. assign data_sram_wdata = EX_rkd_value;
  85.  
  86. endmodule

MEM stage

  1. module MEM_stage(
  2. 	input  clk,
  3.     input  reset,
  4.     input  WB_allow_in,
  5.     output MEM_allow_in,
  6.     input  [70:0]EX_MEM_bus,
  7. 	input  [31:0] data_sram_rdata,
  8. 	input  EX_to_MEM_valid,	
  9. 	output MEM_to_WB_valid,
  10. 	output [69:0]MEM_WB_bus
  11. 	);
  12.  
  13. reg [31:0] MEM_pc;
  14. reg MEM_res_from_mem;
  15. reg MEM_gr_we;
  16. reg [4:0]MEM_dest;
  17. reg [31:0]MEM_alu_result;
  18. wire [31:0] MEM_final_result;
  19. wire [31:0] MEM_result;
  20.  
  21. reg MEM_valid;
  22. wire MEM_ready_go;
  23. assign MEM_ready_go    = 1'b1;
  24. assign MEM_allow_in     = !MEM_valid || MEM_ready_go && WB_allow_in;
  25. assign MEM_to_WB_valid = MEM_valid && MEM_ready_go;
  26. always @(posedge clk) begin
  27.     if (reset) begin
  28.         MEM_valid <= 1'b0;
  29.     end
  30.     else if (MEM_allow_in) begin
  31.         MEM_valid <= EX_to_MEM_valid;
  32.     end
  33.  
  34.     if (EX_to_MEM_valid && MEM_allow_in) begin
  35.     	{MEM_pc ,
  36.         MEM_gr_we ,
  37. 		MEM_dest,
  38. 		MEM_alu_result,
  39. 		MEM_res_from_mem } <= EX_MEM_bus;
  40.     end
  41. end
  42. assign MEM_result = data_sram_rdata;
  43. assign MEM_final_result = MEM_res_from_mem ? MEM_result : MEM_alu_result;
  44. assign MEM_WB_bus = {
  45. 						MEM_pc,//69:38
  46. 						MEM_gr_we,//37
  47. 						MEM_dest,// 36:32
  48. 						MEM_final_result//31:0
  49. };
  50. endmodule

WB stage

  1. module WB_stage(
  2.   input  clk,
  3.   input  reset,
  4.   output WB_allow_in,
  5.   input  MEM_to_WB_valid,
  6.   input  [69:0] MEM_WB_bus,
  7.   output [37:0] WB_rf_bus,
  8.   output [31:0] debug_wb_pc,
  9.   output [ 3:0] debug_wb_rf_we,
  10.   output [ 4:0] debug_wb_rf_wnum,
  11.   output [31:0] debug_wb_rf_wdata
  12.   );
  13. reg [31:0] WB_pc;
  14. reg WB_valid;
  15. wire WB_ready_go;
  16.  
  17. reg WB_gr_we;
  18. reg [4:0]WB_dest;
  19. reg [31:0]WB_final_result;
  20. wire rf_we   ;
  21. wire [4:0]rf_waddr;
  22. wire [31:0]rf_wdata;
  23. assign WB_ready_go = 1'b1;
  24. assign WB_allow_in  = !WB_valid || WB_ready_go;
  25. always @(posedge clk) begin
  26.     if (reset) begin
  27.         WB_valid <= 1'b0;
  28.     end
  29.     else if (WB_allow_in) begin
  30.         WB_valid <= MEM_to_WB_valid;
  31.     end
  32.  
  33.     if (MEM_to_WB_valid && WB_allow_in) begin
  34.       {WB_pc,
  35.        WB_gr_we,
  36.        WB_dest,
  37.        WB_final_result} <= MEM_WB_bus;
  38.        
  39.     end
  40. end
  41.  
  42. assign rf_we    = WB_gr_we && WB_valid;
  43. assign rf_waddr = WB_dest;
  44. assign rf_wdata = WB_final_result;
  45.  
  46. assign WB_rf_bus = {rf_we,//37
  47.                     rf_waddr,//36:32
  48.                     rf_wdata//31:0
  49.                     };
  50. assign debug_wb_pc       = rf_we ? WB_pc : debug_wb_pc;
  51. assign debug_wb_rf_we   = {4{rf_we}};
  52. assign debug_wb_rf_wnum  = WB_valid && rf_we ? WB_dest : debug_wb_rf_wnum;
  53. assign debug_wb_rf_wdata = WB_valid && rf_we ? WB_final_result : debug_wb_rf_wdata;
  54.  
  55. endmodule

mycpu top

  1. module mycpu_top(
  2.     input  wire        clk,
  3.     input  wire        resetn,
  4.     // inst sram interface
  5.     output wire        inst_sram_en,
  6.     output wire [ 3:0] inst_sram_we,
  7.     output wire [31:0] inst_sram_addr,
  8.     output wire [31:0] inst_sram_wdata,
  9.     input  wire [31:0] inst_sram_rdata,
  10.     // data sram interface
  11.     output wire        data_sram_en,
  12.     output wire [ 3:0] data_sram_we,
  13.     output wire [31:0] data_sram_addr,
  14.     output wire [31:0] data_sram_wdata,
  15.     input  wire [31:0] data_sram_rdata,
  16.     // trace debug interface
  17.     output wire [31:0] debug_wb_pc,
  18.     output wire [ 3:0] debug_wb_rf_we,
  19.     output wire [ 4:0] debug_wb_rf_wnum,
  20.     output wire [31:0] debug_wb_rf_wdata
  21. );
  22. reg         reset;
  23. always @(posedge clk) reset <= ~resetn;
  24.  
  25. // allow_in
  26. wire ID_allow_in;
  27. wire EX_allow_in;
  28. wire MEM_allow_in;
  29. wire WB_allow_in;
  30. //bus
  31. wire [63:0]IF_ID_bus;
  32. wire [150:0]ID_EX_bus;
  33. wire [70:0]EX_MEM_bus;
  34. wire [69:0]MEM_WB_bus;
  35. wire [32:0]br_bus;
  36. wire [37:0]WB_rf_bus;
  37. //valid
  38. wire IF_to_ID_valid;
  39. wire ID_to_EX_valid;
  40. wire EX_to_MEM_valid;
  41. wire MEM_to_WB_valid;
  42. //inst_bl
  43. wire inst_bl;
  44. IF_stage IF(
  45.     .clk(clk),
  46.     .reset(reset),
  47.     .ID_allow_in(ID_allow_in),
  48.     .br_bus(br_bus),
  49.     .inst_sram_en(inst_sram_en),
  50.     .inst_sram_we(inst_sran_we),
  51.     .inst_sram_addr(inst_sram_addr),
  52.     .inst_sram_wdata(inst_sram_wdata),
  53.     .inst_sram_rdata(inst_sram_rdata),
  54.     .IF_ID_bus(IF_ID_bus),
  55.     .IF_to_ID_valid(IF_to_ID_valid)
  56.     );
  57. ID_stage ID(
  58.    .clk(clk),
  59.    .reset(reset),
  60.    .EX_allow_in(EX_allow_in),
  61.    .IF_to_ID_valid(IF_to_ID_valid),
  62.    .IF_ID_bus(IF_ID_bus),
  63.    .WB_rf_bus(WB_rf_bus),
  64.    .ID_allow_in(ID_allow_in),
  65.    .br_bus(br_bus),
  66.    .ID_EX_bus(ID_EX_bus),
  67.    .ID_to_EX_valid(ID_to_EX_valid),
  68.    .to_EX_inst_bl(inst_bl)
  69.     );
  70. EX_stage EX(
  71.     .clk(clk),
  72.     .reset(reset),
  73.     .MEM_allow_in(MEM_allow_in),
  74.     .ID_to_EX_valid(ID_to_EX_valid),
  75.     .EX_allow_in(EX_allow_in),
  76.     .ID_EX_bus(ID_EX_bus),
  77.     .inst_bl(inst_bl),
  78.     .EX_MEM_bus(EX_MEM_bus),
  79.     .EX_to_MEM_valid(EX_to_MEM_valid),
  80.     .data_sram_en(data_sram_en),
  81.     .data_sram_we(data_sram_we),
  82.     .data_sram_addr(data_sram_addr),
  83.     .data_sram_wdata(data_sram_wdata)
  84. );
  85. MEM_stage MEM(
  86.     .clk(clk),
  87.     .reset(reset),
  88.     .WB_allow_in(WB_allow_in),
  89.     .MEM_allow_in(MEM_allow_in),
  90.     .EX_MEM_bus(EX_MEM_bus),
  91.     .data_sram_rdata(data_sram_rdata),
  92.     .EX_to_MEM_valid(EX_to_MEM_valid),    
  93.     .MEM_to_WB_valid(MEM_to_WB_valid),
  94.     .MEM_WB_bus(MEM_WB_bus)
  95.     );
  96. WB_stage WB(
  97.     .clk(clk),
  98.     .reset(reset),
  99.     .WB_allow_in(WB_allow_in),
  100.     .MEM_to_WB_valid(MEM_to_WB_valid),
  101.     .MEM_WB_bus(MEM_WB_bus),
  102.     .WB_rf_bus(WB_rf_bus),
  103.     .debug_wb_pc(debug_wb_pc) ,
  104.     .debug_wb_rf_we(debug_wb_rf_we),
  105.     .debug_wb_rf_wnum(debug_wb_rf_wnum),
  106.     .debug_wb_rf_wdata(debug_wb_rf_wdata)
  107.  
  108.     );
  109. endmodule

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/942004
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号