axi_tdl 0.0.15 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fe093880be9872cf37e3a6b02b859ebc7310754fb3230b2fe3930ee8a5f5bed
-  data.tar.gz: d91966e9e6afe30412e01ee25fe8a1ad10a583858b00f8f82fdd27154120a102
+  metadata.gz: '048d045e78b400e945ff441c154ef78f8073619c51a1547e84526cb9345d72f4'
+  data.tar.gz: baa90f99cf5d67251033740eb77a6314a74b445520159da7fba098d57cffd7f7
 SHA512:
-  metadata.gz: 80a0a155eabaaedfea21850addd3bb1f3004bfa8c6e07ede885c2041e6ccb1c8f58a7c1a11131c0fb3c9d9b7405750a13d11c8a8a62cde1b71d063dcbd6336ec
-  data.tar.gz: 0c0987911528b7fb91740ad6b606998a85dcab0f5cdf381f76192343121806129d83e6573cd526fdae47ed11439085b4996ff98df1f53a59a54353618eb04489
+  metadata.gz: 95f82468aeffc02b0c0bc09574d9805eef139180474f02a736fb85f8081a874947eb9d4730ebca7197e5d2051c9d8c73f8404b2732d1b3810eab9e4ffbf4cd71
+  data.tar.gz: ec8a233a0df4d3b6f47f4a5078f08ee538acf7153e09c62d0cba18f4e95bcecfca253c211cfa298d51d3486686bb9c487a3e5cbc45b41d2f699c90ac5c36d95a

data/.github/workflows/gem-push.yml

@@ -35,8 +35,10 @@ jobs:
         mkdir -p $HOME/.gem
         touch $HOME/.gem/credentials
         chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${RUBYGEMS_API_KEY}\n" > $HOME/.gem/credentials
         gem build *.gemspec
         gem push *.gem
       env:
-        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          RUBYGEMS_API_KEY: ${{secrets.RUBYGEMS_API_KEY}}
+          # RELEASE_COMMAND: rake release

data/Rakefile

@@ -12,3 +12,10 @@ Rake::TestTask.new(:test) do |t|
     # t.ruby_opts = ["-c"]
     # t.verbose = true
 end
+
+desc "编译TB"
+task :tb do 
+    require_relative "./lib/axi_tdl.rb"
+    puts AxiTdl::VERSION
+    require_relative "./lib/axi/techbench/tb_axi_stream_split_channel.rb"
+end

data/axi_tdl.gemspec

@@ -1,4 +1,3 @@
-
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "axi_tdl/version"

data/lib/axi/AXI4/axi4_direct_A1.sv

@@ -53,7 +53,7 @@ initial begin
     case(MODE)
     "BOTH_to_BOTH","BOTH_to_ONLY_READ","BOTH_to_ONLY_WRITE":
         assert(slaver.MODE =="BOTH")
-        else $error("SLAVER AXIS MODE<%s> != BOTH",slaver.MODE);
+        else $error("SLAVER AXIS MODE<%0s> != BOTH",slaver.MODE);
     "ONLY_READ_to_BOTH":
         assert(slaver.MODE == "ONLY_READ")
         else $error("SLAVER AXIS MODE != ONLY_READ");

data/lib/axi/AXI4/axi4_direct_B1.sv

@@ -12,61 +12,61 @@ madified:
 (* axi4 = "true" *)
 module axi4_direct_B1 (
     (* up_stream = "true" *)
-    axi_inf.slaver      slaver,
+    axi_inf.slaver      slaver_inf,
     (* down_stream = "true" *)
-    axi_inf.master      master
+    axi_inf.master      master_inf
 );
 
 
 generate
-if(slaver.MODE == "ONLY_READ" && master.MODE == "ONLY_READ")
+if(slaver_inf.MODE == "ONLY_READ" && master_inf.MODE == "ONLY_READ")
 axi4_direct_A1 #(
     .MODE   ("ONLY_READ_to_ONLY_READ")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_ONLY_READ_to_ONLY_READ(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "ONLY_READ" && master.MODE == "BOTH")
+else if(slaver_inf.MODE == "ONLY_READ" && master_inf.MODE == "BOTH")
 axi4_direct_A1 #(
     .MODE   ("ONLY_READ_to_BOTH")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_ONLY_READ_to_BOTH(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "ONLY_WRITE" && master.MODE == "BOTH")
