// PI-AR035-F1-1 / XC7A35T CVE2 (CV32E20) EP02: traps, timer, software and external IRQ.
// 16 KiB unified-address instruction/data RAM, UART at 0x1000_0000,
// minimal CLINT at 0x2000_0000.
module top_cve2_ep02 (
    input  wire clk,       // 50 MHz, pin Y18
    input  wire rst_n,     // active-low reset, pin M6 (KEY3)
    output wire led,       // LED1, pin M5, active low
    output wire uart_tx    // pin L5, 115200 8N1
);

    import cve2_pkg::*;

    // ------------------------------------------------------------------
    // Reset synchronizer
    // ------------------------------------------------------------------
    (* ASYNC_REG = "TRUE" *) reg [1:0] rst_sync;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            rst_sync <= 2'b00;
        else
            rst_sync <= {rst_sync[0], 1'b1};
    end
    wire rst_ni = rst_sync[1];

    // ------------------------------------------------------------------
    // Core buses
    // ------------------------------------------------------------------
    wire        instr_req;
    wire        instr_gnt;
    wire        instr_rvalid;
    wire [31:0] instr_addr;
    wire [31:0] instr_rdata;
    wire        instr_err;

    wire        data_req;
    wire        data_gnt;
    wire        data_rvalid;
    wire        data_we;
    wire [3:0]  data_be;
    wire [31:0] data_addr;
    wire [31:0] data_wdata;
    wire [31:0] data_rdata;
    wire        data_err;

    // Interrupt lines from the minimal CLINT
    wire        irq_software;
    wire        irq_timer;
    wire        irq_external;

    // ------------------------------------------------------------------
    // Address decode
    // ------------------------------------------------------------------
    localparam [31:0] RAM_BASE = 32'h0000_0000;
    localparam [31:0] RAM_SIZE = 32'h0000_4000;   // 16 KiB
    localparam [19:0] UART_SEL  = 20'h1_0000;      // 0x1000_0000 >> 12
    localparam [19:0] CLINT_SEL = 20'h2_0000;      // 0x2000_0000 >> 12

    wire instr_is_ram  = (instr_addr < RAM_SIZE);
    wire data_is_ram   = (data_addr  < RAM_SIZE);
    wire data_is_uart  = (data_addr[31:12] == UART_SEL);
    wire data_is_clint = (data_addr[31:12] == CLINT_SEL);

    assign instr_gnt = instr_req && instr_is_ram;
    assign data_gnt  = data_req  && (data_is_ram || data_is_uart || data_is_clint);

    assign instr_err = 1'b0;
    assign data_err  = 1'b0;

    // ------------------------------------------------------------------
    // CVE2 core
    // ------------------------------------------------------------------
    prim_ram_1p_pkg::ram_1p_cfg_t ram_cfg;
    assign ram_cfg = '0;

    cve2_top #(
        .MHPMCounterNum   (10),
        .MHPMCounterWidth (40),
        .RV32E            (1'b0),
        .RV32M            (RV32MFast),
        .XInterface       (1'b0)
    ) u_core (
        .clk_i          (clk),
        .rst_ni         (rst_ni),
        .test_en_i      (1'b0),
        .ram_cfg_i      (ram_cfg),

        .hart_id_i      (32'b0),
        .boot_addr_i    (32'b0),

        .instr_req_o    (instr_req),
        .instr_gnt_i    (instr_gnt),
        .instr_rvalid_i (instr_rvalid),
        .instr_addr_o   (instr_addr),
        .instr_rdata_i  (instr_rdata),
        .instr_err_i    (instr_err),

        .data_req_o     (data_req),
        .data_gnt_i     (data_gnt),
        .data_rvalid_i  (data_rvalid),
        .data_we_o      (data_we),
        .data_be_o      (data_be),
        .data_addr_o    (data_addr),
        .data_wdata_o   (data_wdata),
        .data_rdata_i   (data_rdata),
        .data_err_i     (data_err),

        .x_issue_valid_o (),
        .x_issue_ready_i (1'b0),
        .x_issue_req_o   (),
        .x_issue_resp_i  ('0),
        .x_register_o    (),
        .x_commit_valid_o(),
        .x_commit_o      (),
        .x_result_valid_i(1'b0),
        .x_result_ready_o(),
        .x_result_i      ('0),

        .irq_software_i (irq_software),
        .irq_timer_i    (irq_timer),
        .irq_external_i (irq_external),
        .irq_fast_i     (16'b0),
        .irq_nm_i       (1'b0),

        .debug_req_i       (1'b0),
        .debug_halted_o    (),
        .dm_halt_addr_i    (32'b0),
        .dm_exception_addr_i(32'b0),
        .crash_dump_o      (),

        .fetch_enable_i (1'b1),
        .core_sleep_o   ()
    );

    // ------------------------------------------------------------------
    // Instruction RAM (read-only)
    // ------------------------------------------------------------------
    wire        imem_rvalid;
    wire [31:0] imem_rdata;

    simple_ram #(
        .DEPTH     (4096),
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep02/sw/firmware.hex")
    ) u_imem (
        .clk    (clk),
        .rst_n  (rst_ni),
        .req    (instr_req && instr_is_ram),
        .we     (1'b0),
        .be     (4'b0),
        .addr   (instr_addr),
        .wdata  (32'b0),
        .rvalid (imem_rvalid),
        .rdata  (imem_rdata)
    );

    assign instr_rvalid = imem_rvalid;
    assign instr_rdata  = imem_rdata;

    // ------------------------------------------------------------------
    // Data RAM (read/write)
    // ------------------------------------------------------------------
    wire        dmem_rvalid;
    wire [31:0] dmem_rdata;

    simple_ram #(
        .DEPTH     (4096),
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep02/sw/firmware.hex")
    ) u_dmem (
        .clk    (clk),
        .rst_n  (rst_ni),
        .req    (data_req && data_is_ram),
        .we     (data_we),
        .be     (data_be),
        .addr   (data_addr),
        .wdata  (data_wdata),
        .rvalid (dmem_rvalid),
        .rdata  (dmem_rdata)
    );

    // ------------------------------------------------------------------
    // Minimal CLINT / interrupt controller at 0x2000_0000
    //   0x00 mtime low, 0x04 mtime high
    //   0x08 mtimecmp low, 0x0c mtimecmp high
    //   0x10 msip (software IRQ), 0x14 external pending
    //   0x18 irq status {ext, timer, software}
    // ------------------------------------------------------------------
    wire        clint_rvalid;
    wire [31:0] clint_rdata;

    clint_min u_clint (
        .clk          (clk),
        .rst_n        (rst_ni),
        .req          (data_req && data_is_clint),
        .we           (data_we),
        .be           (data_be),
        .addr         (data_addr),
        .wdata        (data_wdata),
        .rvalid       (clint_rvalid),
        .rdata        (clint_rdata),
        .irq_timer    (irq_timer),
        .irq_software (irq_software),
        .irq_external (irq_external)
    );

    // ------------------------------------------------------------------
    // UART (memory mapped at 0x1000_0000)
    //   0x1000_0000 : TX byte (write), read returns 0
    //   0x1000_0004 : status, bit0 = busy
    // ------------------------------------------------------------------
    wire uart_wr = data_req && data_is_uart && data_we && data_be[0];

    reg        uart_start;
    reg [7:0]  uart_data;
    reg        uart_rvalid;
    wire       uart_busy;

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            uart_start  <= 1'b0;
            uart_data   <= 8'b0;
            uart_rvalid <= 1'b0;
        end else begin
            uart_start  <= uart_wr;
            if (uart_wr)
                uart_data <= data_wdata[7:0];
            uart_rvalid <= data_req && data_is_uart;
        end
    end

    uart_tx #(
        .CLK_FREQ (50_000_000),
        .BAUD     (115200)
    ) u_uart (
        .clk      (clk),
        .rst_n    (rst_ni),
        .tx_start (uart_start),
        .tx_data  (uart_data),
        .tx       (uart_tx),
        .busy     (uart_busy)
    );

    assign data_rvalid = dmem_rvalid | uart_rvalid | clint_rvalid;
    assign data_rdata  = data_is_clint ? clint_rdata :
                         data_is_uart  ? {31'b0, uart_busy} : dmem_rdata;

    // ------------------------------------------------------------------
    // Heartbeat LED (active low): ~0.67 s toggle
    // ------------------------------------------------------------------
    reg [25:0] blink_cnt;
    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni)
            blink_cnt <= 26'b0;
        else
            blink_cnt <= blink_cnt + 1'b1;
    end
    assign led = ~blink_cnt[25];

endmodule

// ----------------------------------------------------------------------
// Minimal CLINT: 64-bit mtime, 64-bit mtimecmp, software IRQ, external pending.
// ----------------------------------------------------------------------
module clint_min (
    input  wire        clk,
    input  wire        rst_n,
    input  wire        req,
    input  wire        we,
    input  wire [3:0]  be,
    input  wire [31:0] addr,
    input  wire [31:0] wdata,
    output reg         rvalid,
    output reg  [31:0] rdata,
    output wire        irq_timer,
    output wire        irq_software,
    output wire        irq_external
);

    reg [63:0] mtime;
    reg [63:0] mtimecmp;
    reg        msip;
    reg        ext_pending;

    wire [7:0] off = addr[7:0];

    assign irq_timer    = (mtime >= mtimecmp);
    assign irq_software = msip;
    assign irq_external = ext_pending;

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            mtime       <= 64'b0;
            mtimecmp    <= 64'hffff_ffff_ffff_ffff;
            msip        <= 1'b0;
            ext_pending <= 1'b0;
            rvalid      <= 1'b0;
        end else begin
            mtime  <= mtime + 1'b1;
            rvalid <= req;
            if (req && we) begin
                case (off)
                    8'h08: begin
                        if (be[0]) mtimecmp[7:0]   <= wdata[7:0];
                        if (be[1]) mtimecmp[15:8]  <= wdata[15:8];
                        if (be[2]) mtimecmp[23:16] <= wdata[23:16];
                        if (be[3]) mtimecmp[31:24] <= wdata[31:24];
                    end
                    8'h0c: mtimecmp[63:32] <= wdata;
                    8'h10: msip        <= wdata[0];
                    8'h14: ext_pending <= wdata[0];
                    default: ;
                endcase
            end
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            rdata <= 32'b0;
        end else if (req) begin
            case (off)
                8'h00: rdata <= mtime[31:0];
                8'h04: rdata <= mtime[63:32];
                8'h08: rdata <= mtimecmp[31:0];
                8'h0c: rdata <= mtimecmp[63:32];
                8'h10: rdata <= {31'b0, msip};
                8'h14: rdata <= {31'b0, ext_pending};
                8'h18: rdata <= {29'b0, ext_pending, irq_timer, msip};
                default: rdata <= 32'b0;
            endcase
        end
    end

endmodule

// ----------------------------------------------------------------------
// Simple 32-bit RAM with byte writes and 1-cycle read latency.
// ----------------------------------------------------------------------
module simple_ram #(
    parameter integer DEPTH     = 4096,
    parameter         INIT_FILE = ""
) (
    input  wire        clk,
    input  wire        rst_n,
    input  wire        req,
    input  wire        we,
    input  wire [3:0]  be,
    input  wire [31:0] addr,
    input  wire [31:0] wdata,
    output reg         rvalid,
    output reg  [31:0] rdata
);

    localparam integer AW = $clog2(DEPTH);
    reg [31:0] mem [0:DEPTH-1];
    integer i;

    initial begin
        if (INIT_FILE != "")
            $readmemh(INIT_FILE, mem);
        else
            for (i = 0; i < DEPTH; i = i + 1)
                mem[i] = 32'h0000_0013; // NOP
    end

    wire [AW-1:0] idx = addr[AW+1:2];

    always @(posedge clk) begin
        if (req) begin
            if (we) begin
                if (be[0]) mem[idx][7:0]   <= wdata[7:0];
                if (be[1]) mem[idx][15:8]  <= wdata[15:8];
                if (be[2]) mem[idx][23:16] <= wdata[23:16];
                if (be[3]) mem[idx][31:24] <= wdata[31:24];
            end
            rdata <= mem[idx];
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            rvalid <= 1'b0;
        else
            rvalid <= req;
    end

endmodule

// ----------------------------------------------------------------------
// 115200 8N1 UART transmitter
// ----------------------------------------------------------------------
module uart_tx #(
    parameter integer CLK_FREQ = 50_000_000,
    parameter integer BAUD     = 115200
) (
    input  wire       clk,
    input  wire       rst_n,
    input  wire       tx_start,
    input  wire [7:0] tx_data,
    output reg        tx,
    output reg        busy
);

    localparam integer CLKS_PER_BIT = CLK_FREQ / BAUD;

    reg [15:0] clk_cnt;
    reg [3:0]  bit_idx;
    reg [9:0]  shift;

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            tx      <= 1'b1;
            busy    <= 1'b0;
            clk_cnt <= 16'b0;
            bit_idx <= 4'b0;
            shift   <= 10'b0;
        end else if (!busy) begin
            tx <= 1'b1;
            if (tx_start) begin
                shift   <= {1'b1, tx_data, 1'b0}; // stop, data, start
                bit_idx <= 4'b0;
                clk_cnt <= 16'b0;
                busy    <= 1'b1;
                tx      <= 1'b0;                  // start bit
            end
        end else begin
            if (clk_cnt == CLKS_PER_BIT - 1) begin
                clk_cnt <= 16'b0;
                if (bit_idx == 4'd9) begin
                    busy    <= 1'b0;
                    tx      <= 1'b1;
                end else begin
                    bit_idx <= bit_idx + 1'b1;
                    tx      <= shift[bit_idx + 1'b1];
                end
            end else begin
                clk_cnt <= clk_cnt + 1'b1;
            end
        end
    end

endmodule
