Subversion Repositories wb2axi4

//Author     : Alex Zhang (cgzhangwei@gmail.com)
//Date       : 03-11-2015
`include "wb2axi_parameters.vh"
module axi2wb (
axi_clk,
wb_clk,
axi_resetn,
wb_resetn,
ENABLE,
AXI_IF,
WB_TX_IF
);
parameter AXI_ID_W         = `WB2AXI_AXI_ID_W   ;
parameter AXI_ADDR_W       = `WB2AXI_AXI_ADDR_W ;
parameter AXI_DATA_W       = `WB2AXI_AXI_DATA_W ;
parameter AXI_PROT_W       = `WB2AXI_AXI_PROT_W ;
parameter AXI_STB_W        = `WB2AXI_AXI_STB_W  ;
parameter AXI_LEN_W        = `WB2AXI_AXI_LEN_W  ;
parameter AXI_SIZE_W       = `WB2AXI_AXI_SIZE_W ;
parameter AXI_BURST_W      = `WB2AXI_AXI_BURST_W;
parameter AXI_LOCK_W       = `WB2AXI_AXI_LOCK_W ;
parameter AXI_CACHE_W      = `WB2AXI_AXI_CACHE_W;
parameter AXI_RESP_W       = `WB2AXI_AXI_RESP_W ;

parameter FIFO_ADDR_DEPTH_W = 10;
parameter FIFO_ADDR_W       = AXI_ID_W+AXI_ADDR_W+AXI_PROT_W+AXI_LEN_W+AXI_SIZE_W+AXI_BURST_W+AXI_LOCK_W+AXI_CACHE_W+1;
parameter FIFO_DATA_DEPTH_W = 11;
parameter FIFO_DATA_W       = AXI_ID_W+AXI_DATA_W+AXI_STB_W+2;

parameter WB_ADR_W          = 32;
parameter WB_DAT_W          = 32;
parameter WB_TGA_W          = 8;
parameter WB_TGD_W          = 8;
parameter WB_TGC_W          = 4;
parameter WB_SEL_W          = 4;
parameter WB_CTI_W          = 3;
parameter WB_BTE_W          = 2;

localparam SRAM_UNUSED_ADDR_W= 4;
localparam AXI_MAX_RESP_W    = 4;
localparam FA_SRAM_UNUSED_ADDR_W = 1;
localparam FD_SRAM_UNUSED_ADDR_W = 1;
input  wire             axi_clk;
input  wire             wb_clk;
input  wire             axi_resetn;
input  wire             wb_resetn;
input  wire             ENABLE;
axi_if.target           AXI_IF;
wishbone_if.master      WB_TX_IF;

sram_if #(.DATA_W(32), .ADDR_W(11))  dat_sram_tx();
sram_if #(.DATA_W(64), .ADDR_W(10))  adr_sram_tx();

wire                   sync_ENABLE_axi;
wire                   sync_ENABLE_wb ;
wire                   fifo_adr_full  ;
wire                   fifo_dat_full  ;
wire [FIFO_DATA_W-1:0] fifo_dat_rdata ;
wire [FIFO_ADDR_W-1:0] fifo_adr_rdata ;

sync_doble_ff #(.DATA_W(1)) I_SYNC_ENABLE_AXI (
  .CLK              (           axi_clk ),
  .RESET_N          (        axi_resetn ),
  .DIN              (            ENABLE ),
  .DOUT             (   sync_ENABLE_axi )
);
sync_doble_ff #(.DATA_W(1)) I_SYNC_ENABLE_WB (
  .CLK              (            wb_clk ),
  .RESET_N          (         wb_resetn ),
  .DIN              (            ENABLE ),
  .DOUT             (   sync_ENABLE_wb  )
);
wire [FIFO_ADDR_W-1:0]  fifo_addr_info;
wire [FIFO_DATA_W-1:0]  fifo_data_info;
wire                    fifo_addr_wr  ;
wire                    fifo_data_wr  ;
wire [FIFO_ADDR_W-1:0]  fifo_adr_wdata;
wire [FIFO_DATA_W-1:0]  fifo_dat_wdata;