+else if(slaver_inf.MODE == "ONLY_WRITE" && master_inf.MODE == "BOTH")
 axi4_direct_A1 #(
     .MODE   ("ONLY_WRITE_to_BOTH")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_ONLY_WRITE_to_BOTH(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "ONLY_WRITE" && master.MODE == "ONLY_WRITE")
+else if(slaver_inf.MODE == "ONLY_WRITE" && master_inf.MODE == "ONLY_WRITE")
 axi4_direct_A1 #(
     .MODE   ("ONLY_WRITE_to_ONLY_WRITE")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_ONLY_WRITE_to_ONLY_WRITE(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "BOTH" && master.MODE == "ONLY_WRITE")
+else if(slaver_inf.MODE == "BOTH" && master_inf.MODE == "ONLY_WRITE")
 axi4_direct_A1 #(
     .MODE   ("BOTH_to_ONLY_WRITE")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_BOTH_to_ONLY_WRITE(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "BOTH" && master.MODE == "ONLY_READ")
+else if(slaver_inf.MODE == "BOTH" && master_inf.MODE == "ONLY_READ")
 axi4_direct_A1 #(
     .MODE   ("BOTH_to_ONLY_READ")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_BOTH_to_ONLY_READ(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
-else if(slaver.MODE == "BOTH" && master.MODE == "BOTH")
+else if(slaver_inf.MODE == "BOTH" && master_inf.MODE == "BOTH")
 axi4_direct_A1 #(
     .MODE   ("BOTH_to_BOTH")    //ONLY_READ to BOTH,ONLY_WRITE to BOTH,BOTH to BOTH,BOTH to ONLY_READ,BOTH to ONLY_WRITE
 )axi4_direct_inst_BOTH_to_BOTH(
-/*  axi_inf.slaver */     .slaver   (slaver ),
-/*  axi_inf.master */     .master   (master )
+/*  axi_inf.slaver */     .slaver   (slaver_inf ),
+/*  axi_inf.master */     .master   (master_inf )
 );
 
 endgenerate

data/lib/axi/AXI4/axi4_direct_verc.sv

