Add grouped request

mbertuletti · mbertuletti · commit bc6fa6f3ab52 · 2025-10-16T14:11:17.000+02:00
diff --git a/rtl/variable_latency_interconnect/burst_manager.sv b/rtl/variable_latency_interconnect/burst_manager.sv
@@ -22,10 +22,13 @@ module burst_manager
   // determines the width of the byte offset in a memory word. normally this can be left at the default vaule,
   // but sometimes it needs to be overridden (e.g. when meta-data is supplied to the memory via the wdata signal).
   parameter int unsigned  ByteOffWidth = $clog2(DataWidth-1)-3,
+  // Group Request Extension Grouping Factor for TCDM
+  parameter int unsigned ReqGF = 1,
   // Group Response Extension Grouping Factor for TCDM
   parameter int unsigned  RspGF = 1,
   // Dependant parameters. DO NOT CHANGE!
-  parameter int unsigned NumInLog2 = (NumIn == 1) ? 1 : $clog2(NumIn),
+  parameter int unsigned NumInLog2 = (NumIn > 32'd1) ? unsigned'($clog2(NumIn)) : 32'd1,
+  parameter int unsigned NumOutLog2 = (NumOut > 32'd1) ? unsigned'($clog2(NumOut)) : 32'd1,
   // Burst response type can be overwritten for DataWidth > 32b
   // This can happen when the DataWidth includes transaction metadata
   parameter type burst_resp_t = burst_pkg::burst_gresp_t
@@ -70,11 +73,50 @@ module burst_manager
   // Include FF module
   `include "common_cells/registers.svh"
 
-  localparam int unsigned NumOutLog2 = (NumOut > 32'd1) ? unsigned'($clog2(NumOut)) : 32'd1;
+  /***************
+   * Burst WRITE *
+   ***************/
+
+  localparam int unsigned NumGroupReq = ReqGF > 0 ? NumOut >> $clog2(ReqGF) : NumOut;
+  logic   [NumOut-1:0][NumInLog2-1:0] req_ini_addr;
+  logic   [NumOut-1:0][AddrWidth-1:0] req_tgt_addr;
+  logic   [NumOut-1:0][DataWidth-1:0] req_wdata;
+  logic   [NumOut-1:0]                req_wen;
+  logic   [NumOut-1:0][BeWidth-1:0]   req_be;
+  burst_t [NumOut-1:0]                req_burst;
+  logic   [NumOut-1:0]                req_valid;
+  logic   [NumOut-1:0]                req_ready;
+
+  // Write request ungrouper
+  always_comb begin
+    req_ini_addr = req_ini_addr_i;
+    req_tgt_addr = req_tgt_addr_i;
+    req_wdata    = req_wdata_i;
+    req_wen      = req_wen_i;
+    req_be       = req_be_i;
+    req_burst    = req_burst_i;
+    req_valid    = req_valid_i;
+    // Redistribute grouped write requests
+    for (int i = 0; i < NumGroupReq; i++) begin
+      for (int j = 0; j < ReqGF; j++) begin
+        if (req_burst[i*ReqGF].isburst && req_wen_i[i*ReqGF] && ReqGF > 1) begin
+          req_ini_addr[i*ReqGF+j] = req_ini_addr_i[i*ReqGF] + j;
+          req_tgt_addr[i*ReqGF+j] = req_tgt_addr_i[i*ReqGF] + j;
+          req_wen[i*ReqGF+j]      = req_wen_i[i*ReqGF];
+          req_be[i*ReqGF+j]       = req_be_i[i*ReqGF];
+          req_burst[i*ReqGF+j]    = '0;
+          req_valid[i*ReqGF+j]    = req_valid_i[i*ReqGF];
+          if (j > 0) begin
+            req_wdata[i*ReqGF+j]  = req_burst_i[i*ReqGF].gdata[j];
+          end
+        end
+      end
+    end
+  end
 
-  /******************
-   * Burst Identify *
-   ******************/
+  /**************
+   * Burst READ *
+   **************/
 
   typedef struct packed {
     logic   [NumInLog2-1:0] ini_addr;
@@ -93,21 +135,20 @@ module burst_manager
   logic      [NumOut-1:0]      ready_mask;
   logic      [NumOut-1:0]      valid_mask;
 
-
   always_comb begin
     prearb_data    = '0;
     prearb_valid   = '0;
-    valid_mask     = req_valid_i;
+    valid_mask     = req_valid;
     for (int unsigned i = 0; i < NumOut; i++) begin
-      if (req_valid_i[i] && req_burst_i[i].isburst) begin
-        prearb_data[i].ini_addr = req_ini_addr_i[i];
-        prearb_data[i].tgt_addr = req_tgt_addr_i[i];
-        prearb_data[i].wdata = req_wdata_i[i];
-        prearb_data[i].wen = req_wen_i[i];
-        prearb_data[i].ben = req_be_i[i];
-        prearb_data[i].burst = req_burst_i[i];
-        prearb_valid[i] = 1'b1;
-        valid_mask[i] = 1'b0;
+      if (req_valid[i] && req_burst[i].isburst) begin
+        prearb_data[i].ini_addr = req_ini_addr[i];
+        prearb_data[i].tgt_addr = req_tgt_addr[i];
+        prearb_data[i].wdata    = req_wdata[i];
+        prearb_data[i].wen      = req_wen[i];
+        prearb_data[i].ben      = req_be[i];
+        prearb_data[i].burst    = req_burst[i];
+        prearb_valid[i]         = 1'b1;
+        valid_mask[i]           = 1'b0;
       end
     end
   end
@@ -116,11 +157,11 @@ module burst_manager
   assign ready_mask = prearb_valid & prearb_ready;
 
   rr_arb_tree #(
-    .NumIn     ( NumOut       ),
-    .DataType  ( arb_data_t    ),
-    .ExtPrio   ( 1'b0),
-    .AxiVldRdy ( 1'b1),
-    .LockIn    ( 1'b1)
+    .NumIn     ( NumOut     ),
+    .DataType  ( arb_data_t ),
+    .ExtPrio   ( 1'b0       ),
+    .AxiVldRdy ( 1'b1       ),
+    .LockIn    ( 1'b1       )
   ) i_rr_arb_tree (
     .clk_i   ( clk_i           ),
     .rst_ni  ( rst_ni          ),
@@ -217,11 +258,11 @@ module burst_manager
     fifo_pop = 1'b0;
 
     // Bypass all requests by default
-    req_wdata_o    = req_wdata_i;
-    req_tgt_addr_o = req_tgt_addr_i;
-    req_ini_addr_o = req_ini_addr_i;
-    req_wen_o      = req_wen_i;
-    req_be_o       = req_be_i;
+    req_wdata_o    = req_wdata;
+    req_ini_addr_o = req_ini_addr;
+    req_tgt_addr_o = req_tgt_addr;
+    req_wen_o      = req_wen;
+    req_be_o       = req_be;
 
     case (state_q)
 
@@ -273,9 +314,9 @@ module burst_manager
     endcase
   end
 
-  /******************
-   *   Rsp Handling *
-   ******************/
+  /***********************
+   *   Response Handling *
+   ***********************/
 
   if (RspGF == 1) begin : gen_grouper_bypass
     // Bypass all responses if no grouping
@@ -288,7 +329,7 @@ module burst_manager
   end else begin : gen_grouper
 
     // Number of groups we will check for grouping rsp
-    localparam int unsigned NumGroup = RspGF > 0 ? NumOut >> $clog2(RspGF) : NumOut;
+    localparam int unsigned NumGroupRsp = RspGF > 0 ? NumOut >> $clog2(RspGF) : NumOut;
 
     logic         [NumOut-1:0][NumInLog2-1:0] grouped_resp_ini_addr;
     logic         [NumOut-1:0][DataWidth-1:0] grouped_resp_rdata;
@@ -298,7 +339,7 @@ module burst_manager
 
     always_comb begin
       // Latch the new ports requested in burst
-      for (int i = 0; i < NumGroup; i ++) begin
+      for (int i = 0; i < NumGroupRsp; i ++) begin
         // If ready cancel the reservation
         if (resp_valid_o[i*RspGF] && resp_ready_i[i*RspGF]) begin
           group_mask_d[i*RspGF+:RspGF] = '0;
@@ -314,7 +355,7 @@ module burst_manager
 
     // Assign input data to grouped response
     always_comb begin
-      for (int i = 0; i < NumGroup; i++) begin
+      for (int i = 0; i < NumGroupRsp; i++) begin
         grouped_resp_ini_addr[i*RspGF]           = resp_ini_addr_i[i*RspGF];
         grouped_resp_rdata[i*RspGF]              = resp_rdata_i[i*RspGF];
         grouped_resp_burst[i*RspGF].isburst      = &resp_valid_i[i*RspGF+:RspGF];
diff --git a/rtl/variable_latency_interconnect/burst_pkg.sv b/rtl/variable_latency_interconnect/burst_pkg.sv
@@ -20,12 +20,17 @@ package burst_pkg;
   localparam integer unsigned BurstLen = `ifdef BURSTLEN `BURSTLEN `else 1 `endif;
   parameter int unsigned BurstLenWidth = BurstLen == 1 ? 1 : $clog2(BurstLen);
 
+  // Grouped request in bursted writes
+  localparam integer unsigned ReqGF = `ifdef GROUP_REQ `GROUP_REQ `else 1 `endif;
+  localparam int ReqBurstMSB = (ReqGF > 1) ? (ReqGF - 2) : 0;
+
   // Number of cuts if a burst crosses the target memory boundary
   localparam integer unsigned NumCuts = 1;
 
   typedef struct packed {
     logic isburst;
     logic [BurstLenWidth-1:0] blen;
+    logic [ReqBurstMSB:0][31:0] gdata;
   } burst_t;
 
   /********************************
@@ -34,9 +39,9 @@ package burst_pkg;
 
  // Grouping Factor of response data
   localparam integer unsigned RspGF = `ifdef GROUP_RSP `GROUP_RSP `else 1 `endif;
-
-  // replace rdata payload with this when the response is grouped
   localparam int RspBurstMSB = (RspGF > 1) ? (RspGF - 2) : 0;
+
+  // Add this to rdata payload when the response is grouped
   typedef struct packed {
     logic isburst;
     logic [RspBurstMSB:0][31:0] gdata;
diff --git a/rtl/variable_latency_interconnect/burst_req_grouper.sv b/rtl/variable_latency_interconnect/burst_req_grouper.sv
@@ -23,6 +23,8 @@ module burst_req_grouper
   // Determines the width of the byte offset in a memory word. Normally this can be left at the default value,
   // but sometimes it needs to be overridden (e.g., when metadata is supplied to the memory via the wdata signal).
   parameter int unsigned ByteOffWidth      = $clog2(DataWidth-1)-3,
+  // Group Request Extension Grouping Factor for TCDM
+  parameter int unsigned  ReqGF = 1,
   // Group Response Extension Grouping Factor for TCDM
   parameter int unsigned  RspGF = 1,
   // Dependant parameters. DO NOT CHANGE!
@@ -64,6 +66,8 @@ module burst_req_grouper
 );
 
   `include "common_cells/registers.svh"
+  localparam int unsigned NumGroupReq = ReqGF > 1 ? NumIn >> $clog2(ReqGF) : NumIn;
+  localparam int unsigned NumGroupRsp = RspGF > 1 ? NumIn >> $clog2(RspGF) : NumIn;
 
   /*************/
   /* Request   */
@@ -86,58 +90,93 @@ module burst_req_grouper
   logic                 req_bursted_valid;
 
   // To verify that the request goes to consecutive addresses
-  logic consecutive;
+  logic [NumIn-2:0] consecutive;
+  logic consecutive_read, consecutive_write;
 
   always_comb begin
 
-    // Assign input requests to cutter inputs
-    req_cutter_tgt_addr = req_tgt_addr_i[0];
-    req_cutter_wdata = req_wdata_i;
-    req_cutter_wen = req_wen_i[0];
-    req_cutter_be = req_be_i[0];
-    req_cutter_burst.isburst = 1'b0;
-    req_cutter_burst.blen = NumIn;
+    // Bypass input
+    req_ini_addr_o = req_ini_addr_i;
+    req_tgt_addr_o = req_tgt_addr_i;
+    req_wdata_o    = req_wdata_i;
+    req_wen_o      = req_wen_i;
+    req_be_o       = req_be_i;
+    req_burst_o    = '0;
+    req_valid_o    = req_valid_i;
+    req_ready_o    = req_ready_i;
 
     // Check if request goes to consecutive addresses
-    for (int i = 1; i < NumIn; i++) begin
-      if (req_valid_i[i] && req_valid_i[i-1]) begin
-        consecutive = (req_tgt_addr_i[i][AddrWidth-1:ByteOffWidth] == req_tgt_addr_i[i-1][AddrWidth-1:ByteOffWidth] + 1);
-      end else begin
-        consecutive = 1'b0;
+    for (int i = 0; i < NumIn-1; i++) begin
+      consecutive[i] = (req_tgt_addr_i[i+1][AddrWidth-1:ByteOffWidth]
+                      - req_tgt_addr_i[i][AddrWidth-1:ByteOffWidth]) == AddrWidth'(1);
+    end
+
+    /* WRITE */
+
+    // Assign grouped requests
+    if (ReqGF > 1) begin
+      for (int i = 0; i < NumGroupReq; i++) begin
+        consecutive_write = &consecutive[i*ReqGF+:(ReqGF-1)] && &req_wen_i[i*ReqGF+:ReqGF];
+        if (&req_valid_i[i*ReqGF+:ReqGF] && consecutive_write) begin
+          req_ini_addr_o[i*ReqGF]           = req_ini_addr_i[i*ReqGF];
+          req_tgt_addr_o[i*ReqGF]           = req_tgt_addr_i[i*ReqGF];
+          req_wdata_o[i*ReqGF]              = req_wdata_i[i*ReqGF];
+          req_wen_o[i*ReqGF]                = req_wen_i[i*ReqGF];
+          req_be_o[i*ReqGF]                 = req_be_i[i*ReqGF];
+          req_burst_o[i*ReqGF].isburst      = 1'b1;
+          req_burst_o[i*ReqGF].blen         = '0;
+          req_valid_o[i*ReqGF]              = req_valid_i[i*ReqGF];
+          req_ready_o[i*ReqGF]              = req_valid_o[i*ReqGF] && req_ready_i[i*ReqGF];
+          for (int j = 1; j < ReqGF; j++) begin
+            req_ini_addr_o[i*ReqGF+j]       = '0;
+            req_tgt_addr_o[i*ReqGF+j]       = '0;
+            req_wdata_o[i*ReqGF+j]          = '0;
+            req_wen_o[i*ReqGF+j]            = 1'b0;
+            req_be_o[i*ReqGF+j]             = '0;
+            req_burst_o[i*ReqGF+j]          = '0;
+            req_valid_o[i*ReqGF+j]          = 1'b0;
+            req_ready_o[i*ReqGF+j]          = req_valid_o[i*ReqGF] && req_ready_i[i*ReqGF];
+            // Redistribute the outputs from the i*RspGF'th input
+            req_burst_o[i*ReqGF].gdata      = req_wdata_i[i*ReqGF+j];
+          end
+        end
       end
     end
 
-    // Burst the request
-    if (&req_valid_i && !req_wen_i[0] && consecutive) begin
-      // Send a burst request on the first port
+    /* READ */
+
+    // Assign input requests to cutter inputs
+    req_cutter_tgt_addr      = req_tgt_addr_i[0];
+    req_cutter_wdata         = req_wdata_i;
+    req_cutter_wen           = req_wen_i[0];
+    req_cutter_be            = req_be_i[0];
+    req_cutter_burst.isburst = 1'b0;
+    req_cutter_burst.blen    = NumIn;
+
+    consecutive_read = &consecutive && (~|req_wen_i);
+
+    // Burst the read request
+    if (&req_valid_i && consecutive_read) begin
       req_cutter_burst.isburst = 1'b1;
-      req_tgt_addr_o[0] = req_bursted_tgt_addr;
-      req_wdata_o[0] = req_bursted_wdata;
-      req_wen_o[0] = req_bursted_wen;
-      req_be_o[0] = req_bursted_be;
-      req_burst_o[0] = req_bursted_burst;
-      req_valid_o[0] = req_bursted_valid;
-      req_ready_o[0] = cutter_ready;
+      req_ini_addr_o[0]        = req_bursted_ini_addr;
+      req_tgt_addr_o[0]        = req_bursted_tgt_addr;
+      req_wdata_o[0]           = req_bursted_wdata;
+      req_wen_o[0]             = req_bursted_wen;
+      req_be_o[0]              = req_bursted_be;
+      req_burst_o[0]           = req_bursted_burst;
+      req_valid_o[0]           = req_bursted_valid;
+      req_ready_o[0]           = cutter_ready;
       // Silence other ports
       for (int i = 1; i < NumIn; i++) begin
-        req_tgt_addr_o[i] = '0;
-        req_wdata_o[i] = '0;
-        req_wen_o[i] = 1'b0;
-        req_be_o[i] = '0;
-        req_burst_o[i] = '0;
-        req_valid_o[i] = 1'b0;
-        req_ready_o[i] = cutter_ready;
+        req_ini_addr_o[i]      = '0;
+        req_tgt_addr_o[i]      = '0;
+        req_wdata_o[i]         = '0;
+        req_wen_o[i]           = 1'b0;
+        req_be_o[i]            = '0;
+        req_burst_o[i]         = '0;
+        req_valid_o[i]         = 1'b0;
+        req_ready_o[i]         = cutter_ready;
       end
-    end else begin
-      // Bypass input
-      req_ini_addr_o = req_ini_addr_i;
-      req_tgt_addr_o = req_tgt_addr_i;
-      req_wdata_o = req_wdata_i;
-      req_wen_o = req_wen_i;
-      req_be_o = req_be_i;
-      req_burst_o = '0;
-      req_valid_o = req_valid_i;
-      req_ready_o = req_ready_i;
     end
 
   end
@@ -177,9 +216,6 @@ module burst_req_grouper
   /* Response  */
   /*************/
 
-
-  localparam int unsigned NumGroup = RspGF > 1 ? NumIn >> $clog2(RspGF) : NumIn;
-
   if (RspGF == 1) begin: gen_default_assignment
 
     // Default assignment
@@ -197,7 +233,7 @@ module burst_req_grouper
       resp_valid_o = resp_valid_i;
       resp_ready_o = resp_ready_i;
 
-      for (int ii = 0; ii < NumGroup; ii++) begin
+      for (int ii = 0; ii < NumGroupRsp; ii++) begin
         if (resp_valid_i[ii*RspGF] && resp_burst_i[ii*RspGF].isburst) begin
           // If the response is grouped only one every RspGF input will be
           // valid. If any of the other inputs is valid give them priority.
diff --git a/rtl/variable_latency_interconnect/burst_variable_latency_interconnect.sv b/rtl/variable_latency_interconnect/burst_variable_latency_interconnect.sv
@@ -27,9 +27,8 @@ module burst_variable_latency_interconnect import tcdm_interconnect_pkg::topo_e;
   parameter int unsigned DataWidth         = 32,                    // Data Word Width
   parameter int unsigned BeWidth           = DataWidth/8,           // Byte Strobe Width
   parameter int unsigned AddrMemWidth      = 12,                    // Number of Address bits per Target
-  parameter int unsigned RspGF             = 1,                     // Grouping Factor for the Burst Response
   parameter int unsigned BurstWidth        = 1,                     // Burst Signal Width
-  parameter int unsigned BurstRspWidth     = (RspGF-1)*DataWidth,   // Burst Response Widening
+  parameter int unsigned BurstRspWidth     = 1,                     // Burst Response Widening
   parameter bit AxiVldRdy                  = 1'b1,                  // Valid/ready signaling
   // Spill registers
   // A bit set at position i indicates a spill register at the i-th crossbar layer.
