[嵌入式]NICE的Verilog代码

一、端口说明

// System	
    input                         nice_clk             ,
    input                         nice_rst_n	          ,
    output                        nice_active	       ,
    output                        nice_mem_holdup	    ,//avoid memory read or write by other devices

    // Control cmd_req
    input                         nice_req_valid       ,//E203 send a nice request
    output                        nice_req_ready       ,//nice can receive request
    input  [`E203_XLEN-1:0]       nice_req_inst        ,//custom instruction
    input  [`E203_XLEN-1:0]       nice_req_rs1         ,//the register 1
    input  [`E203_XLEN-1:0]       nice_req_rs2         ,//the register 2

    // Control cmd_rsp	
    output                        nice_rsp_valid       ,//nice send response
    input                         nice_rsp_ready       ,//e203 can receive response
    output [`E203_XLEN-1:0]       nice_rsp_rdat        ,//compute result 
    output                        nice_rsp_err    	  ,  //nice has error

    // Memory lsu_req	
    output                        nice_icb_cmd_valid   ,//nice send a memory request
    input                         nice_icb_cmd_ready   ,//e203 can receive memory request
    output [`E203_ADDR_SIZE-1:0]  nice_icb_cmd_addr    ,//memory request address
    output                        nice_icb_cmd_read    ,//0:write 1:read 
    output [`E203_XLEN-1:0]       nice_icb_cmd_wdata   ,//write data request
    output [1:0]                  nice_icb_cmd_size    ,//00:byte 01:half-word 10:word 11:reserved
    
    // Memory lsu_rsp	
    input                         nice_icb_rsp_valid   ,//e203 send memory response
    output                        nice_icb_rsp_ready   ,//nice can receive memory
    input  [`E203_XLEN-1:0]       nice_icb_rsp_rdata   ,//the data read from memory
    input                         nice_icb_rsp_err	     //error during memory access

二、RISC-V的指令

其中opcode有4个可自行扩展

?NICE使用了custom3，如下

wire opcode_custom3 = (opcode == 7'b1111011); 

三、代码中的定义

1、指令相关

①

定义opcode为指令的{6->0},rv32_func3为{14->12}, rv32_func7为{31->25}

wire [6:0] opcode      = {7{nice_req_valid}} & nice_req_inst[6:0];  //nice_req_valid=1, op == construcion[6:0]
wire [2:0] rv32_func3  = {3{nice_req_valid}} & nice_req_inst[14:12];//nice_req_valid=1, func3 == construcion[14:12]
wire [6:0] rv32_func7  = {7{nice_req_valid}} & nice_req_inst[31:25];//nice_req_valid=1, func7 == construcion[31:25]

②

定义扩展模式custom3 = 7'h3b

wire opcode_custom3 = (opcode == 7'b1111011);

③

定义func3和func7相关

   wire rv32_func3_000 = (rv32_func3 == 3'b000); 
   wire rv32_func3_001 = (rv32_func3 == 3'b001); 
   wire rv32_func3_010 = (rv32_func3 == 3'b010); 
   wire rv32_func3_011 = (rv32_func3 == 3'b011); 
   wire rv32_func3_100 = (rv32_func3 == 3'b100); 
   wire rv32_func3_101 = (rv32_func3 == 3'b101); 
   wire rv32_func3_110 = (rv32_func3 == 3'b110); 
   wire rv32_func3_111 = (rv32_func3 == 3'b111); 

   wire rv32_func7_0000000 = (rv32_func7 == 7'b0000000); 
   wire rv32_func7_0000001 = (rv32_func7 == 7'b0000001); 
   wire rv32_func7_0000010 = (rv32_func7 == 7'b0000010); 
   wire rv32_func7_0000011 = (rv32_func7 == 7'b0000011); 
   wire rv32_func7_0000100 = (rv32_func7 == 7'b0000100); 
   wire rv32_func7_0000101 = (rv32_func7 == 7'b0000101); 
   wire rv32_func7_0000110 = (rv32_func7 == 7'b0000110); 
   wire rv32_func7_0000111 = (rv32_func7 == 7'b0000111); 

④

定义三条自定义指令在custom3情况下与func3、func7的关系

wire custom3_lbuf     = opcode_custom3 & rv32_func3_010 & rv32_func7_0000001;//the instrution is {7'h01,10'hxx,3'h2,5'hxx,7'h3b}
wire custom3_sbuf     = opcode_custom3 & rv32_func3_010 & rv32_func7_0000010;//the instrution is {7'h02,10'hxx,3'h2,5'hxx,7'h3b}
wire custom3_rowsum   = opcode_custom3 & rv32_func3_110 & rv32_func7_0000110;//the instrution is {7'h06,10'hxx,3'h2,5'hxx,7'h3b}

具体的来说，三条指令如下?

⑤

定义两个信号，分别代表协处理器指令和需要访问memory

  
   //  multi-cyc op 
   
   wire custom_multi_cyc_op = custom3_lbuf | custom3_sbuf | custom3_rowsum;//the instrution is made by nice
   // need access memory
   wire custom_mem_op = custom3_lbuf | custom3_sbuf | custom3_rowsum;//the instrution is made by nice and need memory 
 

2、状态机相关

①

状态机的4状态，空闲和三个指令

   parameter NICE_FSM_WIDTH = 2; 
   parameter IDLE     = 2'd0; 
   parameter LBUF     = 2'd1; 
   parameter SBUF     = 2'd2; 
   parameter ROWSUM   = 2'd3; 

②

定义现态和次态，以及四个状态的下个状态

   wire [NICE_FSM_WIDTH-1:0] state_r; 
   wire [NICE_FSM_WIDTH-1:0] nxt_state; 
   wire [NICE_FSM_WIDTH-1:0] state_idle_nxt; 
   wire [NICE_FSM_WIDTH-1:0] state_lbuf_nxt; 
   wire [NICE_FSM_WIDTH-1:0] state_sbuf_nxt; 
   wire [NICE_FSM_WIDTH-1:0] state_rowsum_nxt; 

③

定义现在是什么状态的四个信号

   wire state_is_idle     = (state_r == IDLE); 
   wire state_is_lbuf     = (state_r == LBUF); 
   wire state_is_sbuf     = (state_r == SBUF); 
   wire state_is_rowsum   = (state_r == ROWSUM); 

④

定义状态离开使能信号，四个状态的和真实状态的，共5个

   wire state_idle_exit_ena; 
   wire state_lbuf_exit_ena; 
   wire state_sbuf_exit_ena; 
   wire state_rowsum_exit_ena; 
   wire state_ena;

⑤

不知道干什么用的，illgel_instr为0代表是协处理器指令，为1代表不是

   wire nice_req_hsked;
   wire nice_rsp_hsked;
   wire nice_icb_rsp_hsked;
   wire illgel_instr = ~(custom_multi_cyc_op);

   wire lbuf_icb_rsp_hsked_last;
   wire sbuf_icb_rsp_hsked_last;
   wire rowsum_done;

四、功能

1、状态转换

①IDLE的次态选择

当指令为协处理器扩展的三条指令，则state_idle_nxt为相应的指令对应的状态，否则保持IDLE不变

   assign state_idle_nxt =  custom3_lbuf    ? LBUF   : 
                            custom3_sbuf    ? SBUF   :
                            custom3_rowsum  ? ROWSUM :
			    IDLE;

②

三个指令状态的次态，都为IDLE

assign state_lbuf_nxt = IDLE;
assign state_sbuf_nxt = IDLE;
assign state_rowsum_nxt = IDLE;

③

给状态离开使能信号赋值

当现态为IDLE，并且（nice_req_hsked)，并且当前为三指令之一，state_idle_exit_ena为高

assign state_idle_exit_ena = state_is_idle & nice_req_hsked & ~illgel_instr; 

现态为lbuf，并且(lbuf_icb_rsp_hsked_last)，state_lbuf_exit_ena为高

assign state_lbuf_exit_ena = state_is_lbuf & lbuf_icb_rsp_hsked_last;

现态为sbuf，并且(sbuf_icb_rsp_hsked_last)，state_sbuf_exit_ena为高

assign state_sbuf_exit_ena = state_is_sbuf & sbuf_icb_rsp_hsked_last;

现态为rowsum，并且rowsum_done为高，state_rowsum_exit_ena为高

assign state_rowsum_exit_ena = state_is_rowsum & rowsum_done;

④次态赋值

当前状态的离开使能为高时，为其对应的次态，否则为2'b00即IDLE

   assign nxt_state =   ({NICE_FSM_WIDTH{state_idle_exit_ena   }} & state_idle_nxt   )
                      | ({NICE_FSM_WIDTH{state_lbuf_exit_ena   }} & state_lbuf_nxt   ) 
                      | ({NICE_FSM_WIDTH{state_sbuf_exit_ena   }} & state_sbuf_nxt   ) 
                      | ({NICE_FSM_WIDTH{state_rowsum_exit_ena }} & state_rowsum_nxt ) 
                      ;

⑤

状态转换使能，为四个使能的或

   assign state_ena =   state_idle_exit_ena | state_lbuf_exit_ena 
                      | state_sbuf_exit_ena | state_rowsum_exit_ena;

⑥时序状态机

调用sirv_gnrl_dfflr，D触发器，实现状态机

sirv_gnrl_dfflr #(NICE_FSM_WIDTH)   state_dfflr 
    (state_ena, nxt_state, state_r, nice_clk, nice_rst_n);

2、一个lbuf的计数器

①信号定义

②信号赋值

1）已知assign nice_icb_rsp_hsked = nice_icb_rsp_valid & nice_icb_rsp_ready;并且nice_icb_rsp_ready is 1'b1 always，所以nice_icb_rsp_hsked = nice_icb_rsp_valid

所以lbuf_icb_rsp_hsked，当前状态为lbuf，储存响应握手

2）lbuf_icb_rsp_hsked_last，当前状态为lbuf，储存响应握手，计数为最后值

3）lbuf_cnt_last即计数到最后值，也就是lbuf_cnt_r为clonum2‘b10

4）已知assign nice_req_hsked = nice_req_valid & nice_req_ready;

所以lbuf_cnt_clr含义为当前指令为lbuf，命令请求握手

5）lbuf_cnt_incr为当前状态为lbuf，储存响应握手，计数值不是最后值

6）lbuf_cnt_ena，当前指令为lbuf，命令请求握手；或者当前状态lbuf，储存指令握手，计数值不是最后值

7）当前指令lbuf，命令请求握手，lbuf_cnt_nxt归零；当前状态lbuf，储存响应握手，计数值不是最后值，lbuf_cnt_nxt为lbuf_cnt_r+1

8）nice_rsp_valid_lbuf，当前状态为lbuf，计数值为最后值，E203发出储存响应信号

9）nice_icb_cmd_valid_lbuf，当前状态为lbuf，且现计数值小于最后值

   assign lbuf_icb_rsp_hsked = state_is_lbuf & nice_icb_rsp_hsked;
   assign lbuf_icb_rsp_hsked_last = lbuf_icb_rsp_hsked & lbuf_cnt_last;
   assign lbuf_cnt_last = (lbuf_cnt_r == clonum);
   assign lbuf_cnt_clr = custom3_lbuf & nice_req_hsked;
   assign lbuf_cnt_incr = lbuf_icb_rsp_hsked & ~lbuf_cnt_last;
   assign lbuf_cnt_ena = lbuf_cnt_clr | lbuf_cnt_incr;
   assign lbuf_cnt_nxt =   ({ROWBUF_IDX_W{lbuf_cnt_clr }} & {ROWBUF_IDX_W{1'b0}})
                         | ({ROWBUF_IDX_W{lbuf_cnt_incr}} & (lbuf_cnt_r + 1'b1) )
                         ;
   // nice_rsp_valid wait for nice_icb_rsp_valid in LBUF
   assign nice_rsp_valid_lbuf = state_is_lbuf & lbuf_cnt_last & nice_icb_rsp_valid;

   // nice_icb_cmd_valid sets when lbuf_cnt_r is not full in LBUF
   assign nice_icb_cmd_valid_lbuf = (state_is_lbuf & (lbuf_cnt_r < clonum));

③D触发器构成时序计数器

时钟：nice_clk ; 复位信号：nice_rst_n ; 使能信号：lbuf_cnt_ena ;

输入数据lbuf_cnt_nxt ； 输出数据：lbuf_cnt_r

  sirv_gnrl_dfflr #(ROWBUF_IDX_W)   lbuf_cnt_dfflr 
    (lbuf_cnt_ena, lbuf_cnt_nxt, lbuf_cnt_r, nice_clk, nice_rst_n);

3、sbuf计数器

①信号定义

②信号赋值

1）sbuf_icb_cmd_hsked，当前状态为sbuf，或（idle状态指令为sbuf)，储存请求握手成功

2）sbuf_icb_rsp_hsked，当前状态sbuf，储存响应握手

3）sbuf_icb_rsp_hsked_last，当前状态sbuf，储存响应握手，计数值为最后值

4）sbuf_cnt_last，计数值为最后值

5）sbuf_cnt_clr，就是sbuf_icb_rsp_hsked_last，当前状态sbuf，储存响应握手，计数值为最后值

6）sbuf_cnt_incr，当前状态sbuf，储存响应握手，计数值不是最后值

7）sbuf_cnt_ena，当前状态sbuf，储存响应握手

8）sbuf_cnt_nxt，当前状态sbuf，储存响应握手，（计数值为最后值则为2'b00；否则为现在计数值+1）

9）nice_rsp_valid_sbuf，当前状态sbuf，计数值为最后值，E203发出储存响应信号

   assign sbuf_icb_cmd_hsked = (state_is_sbuf | (state_is_idle & custom3_sbuf)) & nice_icb_cmd_hsked;
   assign sbuf_icb_rsp_hsked = state_is_sbuf & nice_icb_rsp_hsked;
   assign sbuf_icb_rsp_hsked_last = sbuf_icb_rsp_hsked & sbuf_cnt_last;
   assign sbuf_cnt_last = (sbuf_cnt_r == clonum);
   //assign sbuf_cnt_clr = custom3_sbuf & nice_req_hsked;
   assign sbuf_cnt_clr = sbuf_icb_rsp_hsked_last;
   assign sbuf_cnt_incr = sbuf_icb_rsp_hsked & ~sbuf_cnt_last;
   assign sbuf_cnt_ena = sbuf_cnt_clr | sbuf_cnt_incr;
   assign sbuf_cnt_nxt =   ({ROWBUF_IDX_W{sbuf_cnt_clr }} & {ROWBUF_IDX_W{1'b0}})
                         | ({ROWBUF_IDX_W{sbuf_cnt_incr}} & (sbuf_cnt_r + 1'b1) )
                         ;
   // nice_rsp_valid wait for nice_icb_rsp_valid in SBUF
   assign nice_rsp_valid_sbuf = state_is_sbuf & sbuf_cnt_last & nice_icb_rsp_valid;

③D触发器构成时序计数器

  sirv_gnrl_dfflr #(ROWBUF_IDX_W)   sbuf_cnt_dfflr 
    (sbuf_cnt_ena, sbuf_cnt_nxt, sbuf_cnt_r, nice_clk, nice_rst_n);

4、sbuf_cmd计数器

①信号定义

②信号赋值

1）sbuf_cmd_cnt_last，sbuf_cmd计数值为最后值

2）sbuf_cmd_cnt_clr，当前状态sbuf，储存响应握手，sbuf计数值为最后值

3）sbuf_cmd_cnt_incr，当前状态为sbuf，或（idle状态指令为sbuf)，储存请求握手成功，subf_cmd计数值不是最后值

4）sbuf_cmd_cnt_ena，（当前状态sbuf，储存响应握手，sbuf计数值为最后值）或（当前状态为sbuf，或（idle状态指令为sbuf)，储存请求握手成功，subf_cmd计数值不是最后值）

5）sbuf_cmd_cnt_nxt，当前状态sbuf，储存响应握手，sbuf计数为最后值，为2'b00；当前状态为sbuf，或（idle状态指令为sbuf)，储存请求握手成功，sbuf_cmd计数值不是最后值，为sbuf_cmd_cnt_r+1

6）nice_icb_cmd_valid_sbuf，当前状态sbuf，sbuf_cmd小于等于最后值，sbuf不等于最后值

   assign sbuf_cmd_cnt_last = (sbuf_cmd_cnt_r == clonum);
   assign sbuf_cmd_cnt_clr = sbuf_icb_rsp_hsked_last;
   assign sbuf_cmd_cnt_incr = sbuf_icb_cmd_hsked & ~sbuf_cmd_cnt_last;
   assign sbuf_cmd_cnt_ena = sbuf_cmd_cnt_clr | sbuf_cmd_cnt_incr;
   assign sbuf_cmd_cnt_nxt =   ({ROWBUF_IDX_W{sbuf_cmd_cnt_clr }} & {ROWBUF_IDX_W{1'b0}})
                             | ({ROWBUF_IDX_W{sbuf_cmd_cnt_incr}} & (sbuf_cmd_cnt_r + 1'b1) )
                             ;
   // nice_icb_cmd_valid sets when sbuf_cmd_cnt_r is not full in SBUF
   assign nice_icb_cmd_valid_sbuf = (state_is_sbuf & (sbuf_cmd_cnt_r <= clonum) & (sbuf_cnt_r != clonum));

③D触发器构成时序计数器

   sirv_gnrl_dfflr #(ROWBUF_IDX_W)   sbuf_cmd_cnt_dfflr 
    (sbuf_cmd_cnt_ena, sbuf_cmd_cnt_nxt, sbuf_cmd_cnt_r, nice_clk, nice_rst_n);

5、rowsum的rowbuf counter

①信号定义

   wire [ROWBUF_IDX_W-1:0] rowbuf_cnt_r; 
   wire [ROWBUF_IDX_W-1:0] rowbuf_cnt_nxt; 
   wire rowbuf_cnt_clr;
   wire rowbuf_cnt_incr;
   wire rowbuf_cnt_ena;
   wire rowbuf_cnt_last;
   wire rowbuf_icb_rsp_hsked;
   wire rowbuf_rsp_hsked;
   wire nice_rsp_valid_rowsum;

②信号赋值

   assign rowbuf_rsp_hsked = nice_rsp_valid_rowsum & nice_rsp_ready;
   assign rowbuf_icb_rsp_hsked = state_is_rowsum & nice_icb_rsp_hsked;
   assign rowbuf_cnt_last = (rowbuf_cnt_r == clonum);
   assign rowbuf_cnt_clr = rowbuf_icb_rsp_hsked & rowbuf_cnt_last;
   assign rowbuf_cnt_incr = rowbuf_icb_rsp_hsked & ~rowbuf_cnt_last;
   assign rowbuf_cnt_ena = rowbuf_cnt_clr | rowbuf_cnt_incr;
   assign rowbuf_cnt_nxt =   ({ROWBUF_IDX_W{rowbuf_cnt_clr }} & {ROWBUF_IDX_W{1'b0}})
                           | ({ROWBUF_IDX_W{rowbuf_cnt_incr}} & (rowbuf_cnt_r + 1'b1))
                           ;

③D触发器构成时序计数器

  sirv_gnrl_dfflr #(ROWBUF_IDX_W)   rowbuf_cnt_dfflr 
    (rowbuf_cnt_ena, rowbuf_cnt_nxt, rowbuf_cnt_r, nice_clk, nice_rst_n);

6、rowsum的recieve data buffer

①信号定义

   wire rcv_data_buf_ena;
   wire rcv_data_buf_set;
   wire rcv_data_buf_clr;
   wire rcv_data_buf_valid;
   wire [`E203_XLEN-1:0] rcv_data_buf; 
   wire [ROWBUF_IDX_W-1:0] rcv_data_buf_idx; 
   wire [ROWBUF_IDX_W-1:0] rcv_data_buf_idx_nxt; 