axi_ingress #(
      .AXI_ID_W        (    AXI_ID_W    ),
      .AXI_ADDR_W      (    AXI_ADDR_W   ),
      .AXI_DATA_W      (    AXI_DATA_W   ),
      .AXI_PROT_W      (    AXI_PROT_W   ),
      .AXI_STB_W       (    AXI_STB_W    ),
      .AXI_LEN_W       (    AXI_LEN_W    ),
      .AXI_SIZE_W      (    AXI_SIZE_W   ),
      .AXI_BURST_W     (    AXI_BURST_W  ),
      .AXI_LOCK_W      (    AXI_LOCK_W   ),
      .AXI_CACHE_W     (    AXI_CACHE_W  ),
      .AXI_RESP_W      (    AXI_RESP_W   ),
      .AXI_MAX_RESP_W  ( AXI_MAX_RESP_W  ),
      .FIFO_DAT_W      (   FIFO_DATA_W   ),
      .FIFO_ADR_W      (   FIFO_ADDR_W   )
) I_AXI_INGRESS (
  .axi_clk        ( axi_clk       ),
  .reset_n        ( axi_resetn    ),
  .AXI_IF         ( AXI_IF        ),
  .fifo_full      ( fifo_full     ),
  .fifo_addr_info ( fifo_addr_info),
  .fifo_data_info ( fifo_data_info),
  .fifo_addr_wr   ( fifo_addr_wr  ),
  .fifo_data_wr   ( fifo_data_wr  )
);

assign fifo_full  = fifo_adr_full | fifo_dat_full;