@@ -25,9 +25,9 @@ module axi4_direct_verc #(
     `parameter_string IGNORE_LSIZE = "FALSE"    //(* show = "false" *)
 )(
     (* axi4_up = "true" *)
-    axi_inf.slaver      slaver,
+    axi_inf.slaver      slaver_inf,
     (* axi4_down = "true" *)
-    axi_inf.master      master
+    axi_inf.master      master_inf
 );
 
 
@@ -36,60 +36,60 @@ import SystemPkg::*;
 initial begin
     #(1us);
     if(IGNORE_IDSIZE == "FALSE")begin
-        assert(slaver.IDSIZE <= master.IDSIZE)      //idsize of slaver can be smaller thane master's
+        assert(slaver_inf.IDSIZE <= master_inf.IDSIZE)      //idsize of slaver_inf can be smaller thane master_inf's
         else begin
             $error("SLAVER AXIS IDSIZE != MASTER AXIS IDSIZE");
             $finish;
         end
     end
     if(IGNORE_DSIZE == "FALSE")begin
-        assert(slaver.DSIZE == master.DSIZE)
+        assert(slaver_inf.DSIZE == master_inf.DSIZE)
         else $error("SLAVER AXIS DSIZE != MASTER AXIS DSIZE");
     end
     if(IGNORE_ASIZE == "FALSE")begin
-        assert(slaver.ASIZE == master.ASIZE)
+        assert(slaver_inf.ASIZE == master_inf.ASIZE)
         else $error("SLAVER AXIS ASIZE != MASTER AXIS ASIZE");
     end
     if(IGNORE_LSIZE == "FALSE")begin
-        assert(slaver.LSIZE == master.LSIZE)
+        assert(slaver_inf.LSIZE == master_inf.LSIZE)
         else $error("SLAVER AXIS LSIZE != MASTER AXIS LSIZE");
     end
     case(MODE)
     "BOTH_to_BOTH","BOTH_to_ONLY_READ","BOTH_to_ONLY_WRITE":
-        assert(slaver.MODE =="BOTH" && SLAVER_MODE=="BOTH")
-        else $error("SLAVER AXIS MODE<%s> != BOTH",slaver.MODE);
+        assert(slaver_inf.MODE =="BOTH" && SLAVER_MODE=="BOTH")
+        else $error("SLAVER AXIS MODE<%s> != BOTH",slaver_inf.MODE);
     "ONLY_READ_to_BOTH":
-        assert(slaver.MODE == "ONLY_READ" && SLAVER_MODE=="ONLY_READ")
+        assert(slaver_inf.MODE == "ONLY_READ" && SLAVER_MODE=="ONLY_READ")
         else $error("SLAVER AXIS MODE != ONLY_READ");
     "ONLY_WRITE_to_BOTH","ONLY_WRITE_to_ONLY_WRITE":
-        assert(slaver.MODE == "ONLY_WRITE" && SLAVER_MODE=="ONLY_WRITE")
+        assert(slaver_inf.MODE == "ONLY_WRITE" && SLAVER_MODE=="ONLY_WRITE")
         else begin
             $error("SLAVER AXIS MODE != ONLY_WRITE");
             $finish;
         end
     "ONLY_READ_to_ONLY_READ":
-        assert(slaver.MODE == "ONLY_READ" && SLAVER_MODE=="ONLY_READ")
+        assert(slaver_inf.MODE == "ONLY_READ" && SLAVER_MODE=="ONLY_READ")
         else $error("SLAVER AXIS MODE != ONLY_READ");
     default:
-        assert(slaver.MODE == "_____")
+        assert(slaver_inf.MODE == "_____")
         else $error("SLAVER AXIS MODE ERROR")  ;
     endcase
 
     case(MODE)
     "ONLY_WRITE_to_BOTH","ONLY_READ_to_BOTH","BOTH_to_BOTH":
-        assert(master.MODE == "BOTH" && MASTER_MODE=="BOTH")
+        assert(master_inf.MODE == "BOTH" && MASTER_MODE=="BOTH")
         else $error("MASTER AXIS MODE != BOTH");
     "BOTH_to_ONLY_READ":
-        assert(master.MODE == "ONLY_READ" && MASTER_MODE=="ONLY_READY")
+        assert(master_inf.MODE == "ONLY_READ" && MASTER_MODE=="ONLY_READY")
         else $error("MASTER AXIS MODE != ONLY_READ");
     "BOTH_to_ONLY_WRITE","ONLY_WRITE_to_ONLY_WRITE":
-        assert(master.MODE == "ONLY_WRITE" && MASTER_MODE=="ONLY_WRITE")
+        assert(master_inf.MODE == "ONLY_WRITE" && MASTER_MODE=="ONLY_WRITE")
         else $error("MASTER AXIS MODE != ONLY_WRITE");
     "ONLY_READ_to_ONLY_READ":
-        assert(master.MODE == "ONLY_READ" && MASTER_MODE=="ONLY_READ")
+        assert(master_inf.MODE == "ONLY_READ" && MASTER_MODE=="ONLY_READ")
         else $error("MASTER AXIS MODE != ONLY_READ");
     default:
-        assert(master.MODE == "_____")
+        assert(master_inf.MODE == "_____")
         else $error("MASTER AXIS MODE ERROR");
     endcase
 
@@ -97,49 +97,49 @@ end
 
 generate
     if(MASTER_MODE!="ONLY_READ")begin
-        assign master.axi_awid     = slaver.axi_awid   ;
-        assign master.axi_awaddr   = slaver.axi_awaddr ;
-        assign master.axi_awlen    = slaver.axi_awlen  ;
-        assign master.axi_awsize   = slaver.axi_awsize ;
-        assign master.axi_awburst  = slaver.axi_awburst;
-        assign master.axi_awlock   = slaver.axi_awlock ;
-        assign master.axi_awcache  = slaver.axi_awcache;
-        assign master.axi_awprot   = slaver.axi_awprot ;
-        assign master.axi_awqos    = slaver.axi_awqos  ;
-        assign master.axi_awvalid  = slaver.axi_awvalid;
-        assign slaver.axi_awready  = master.axi_awready;
-        assign master.axi_wdata    = slaver.axi_wdata  ;
-        assign master.axi_wstrb    = slaver.axi_wstrb  ;
-        assign master.axi_wlast    = slaver.axi_wlast  ;
-        assign master.axi_wvalid   = slaver.axi_wvalid ;
-        assign slaver.axi_wready   = master.axi_wready ;
-        assign master.axi_bready   = slaver.axi_bready ;
-        assign slaver.axi_bid      = master.axi_bid    ;
-        assign slaver.axi_bresp    = master.axi_bresp  ;
-        assign slaver.axi_bvalid   = master.axi_bvalid ;
+        assign master_inf.axi_awid     = slaver_inf.axi_awid   ;
+        assign master_inf.axi_awaddr   = slaver_inf.axi_awaddr ;
+        assign master_inf.axi_awlen    = slaver_inf.axi_awlen  ;
+        assign master_inf.axi_awsize   = slaver_inf.axi_awsize ;
+        assign master_inf.axi_awburst  = slaver_inf.axi_awburst;
+        assign master_inf.axi_awlock   = slaver_inf.axi_awlock ;
+        assign master_inf.axi_awcache  = slaver_inf.axi_awcache;
+        assign master_inf.axi_awprot   = slaver_inf.axi_awprot ;
+        assign master_inf.axi_awqos    = slaver_inf.axi_awqos  ;
+        assign master_inf.axi_awvalid  = slaver_inf.axi_awvalid;
+        assign slaver_inf.axi_awready  = master_inf.axi_awready;
+        assign master_inf.axi_wdata    = slaver_inf.axi_wdata  ;
+        assign master_inf.axi_wstrb    = slaver_inf.axi_wstrb  ;
+        assign master_inf.axi_wlast    = slaver_inf.axi_wlast  ;
+        assign master_inf.axi_wvalid   = slaver_inf.axi_wvalid ;
+        assign slaver_inf.axi_wready   = master_inf.axi_wready ;
+        assign master_inf.axi_bready   = slaver_inf.axi_bready ;
+        assign slaver_inf.axi_bid      = master_inf.axi_bid    ;
+        assign slaver_inf.axi_bresp    = master_inf.axi_bresp  ;
+        assign slaver_inf.axi_bvalid   = master_inf.axi_bvalid ;
     end
 endgenerate
 
 
 generate
     if(MASTER_MODE!="ONLY_WRITE")begin
-        assign master.axi_arid     = slaver.axi_arid   ;
-        assign master.axi_araddr   = slaver.axi_araddr ;
-        assign master.axi_arlen    = slaver.axi_arlen  ;
-        assign master.axi_arsize   = slaver.axi_arsize ;
-        assign master.axi_arburst  = slaver.axi_arburst;
-        assign master.axi_arlock   = slaver.axi_arlock ;
-        assign master.axi_arcache  = slaver.axi_arcache;
-        assign master.axi_arprot   = slaver.axi_arprot ;
-        assign master.axi_arqos    = slaver.axi_arqos  ;
-        assign master.axi_arvalid  = slaver.axi_arvalid;
-        assign slaver.axi_arready  = master.axi_arready;
-        assign master.axi_rready   = slaver.axi_rready ;
-        assign slaver.axi_rid      = master.axi_rid    ;
-        assign slaver.axi_rdata    = master.axi_rdata  ;
-        assign slaver.axi_rresp    = master.axi_rresp  ;
-        assign slaver.axi_rlast    = master.axi_rlast  ;
-        assign slaver.axi_rvalid   = master.axi_rvalid ;
+        assign master_inf.axi_arid     = slaver_inf.axi_arid   ;
+        assign master_inf.axi_araddr   = slaver_inf.axi_araddr ;
+        assign master_inf.axi_arlen    = slaver_inf.axi_arlen  ;
+        assign master_inf.axi_arsize   = slaver_inf.axi_arsize ;
+        assign master_inf.axi_arburst  = slaver_inf.axi_arburst;
+        assign master_inf.axi_arlock   = slaver_inf.axi_arlock ;
+        assign master_inf.axi_arcache  = slaver_inf.axi_arcache;
+        assign master_inf.axi_arprot   = slaver_inf.axi_arprot ;
+        assign master_inf.axi_arqos    = slaver_inf.axi_arqos  ;
+        assign master_inf.axi_arvalid  = slaver_inf.axi_arvalid;
+        assign slaver_inf.axi_arready  = master_inf.axi_arready;
+        assign master_inf.axi_rready   = slaver_inf.axi_rready ;
+        assign slaver_inf.axi_rid      = master_inf.axi_rid    ;
+        assign slaver_inf.axi_rdata    = master_inf.axi_rdata  ;
+        assign slaver_inf.axi_rresp    = master_inf.axi_rresp  ;
+        assign slaver_inf.axi_rlast    = master_inf.axi_rlast  ;
+        assign slaver_inf.axi_rvalid   = master_inf.axi_rvalid ;
     end
 endgenerate
 

data/lib/axi/AXI4/axi4_dpram_cache.sv

@@ -5,7 +5,7 @@ _______________________________________
 descript:
 author : Cook.Darwin
 Version: VERA.0.0
-created: xxxx.xx.xx
+creaded: XXXX.XX.XX
 madified:
 ***********************************************/
 `timescale 1ns/1ps
