// PI-AR035-F1-1 / XC7A35T CVE2 (CV32E20) EP03 board control core.
// Replaces the MicroBlaze control plane with CVE2, keeps the ACM:* UART protocol,
// and drives board LED/KEY, QSPI Flash, I2C EEPROM, TF card and a watchdog.
//
// Memory map
//   0x0000_0000  16 KiB instruction RAM (firmware image)
//   0x0000_0000  16 KiB data RAM (shared image, separate BRAM)
//   0x1000_0000  UART   +0 TX, +4 status, +8 RX
//   0x3000_0000  WDT    +0 arm/disarm, +4 kick, +8 reset cause, +C status
//   0x4000_0000  LED    [7:0], 1 = on (pin driven low)
//   0x4001_0000  KEY    [1:0] pressed, [3:2] seen-since-reset
//   0x4002_0000  GPIO   +0 output, +4 input
//      out[0] flash_cs_n, [1] flash_sclk, [2] flash_mosi,
//      [3] flash_wp_n,  [4] flash_hold_n,
//      [5] sd_ncs, [6] sd_sclk, [7] sd_mosi,
//      [8] i2c_scl_low, [9] i2c_sda_low
//      in[0] flash_miso, [1] sd_miso, [2] i2c_scl, [3] i2c_sda