async_fifo #(
  .FIFO_DEPTH_W      (FIFO_ADDR_DEPTH_W),
  .FIFO_W            (FIFO_ADDR_W),
  .SRAM_UNUSED_ADDR_W(FA_SRAM_UNUSED_ADDR_W)
) I_FIFO_ADR (
  .wrclk_RESET_N    (      axi_resetn ),
  .rdclk_RESET_N    (       wb_resetn ),
  .wr_en            ( sync_ENABLE_axi ),
  .rd_en            ( sync_ENABLE_wb  ),
  .fifo_wr_clk      (         axi_clk ),
  .fifo_rd_clk      (         wb_clk  ),
  .fifo_wr          (     fifo_adr_wr ),
  .fifo_rd          (     fifo_adr_rd ),
  .fifo_wdata       (  fifo_adr_wdata ),
  .fifo_rdata       (  fifo_adr_rdata ),
  .fifo_empty       (  fifo_adr_empty ),
  .fifo_full        (   fifo_adr_full ),
  .fifo_level       (                 ),
  .SRAM_IF          (     adr_sram_tx )
);
wire    adr_sram_enable;
wire    adr_sram_wr;
wire [FIFO_ADDR_W-1:0] adr_sram_din;
wire [FIFO_ADDR_W-1:0] adr_sram_dout;
wire [FIFO_ADDR_DEPTH_W-1:0] adr_sram_addr;
sram_model #(
  .MEM_ADDR_W  (FIFO_ADDR_DEPTH_W),
  .MEM_DATA_W  (FIFO_ADDR_W)
) SRAM_ADR_1phc1024x32mx4tn(
  .CLK(axi_clk        ),
  .NCE(adr_sram_enable),
  .NWRT(adr_sram_wr   ),
  .NOE(1'b0           ),
  .DIN(adr_sram_din   ),
  .ADDR(adr_sram_addr ),
  .DOUT(adr_sram_dout )
);
assign adr_sram_enable   = adr_sram_tx.rd_l | adr_sram_tx.wr_l;
assign adr_sram_wr       = adr_sram_tx.wr_l;
assign adr_sram_din      = adr_sram_tx.wdata;
assign adr_sram_addr     = ~adr_sram_tx.wr_l ? adr_sram_tx.wr_address : adr_sram_tx.rd_address;
assign adr_sram_tx.rdata = adr_sram_dout;

assign fifo_adr_wr    = fifo_addr_wr;
assign fifo_adr_wdata = fifo_addr_info;
async_fifo #(
  .FIFO_DEPTH_W      (FIFO_DATA_DEPTH_W),
  .FIFO_W            (FIFO_DATA_W),
  .SRAM_UNUSED_ADDR_W(FD_SRAM_UNUSED_ADDR_W)
) I_FIFO_DAT (
  .wrclk_RESET_N    (      axi_resetn ),
  .rdclk_RESET_N    (       wb_resetn ),
  .wr_en            ( sync_ENABLE_axi ),
  .rd_en            ( sync_ENABLE_wb  ),
  .fifo_wr_clk      (         axi_clk ),
  .fifo_rd_clk      (         wb_clk  ),
  .fifo_wr          (     fifo_dat_wr ),
  .fifo_rd          (     fifo_dat_rd ),
  .fifo_wdata       (  fifo_dat_wdata ),
  .fifo_rdata       (  fifo_dat_rdata ),
  .fifo_empty       (  fifo_dat_empty ),
  .fifo_full        (   fifo_dat_full ),
  .fifo_level       (                 ),
  .SRAM_IF          (     dat_sram_tx )
);
wire    dat_sram_enable; 
wire    dat_sram_wr; 
wire [FIFO_DATA_W-1:0]       dat_sram_din;
wire [FIFO_DATA_W-1:0]       dat_sram_dout;
wire [FIFO_DATA_DEPTH_W-1:0] dat_sram_addr;
sram_model #(
  .MEM_ADDR_W  (FIFO_DATA_DEPTH_W),
  .MEM_DATA_W  (FIFO_DATA_W)
) SRAM_DAT_1phc1024x32mx4tn(
  .CLK(axi_clk        ),
  .NCE(dat_sram_enable),
  .NWRT(dat_sram_wr   ),
  .NOE(1'b0           ),
  .DIN(dat_sram_din   ),
  .ADDR(dat_sram_addr),
  .DOUT(dat_sram_dout)
);
assign dat_sram_enable   = dat_sram_tx.rd_l | dat_sram_tx.wr_l;
assign dat_sram_wr       = dat_sram_tx.wr_l;
assign dat_sram_din      = dat_sram_tx.wdata;
assign dat_sram_addr     = ~dat_sram_tx.wr_l ? dat_sram_tx.wr_address : dat_sram_tx.rd_address;
assign dat_sram_tx.rdata = dat_sram_dout;


assign fifo_dat_wr    = fifo_data_wr;
assign fifo_dat_wdata = fifo_data_info;
wb_egress #(   
  .WB_ADR_W   (WB_ADR_W   ),  
  .WB_DAT_W   (WB_DAT_W   ),  
  .WB_TGA_W   (WB_TGA_W   ),  
  .WB_TGD_W   (WB_TGD_W   ),  
  .WB_TGC_W   (WB_TGC_W   ),  
  .WB_SEL_W   (WB_SEL_W   ),  
  .WB_CTI_W   (WB_CTI_W   ),  
  .WB_BTE_W   (WB_BTE_W   ),  
  .AXI_ID_W   (AXI_ID_W   ),  
  .AXI_ADDR_W (AXI_ADDR_W ),  
  .AXI_LEN_W  (AXI_LEN_W  ),  
  .AXI_SIZE_W (AXI_SIZE_W ),  
  .AXI_BURST_W(AXI_BURST_W),  
  .AXI_LOCK_W (AXI_LOCK_W ),  
  .AXI_CACHE_W(AXI_CACHE_W),  
  .AXI_PROT_W (AXI_PROT_W ),  
  .AXI_DATA_W (AXI_DATA_W ),  
  .AXI_STB_W  (AXI_STB_W )  
) I_WB_EGRESS(
  .wb_clk         ( wb_clk         ),
  .wb_resetn      ( wb_resetn      ),
  .ENABLE         ( sync_ENABLE_wb ),
  .WB_TX_IF       ( WB_TX_IF       ),
  .fifo_adr_rdata ( fifo_adr_rdata ),
  .fifo_adr_rd    ( fifo_adr_rd    ),
  .fifo_adr_empty ( fifo_adr_empty ),
  .fifo_dat_rdata ( fifo_dat_rdata ),
  .fifo_dat_rd    ( fifo_dat_rd    ),
  .fifo_dat_empty ( fifo_dat_empty )
);

endmodule