@@ -20,7 +20,7 @@ module axi4_dpram_cache #(
 //==========================================================================
 //-------- define ----------------------------------------------------------
 
-cm_ram_inf #(.DSIZE(a_inf.DSIZE),.RSIZE(a_inf.ASIZE),.MSIZE( a_inf.DSIZE/8)) xram_inf();
+cm_ram_inf #(.DSIZE(a_inf.DSIZE),.RSIZE(a_inf.ASIZE),.MSIZE((a_inf.DSIZE / 8))) xram_inf();
 axi_stream_inf #(.DSIZE(a_inf.ASIZE+a_inf.DSIZE+1),.USIZE(1)) a_axis_inf (.aclk(a_inf.axi_aclk),.aresetn(a_inf.axi_aresetn),.aclken(1'b1)) ;
 axi_stream_inf #(.DSIZE(a_inf.DSIZE),.USIZE(1)) a_axis_rd_inf (.aclk(a_inf.axi_aclk),.aresetn(a_inf.axi_aresetn),.aclken(1'b1)) ;
 data_inf_c #(.DSIZE(a_inf.ASIZE+1)) a_datac_rd_inf (.clock(a_inf.axi_aclk),.rst_n(a_inf.axi_aresetn)) ;
@@ -69,44 +69,44 @@ common_ram_wrapper #(
 //==========================================================================
 //-------- expression ------------------------------------------------------
 initial begin
