一、AHB总线学习

   1. AHB总线结构

         基于AHB总线的master读写设计(Verilog)-LMLPHP

    如图所示,AHB总线系统利用中央多路选择机制实现主机与从机的互联问题。从图中可以看出,AHB总线结构主要可分为三部分:主机、从机、控制部分。控制部分由仲裁器、数据多路选择、地址和数据多路选择及地址译码器组成。主机首先需要向仲裁器提出使用总线的请求hbusreq信号,仲裁器通过仲裁(多主机使用总线的优先级)授权(hgrant)给某一主机(注意:一个周期内只能有一个主机接入总线),此时,主机就可以开始进行AHB传输了。主机首先发出地址和控制信号。这些信号主要提供地址信息、传输方向、带宽及burst类型(burst传输并非本文重点,故不作讨论)。由于AHB总线统一给每个从机分配地址,译码器可以根据主机发出的地址选择哪个主机与从机进行互联。

2、AHB总线基本传输

        AHB总线的一次传输主要由两部分组成:地址段(开始传输的第一个周期)和数据段(传输开始后的周期)。在hclk上升沿来临时,获得授权的主机驱动地址和控制信号到AHB总线上,在hclk下一周期的上升沿时,slave开始采样地址和控制信息。获取地址和控制信息的slave会返回hresp(回应信号)给master,而在hclk的第三个时钟上升沿hresp被master采样,与此同时,master与slave间完成数据的第一次读写操作。

      在进行数据传输时,若从机没有准备好接收下一个数据iketongg将hready信号拉低来插入一个空闲周期,等下一周期hready重新为高时再接收数据。主机在当前周期发送完部分数据,而在下一周期没有准备好发后面的数据,可通过加入BUSY状态来延缓传输。

二、基于AHB总线的读写设计

   1、输入输出接口

          在设计某个模块时,首先需要理清它有哪些输入输出,从而对设计进行一个整体了解。由于本文的读写模块设计属于比较基础的AHB传输,不涉及突发传输、锁定传输和从机的分块传输。本设计的输入有:hclk_i、irst_n、hgrant_i、hrdata_i、hready_i,输出有:hwdata_o、htrans_o、hwrite_o、haddr_o、hbusreq_o。

   1、状态机设计

          状态机的设计比较重要,本设计的主状态机是:空闲状态、读状态、写状态,从状态机分为读状态机(rd_fsm_r)和写状态机(wr_fsm_r),读状态机和写状态机的状态转移图如图所示。

基于AHB总线的master读写设计(Verilog)-LMLPHP

 根据AHB总线地址段和数据段的特性,可将其分为:空闲状态、请求总线状态、地址段状态、读/写数据状态和读/写最后一个字节状态。注意:在状态机中,何时有效很重要,从图中可以看出,各状态的触发条件都有hready_i信号(由于hready_i信号是一直在变化的,可能前一个状态hready_i信号为高,但后一个状态会变低,不能使用软件思维去思考。),其次,何时开始读/写数据,何时数据读/写完成,这都是由计数器计数来决定的

  2、设计时序图

         读写过程比较类似,时序图如图所示:

          基于AHB总线的master读写设计(Verilog)-LMLPHP

 从图中可以看出,地址与数据并非在同一周期(AHB总线的特性)。当前周期的地址,存储的数据在下一周期才会出现。这种地址和数据交叠出现使总线能进行高性能操作的同时,给从机也提供了足够的时间来响应传输。

   3、基本代码

      (1)状态机逻辑