module top_cve2_ep03 (
    input  wire       clk,          // 50 MHz, pin Y18
    input  wire       rst_n,        // active-low, pin M6
    input  wire       uart_rx,      // pin L4
    output wire       uart_tx,      // pin L5
    input  wire [1:0] key_n,        // KEY1=L3, KEY2=K3, active low
    output wire [7:0] led_n,        // LED1..8, active low
    output wire       flash_cs_n,   // T19
    output wire       flash_mosi,   // P22
    input  wire       flash_miso,   // R22
    output wire       flash_wp_n,   // P21
    output wire       flash_hold_n, // R21
    output wire       sd_ncs,       // N13
    output wire       sd_sclk,      // N15
    output wire       sd_mosi,      // P15
    input  wire       sd_miso,      // P16
    inout  wire       i2c_scl,      // Y19
    inout  wire       i2c_sda       // T20
);

    import cve2_pkg::*;

    // ------------------------------------------------------------------
    // External reset and watchdog reset
    // ------------------------------------------------------------------
    wire ext_rst_n = rst_n;

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

    reg [3:0]  wdt_rst_cnt;
    reg        wdt_rst;
    reg        wdt_cause;
    reg        wdt_armed;
    reg [25:0] wdt_cnt;
    reg        wdt_expired;

    localparam integer WDT_CYCLES = 25_000_000; // 500 ms at 50 MHz

    wire rst_ni = ext_rst_sync & ~wdt_rst;

    // ------------------------------------------------------------------
    // CVE2 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;

    // ------------------------------------------------------------------
    // Address decode
    // ------------------------------------------------------------------
    localparam [31:0] RAM_SIZE   = 32'h0000_4000; // 16 KiB
    localparam [19:0] UART_SEL   = 20'h1_0000;    // 0x1000_0000 >> 12
    localparam [19:0] WDT_SEL    = 20'h3_0000;    // 0x3000_0000 >> 12
    localparam [19:0] LED_SEL    = 20'h4_0000;    // 0x4000_0000 >> 12
    localparam [19:0] KEY_SEL    = 20'h4_0010;    // 0x4001_0000 >> 12
    localparam [19:0] GPIO_SEL   = 20'h4_0020;    // 0x4002_0000 >> 12
    localparam [19:0] DBG_SEL    = 20'h4_0030;    // 0x4003_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_wdt  = (data_addr[31:12] == WDT_SEL);
    wire data_is_led  = (data_addr[31:12] == LED_SEL);
    wire data_is_key  = (data_addr[31:12] == KEY_SEL);
    wire data_is_gpio = (data_addr[31:12] == GPIO_SEL);
    wire data_is_dbg  = (data_addr[31:12] == DBG_SEL);

    assign instr_gnt = instr_req && instr_is_ram;
    assign data_gnt  = data_req && (data_is_ram || data_is_uart || data_is_wdt ||
                                    data_is_led || data_is_key || data_is_gpio || data_is_dbg);

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

    wire wdt_arm_wr  = data_req && data_we && data_is_wdt && (data_addr[7:0] == 8'h00) && data_be[0] && data_wdata[0];
    wire wdt_dis_wr  = data_req && data_we && data_is_wdt && (data_addr[7:0] == 8'h00) && data_be[0] && !data_wdata[0];
    wire wdt_kick_wr = data_req && data_we && data_is_wdt && (data_addr[7:0] == 8'h04) && data_be[0] && data_wdata[0];

    always @(posedge clk or negedge ext_rst_n) begin
        if (!ext_rst_n) begin
            wdt_rst_cnt <= 4'd0;
            wdt_rst     <= 1'b0;
            wdt_cause   <= 1'b0;
            wdt_armed   <= 1'b0;
            wdt_cnt     <= 26'd0;
            wdt_expired <= 1'b0;
        end else begin
            wdt_expired <= 1'b0;

            if (wdt_rst) begin
                if (wdt_rst_cnt == 4'd0)
                    wdt_rst <= 1'b0;
                else
                    wdt_rst_cnt <= wdt_rst_cnt - 1'b1;
            end

            if (wdt_arm_wr && !wdt_rst) begin
                wdt_armed <= 1'b1;
                wdt_cnt   <= WDT_CYCLES;
            end else if (wdt_kick_wr && !wdt_rst) begin
                wdt_cnt <= WDT_CYCLES;
            end else if (wdt_dis_wr && !wdt_rst) begin
                wdt_armed <= 1'b0;
                wdt_cnt   <= 26'd0;
            end else if (wdt_armed && !wdt_rst) begin
                if (wdt_cnt == 26'd0) begin
                    wdt_armed   <= 1'b0;
                    wdt_expired <= 1'b1;
                    wdt_cause   <= 1'b1;
                    wdt_rst     <= 1'b1;
                    wdt_rst_cnt <= 4'd15;
                end else begin
                    wdt_cnt <= wdt_cnt - 1'b1;
                end
            end
        end
    end


    // ------------------------------------------------------------------
    // 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 (1'b0),
        .irq_timer_i    (1'b0),
        .irq_external_i (1'b0),
        .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_ep03/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_ep03/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)
    );

    // ------------------------------------------------------------------
    // UART 115200 8N1 with 16-byte RX FIFO
    // ------------------------------------------------------------------
    localparam integer CLK_FREQ = 50_000_000;
    localparam integer BAUD     = 115200;
    localparam integer CLKS_PER_BIT = CLK_FREQ / BAUD;

    wire [7:0] uart_rx_data;
    wire       uart_rx_valid;
    wire       uart_tx_busy;
    wire       uart_wr = data_req && data_we && data_is_uart &&
                         (data_addr[3:0] == 4'h0) && data_be[0];
    wire       uart_rd = data_req && !data_we && data_is_uart &&
                         (data_addr[3:0] == 4'h8);

    uart_rx_fifo u_rx (
        .clk      (clk),
        .rst_n    (rst_ni),
        .rx       (uart_rx),
        .rd       (uart_rd),
        .rdata    (uart_rx_data),
        .valid    (uart_rx_valid)
    );

    uart_tx #(
        .CLK_FREQ (CLK_FREQ),
        .BAUD     (BAUD)
    ) u_tx (
        .clk      (clk),
        .rst_n    (rst_ni),
        .tx_start (uart_wr),
        .tx_data  (data_wdata[7:0]),
        .tx       (uart_tx),
        .busy     (uart_tx_busy)
    );

    // ------------------------------------------------------------------
    // LED / KEY / GPIO / WDT registers
    // ------------------------------------------------------------------
    reg [7:0]  led_reg;      // 1 = LED on
    reg [15:0] gpio_reg;     // output bits
    reg [1:0]  key_stable;   // debounced, 1 = pressed
    reg [1:0]  key_seen;     // sticky since reset
    reg [19:0] key_cnt0, key_cnt1;
    (* ASYNC_REG = "TRUE" *) reg [1:0] key_sync0, key_sync1;

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            key_sync0 <= 2'b00;
            key_sync1 <= 2'b00;
            key_stable <= 2'b00;
            key_seen <= 2'b00;
            key_cnt0 <= 20'd0;
            key_cnt1 <= 20'd0;
        end else begin
            key_sync0 <= ~key_n;          // pressed = 1
            key_sync1 <= key_sync0;

            if (key_sync1[0] == key_stable[0]) begin
                key_cnt0 <= 20'd0;
            end else if (key_cnt0 == 20'd999_999) begin
                key_cnt0 <= 20'd0;
                key_stable[0] <= key_sync1[0];
                if (key_sync1[0]) key_seen[0] <= 1'b1;
            end else begin
                key_cnt0 <= key_cnt0 + 1'b1;
            end

            if (key_sync1[1] == key_stable[1]) begin
                key_cnt1 <= 20'd0;
            end else if (key_cnt1 == 20'd999_999) begin
                key_cnt1 <= 20'd0;
                key_stable[1] <= key_sync1[1];
                if (key_sync1[1]) key_seen[1] <= 1'b1;
            end else begin
                key_cnt1 <= key_cnt1 + 1'b1;
            end
        end
    end

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            led_reg  <= 8'h00;
            gpio_reg <= 16'h0039; // flash/sd CS high, WP/HOLD high, I2C released
        end else begin
            if (data_req && data_we && data_is_led && data_be[0])
                led_reg <= data_wdata[7:0];
            if (data_req && data_we && data_is_gpio && (data_addr[3:0] == 4'h0) && data_be[1:0])
                gpio_reg <= data_wdata[15:0];
        end
    end

    assign led_n        = ~led_reg;
    assign flash_cs_n   = gpio_reg[0];
    assign flash_mosi   = gpio_reg[2];
    assign flash_wp_n   = gpio_reg[3];
    assign flash_hold_n = gpio_reg[4];
    assign sd_ncs       = gpio_reg[5];
    assign sd_sclk      = gpio_reg[6];
    assign sd_mosi      = gpio_reg[7];
    assign i2c_scl      = gpio_reg[8] ? 1'b0 : 1'bz;
    assign i2c_sda      = gpio_reg[9] ? 1'b0 : 1'bz;

    wire [3:0] gpio_in = {i2c_sda, i2c_scl, sd_miso, flash_miso};

    // Debug telemetry: proves whether STARTUPE2 is actually toggling CCLK.
    reg [15:0] sclk_rise_cnt;
    reg        sclk_d;
    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            sclk_rise_cnt <= 16'd0;
            sclk_d        <= 1'b0;
        end else begin
            sclk_d <= gpio_reg[1];
            if (gpio_reg[1] && !sclk_d)
                sclk_rise_cnt <= sclk_rise_cnt + 1'b1;
        end
    end

    // QSPI Flash clock must come from the dedicated CCLK pin, not a fabric pin.
    wire cfg_eos;
    wire cfg_ready;
    (* ASYNC_REG = "TRUE" *) reg [1:0] eos_sync;
    reg cfg_ready_r;
    // EOS is a one-shot pulse at the end of configuration. The board reset may
    // still be asserted at that moment, so this must not be cleared by rst_ni:
    // once EOS has been seen, CCLK ownership stays with the user design.
    always @(posedge clk) begin
        eos_sync <= {eos_sync[0], cfg_eos};
        if (eos_sync[0])
            cfg_ready_r <= 1'b1;
    end
    assign cfg_ready = cfg_ready_r;

    STARTUPE2 #(
        .PROG_USR      ("FALSE"),
        .SIM_CCLK_FREQ (0.0)
    ) u_startup (
        .CFGCLK    (),
        .CFGMCLK   (),
        .EOS       (cfg_eos),
        .PREQ      (),
        .CLK       (1'b0),
        .GSR       (1'b0),
        .GTS       (1'b0),
        .KEYCLEARB (1'b0),
        .PACK      (1'b0),
        .USRCCLKO  (gpio_reg[1]),
        .USRCCLKTS (~cfg_ready),
        .USRDONEO  (1'b1),
        .USRDONETS (1'b1)
    );

    // ------------------------------------------------------------------
    // Peripheral read mux and response
    // ------------------------------------------------------------------
    reg [31:0] periph_rdata;
    reg        periph_rvalid;

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            periph_rdata  <= 32'b0;
            periph_rvalid <= 1'b0;
        end else begin
            periph_rvalid <= data_req && !data_is_ram;
            if (data_req && !data_is_ram) begin
                if (data_is_uart)
                    periph_rdata <= (data_addr[3:0] == 4'h8) ? {24'b0, uart_rx_valid ? uart_rx_data : 8'h00} :
                                    {30'b0, uart_rx_valid, uart_tx_busy};
                else if (data_is_wdt)
                    periph_rdata <= (data_addr[7:0] == 8'h08) ? {31'b0, wdt_cause} :
                                    (data_addr[7:0] == 8'h0c) ? {30'b0, wdt_expired, wdt_armed} : 32'b0;
                else if (data_is_led)
                    periph_rdata <= {24'b0, led_reg};
                else if (data_is_key)
                    periph_rdata <= {28'b0, key_seen, key_stable};
                else if (data_is_gpio)
                    periph_rdata <= (data_addr[3:0] == 4'h4) ? {28'b0, gpio_in} : {16'b0, gpio_reg};
                else if (data_is_dbg)
                    periph_rdata <= {13'b0, sclk_rise_cnt, flash_miso, eos_sync[0], cfg_ready};
                else
                    periph_rdata <= 32'b0;
            end
        end
    end

    assign data_rvalid = data_is_ram ? dmem_rvalid : periph_rvalid;
    assign data_rdata  = data_is_ram ? dmem_rdata  : periph_rdata;

endmodule

// ----------------------------------------------------------------------
// UART receiver with 16-byte FIFO. 16x oversampling, 8N1, LSB first.
// ----------------------------------------------------------------------
module uart_rx_fifo (
    input  wire       clk,
    input  wire       rst_n,
    input  wire       rx,
    input  wire       rd,
    output wire [7:0] rdata,
    output wire       valid
);

    localparam integer CLKS_PER_BIT = 434; // 50 MHz / 115200

    (* ASYNC_REG = "TRUE" *) reg [1:0] rx_sync;
    reg        busy;
    reg [8:0]  clk_cnt;
    reg [3:0]  bit_idx;
    reg [7:0]  shift;

    reg [7:0]  fifo [0:15];
    reg [3:0]  wr_ptr;
    reg [3:0]  rd_ptr;
    reg [4:0]  count;

    assign valid = (count != 5'd0);
    assign rdata = fifo[rd_ptr];

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            rx_sync <= 2'b11;
            busy    <= 1'b0;
            clk_cnt <= 9'd0;
            bit_idx <= 4'd0;
            shift   <= 8'd0;
            wr_ptr  <= 4'd0;
            rd_ptr  <= 4'd0;
            count   <= 5'd0;
        end else begin
            rx_sync <= {rx_sync[0], rx};

            if (!busy) begin
                if (!rx_sync[1]) begin
                    busy    <= 1'b1;
                    clk_cnt <= CLKS_PER_BIT / 2; // sample middle of start bit
                    bit_idx <= 4'd0;
                end
            end else if (clk_cnt == 9'd0) begin
                if (bit_idx == 4'd0) begin
                    if (rx_sync[1]) begin
                        busy <= 1'b0;            // false start
                    end else begin
                        bit_idx <= 4'd1;
                        clk_cnt <= CLKS_PER_BIT - 1;
                    end
                end else if (bit_idx <= 4'd8) begin
                    shift[bit_idx - 1'b1] <= rx_sync[1];
                    bit_idx <= bit_idx + 1'b1;
                    clk_cnt <= CLKS_PER_BIT - 1;
                end else begin
                    if (rx_sync[1]) begin        // valid stop bit
                        fifo[wr_ptr] <= shift;
                        wr_ptr <= wr_ptr + 1'b1;
                        if (count < 5'd16) count <= count + 1'b1;
                    end
                    busy <= 1'b0;
                end
            end else begin
                clk_cnt <= clk_cnt - 1'b1;
            end

            if (rd && count != 5'd0) begin
                rd_ptr <= rd_ptr + 1'b1;
                count  <= count - 1'b1;
            end
        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;
            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
