| // Copyright lowRISC contributors. |
| // Licensed under the Apache License, Version 2.0, see LICENSE for details. |
| // SPDX-License-Identifier: Apache-2.0 |
| // |
| // Register Top module auto-generated by `reggen` |
| |
| `include "prim_assert.sv" |
| |
| module i2s_reg_top ( |
| input clk_i, |
| input rst_ni, |
| input tlul_pkg::tl_h2d_t tl_i, |
| output tlul_pkg::tl_d2h_t tl_o, |
| // To HW |
| output i2s_reg_pkg::i2s_reg2hw_t reg2hw, // Write |
| input i2s_reg_pkg::i2s_hw2reg_t hw2reg, // Read |
| |
| // Integrity check errors |
| output logic intg_err_o, |
| |
| // Config |
| input devmode_i // If 1, explicit error return for unmapped register access |
| ); |
| |
| import i2s_reg_pkg::* ; |
| |
| localparam int AW = 6; |
| localparam int DW = 32; |
| localparam int DBW = DW/8; // Byte Width |
| |
| // register signals |
| logic reg_we; |
| logic reg_re; |
| logic [AW-1:0] reg_addr; |
| logic [DW-1:0] reg_wdata; |
| logic [DBW-1:0] reg_be; |
| logic [DW-1:0] reg_rdata; |
| logic reg_error; |
| |
| logic addrmiss, wr_err; |
| |
| logic [DW-1:0] reg_rdata_next; |
| logic reg_busy; |
| |
| tlul_pkg::tl_h2d_t tl_reg_h2d; |
| tlul_pkg::tl_d2h_t tl_reg_d2h; |
| |
| |
| // incoming payload check |
| logic intg_err; |
| tlul_cmd_intg_chk u_chk ( |
| .tl_i(tl_i), |
| .err_o(intg_err) |
| ); |
| |
| // also check for spurious write enables |
| logic reg_we_err; |
| logic [8:0] reg_we_check; |
| prim_reg_we_check #( |
| .OneHotWidth(9) |
| ) u_prim_reg_we_check ( |
| .clk_i(clk_i), |
| .rst_ni(rst_ni), |
| .oh_i (reg_we_check), |
| .en_i (reg_we && !addrmiss), |
| .err_o (reg_we_err) |
| ); |
| |
| logic err_q; |
| always_ff @(posedge clk_i or negedge rst_ni) begin |
| if (!rst_ni) begin |
| err_q <= '0; |
| end else if (intg_err || reg_we_err) begin |
| err_q <= 1'b1; |
| end |
| end |
| |
| // integrity error output is permanent and should be used for alert generation |
| // register errors are transactional |
| assign intg_err_o = err_q | intg_err | reg_we_err; |
| |
| // outgoing integrity generation |
| tlul_pkg::tl_d2h_t tl_o_pre; |
| tlul_rsp_intg_gen #( |
| .EnableRspIntgGen(1), |
| .EnableDataIntgGen(1) |
| ) u_rsp_intg_gen ( |
| .tl_i(tl_o_pre), |
| .tl_o(tl_o) |
| ); |
| |
| assign tl_reg_h2d = tl_i; |
| assign tl_o_pre = tl_reg_d2h; |
| |
| tlul_adapter_reg #( |
| .RegAw(AW), |
| .RegDw(DW), |
| .EnableDataIntgGen(0) |
| ) u_reg_if ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| .tl_i (tl_reg_h2d), |
| .tl_o (tl_reg_d2h), |
| |
| .en_ifetch_i(prim_mubi_pkg::MuBi4False), |
| .intg_error_o(), |
| |
| .we_o (reg_we), |
| .re_o (reg_re), |
| .addr_o (reg_addr), |
| .wdata_o (reg_wdata), |
| .be_o (reg_be), |
| .busy_i (reg_busy), |
| .rdata_i (reg_rdata), |
| .error_i (reg_error) |
| ); |
| |
| // cdc oversampling signals |
| |
| assign reg_rdata = reg_rdata_next ; |
| assign reg_error = (devmode_i & addrmiss) | wr_err | intg_err; |
| |
| // Define SW related signals |
| // Format: <reg>_<field>_{wd|we|qs} |
| // or <reg>_{wd|we|qs} if field == 1 or 0 |
| logic intr_state_we; |
| logic intr_state_tx_watermark_qs; |
| logic intr_state_tx_watermark_wd; |
| logic intr_state_rx_watermark_qs; |
| logic intr_state_rx_watermark_wd; |
| logic intr_state_tx_empty_qs; |
| logic intr_state_tx_empty_wd; |
| logic intr_state_rx_overflow_qs; |
| logic intr_state_rx_overflow_wd; |
| logic intr_enable_we; |
| logic intr_enable_tx_watermark_qs; |
| logic intr_enable_tx_watermark_wd; |
| logic intr_enable_rx_watermark_qs; |
| logic intr_enable_rx_watermark_wd; |
| logic intr_enable_tx_empty_qs; |
| logic intr_enable_tx_empty_wd; |
| logic intr_enable_rx_overflow_qs; |
| logic intr_enable_rx_overflow_wd; |
| logic intr_test_we; |
| logic intr_test_tx_watermark_wd; |
| logic intr_test_rx_watermark_wd; |
| logic intr_test_tx_empty_wd; |
| logic intr_test_rx_overflow_wd; |
| logic ctrl_we; |
| logic ctrl_tx_qs; |
| logic ctrl_tx_wd; |
| logic ctrl_rx_qs; |
| logic ctrl_rx_wd; |
| logic ctrl_slpbk_qs; |
| logic ctrl_slpbk_wd; |
| logic [6:0] ctrl_nco_rx_qs; |
| logic [6:0] ctrl_nco_rx_wd; |
| logic [6:0] ctrl_nco_tx_qs; |
| logic [6:0] ctrl_nco_tx_wd; |
| logic status_re; |
| logic status_txfull_qs; |
| logic status_rxfull_qs; |
| logic status_txempty_qs; |
| logic status_rxempty_qs; |
| logic rdata_re; |
| logic [31:0] rdata_qs; |
| logic wdata_we; |
| logic [31:0] wdata_wd; |
| logic fifo_ctrl_we; |
| logic fifo_ctrl_rxrst_wd; |
| logic fifo_ctrl_txrst_wd; |
| logic [2:0] fifo_ctrl_rxilvl_qs; |
| logic [2:0] fifo_ctrl_rxilvl_wd; |
| logic [1:0] fifo_ctrl_txilvl_qs; |
| logic [1:0] fifo_ctrl_txilvl_wd; |
| logic fifo_status_re; |
| logic [5:0] fifo_status_txlvl_qs; |
| logic [5:0] fifo_status_rxlvl_qs; |
| |
| // Register instances |
| // R[intr_state]: V(False) |
| // F[tx_watermark]: 0:0 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessW1C), |
| .RESVAL (1'h0) |
| ) u_intr_state_tx_watermark ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_state_we), |
| .wd (intr_state_tx_watermark_wd), |
| |
| // from internal hardware |
| .de (hw2reg.intr_state.tx_watermark.de), |
| .d (hw2reg.intr_state.tx_watermark.d), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_state.tx_watermark.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_state_tx_watermark_qs) |
| ); |
| |
| // F[rx_watermark]: 1:1 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessW1C), |
| .RESVAL (1'h0) |
| ) u_intr_state_rx_watermark ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_state_we), |
| .wd (intr_state_rx_watermark_wd), |
| |
| // from internal hardware |
| .de (hw2reg.intr_state.rx_watermark.de), |
| .d (hw2reg.intr_state.rx_watermark.d), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_state.rx_watermark.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_state_rx_watermark_qs) |
| ); |
| |
| // F[tx_empty]: 2:2 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessW1C), |
| .RESVAL (1'h0) |
| ) u_intr_state_tx_empty ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_state_we), |
| .wd (intr_state_tx_empty_wd), |
| |
| // from internal hardware |
| .de (hw2reg.intr_state.tx_empty.de), |
| .d (hw2reg.intr_state.tx_empty.d), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_state.tx_empty.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_state_tx_empty_qs) |
| ); |
| |
| // F[rx_overflow]: 3:3 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessW1C), |
| .RESVAL (1'h0) |
| ) u_intr_state_rx_overflow ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_state_we), |
| .wd (intr_state_rx_overflow_wd), |
| |
| // from internal hardware |
| .de (hw2reg.intr_state.rx_overflow.de), |
| .d (hw2reg.intr_state.rx_overflow.d), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_state.rx_overflow.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_state_rx_overflow_qs) |
| ); |
| |
| |
| // R[intr_enable]: V(False) |
| // F[tx_watermark]: 0:0 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_intr_enable_tx_watermark ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_enable_we), |
| .wd (intr_enable_tx_watermark_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_enable.tx_watermark.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_enable_tx_watermark_qs) |
| ); |
| |
| // F[rx_watermark]: 1:1 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_intr_enable_rx_watermark ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_enable_we), |
| .wd (intr_enable_rx_watermark_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_enable.rx_watermark.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_enable_rx_watermark_qs) |
| ); |
| |
| // F[tx_empty]: 2:2 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_intr_enable_tx_empty ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_enable_we), |
| .wd (intr_enable_tx_empty_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_enable.tx_empty.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_enable_tx_empty_qs) |
| ); |
| |
| // F[rx_overflow]: 3:3 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_intr_enable_rx_overflow ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (intr_enable_we), |
| .wd (intr_enable_rx_overflow_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.intr_enable.rx_overflow.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (intr_enable_rx_overflow_qs) |
| ); |
| |
| |
| // R[intr_test]: V(True) |
| logic intr_test_qe; |
| logic [3:0] intr_test_flds_we; |
| assign intr_test_qe = &intr_test_flds_we; |
| // F[tx_watermark]: 0:0 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_intr_test_tx_watermark ( |
| .re (1'b0), |
| .we (intr_test_we), |
| .wd (intr_test_tx_watermark_wd), |
| .d ('0), |
| .qre (), |
| .qe (intr_test_flds_we[0]), |
| .q (reg2hw.intr_test.tx_watermark.q), |
| .ds (), |
| .qs () |
| ); |
| assign reg2hw.intr_test.tx_watermark.qe = intr_test_qe; |
| |
| // F[rx_watermark]: 1:1 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_intr_test_rx_watermark ( |
| .re (1'b0), |
| .we (intr_test_we), |
| .wd (intr_test_rx_watermark_wd), |
| .d ('0), |
| .qre (), |
| .qe (intr_test_flds_we[1]), |
| .q (reg2hw.intr_test.rx_watermark.q), |
| .ds (), |
| .qs () |
| ); |
| assign reg2hw.intr_test.rx_watermark.qe = intr_test_qe; |
| |
| // F[tx_empty]: 2:2 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_intr_test_tx_empty ( |
| .re (1'b0), |
| .we (intr_test_we), |
| .wd (intr_test_tx_empty_wd), |
| .d ('0), |
| .qre (), |
| .qe (intr_test_flds_we[2]), |
| .q (reg2hw.intr_test.tx_empty.q), |
| .ds (), |
| .qs () |
| ); |
| assign reg2hw.intr_test.tx_empty.qe = intr_test_qe; |
| |
| // F[rx_overflow]: 3:3 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_intr_test_rx_overflow ( |
| .re (1'b0), |
| .we (intr_test_we), |
| .wd (intr_test_rx_overflow_wd), |
| .d ('0), |
| .qre (), |
| .qe (intr_test_flds_we[3]), |
| .q (reg2hw.intr_test.rx_overflow.q), |
| .ds (), |
| .qs () |
| ); |
| assign reg2hw.intr_test.rx_overflow.qe = intr_test_qe; |
| |
| |
| // R[ctrl]: V(False) |
| // F[tx]: 0:0 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_ctrl_tx ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (ctrl_we), |
| .wd (ctrl_tx_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.ctrl.tx.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (ctrl_tx_qs) |
| ); |
| |
| // F[rx]: 1:1 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_ctrl_rx ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (ctrl_we), |
| .wd (ctrl_rx_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.ctrl.rx.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (ctrl_rx_qs) |
| ); |
| |
| // F[slpbk]: 2:2 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (1'h0) |
| ) u_ctrl_slpbk ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (ctrl_we), |
| .wd (ctrl_slpbk_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.ctrl.slpbk.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (ctrl_slpbk_qs) |
| ); |
| |
| // F[nco_rx]: 24:18 |
| prim_subreg #( |
| .DW (7), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (7'h1) |
| ) u_ctrl_nco_rx ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (ctrl_we), |
| .wd (ctrl_nco_rx_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.ctrl.nco_rx.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (ctrl_nco_rx_qs) |
| ); |
| |
| // F[nco_tx]: 31:25 |
| prim_subreg #( |
| .DW (7), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (7'h1) |
| ) u_ctrl_nco_tx ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (ctrl_we), |
| .wd (ctrl_nco_tx_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (), |
| .q (reg2hw.ctrl.nco_tx.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (ctrl_nco_tx_qs) |
| ); |
| |
| |
| // R[status]: V(True) |
| // F[txfull]: 0:0 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_status_txfull ( |
| .re (status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.status.txfull.d), |
| .qre (reg2hw.status.txfull.re), |
| .qe (), |
| .q (reg2hw.status.txfull.q), |
| .ds (), |
| .qs (status_txfull_qs) |
| ); |
| |
| // F[rxfull]: 1:1 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_status_rxfull ( |
| .re (status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.status.rxfull.d), |
| .qre (reg2hw.status.rxfull.re), |
| .qe (), |
| .q (reg2hw.status.rxfull.q), |
| .ds (), |
| .qs (status_rxfull_qs) |
| ); |
| |
| // F[txempty]: 2:2 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_status_txempty ( |
| .re (status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.status.txempty.d), |
| .qre (reg2hw.status.txempty.re), |
| .qe (), |
| .q (reg2hw.status.txempty.q), |
| .ds (), |
| .qs (status_txempty_qs) |
| ); |
| |
| // F[rxempty]: 3:3 |
| prim_subreg_ext #( |
| .DW (1) |
| ) u_status_rxempty ( |
| .re (status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.status.rxempty.d), |
| .qre (reg2hw.status.rxempty.re), |
| .qe (), |
| .q (reg2hw.status.rxempty.q), |
| .ds (), |
| .qs (status_rxempty_qs) |
| ); |
| |
| |
| // R[rdata]: V(True) |
| prim_subreg_ext #( |
| .DW (32) |
| ) u_rdata ( |
| .re (rdata_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.rdata.d), |
| .qre (reg2hw.rdata.re), |
| .qe (), |
| .q (reg2hw.rdata.q), |
| .ds (), |
| .qs (rdata_qs) |
| ); |
| |
| |
| // R[wdata]: V(False) |
| logic wdata_qe; |
| logic [0:0] wdata_flds_we; |
| prim_flop #( |
| .Width(1), |
| .ResetValue(0) |
| ) u_wdata0_qe ( |
| .clk_i(clk_i), |
| .rst_ni(rst_ni), |
| .d_i(&wdata_flds_we), |
| .q_o(wdata_qe) |
| ); |
| prim_subreg #( |
| .DW (32), |
| .SwAccess(prim_subreg_pkg::SwAccessWO), |
| .RESVAL (32'h0) |
| ) u_wdata ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (wdata_we), |
| .wd (wdata_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (wdata_flds_we[0]), |
| .q (reg2hw.wdata.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs () |
| ); |
| assign reg2hw.wdata.qe = wdata_qe; |
| |
| |
| // R[fifo_ctrl]: V(False) |
| logic fifo_ctrl_qe; |
| logic [3:0] fifo_ctrl_flds_we; |
| prim_flop #( |
| .Width(1), |
| .ResetValue(0) |
| ) u_fifo_ctrl0_qe ( |
| .clk_i(clk_i), |
| .rst_ni(rst_ni), |
| .d_i(&fifo_ctrl_flds_we), |
| .q_o(fifo_ctrl_qe) |
| ); |
| // F[rxrst]: 0:0 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessWO), |
| .RESVAL (1'h0) |
| ) u_fifo_ctrl_rxrst ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (fifo_ctrl_we), |
| .wd (fifo_ctrl_rxrst_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (fifo_ctrl_flds_we[0]), |
| .q (reg2hw.fifo_ctrl.rxrst.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs () |
| ); |
| assign reg2hw.fifo_ctrl.rxrst.qe = fifo_ctrl_qe; |
| |
| // F[txrst]: 1:1 |
| prim_subreg #( |
| .DW (1), |
| .SwAccess(prim_subreg_pkg::SwAccessWO), |
| .RESVAL (1'h0) |
| ) u_fifo_ctrl_txrst ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (fifo_ctrl_we), |
| .wd (fifo_ctrl_txrst_wd), |
| |
| // from internal hardware |
| .de (1'b0), |
| .d ('0), |
| |
| // to internal hardware |
| .qe (fifo_ctrl_flds_we[1]), |
| .q (reg2hw.fifo_ctrl.txrst.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs () |
| ); |
| assign reg2hw.fifo_ctrl.txrst.qe = fifo_ctrl_qe; |
| |
| // F[rxilvl]: 4:2 |
| prim_subreg #( |
| .DW (3), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (3'h2) |
| ) u_fifo_ctrl_rxilvl ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (fifo_ctrl_we), |
| .wd (fifo_ctrl_rxilvl_wd), |
| |
| // from internal hardware |
| .de (hw2reg.fifo_ctrl.rxilvl.de), |
| .d (hw2reg.fifo_ctrl.rxilvl.d), |
| |
| // to internal hardware |
| .qe (fifo_ctrl_flds_we[2]), |
| .q (reg2hw.fifo_ctrl.rxilvl.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (fifo_ctrl_rxilvl_qs) |
| ); |
| assign reg2hw.fifo_ctrl.rxilvl.qe = fifo_ctrl_qe; |
| |
| // F[txilvl]: 6:5 |
| prim_subreg #( |
| .DW (2), |
| .SwAccess(prim_subreg_pkg::SwAccessRW), |
| .RESVAL (2'h2) |
| ) u_fifo_ctrl_txilvl ( |
| .clk_i (clk_i), |
| .rst_ni (rst_ni), |
| |
| // from register interface |
| .we (fifo_ctrl_we), |
| .wd (fifo_ctrl_txilvl_wd), |
| |
| // from internal hardware |
| .de (hw2reg.fifo_ctrl.txilvl.de), |
| .d (hw2reg.fifo_ctrl.txilvl.d), |
| |
| // to internal hardware |
| .qe (fifo_ctrl_flds_we[3]), |
| .q (reg2hw.fifo_ctrl.txilvl.q), |
| .ds (), |
| |
| // to register interface (read) |
| .qs (fifo_ctrl_txilvl_qs) |
| ); |
| assign reg2hw.fifo_ctrl.txilvl.qe = fifo_ctrl_qe; |
| |
| |
| // R[fifo_status]: V(True) |
| // F[txlvl]: 5:0 |
| prim_subreg_ext #( |
| .DW (6) |
| ) u_fifo_status_txlvl ( |
| .re (fifo_status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.fifo_status.txlvl.d), |
| .qre (), |
| .qe (), |
| .q (), |
| .ds (), |
| .qs (fifo_status_txlvl_qs) |
| ); |
| |
| // F[rxlvl]: 21:16 |
| prim_subreg_ext #( |
| .DW (6) |
| ) u_fifo_status_rxlvl ( |
| .re (fifo_status_re), |
| .we (1'b0), |
| .wd ('0), |
| .d (hw2reg.fifo_status.rxlvl.d), |
| .qre (), |
| .qe (), |
| .q (), |
| .ds (), |
| .qs (fifo_status_rxlvl_qs) |
| ); |
| |
| |
| |
| logic [8:0] addr_hit; |
| always_comb begin |
| addr_hit = '0; |
| addr_hit[0] = (reg_addr == I2S_INTR_STATE_OFFSET); |
| addr_hit[1] = (reg_addr == I2S_INTR_ENABLE_OFFSET); |
| addr_hit[2] = (reg_addr == I2S_INTR_TEST_OFFSET); |
| addr_hit[3] = (reg_addr == I2S_CTRL_OFFSET); |
| addr_hit[4] = (reg_addr == I2S_STATUS_OFFSET); |
| addr_hit[5] = (reg_addr == I2S_RDATA_OFFSET); |
| addr_hit[6] = (reg_addr == I2S_WDATA_OFFSET); |
| addr_hit[7] = (reg_addr == I2S_FIFO_CTRL_OFFSET); |
| addr_hit[8] = (reg_addr == I2S_FIFO_STATUS_OFFSET); |
| end |
| |
| assign addrmiss = (reg_re || reg_we) ? ~|addr_hit : 1'b0 ; |
| |
| // Check sub-word write is permitted |
| always_comb begin |
| wr_err = (reg_we & |
| ((addr_hit[0] & (|(I2S_PERMIT[0] & ~reg_be))) | |
| (addr_hit[1] & (|(I2S_PERMIT[1] & ~reg_be))) | |
| (addr_hit[2] & (|(I2S_PERMIT[2] & ~reg_be))) | |
| (addr_hit[3] & (|(I2S_PERMIT[3] & ~reg_be))) | |
| (addr_hit[4] & (|(I2S_PERMIT[4] & ~reg_be))) | |
| (addr_hit[5] & (|(I2S_PERMIT[5] & ~reg_be))) | |
| (addr_hit[6] & (|(I2S_PERMIT[6] & ~reg_be))) | |
| (addr_hit[7] & (|(I2S_PERMIT[7] & ~reg_be))) | |
| (addr_hit[8] & (|(I2S_PERMIT[8] & ~reg_be))))); |
| end |
| |
| // Generate write-enables |
| assign intr_state_we = addr_hit[0] & reg_we & !reg_error; |
| |
| assign intr_state_tx_watermark_wd = reg_wdata[0]; |
| |
| assign intr_state_rx_watermark_wd = reg_wdata[1]; |
| |
| assign intr_state_tx_empty_wd = reg_wdata[2]; |
| |
| assign intr_state_rx_overflow_wd = reg_wdata[3]; |
| assign intr_enable_we = addr_hit[1] & reg_we & !reg_error; |
| |
| assign intr_enable_tx_watermark_wd = reg_wdata[0]; |
| |
| assign intr_enable_rx_watermark_wd = reg_wdata[1]; |
| |
| assign intr_enable_tx_empty_wd = reg_wdata[2]; |
| |
| assign intr_enable_rx_overflow_wd = reg_wdata[3]; |
| assign intr_test_we = addr_hit[2] & reg_we & !reg_error; |
| |
| assign intr_test_tx_watermark_wd = reg_wdata[0]; |
| |
| assign intr_test_rx_watermark_wd = reg_wdata[1]; |
| |
| assign intr_test_tx_empty_wd = reg_wdata[2]; |
| |
| assign intr_test_rx_overflow_wd = reg_wdata[3]; |
| assign ctrl_we = addr_hit[3] & reg_we & !reg_error; |
| |
| assign ctrl_tx_wd = reg_wdata[0]; |
| |
| assign ctrl_rx_wd = reg_wdata[1]; |
| |
| assign ctrl_slpbk_wd = reg_wdata[2]; |
| |
| assign ctrl_nco_rx_wd = reg_wdata[24:18]; |
| |
| assign ctrl_nco_tx_wd = reg_wdata[31:25]; |
| assign status_re = addr_hit[4] & reg_re & !reg_error; |
| assign rdata_re = addr_hit[5] & reg_re & !reg_error; |
| assign wdata_we = addr_hit[6] & reg_we & !reg_error; |
| |
| assign wdata_wd = reg_wdata[31:0]; |
| assign fifo_ctrl_we = addr_hit[7] & reg_we & !reg_error; |
| |
| assign fifo_ctrl_rxrst_wd = reg_wdata[0]; |
| |
| assign fifo_ctrl_txrst_wd = reg_wdata[1]; |
| |
| assign fifo_ctrl_rxilvl_wd = reg_wdata[4:2]; |
| |
| assign fifo_ctrl_txilvl_wd = reg_wdata[6:5]; |
| assign fifo_status_re = addr_hit[8] & reg_re & !reg_error; |
| |
| // Assign write-enables to checker logic vector. |
| always_comb begin |
| reg_we_check = '0; |
| reg_we_check[0] = intr_state_we; |
| reg_we_check[1] = intr_enable_we; |
| reg_we_check[2] = intr_test_we; |
| reg_we_check[3] = ctrl_we; |
| reg_we_check[4] = 1'b0; |
| reg_we_check[5] = 1'b0; |
| reg_we_check[6] = wdata_we; |
| reg_we_check[7] = fifo_ctrl_we; |
| reg_we_check[8] = 1'b0; |
| end |
| |
| // Read data return |
| always_comb begin |
| reg_rdata_next = '0; |
| unique case (1'b1) |
| addr_hit[0]: begin |
| reg_rdata_next[0] = intr_state_tx_watermark_qs; |
| reg_rdata_next[1] = intr_state_rx_watermark_qs; |
| reg_rdata_next[2] = intr_state_tx_empty_qs; |
| reg_rdata_next[3] = intr_state_rx_overflow_qs; |
| end |
| |
| addr_hit[1]: begin |
| reg_rdata_next[0] = intr_enable_tx_watermark_qs; |
| reg_rdata_next[1] = intr_enable_rx_watermark_qs; |
| reg_rdata_next[2] = intr_enable_tx_empty_qs; |
| reg_rdata_next[3] = intr_enable_rx_overflow_qs; |
| end |
| |
| addr_hit[2]: begin |
| reg_rdata_next[0] = '0; |
| reg_rdata_next[1] = '0; |
| reg_rdata_next[2] = '0; |
| reg_rdata_next[3] = '0; |
| end |
| |
| addr_hit[3]: begin |
| reg_rdata_next[0] = ctrl_tx_qs; |
| reg_rdata_next[1] = ctrl_rx_qs; |
| reg_rdata_next[2] = ctrl_slpbk_qs; |
| reg_rdata_next[24:18] = ctrl_nco_rx_qs; |
| reg_rdata_next[31:25] = ctrl_nco_tx_qs; |
| end |
| |
| addr_hit[4]: begin |
| reg_rdata_next[0] = status_txfull_qs; |
| reg_rdata_next[1] = status_rxfull_qs; |
| reg_rdata_next[2] = status_txempty_qs; |
| reg_rdata_next[3] = status_rxempty_qs; |
| end |
| |
| addr_hit[5]: begin |
| reg_rdata_next[31:0] = rdata_qs; |
| end |
| |
| addr_hit[6]: begin |
| reg_rdata_next[31:0] = '0; |
| end |
| |
| addr_hit[7]: begin |
| reg_rdata_next[0] = '0; |
| reg_rdata_next[1] = '0; |
| reg_rdata_next[4:2] = fifo_ctrl_rxilvl_qs; |
| reg_rdata_next[6:5] = fifo_ctrl_txilvl_qs; |
| end |
| |
| addr_hit[8]: begin |
| reg_rdata_next[5:0] = fifo_status_txlvl_qs; |
| reg_rdata_next[21:16] = fifo_status_rxlvl_qs; |
| end |
| |
| default: begin |
| reg_rdata_next = '1; |
| end |
| endcase |
| end |
| |
| // shadow busy |
| logic shadow_busy; |
| assign shadow_busy = 1'b0; |
| |
| // register busy |
| assign reg_busy = shadow_busy; |
| |
| // Unused signal tieoff |
| |
| // wdata / byte enable are not always fully used |
| // add a blanket unused statement to handle lint waivers |
| logic unused_wdata; |
| logic unused_be; |
| assign unused_wdata = ^reg_wdata; |
| assign unused_be = ^reg_be; |
| |
| // Assertions for Register Interface |
| `ASSERT_PULSE(wePulse, reg_we, clk_i, !rst_ni) |
| `ASSERT_PULSE(rePulse, reg_re, clk_i, !rst_ni) |
| |
| `ASSERT(reAfterRv, $rose(reg_re || reg_we) |=> tl_o_pre.d_valid, clk_i, !rst_ni) |
| |
| `ASSERT(en2addrHit, (reg_we || reg_re) |-> $onehot0(addr_hit), clk_i, !rst_ni) |
| |
| // this is formulated as an assumption such that the FPV testbenches do disprove this |
| // property by mistake |
| //`ASSUME(reqParity, tl_reg_h2d.a_valid |-> tl_reg_h2d.a_user.chk_en == tlul_pkg::CheckDis) |
| |
| endmodule |