-    assert( a_inf.ASIZE==b_inf.ASIZE)else begin
-         $error("a_inf.ASIZE != b_inf.ASIZE");
-         $stop;
+    assert(a_inf.ASIZE==b_inf.ASIZE)else begin
+        $error("a_inf.ASIZE != b_inf.ASIZE");
+        $stop;
     end
-    assert( a_inf.DSIZE==b_inf.DSIZE)else begin
-         $error("a_inf.ASIZE != b_inf.ASIZE");
-         $stop;
+    assert(a_inf.DSIZE==b_inf.DSIZE)else begin
+        $error("a_inf.ASIZE != b_inf.ASIZE");
+        $stop;
     end
 end
 
-assign  a_axis_inf.axis_tready = a_axis_inf.axis_tdata[ a_inf.ASIZE+a_inf.DSIZE+1-1] || (a_datac_rd_inf.ready && !a_axis_inf.axis_tdata[ a_inf.ASIZE+a_inf.DSIZE+1-1]);
-assign  a_datac_rd_inf.data = {a_axis_inf.axis_tlast,a_axis_inf.axis_tdata[ ( a_inf.ASIZE+a_inf.DSIZE+1-1)-1: ( a_inf.ASIZE+a_inf.DSIZE+1-a_inf.ASIZE)-1]};
-assign  a_datac_rd_inf.valid = a_axis_inf.axis_tvalid && !a_axis_inf.axis_tdata[ a_inf.ASIZE+a_inf.DSIZE+1-1];
+assign a_axis_inf.axis_tready = a_axis_inf.axis_tdata[a_inf.ASIZE+a_inf.DSIZE+1-1] || (a_datac_rd_inf.ready && !a_axis_inf.axis_tdata[a_inf.ASIZE+a_inf.DSIZE+1-1]);
+assign a_datac_rd_inf.data = {a_axis_inf.axis_tlast,a_axis_inf.axis_tdata[(a_inf.ASIZE+a_inf.DSIZE+1-1)-1:(a_inf.ASIZE+a_inf.DSIZE+1-a_inf.ASIZE)-1]};
+assign a_datac_rd_inf.valid = a_axis_inf.axis_tvalid && !a_axis_inf.axis_tdata[a_inf.ASIZE+a_inf.DSIZE+1-1];
 