module ahb_test(hbusreq_o,haddr_o,htrans_o,hwdata_o,hwrite_o,
                           hclk_i,irst_n,hgrant_i,hready_i,hrdata_i,we_i,re_i);

   input  hclk_i,irst_n,we_i,re_i,hgrant_i,hready_i;
   input  [31:0] hrdata_i;
   output hbusreq_o,hwrite_o;
   output [31:0] hwdata_o;
   output [1:0] htrans_o;
   output [31:0] haddr_o;

   reg [1:0] main_fsm_r;
   reg [2:0] rd_fsm_r;
   reg [2:0] wr_fsm_r;
   reg  [31:0 haddr_r;
   reg [2:0] rd_cnt_r;
   reg [2:0] wr_cnt_r;

    parameter  data_size = 4; //读写4个字节数据
    parameter rd_base_addr = 'h1A00;
    parameter  wr_base_addr = 'h1B00;

//the status of main fsm
    parameter    S0 = 'd0;
    parameter    S1 = 'd1;
    parameter    S2 = 'd2;

//the status of read fsm
    parameter  RD_IDLE = 3'b000;
    parameter  RD_BUSREQ = 3'b001;
    parameter  RD_ADDR = 3'b010;
    parameter  RD_RD = 3'b011;
    parameter  RD_LRD = 3'b100;

     wire   fsm_rd_idle = rd_fsm_r == RD_IDLE;
     wire   fsm_rd_busreq = rd_fsm_r == RD_BUSREQ;
     wire   fsm_rd_addr =  rd_fsm_r ==RD_ADDR;
     wire   fsm_rd_rd =  rd_fsm_r == RD_RD;
     wire   fsm_rd_lrd = rd_fsm_r === RD_LRD;
     wire    rd_last_data = rd_cnt_r == data_size - 1'd1;

//the status of write fsm
    parameter  WR_IDLE = 3'b000;
    parameter  WR_BUSREQ = 3'b001;
    parameter  WR_ADDR = 3'b010;
    parameter  WR_WD = 3'b011;
    parameter  WR_LWD = 3'b100;

     wire   fsm_wr_idle = wr_fsm_r == WR_IDLE;
     wire   fsm_wr_busreq = wr_fsm_r == WR_BUSREQ;
     wire   fsm_wr_addr =  wr_fsm_r ==WR_ADDR;
     wire   fsm_wr_wd =  wr_fsm_r == WR_WD;
     wire   fsm_wr_lwd = wr_fsm_r === WR_LWD;
     wire    wr_last_data = wr_cnt_r == data_size - 1'd1;

//Main  FSM  
       wire rd_done;
       wire wr_done;
       reg we_r,re_r;
       reg  [1:0] main_fsm_r;

       always @(posedge hclk_i)
             if(~irst_n)
                main_fsm_r   <=S0;
              else
                 case(main_fsm_r)
                     S0: if(we_r | re_r)
                         main_fsm_r    <= S1;
                     S1: if(rd_done)
                          main_fsm_r   <=S2;
                     S2: if(wr_done)
                          main_fsm_r   <=S0;
                    default:
                          main_fsm_r   <= S0;
                  endcase

//Sub Read FSM
       always @(posedge hclk_i)
             if(~irst_n)
                rd_fsm_r   <= RD_IDLE;
             else
                 case(rd_fsm_r)
                    RD_IDLE : if((we_r | re_r) | (rd_done))
                              rd_fsm_r    <= RD_BUSREQ;
                    RD_BUSREQ : if(hgrant_i & hready_i)
                              rd_fsm_r    <= RD_ADDR;
                     RD_ADDR : if(hready_i)
                              rd_fsm_r    <= RD_RD;
                     RD_RD : if(rd_cnt_r == data_size-2 & hready_i)
                              rd_fsm_r    <= RD_LRD;
                     RD_LRD : if(hready_i & rd_last_data)
                              rd_fsm_r    <= RD_IDLE;
                       default:
                                rd_fsm_r    <= RD_IDLE;
                    endcase

//Sub Write FSM
       always @(posedge hclk_i)
             if(~irst_n)
                wr_fsm_r   <= WR_IDLE;
             else
                 case(wr_fsm_r)
                    WR_IDLE : if(rd_done)
                              wr_fsm_r    <= WR_BUSREQ;
                    WR_BUSREQ : if(hgrant_i & hready_i)
                              wr_fsm_r    <= WR_ADDR;
                     WR_ADDR : if(hready_i)
                              wr_fsm_r    <= WR_WD;
                     WR_WD : if(wr_cnt_r == data_size-2 & hready_i)
                              wr_fsm_r    <= WR_LWD;
                     WR_LWD : if(hready_i & wr_last_data)
                              wr_fsm_r    <= WR_IDLE;
                       default:
                                wr_fsm_r    <= WR_IDLE;
                    endcase

(2)寄存器逻辑

//we_r
always @(posedge hclk_i)
    if(~irst_n | we_r)
       we_r    <= 1'b0;
    else(we_i)
        we_r    <=1'b1;

//re_r
always @(posedge hclk_i)
    if(~irst_n | re_r)
       re_r    <= 1'b0;
    else(re_i)
        re_r    <=1'b1;

assign rd_done = main_fsm_r == S1 & hready_i & rd_last_data;

assign wr_done = main_fsm_r == S2 & hready_i & wr_last_data;

assign hwrite_o = (main_fsm_r == S2) ? 'd1 : 'd0;

assign  hbusreq_o = (fsm_rd_busreq || fsm_wr_busreq) ? 'd1 : 'd0;

//rd_done_r
always @(posedge hclk_i)
    if(~irst_n || rd_done_r)
        rd_done_r    <= 'd0;
    else if(rd_done)
         rd_done_r    <= 'd1;

//wr_done_r
always @(posedge hclk_i)
    if(~irst_n || wr_done_r)
        wr_done_r    <= 'd0;
    else if(wr_done)
         wr_done_r    <= 'd1;

assign  htrans_o = (fsm_rd_addr || fsm_wr_addr) ? 2'b10 : 2'b11;
wire  addr_add_en = (main_fsm_r == S1 || main_fsm_r == S2) &&
                   (fsm_rd_addr || fsm_rd_rd || fsm_wr_addr || fsm_wr_wd);

//haddr_r
always @(posedge hclk_i)
     if(~irst_n)
          haddr_r    <= 32'd0;
    else if(main_fsm_r == S1 & fsm_rd_busreq & hready_i)
           haddr_r    <= rd_base_addr;
    else if(main_fsm_r == S2 & fsm_wr_busreq & hready_i)
           haddr_r    <= wr_base_addr;
    else if(addr_add_en)
           haddr_r    <= haddr_r + 32'd4;


//rd_cnt_r
always @(posedge hclk_i)
     if (~irst_n)
          rd_cnt_r    <= 3'd0;
     else if (hready_i & fsm_rd_addr)
          rd_cnt_r    <= 3'd0;
     else if (hready_i & fsm_rd_rd)
          rd_cnt_r    <= rd_cnt_r + 1'd1;
      else if (hready_i & rd_last_data)
          rd_cnt_r    <= 3'd0;

//wr_cnt_r
always @(posedge hclk_i)
     if (~irst_n)
          wr_cnt_r    <= 3'd0;
     else if (hready_i & fsm_wr_addr)
          wr_cnt_r    <= 3'd0;
     else if (hready_i & fsm_wr_wd)
          wr_cnt_r    <= wr_cnt_r + 1'd1;
      else if (hready_i & wr_last_data)
          wr_cnt_r    <= 3'd0;

reg  [31:0] rd_data_r [ 0 : data_size-1];
//rd_data_r
always @(posedge hclk_i)
      if(~irst_n)
        {rd_data_r[0],rd_data_r[1],rd_data_r[2],rd_data_r[3]}  <= 32'd0;
      else if(main_fsm_r == S1 & (fsm_rd_rd || fsm_rd_lrd) & hready_i)
             rd_data_r    <= hrdata_i;

assign  hwdata_o = (main_fsm_r == S2 & (fsm_wr_wd || fsm_wr_lwd) & hready_i) ? rd_data_r[wr_cnt_r] : 32'b0;
assign  haddr_o = haddr_r;

endmodule

 至此,本文基于AHB总线的master读写设计就完成了。在设计过程中,重要的是画出状态机,并理解每个状态的逻辑及状态与状态间跳转的触发条件。需要理解阻塞赋值和非阻塞赋值。在这里说一下我对阻塞赋值和非阻塞赋值的理解:

(1)阻塞赋值(需要使用寄存器将值存储起来,使用always块赋值):当前周期时钟上升沿时存储值,下一周期时钟上升沿才会进行赋值操作。(和下一周期的时序也有关系)

(2)非阻塞赋值(组合逻辑,assign赋值):当前周期时钟上升沿赋值生效,不存储值。使用assign能实时给wire型信号赋值。(在当前周期完成操作)

模块输入输出一般都是wire型,内部逻辑可以是wire也可以是reg,一般先对一些内部逻辑信号进行各种操作,最后再将其赋值给输出信号。如本文assign haddr_o = haddr_r;中间对haddr_r进行操作,最后将其赋值给haddr_o。

   

10-22 01:33