| // Copyright lowRISC contributors. |
| // Licensed under the Apache License, Version 2.0, see LICENSE for details. |
| // SPDX-License-Identifier: Apache-2.0 |
| // |
| // TL-UL socket M:1 module |
| // |
| // Verilog parameters |
| // M: Number of host ports. |
| // HReqPass: M bit array to allow requests to pass through the host i |
| // FIFO with no clock delay if the request FIFO is empty. If |
| // 1'b0, at least one clock cycle of latency is created. |
| // Default is 1'b1. |
| // HRspPass: Same as HReqPass but for host response FIFO. |
| // HReqDepth: Mx4 bit array. bit[i*4+:4] is depth of host i request FIFO. |
| // Depth of zero is allowed if ReqPass is true. A maximum value |
| // of 16 is allowed, default is 2. |
| // HRspDepth: Same as HReqDepth but for host response FIFO. |
| // DReqPass: Same as HReqPass but for device request FIFO. |
| // DRspPass: Same as HReqPass but for device response FIFO. |
| // DReqDepth: Same as HReqDepth but for device request FIFO. |
| // DRspDepth: Same as HReqDepth but for device response FIFO. |
| |
| `include "prim_assert.sv" |
| |
| module tlul_socket_m1 #( |
| parameter int unsigned M = 4, |
| parameter bit [M-1:0] HReqPass = {M{1'b1}}, |
| parameter bit [M-1:0] HRspPass = {M{1'b1}}, |
| parameter bit [M*4-1:0] HReqDepth = {M{4'h1}}, |
| parameter bit [M*4-1:0] HRspDepth = {M{4'h1}}, |
| parameter bit DReqPass = 1'b1, |
| parameter bit DRspPass = 1'b1, |
| parameter bit [3:0] DReqDepth = 4'h1, |
| parameter bit [3:0] DRspDepth = 4'h1 |
| ) ( |
| input clk_i, |
| input rst_ni, |
| |
| input tlul_pkg::tl_h2d_t tl_h_i [M], |
| output tlul_pkg::tl_d2h_t tl_h_o [M], |
| |
| output tlul_pkg::tl_h2d_t tl_d_o, |
| input tlul_pkg::tl_d2h_t tl_d_i |
| ); |
| |
| `ASSERT_INIT(maxM, M < 16) |
| |
| |
| // Signals |
| // |
| // tl_h_i/o[0] | tl_h_i/o[1] | ... | tl_h_i/o[M-1] |
| // | | | |
| // u_hostfifo[0] u_hostfifo[1] u_hostfifo[M-1] |
| // | | | |
| // hreq_fifo_o(i) / hrsp_fifo_i(i) |
| // --------------------------------------- |
| // | request/grant/req_data | |
| // | | |
| // | PRIM_ARBITER | |
| // | | |
| // | arb_valid / arb_ready / arb_data | |
| // --------------------------------------- |
| // | |
| // dreq_fifo_i / drsp_fifo_o |
| // | |
| // u_devicefifo |
| // | |
| // tl_d_o/i |
| // |
| // Required ID width to distinguish between host ports |
| // Used in response steering |
| localparam int unsigned IDW = top_pkg::TL_AIW; |
| localparam int unsigned STIDW = $clog2(M); |
| |
| tlul_pkg::tl_h2d_t hreq_fifo_o [M]; |
| tlul_pkg::tl_d2h_t hrsp_fifo_i [M]; |
| |
| logic [M-1:0] hrequest; |
| logic [M-1:0] hgrant; |
| |
| tlul_pkg::tl_h2d_t dreq_fifo_i; |
| tlul_pkg::tl_d2h_t drsp_fifo_o; |
| |
| logic arb_valid; |
| logic arb_ready; |
| tlul_pkg::tl_h2d_t arb_data; |
| |
| // Host Req/Rsp FIFO |
| for (genvar i = 0 ; i < M ; i++) begin : gen_host_fifo |
| tlul_pkg::tl_h2d_t hreq_fifo_i; |
| |
| // ID Shifting |
| logic [STIDW-1:0] reqid_sub; |
| logic [IDW-1:0] shifted_id; |
| assign reqid_sub = i; // can cause conversion error? |
| assign shifted_id = { |
| tl_h_i[i].a_source[0+:(IDW-STIDW)], |
| reqid_sub |
| }; |
| |
| `ASSERT(idInRange, tl_h_i[i].a_valid |-> tl_h_i[i].a_source[IDW-1 -:STIDW] == '0) |
| |
| // assign not connected bits to nc_* signal to make lint happy |
| logic [IDW-1 : IDW-STIDW] unused_tl_h_source; |
| assign unused_tl_h_source = tl_h_i[i].a_source[IDW-1 -: STIDW]; |
| |
| // Put shifted ID |
| assign hreq_fifo_i = '{ |
| a_valid: tl_h_i[i].a_valid, |
| a_opcode: tl_h_i[i].a_opcode, |
| a_param: tl_h_i[i].a_param, |
| a_size: tl_h_i[i].a_size, |
| a_source: shifted_id, |
| a_address: tl_h_i[i].a_address, |
| a_mask: tl_h_i[i].a_mask, |
| a_data: tl_h_i[i].a_data, |
| a_user: tl_h_i[i].a_user, |
| d_ready: tl_h_i[i].d_ready |
| }; |
| |
| tlul_fifo_sync #( |
| .ReqPass (HReqPass[i]), |
| .RspPass (HRspPass[i]), |
| .ReqDepth (HReqDepth[i*4+:4]), |
| .RspDepth (HRspDepth[i*4+:4]), |
| .SpareReqW (1) |
| ) u_hostfifo ( |
| .clk_i, |
| .rst_ni, |
| .tl_h_i (hreq_fifo_i), |
| .tl_h_o (tl_h_o[i]), |
| .tl_d_o (hreq_fifo_o[i]), |
| .tl_d_i (hrsp_fifo_i[i]), |
| .spare_req_i (1'b0), |
| .spare_req_o (), |
| .spare_rsp_i (1'b0), |
| .spare_rsp_o () |
| ); |
| end |
| |
| // Device Req/Rsp FIFO |
| tlul_fifo_sync #( |
| .ReqPass (DReqPass), |
| .RspPass (DRspPass), |
| .ReqDepth (DReqDepth), |
| .RspDepth (DRspDepth), |
| .SpareReqW (1) |
| ) u_devicefifo ( |
| .clk_i, |
| .rst_ni, |
| .tl_h_i (dreq_fifo_i), |
| .tl_h_o (drsp_fifo_o), |
| .tl_d_o (tl_d_o), |
| .tl_d_i (tl_d_i), |
| .spare_req_i (1'b0), |
| .spare_req_o (), |
| .spare_rsp_i (1'b0), |
| .spare_rsp_o () |
| ); |
| |
| // Request Arbiter |
| for (genvar i = 0 ; i < M ; i++) begin : gen_arbreqgnt |
| assign hrequest[i] = hreq_fifo_o[i].a_valid; |
| end |
| |
| assign arb_ready = drsp_fifo_o.a_ready; |
| |
| if (tlul_pkg::ArbiterImpl == "PPC") begin : gen_arb_ppc |
| prim_arbiter_ppc #( |
| .N (M), |
| .DW ($bits(tlul_pkg::tl_h2d_t)) |
| ) u_reqarb ( |
| .clk_i, |
| .rst_ni, |
| .req_chk_i ( 1'b0 ), // TL-UL allows dropping valid without ready. See #3354. |
| .req_i ( hrequest ), |
| .data_i ( hreq_fifo_o ), |
| .gnt_o ( hgrant ), |
| .idx_o ( ), |
| .valid_o ( arb_valid ), |
| .data_o ( arb_data ), |
| .ready_i ( arb_ready ) |
| ); |
| end else if (tlul_pkg::ArbiterImpl == "BINTREE") begin : gen_tree_arb |
| prim_arbiter_tree #( |
| .N (M), |
| .DW ($bits(tlul_pkg::tl_h2d_t)) |
| ) u_reqarb ( |
| .clk_i, |
| .rst_ni, |
| .req_chk_i ( 1'b0 ), // TL-UL allows dropping valid without ready. See #3354. |
| .req_i ( hrequest ), |
| .data_i ( hreq_fifo_o ), |
| .gnt_o ( hgrant ), |
| .idx_o ( ), |
| .valid_o ( arb_valid ), |
| .data_o ( arb_data ), |
| .ready_i ( arb_ready ) |
| ); |
| end else begin : gen_unknown |
| `ASSERT_INIT(UnknownArbImpl_A, 0) |
| end |
| |
| logic [ M-1:0] hfifo_rspvalid; |
| logic [ M-1:0] dfifo_rspready; |
| logic [IDW-1:0] hfifo_rspid; |
| logic dfifo_rspready_merged; |
| |
| // arb_data --> dreq_fifo_i |
| // dreq_fifo_i.hd_rspready <= dfifo_rspready |
| |
| assign dfifo_rspready_merged = |dfifo_rspready; |
| assign dreq_fifo_i = '{ |
| a_valid: arb_valid, |
| a_opcode: arb_data.a_opcode, |
| a_param: arb_data.a_param, |
| a_size: arb_data.a_size, |
| a_source: arb_data.a_source, |
| a_address: arb_data.a_address, |
| a_mask: arb_data.a_mask, |
| a_data: arb_data.a_data, |
| a_user: arb_data.a_user, |
| |
| d_ready: dfifo_rspready_merged |
| }; |
| |
| // Response ID steering |
| // drsp_fifo_o --> hrsp_fifo_i[i] |
| |
| // Response ID shifting before put into host fifo |
| assign hfifo_rspid = { |
| {STIDW{1'b0}}, |
| drsp_fifo_o.d_source[IDW-1:STIDW] |
| }; |
| for (genvar i = 0 ; i < M ; i++) begin : gen_idrouting |
| assign hfifo_rspvalid[i] = drsp_fifo_o.d_valid & |
| (drsp_fifo_o.d_source[0+:STIDW] == i); |
| assign dfifo_rspready[i] = hreq_fifo_o[i].d_ready & |
| (drsp_fifo_o.d_source[0+:STIDW] == i) & |
| drsp_fifo_o.d_valid; |
| |
| assign hrsp_fifo_i[i] = '{ |
| d_valid: hfifo_rspvalid[i], |
| d_opcode: drsp_fifo_o.d_opcode, |
| d_param: drsp_fifo_o.d_param, |
| d_size: drsp_fifo_o.d_size, |
| d_source: hfifo_rspid, |
| d_sink: drsp_fifo_o.d_sink, |
| d_data: drsp_fifo_o.d_data, |
| d_user: drsp_fifo_o.d_user, |
| d_error: drsp_fifo_o.d_error, |
| a_ready: hgrant[i] |
| }; |
| end |
| |
| // this assertion fails when rspid[0+:STIDW] not in [0..M-1] |
| `ASSERT(rspIdInRange, drsp_fifo_o.d_valid |-> |
| drsp_fifo_o.d_source[0+:STIDW] >= 0 && drsp_fifo_o.d_source[0+:STIDW] < M) |
| |
| endmodule |