-assign  a_axis_rd_inf.axis_tvalid = a_datac_rd_rel_inf.valid;
-assign  a_axis_rd_inf.axis_tdata = a_datac_rd_rel_inf.data[ a_inf.DSIZE-1:0];
-assign  a_axis_rd_inf.axis_tlast = a_datac_rd_rel_inf.data[ a_inf.ASIZE+a_inf.DSIZE+1-1];
-assign  a_datac_rd_rel_inf.ready = a_axis_rd_inf.axis_tready;
-assign  xram_inf.addra = a_axis_inf.axis_tdata[ ( a_inf.ASIZE+a_inf.DSIZE+1-1)-1: ( a_inf.ASIZE+a_inf.DSIZE+1-a_inf.ASIZE)-1];
-assign  xram_inf.dia = a_axis_inf.axis_tdata[ a_inf.DSIZE-1:0];
-assign  xram_inf.wea = {xram_inf.MSIZE{a_axis_inf.axis_tdata[ a_inf.ASIZE+a_inf.DSIZE+1-1]}};
-assign  xram_inf.ena = 1'b1;
-assign  xram_inf.clka = a_inf.axi_aclk;
-assign  xram_inf.rsta = ~a_inf.axi_aresetn;
+assign a_axis_rd_inf.axis_tvalid = a_datac_rd_rel_inf.valid;
+assign a_axis_rd_inf.axis_tdata = a_datac_rd_rel_inf.data[a_inf.DSIZE-1:0];
+assign a_axis_rd_inf.axis_tlast = a_datac_rd_rel_inf.data[a_inf.ASIZE+a_inf.DSIZE+1-1];
+assign a_datac_rd_rel_inf.ready = a_axis_rd_inf.axis_tready;
+assign xram_inf.addra = a_axis_inf.axis_tdata[(a_inf.ASIZE+a_inf.DSIZE+1-1)-1:(a_inf.ASIZE+a_inf.DSIZE+1-a_inf.ASIZE)-1];
+assign xram_inf.dia = a_axis_inf.axis_tdata[a_inf.DSIZE-1:0];
+assign xram_inf.wea = {xram_inf.MSIZE{a_axis_inf.axis_tdata[a_inf.ASIZE+a_inf.DSIZE+1-1]}};
+assign xram_inf.ena = 1'b1;
+assign xram_inf.clka = a_inf.axi_aclk;
+assign xram_inf.rsta = ~a_inf.axi_aresetn;
 
-assign  b_axis_inf.axis_tready = b_axis_inf.axis_tdata[ b_inf.ASIZE+b_inf.DSIZE+1-1] || (b_datac_rd_inf.ready && !b_axis_inf.axis_tdata[ b_inf.ASIZE+b_inf.DSIZE+1-1]);
-assign  b_datac_rd_inf.data = {b_axis_inf.axis_tlast,b_axis_inf.axis_tdata[ ( b_inf.ASIZE+b_inf.DSIZE+1-1)-1: ( b_inf.ASIZE+b_inf.DSIZE+1-b_inf.ASIZE)-1]};
-assign  b_datac_rd_inf.valid = b_axis_inf.axis_tvalid && !b_axis_inf.axis_tdata[ b_inf.ASIZE+b_inf.DSIZE+1-1];
+assign b_axis_inf.axis_tready = b_axis_inf.axis_tdata[b_inf.ASIZE+b_inf.DSIZE+1-1] || (b_datac_rd_inf.ready && !b_axis_inf.axis_tdata[b_inf.ASIZE+b_inf.DSIZE+1-1]);
+assign b_datac_rd_inf.data = {b_axis_inf.axis_tlast,b_axis_inf.axis_tdata[(b_inf.ASIZE+b_inf.DSIZE+1-1)-1:(b_inf.ASIZE+b_inf.DSIZE+1-b_inf.ASIZE)-1]};
+assign b_datac_rd_inf.valid = b_axis_inf.axis_tvalid && !b_axis_inf.axis_tdata[b_inf.ASIZE+b_inf.DSIZE+1-1];
 