②信号赋值

   assign rcv_data_buf_set = rowbuf_icb_rsp_hsked;
   assign rcv_data_buf_clr = rowbuf_rsp_hsked;
   assign rcv_data_buf_ena = rcv_data_buf_clr | rcv_data_buf_set;
   assign rcv_data_buf_idx_nxt =   ({ROWBUF_IDX_W{rcv_data_buf_clr}} & {ROWBUF_IDX_W{1'b0}})
                                 | ({ROWBUF_IDX_W{rcv_data_buf_set}} & rowbuf_cnt_r        );

③D触发器构成时序计数器

第一个是使能信号的一个时钟延迟

第二个是输入数据的缓冲

第三个是对rowbuf写入的序号

  sirv_gnrl_dfflr #(1)   rcv_data_buf_valid_dfflr 
    (1'b1, rcv_data_buf_ena, rcv_data_buf_valid, nice_clk, nice_rst_n);
  sirv_gnrl_dfflr #(`E203_XLEN)   rcv_data_buf_dfflr 
    (rcv_data_buf_ena, nice_icb_rsp_rdata, rcv_data_buf, nice_clk, nice_rst_n);
  sirv_gnrl_dfflr #(ROWBUF_IDX_W)   rowbuf_cnt_d_dfflr 
    (rcv_data_buf_ena, rcv_data_buf_idx_nxt, rcv_data_buf_idx, nice_clk, nice_rst_n);

7、rowsum的累加

①信号定义

   wire [`E203_XLEN-1:0] rowsum_acc_r;
   wire [`E203_XLEN-1:0] rowsum_acc_nxt;
   wire [`E203_XLEN-1:0] rowsum_acc_adder;
   wire rowsum_acc_ena;
   wire rowsum_acc_set;
   wire rowsum_acc_flg;
   wire nice_icb_cmd_valid_rowsum;
   wire [`E203_XLEN-1:0] rowsum_res;

②信号赋值

2）rowsum_acc_flg，rcv_data_buf_idx非零，且上个周期的状态为rowsum时（储存响应握手或E203发出nice_rsp_ready信号）

   assign rowsum_acc_set = rcv_data_buf_valid & (rcv_data_buf_idx == {ROWBUF_IDX_W{1'b0}});
   assign rowsum_acc_flg = rcv_data_buf_valid & (rcv_data_buf_idx != {ROWBUF_IDX_W{1'b0}});
   assign rowsum_acc_adder = rcv_data_buf + rowsum_acc_r;
   assign rowsum_acc_ena = rowsum_acc_set | rowsum_acc_flg;
   assign rowsum_acc_nxt =   ({`E203_XLEN{rowsum_acc_set}} & rcv_data_buf)
                           | ({`E203_XLEN{rowsum_acc_flg}} & rowsum_acc_adder)
                           ;
   assign rowsum_done = state_is_rowsum & nice_rsp_hsked;
   assign rowsum_res  = rowsum_acc_r;

   // rowsum finishes when the last acc data is added to rowsum_acc_r  
   assign nice_rsp_valid_rowsum = state_is_rowsum & (rcv_data_buf_idx == clonum) & ~rowsum_acc_flg;

   // nice_icb_cmd_valid sets when rcv_data_buf_idx is not full in LBUF
   assign nice_icb_cmd_valid_rowsum = state_is_rowsum & (rcv_data_buf_idx < clonum) & ~rowsum_acc_flg;

③D触发器构成时序

累加的时序操作

   sirv_gnrl_dfflr #(`E203_XLEN)   rowsum_acc_dfflr 
    (rowsum_acc_ena, rowsum_acc_nxt, rowsum_acc_r, nice_clk, nice_rst_n);

8、rowbuf

rowbuf是数据缓存，lbuf和rowsum会写入，sbuf会读出

①信号定义

②信号赋值

写入的选择

1）lbuf_idx，写入序号选择，为lbuf_cnt_r，即lbuf计数的时序输出，当前的计数值，从0到2

2）lbuf_wr，写入使能，为lbuf_icb_rsp_hsked，即当前状态为lbuf，储存响应握手

3）lbuf_wdata，写入数据，外部输入的从memory读取的数据

4）rowsum_dix，写入序号选择，为rcv_data_buf_idx，当前的计数值，从0到2

5）rowsum_wr，写入使能，为rcv_data_buf-valid，是rcv_data_buf_ena缓冲一个时钟

6）rowsum_wdata，写入数据，为rowbuf_r当前数据与rcv_data_buf的加和

7）rowbuf_idx_mux，写入序号选择，若lbuf_wr为高，则为luf_idx，若rowsum_wr为高，则为rowsum_dix

8）rowbuf_wr_mux，写入使能选择，lbuf_wr与rowsum_wr的或

9）rowbuf_wdat_mux，写入数据选择

// lbuf write to rowbuf
   wire [ROWBUF_IDX_W-1:0] lbuf_idx = lbuf_cnt_r; 
   wire lbuf_wr = lbuf_icb_rsp_hsked; 
   wire [`E203_XLEN-1:0] lbuf_wdata = nice_icb_rsp_rdata;

// rowsum write to rowbuf(column accumulated data)
   wire [ROWBUF_IDX_W-1:0] rowsum_idx = rcv_data_buf_idx; 
   wire rowsum_wr = rcv_data_buf_valid; 
   wire [`E203_XLEN-1:0] rowsum_wdata = rowbuf_r[rowsum_idx] + rcv_data_buf;   

// rowbuf write mux
   assign rowbuf_wdat_mux =   ({`E203_XLEN{lbuf_wr  }} & lbuf_wdata  )
                            | ({`E203_XLEN{rowsum_wr}} & rowsum_wdata)
                            ;
   assign rowbuf_wr_mux   =  lbuf_wr | rowsum_wr;
   assign rowbuf_idx_mux  =   ({ROWBUF_IDX_W{lbuf_wr  }} & lbuf_idx  )
                            | ({ROWBUF_IDX_W{rowsum_wr}} & rowsum_idx)
                            ;  

③D触发器构成时序

实例化4个32位的D触发器

1）rowbuf_we为使能信号，为rowbuf_wr_mux与一个表达式的与，i的低2位与rowbuf_idx_mux相等才可以

2）rowbuf_wdat为输入数据，使能时为rowbuf_wdat_mux

   // rowbuf inst
   genvar i;
   generate 
     for (i=0; i<ROWBUF_DP; i=i+1) begin:gen_rowbuf
       assign rowbuf_we[i] =   (rowbuf_wr_mux & (rowbuf_idx_mux == i[ROWBUF_IDX_W-1:0]))
                             ;
  
       assign rowbuf_wdat[i] =   ({`E203_XLEN{rowbuf_we[i]}} & rowbuf_wdat_mux   )
                               ;
  
       sirv_gnrl_dfflr #(`E203_XLEN) rowbuf_dfflr (rowbuf_we[i], rowbuf_wdat[i], rowbuf_r[i], nice_clk, nice_rst_n);
     end
   endgenerate

9、memory的地址

①信号说明

1）nice_icb_cmd_hsked，储存请求握手②信号赋值

2）lbuf_maddr_ena，（当前状态为idle，命令为lbuf，并且储存请求握手）或（当前状态lbuf，储存请求握手）

3）sbuf_maddr_ena，（当前状态为idle，命令为sbuf，并且储存请求握手）或（当前状态sbuf，储存请求握手）

4）rowsum_maddr_ena，（当前状态为idle，命令为rowsum，并且储存请求握手）或（当前状态rowsum，储存请求握手）

5）maddr_ena，（当前状态为idle，命令有效，并且储存请求握手）或（当前状态非idle，储存请求握手）

6）maddr_ena_idle，当前状态为idle，命令为有效，并且储存请求握手

7）maddr_acc_op1，当前状态为idle，命令为有效，并且储存请求握手，为寄存器1值，否则为maddr_acc_r

8）maddr_acc_op2，32/8 = 4，所以每次要加4

9）maddr_acc_next，下一个地址，为当前地址+4

10）maddr_acc_ena，为（当前状态为idle，命令有效，并且储存请求握手）或（当前状态非idle，储存请求握手）

assign nice_icb_cmd_hsked = nice_icb_cmd_valid & nice_icb_cmd_ready; 
   // custom3_lbuf 
   //wire [`E203_XLEN-1:0] lbuf_maddr    = state_is_idle ? nice_req_rs1 : maddr_acc_r ; 
   wire lbuf_maddr_ena    =   (state_is_idle & custom3_lbuf & nice_icb_cmd_hsked)
                            | (state_is_lbuf & nice_icb_cmd_hsked)
                            ;

   // custom3_sbuf 
   //wire [`E203_XLEN-1:0] sbuf_maddr    = state_is_idle ? nice_req_rs1 : maddr_acc_r ; 
   wire sbuf_maddr_ena    =   (state_is_idle & custom3_sbuf & nice_icb_cmd_hsked)
                            | (state_is_sbuf & nice_icb_cmd_hsked)
                            ;

   // custom3_rowsum
   //wire [`E203_XLEN-1:0] rowsum_maddr  = state_is_idle ? nice_req_rs1 : maddr_acc_r ; 
   wire rowsum_maddr_ena  =   (state_is_idle & custom3_rowsum & nice_icb_cmd_hsked)
                            | (state_is_rowsum & nice_icb_cmd_hsked)
                            ;

   // maddr acc 
   //wire  maddr_incr = lbuf_maddr_ena | sbuf_maddr_ena | rowsum_maddr_ena | rbuf_maddr_ena;
   wire  maddr_ena = lbuf_maddr_ena | sbuf_maddr_ena | rowsum_maddr_ena;
   wire  maddr_ena_idle = maddr_ena & state_is_idle;

   wire [`E203_XLEN-1:0] maddr_acc_op1 = maddr_ena_idle ? nice_req_rs1 : maddr_acc_r; // not reused
   wire [`E203_XLEN-1:0] maddr_acc_op2 = maddr_ena_idle ? `E203_XLEN'h4 : `E203_XLEN'h4; 

   wire [`E203_XLEN-1:0] maddr_acc_next = maddr_acc_op1 + maddr_acc_op2;
   wire  maddr_acc_ena = maddr_ena;

③ D触发器

使能信号：maddr_acc_ena，输入数据：maddr_acc_next，输出：maddr_acc_r

sirv_gnrl_dfflr #(`E203_XLEN)   maddr_acc_dfflr 
    (maddr_acc_ena, maddr_acc_next, maddr_acc_r, nice_clk, nice_rst_n);

10、请求响应的信号

1）nice_req_hsked，命令请求握手

2）nice_req_ready，nice发出的命令请求握手信号，当前状态是idle，且指令有效，则为nice_icb_cmd_ready，否则为1'b1

3）nice_rsp_hsked，命令响应握手

4）nice_icb_rsp_hsked，储存响应握手

5）nice_rsp_valid，（当前状态lbuf，lbuf计数值为最后值，E203发出储存响应信号）或（当前状态sbuf，sbuf计数值为最后值，E203发出储存响应信号）或（当前状态rowsum，rcv_data_buf_idx计数值为最后值，rowsum_acc_flg为低）或（rcv_data_buf_idx非零，且上个周期的状态为rowsum时（储存响应握手或E203发出nice_rsp_ready信号））

6）nice_rsp_rdat，当前状态为rowsum时为rowsum_res

7）nice_rsp_err，储存响应握手且在访问memory时出错

   // Control cmd_req
   
   assign nice_req_hsked = nice_req_valid & nice_req_ready;
   assign nice_req_ready = state_is_idle & (custom_mem_op ? nice_icb_cmd_ready : 1'b1);

   
   // Control cmd_rsp
   
   assign nice_rsp_hsked = nice_rsp_valid & nice_rsp_ready; 
   assign nice_icb_rsp_hsked = nice_icb_rsp_valid & nice_icb_rsp_ready;
   assign nice_rsp_valid = nice_rsp_valid_rowsum | nice_rsp_valid_sbuf | nice_rsp_valid_lbuf;
   assign nice_rsp_rdat  = {`E203_XLEN{state_is_rowsum}} & rowsum_res;

   // memory access bus error
   //assign nice_rsp_err_irq  =   (nice_icb_rsp_hsked & nice_icb_rsp_err)
   //                          | (nice_req_hsked & illgel_instr)
   //                          ; 
   assign nice_rsp_err   =   (nice_icb_rsp_hsked & nice_icb_rsp_err);

11、memory相关

1）nice_icb_rsp_ready始终为1'b1

2）sbuf_idx为subf_cmd_cnt_r

3）nice_icb_cmd_valid，（当前状态为idle且E203发出nice_req_valid且指令有效）或（状态lbuf，lbuf计数值小于最后值）或（状态sbuf，sbuf_cmd小于等于最后值且sbuf计数值不是最后值）或（状态rowsum，rcv_data_buf计数值小于最后值，且（rcv_data_buf_idx非零，且上个周期的状态为rowsum时（储存响应握手或E203发出nice_rsp_ready信号））

4）nice_icb_cmd_addr，（状态idle且命令有效）为寄存器1，否则为maddr_acc_r

5）nice_icb_cmd_read，（状态idle且为lbuf或rowsumz指令，为1，为sbuf指令，为0），或者为sbuf状态为0，否则为1

6）nice_icb_cmd_wdata，（状态idle，sbuf指令）或subf状态，为rowbuf_r[sbuf_idx]，否则为0

7）nice_icb_cmd_size，为2，代表4字节32位宽数据

8）nice_mem_holdup，为非idle状态，访问memory锁

 // rsp always ready
   assign nice_icb_rsp_ready = 1'b1; 
   wire [ROWBUF_IDX_W-1:0] sbuf_idx = sbuf_cmd_cnt_r; 

   assign nice_icb_cmd_valid =   (state_is_idle & nice_req_valid & custom_mem_op)
                              | nice_icb_cmd_valid_lbuf
                              | nice_icb_cmd_valid_sbuf
                              | nice_icb_cmd_valid_rowsum
                              ;
   assign nice_icb_cmd_addr  = (state_is_idle & custom_mem_op) ? nice_req_rs1 :
                              maddr_acc_r;
   assign nice_icb_cmd_read  = (state_is_idle & custom_mem_op) ? (custom3_lbuf | custom3_rowsum) : 
                              state_is_sbuf ? 1'b0 : 
                              1'b1;
   assign nice_icb_cmd_wdata = (state_is_idle & custom3_sbuf) ? rowbuf_r[sbuf_idx] :
                              state_is_sbuf ? rowbuf_r[sbuf_idx] : 
                              `E203_XLEN'b0; 

   //assign nice_icb_cmd_wmask = {`sirv_XLEN_MW{custom3_sbuf}} & 4'b1111;
   assign nice_icb_cmd_size  = 2'b10;
   assign nice_mem_holdup    =  state_is_lbuf | state_is_sbuf | state_is_rowsum; 

创作挑战赛

新人创作奖励来咯，坚持创作打卡瓜分现金大奖