-assign  b_axis_rd_inf.axis_tvalid = b_datac_rd_rel_inf.valid;
-assign  b_axis_rd_inf.axis_tdata = b_datac_rd_rel_inf.data[ b_inf.DSIZE-1:0];
-assign  b_axis_rd_inf.axis_tlast = b_datac_rd_rel_inf.data[ b_inf.ASIZE+b_inf.DSIZE+1-1];
-assign  b_datac_rd_rel_inf.ready = b_axis_rd_inf.axis_tready;
-assign  xram_inf.addrb = b_axis_inf.axis_tdata[ ( b_inf.ASIZE+b_inf.DSIZE+1-1)-1: ( b_inf.ASIZE+b_inf.DSIZE+1-b_inf.ASIZE)-1];
-assign  xram_inf.dib = b_axis_inf.axis_tdata[ b_inf.DSIZE-1:0];
-assign  xram_inf.web = {xram_inf.MSIZE{b_axis_inf.axis_tdata[ b_inf.ASIZE+b_inf.DSIZE+1-1]}};
-assign  xram_inf.enb = 1'b1;
-assign  xram_inf.clkb = b_inf.axi_aclk;
-assign  xram_inf.rstb = ~b_inf.axi_aresetn;
+assign b_axis_rd_inf.axis_tvalid = b_datac_rd_rel_inf.valid;
+assign b_axis_rd_inf.axis_tdata = b_datac_rd_rel_inf.data[b_inf.DSIZE-1:0];
+assign b_axis_rd_inf.axis_tlast = b_datac_rd_rel_inf.data[b_inf.ASIZE+b_inf.DSIZE+1-1];
+assign b_datac_rd_rel_inf.ready = b_axis_rd_inf.axis_tready;
+assign xram_inf.addrb = b_axis_inf.axis_tdata[(b_inf.ASIZE+b_inf.DSIZE+1-1)-1:(b_inf.ASIZE+b_inf.DSIZE+1-b_inf.ASIZE)-1];
+assign xram_inf.dib = b_axis_inf.axis_tdata[b_inf.DSIZE-1:0];
+assign xram_inf.web = {xram_inf.MSIZE{b_axis_inf.axis_tdata[b_inf.ASIZE+b_inf.DSIZE+1-1]}};
+assign xram_inf.enb = 1'b1;
+assign xram_inf.clkb = b_inf.axi_aclk;
+assign xram_inf.rstb = ~b_inf.axi_aresetn;
 
 endmodule

data/lib/axi/AXI4/axis_to_axi4_wr.rb

@@ -6,6 +6,7 @@ require_hdl 'axis_length_split_with_addr.sv'
 require_hdl 'axi_stream_long_fifo.sv'
 require_hdl 'axi4_wr_auxiliary_gen_without_resp.sv'
 require_hdl 'axis_valve_with_pipe.sv'
+require_hdl 'independent_clock_fifo.sv'
 
 new_m = SdlModule.new(name:File.basename(__FILE__,".rb"),out_sv_path:__dir__)
 

data/lib/axi/AXI4/axis_to_axi4_wr.sv

@@ -5,7 +5,7 @@ _______________________________________
 descript:
 author : Cook.Darwin
 Version: VERA.0.0
-created: xxxx.xx.xx
+creaded: XXXX.XX.XX
 madified:
 ***********************************************/
 `timescale 1ns/1ps
@@ -56,7 +56,7 @@ logic stream_en;
 axi_stream_inf #(.DSIZE(axis_in.DSIZE),.USIZE(1)) split_out (.aclk(axis_in.aclk),.aresetn(axis_in.aresetn),.aclken(1'b1)) ;
 axi_stream_inf #(.DSIZE(axis_in.DSIZE),.USIZE(1)) long_fifo_axis_out (.aclk(axi_wr.axi_aclk),.aresetn(axi_wr.axi_aresetn),.aclken(1'b1)) ;
 axi_stream_inf #(.DSIZE(axi_wr.IDSIZE + axi_wr.ASIZE + axi_wr.LSIZE),.USIZE(1)) id_add_len_in (.aclk(axi_wr.axi_aclk),.aresetn(axi_wr.axi_aresetn),.aclken(1'b1)) ;
-axi_inf #(.DSIZE(axi_wr.DSIZE),.IDSIZE(axi_wr.IDSIZE),.ASIZE(axi_wr.ASIZE),.LSIZE(axi_wr.LSIZE),.MODE(axi_wr.MODE),.ADDR_STEP(axi_wr.ADDR_STEP)) axi_wr_vcs_cp_R1264 (.axi_aclk(axi_wr.axi_aclk),.axi_aresetn(axi_wr.axi_aresetn)) ;
+axi_inf #(.DSIZE(axi_wr.DSIZE),.IDSIZE(axi_wr.IDSIZE),.ASIZE(axi_wr.ASIZE),.LSIZE(axi_wr.LSIZE),.MODE(axi_wr.MODE),.ADDR_STEP(axi_wr.ADDR_STEP)) axi_wr_vcs_cp_R186 (.axi_aclk(axi_wr.axi_aclk),.axi_aresetn(axi_wr.axi_aresetn)) ;
 axi_stream_inf #(.DSIZE(axis_in.DSIZE),.USIZE(1)) pipe_axis (.aclk(axi_wr.axi_aclk),.aresetn(axi_wr.axi_aresetn),.aclken(1'b1)) ;
 //==========================================================================
 //-------- instance --------------------------------------------------------
@@ -92,16 +92,16 @@ independent_clock_fifo #(
 /* output */.full     (fifo_full                                                              )
 );
 axi4_wr_auxiliary_gen_without_resp axi4_wr_auxiliary_gen_without_resp_inst(
-/* output                        */.stream_en     (stream_en           ),
-/* axi_stream_inf.slaver         */.id_add_len_in (id_add_len_in       ),
-/* axi_inf.master_wr_aux_no_resp */.axi_wr_aux    (axi_wr_vcs_cp_R1264 )
+/* output                        */.stream_en     (stream_en          ),
+/* axi_stream_inf.slaver         */.id_add_len_in (id_add_len_in      ),
+/* axi_inf.master_wr_aux_no_resp */.axi_wr_aux    (axi_wr_vcs_cp_R186 )
 );
 vcs_axi4_comptable #(
     .ORIGIN ("master_wr_aux_no_resp" ),
     .TO     ("master_wr"             )
-)vcs_axi4_comptable_axi_wr_aux_R858_axi_wr_inst(
-/* input  */.origin (axi_wr_vcs_cp_R1264 ),
-/* output */.to     (axi_wr              )
+)vcs_axi4_comptable_axi_wr_aux_R282_axi_wr_inst(
+/* input  */.origin (axi_wr_vcs_cp_R186 ),
+/* output */.to     (axi_wr             )
 );
 axis_valve_with_pipe #(
     .MODE ("BOTH" )
@@ -112,30 +112,30 @@ axis_valve_with_pipe #(
 );
 //==========================================================================
 //-------- expression ------------------------------------------------------
-always_ff@(posedge axis_in.aclk,negedge axis_in.aresetn) begin 
+always@(posedge axis_in.aclk,negedge axis_in.aresetn) begin 
     if(~axis_in.aresetn)begin
-         id <= 0;
+        id <= 0;
     end
     else if(split_out.axis_tvalid && split_out.axis_tready && split_out.axis_tlast)begin
-         id <= ( id+1);
+        id <= (id+1);
     end
     else begin
-         id <= id;
+        id <= id;
     end
 end
 
-assign  addr_s = addr_cur;
-assign  len_s = split_out.axis_tcnt;
-assign  id_add_len_in.axis_tvalid = ~fifo_empty;
-assign  id_add_len_in.axis_tdata = fifo_rdata;
-assign  id_add_len_in.axis_tlast = "1'b1";
-assign  rd_en = id_add_len_in.axis_tready;
+assign addr_s = addr_cur;
+assign len_s = split_out.axis_tcnt;
+assign id_add_len_in.axis_tvalid = ~fifo_empty;
+assign id_add_len_in.axis_tdata = fifo_rdata;
+assign id_add_len_in.axis_tlast = "1'b1";
+assign rd_en = id_add_len_in.axis_tready;
 
-assign  axi_wr.axi_wdata = pipe_axis.axis_tdata;
-assign  axi_wr.axi_wstrb = ~pipe_axis.axis_tkeep;
-assign  axi_wr.axi_wvalid = pipe_axis.axis_tvalid;
-assign  axi_wr.axi_wlast = pipe_axis.axis_tlast;
-assign  axi_wr.axi_bready = 1'b1;
-assign  pipe_axis.axis_tready = axi_wr.axi_wready;
+assign axi_wr.axi_wdata = pipe_axis.axis_tdata;
+assign axi_wr.axi_wstrb = ~pipe_axis.axis_tkeep;
+assign axi_wr.axi_wvalid = pipe_axis.axis_tvalid;
+assign axi_wr.axi_wlast = pipe_axis.axis_tlast;
+assign axi_wr.axi_bready = 1'b1;
+assign pipe_axis.axis_tready = axi_wr.axi_wready;
 
 endmodule