// PI-AR035-F1-1 / XC7A35T CVE2 (CV32E20) EP05 performance benchmark platform.
// A single CVE2 data bus is decoded into GPIO, hardware SPI, hardware I2C,
// four PWM channels, a bus monitor/IRQ aggregator and the existing UART/WDT.
//
// Memory map
//   0x0000_0000  64 KiB instruction RAM (firmware image)
//   0x0000_0000  64 KiB data RAM (same 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  GPIO   +0 OUT, +4 IN, +8 DIR, +C SET, +10 CLR, +14 TOGGLE
//      out[7:0] LED1..8 (1 = on), out[8] flash_wp_n, out[9] flash_hold_n
//      in[1:0]  KEY1..2 (1 = pressed)
//   0x4001_0000  SPI    +0 CTRL, +4 TX, +8 RX, +C STATUS
//      CTRL[0] start, [1] flash_cs_n, [2] sd_ncs, [15:8] clock divider
//   0x4002_0000  I2C    +0 CTRL, +4 TX, +8 RX, +C STATUS
//      CTRL[1] start, [2] read byte, [3] stop, [15:8] quarter-bit divider
//   0x4003_0000  PWM    CH0 +00/+04/+08, CH1 +10, CH2 +20, CH3 +30
//      +40 capture period, +44 capture high, +48 capture status
//   0x4004_0000  BUS    +0 TXN, +4 RD, +8 WR, +C WAIT, +10 ERR
//      +14 IRQ status, +18 IRQ enable, +1C IRQ clear, +20 last addr
//   0x4005_0000  DBG    +0 cfg/clock counters, +4 version
//
// The SPI clock is a single generator shared by QSPI Flash (dedicated CCLK
// through STARTUPE2) and the TF card (fabric pin). MOSI is shared; MISO is
// selected by the active chip select. The I2C pins are open-drain.

module top_cve2_ep05 (
    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 (the "matrix")
    // ------------------------------------------------------------------
    localparam [31:0] RAM_SIZE   = 32'h0001_0000; // 64 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] GPIO_SEL   = 20'h4_0000;    // 0x4000_0000 >> 12
    localparam [19:0] SPI_SEL    = 20'h4_0010;    // 0x4001_0000 >> 12
    localparam [19:0] I2C_SEL    = 20'h4_0020;    // 0x4002_0000 >> 12
    localparam [19:0] PWM_SEL    = 20'h4_0030;    // 0x4003_0000 >> 12
    localparam [19:0] BUS_SEL    = 20'h4_0040;    // 0x4004_0000 >> 12
    localparam [19:0] DBG_SEL    = 20'h4_0050;    // 0x4005_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_gpio = (data_addr[31:12] == GPIO_SEL);
    wire data_is_spi  = (data_addr[31:12] == SPI_SEL);
    wire data_is_i2c  = (data_addr[31:12] == I2C_SEL);
    wire data_is_pwm  = (data_addr[31:12] == PWM_SEL);
    wire data_is_bus  = (data_addr[31:12] == BUS_SEL);
    wire data_is_dbg  = (data_addr[31:12] == DBG_SEL);

    wire data_is_periph = data_is_uart || data_is_wdt || data_is_gpio ||
                          data_is_spi  || data_is_i2c || data_is_pwm ||
                          data_is_bus  || data_is_dbg;
    wire data_is_mapped = data_is_ram || data_is_periph;

    // Every data request is granted. Unmapped addresses return rvalid+err so
    // the core takes a load/store access fault instead of hanging forever.
    assign instr_gnt = instr_req && instr_is_ram;
    assign data_gnt  = data_req;

    assign instr_err = 1'b0;

    // ------------------------------------------------------------------
    // Watchdog (same policy as EP03)
    // ------------------------------------------------------------------
    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;

    wire irq_ext;

    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 (irq_ext),
        .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) and data RAM
    // ------------------------------------------------------------------
    wire        imem_rvalid;
    wire [31:0] imem_rdata;

    simple_ram #(
        .DEPTH     (16384),
        `ifdef FIRMWARE_OS
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep05/sw/firmware_os.hex")
`else
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep05/sw/firmware_o2.hex")
`endif
    ) 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;

    wire        dmem_rvalid;
    wire [31:0] dmem_rdata;

    simple_ram #(
        .DEPTH     (16384),
        `ifdef FIRMWARE_OS
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep05/sw/firmware_os.hex")
`else
        .INIT_FILE ("/media/alinx/nvme4t/fpga-love/pi_ar035_f1_1_cve2_ep05/sw/firmware_o2.hex")
`endif
    ) 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;

    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)
    );

    // ------------------------------------------------------------------
    // GPIO: LEDs, keys and Flash WP/HOLD
    // ------------------------------------------------------------------
    reg [15:0] gpio_out;
    reg [15:0] gpio_dir;
    reg  [1:0] key_pressed;
    reg  [1:0] key_seen;
    reg [19:0] key_cnt0, key_cnt1;
    (* ASYNC_REG = "TRUE" *) reg [1:0] key_sync0, key_sync1;
    reg        key_edge_pulse;

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

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

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

    wire gpio_wr = data_req && data_we && data_is_gpio && data_be[1:0];
    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            gpio_out <= 16'h0300; // WP/HOLD high, LEDs off
            gpio_dir <= 16'hffff;
        end else if (gpio_wr) begin
            case (data_addr[7:0])
                8'h00: gpio_out <= data_wdata[15:0];
                8'h08: gpio_dir <= data_wdata[15:0];
                8'h0c: gpio_out <= gpio_out |  data_wdata[15:0];
                8'h10: gpio_out <= gpio_out & ~data_wdata[15:0];
                8'h14: gpio_out <= gpio_out ^  data_wdata[15:0];
                default: ;
            endcase
        end
    end

    wire [15:0] gpio_in = {14'b0, key_pressed};

    // ------------------------------------------------------------------
    // Hardware SPI master (shared clock/MOSI, two chip selects, MISO mux)
    // ------------------------------------------------------------------
    wire        spi_sclk_out;
    wire        spi_mosi;
    wire        spi_miso;

    reg  [7:0] spi_div;
    reg        spi_cs_flash_n;
    reg        spi_cs_sd_n;
    reg  [7:0] spi_tx;
    reg  [7:0] spi_rx;
    reg        spi_busy;
    reg        spi_done;
    reg  [3:0] spi_bit;
    reg  [7:0] spi_divcnt;
    reg  [7:0] spi_div_lat;
    reg        spi_sclk;
    reg        spi_start_pulse;
    reg        spi_done_d;

    wire spi_ctrl_wr = data_req && data_we && data_is_spi && (data_addr[3:0] == 4'h0) && data_be[0];
    wire spi_tx_wr   = data_req && data_we && data_is_spi && (data_addr[3:0] == 4'h4) && data_be[0];

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            spi_div        <= 8'd124; // ~200 kHz, safe for SD init
            spi_cs_flash_n <= 1'b1;
            spi_cs_sd_n    <= 1'b1;
            spi_start_pulse<= 1'b0;
        end else begin
            spi_start_pulse <= 1'b0;
            if (spi_ctrl_wr) begin
                spi_div         <= data_wdata[15:8];
                spi_cs_flash_n  <= data_wdata[1];
                spi_cs_sd_n     <= data_wdata[2];
                if (data_wdata[0])
                    spi_start_pulse <= 1'b1;
            end
        end
    end

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            spi_tx      <= 8'h00;
            spi_rx      <= 8'h00;
            spi_busy    <= 1'b0;
            spi_done    <= 1'b0;
            spi_bit     <= 4'd0;
            spi_divcnt  <= 8'd0;
            spi_div_lat <= 8'd124;
            spi_sclk    <= 1'b0;
            spi_done_d  <= 1'b0;
        end else begin
            spi_done_d <= spi_done;

            if (spi_tx_wr)
                spi_tx <= data_wdata[7:0];

            if (spi_start_pulse && !spi_busy) begin
                spi_busy    <= 1'b1;
                spi_done    <= 1'b0;
                spi_bit     <= 4'd0;
                spi_divcnt  <= 8'd0;
                spi_div_lat <= spi_div;
                spi_sclk    <= 1'b0;
                spi_rx      <= 8'h00;
            end else if (spi_busy) begin
                if (spi_divcnt >= spi_div_lat) begin
                    spi_divcnt <= 8'd0;
                    spi_sclk   <= ~spi_sclk;
                    if (!spi_sclk) begin
                        // rising edge: sample MISO
                        spi_rx[7 - spi_bit] <= spi_miso;
                    end else begin
                        // falling edge: shift MOSI or finish
                        if (spi_bit == 4'd7) begin
                            spi_busy <= 1'b0;
                            spi_done <= 1'b1;
                            spi_sclk <= 1'b0;
                        end else begin
                            spi_bit <= spi_bit + 1'b1;
                            spi_tx  <= {spi_tx[6:0], 1'b0};
                        end
                    end
                end else begin
                    spi_divcnt <= spi_divcnt + 1'b1;
                end
            end
        end
    end

    assign spi_sclk_out = spi_sclk;
    assign spi_mosi     = spi_tx[7];
    assign spi_miso     = spi_cs_flash_n ? sd_miso : flash_miso;

    assign flash_cs_n = spi_cs_flash_n;
    assign sd_ncs     = spi_cs_sd_n;
    assign sd_sclk    = spi_sclk_out;
    assign sd_mosi    = spi_mosi;
    assign flash_mosi = spi_mosi;

    wire spi_done_pulse = spi_done & ~spi_done_d;

    // ------------------------------------------------------------------
    // Hardware I2C master (open-drain, byte-level, repeated start)
    // ------------------------------------------------------------------
    localparam [2:0] I_IDLE  = 3'd0;
    localparam [2:0] I_START = 3'd1;
    localparam [2:0] I_TXBIT = 3'd2;
    localparam [2:0] I_ACK   = 3'd3;
    localparam [2:0] I_RXBIT = 3'd4;
    localparam [2:0] I_NACK  = 3'd5;
    localparam [2:0] I_STOP  = 3'd6;
    localparam [2:0] I_DONE  = 3'd7;

    reg  [7:0] i2c_div;
    reg  [7:0] i2c_tx;
    reg  [7:0] i2c_rx;
    reg  [7:0] i2c_shift;
    reg  [7:0] i2c_divcnt;
    reg  [7:0] i2c_div_lat;
    reg  [3:0] i2c_bitcnt;
    reg  [2:0] i2c_state;
    reg  [1:0] i2c_phase;
    reg        i2c_scl_low;
    reg        i2c_sda_low;
    reg        i2c_busy;
    reg        i2c_done;
    reg        i2c_ack;
    reg        i2c_bus_active;
    reg        i2c_start_req;
    reg        i2c_read_req;
    reg        i2c_write_req;
    reg        i2c_stop_req;
    reg        i2c_done_d;
    (* ASYNC_REG = "TRUE" *) reg [1:0] i2c_scl_sync, i2c_sda_sync;
    wire i2c_scl_in = i2c_scl_sync[1];
    wire i2c_sda_in = i2c_sda_sync[1];

    // I2C line activity counters for instrumentation without a scope.
    reg        i2c_scl_d, i2c_sda_d;
    reg [31:0] i2c_scl_edges, i2c_sda_edges;
    reg [31:0] i2c_time, i2c_scl_last, i2c_scl_period;
    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            i2c_scl_d     <= 1'b1;
            i2c_sda_d     <= 1'b1;
            i2c_scl_edges <= 32'd0;
            i2c_sda_edges <= 32'd0;
            i2c_time      <= 32'd0;
            i2c_scl_last  <= 32'd0;
            i2c_scl_period<= 32'd0;
        end else begin
            i2c_time  <= i2c_time + 1'b1;
            i2c_scl_d <= i2c_scl_in;
            i2c_sda_d <= i2c_sda_in;
            if (i2c_scl_in && !i2c_scl_d) begin
                i2c_scl_edges <= i2c_scl_edges + 1'b1;
                i2c_scl_period<= i2c_time - i2c_scl_last;
                i2c_scl_last  <= i2c_time;
            end
            if (i2c_sda_in && !i2c_sda_d) i2c_sda_edges <= i2c_sda_edges + 1'b1;
        end
    end

    wire i2c_ctrl_wr = data_req && data_we && data_is_i2c && (data_addr[3:0] == 4'h0) && data_be[0];
    wire i2c_tx_wr   = data_req && data_we && data_is_i2c && (data_addr[3:0] == 4'h4) && data_be[0];

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            i2c_div      <= 8'd156; // ~100 kHz with 4 phases
            i2c_tx       <= 8'h00;
            i2c_rx       <= 8'h00;
            i2c_shift    <= 8'h00;
            i2c_divcnt   <= 8'd0;
            i2c_div_lat  <= 8'd156;
            i2c_bitcnt   <= 4'd0;
            i2c_state    <= I_IDLE;
            i2c_phase    <= 2'd0;
            i2c_scl_low  <= 1'b0;
            i2c_sda_low  <= 1'b0;
            i2c_busy     <= 1'b0;
            i2c_done     <= 1'b0;
            i2c_ack      <= 1'b1;
            i2c_bus_active <= 1'b0;
            i2c_start_req<= 1'b0;
            i2c_read_req <= 1'b0;
            i2c_write_req<= 1'b0;
            i2c_stop_req <= 1'b0;
            i2c_done_d   <= 1'b0;
            i2c_scl_sync <= 2'b11;
            i2c_sda_sync <= 2'b11;
        end else begin
            i2c_scl_sync <= {i2c_scl_sync[0], i2c_scl};
            i2c_sda_sync <= {i2c_sda_sync[0], i2c_sda};
            i2c_done_d   <= i2c_done;

            i2c_start_req <= 1'b0;
            i2c_read_req  <= 1'b0;
            i2c_write_req <= 1'b0;
            i2c_stop_req  <= 1'b0;

            if (i2c_ctrl_wr) begin
                i2c_div <= data_wdata[15:8];
                if (data_wdata[1]) i2c_start_req <= 1'b1;
                if (data_wdata[2]) i2c_read_req  <= 1'b1;
                if (data_wdata[3]) i2c_stop_req  <= 1'b1;
                if (data_wdata[4]) i2c_write_req <= 1'b1;
            end
            if (i2c_tx_wr)
                i2c_tx <= data_wdata[7:0];

            if (i2c_start_req && !i2c_busy) begin
                i2c_busy       <= 1'b1;
                i2c_done       <= 1'b0;
                i2c_ack        <= 1'b1;
                i2c_shift      <= i2c_tx;
                i2c_bitcnt     <= 4'd0;
                i2c_state      <= I_START;
                i2c_phase      <= 2'd0;
                i2c_divcnt     <= 8'd0;
                i2c_div_lat    <= i2c_div;
                i2c_bus_active <= 1'b1;
            end else if (i2c_read_req && !i2c_busy) begin
                i2c_busy    <= 1'b1;
                i2c_done    <= 1'b0;
                i2c_shift   <= 8'h00;
                i2c_bitcnt  <= 4'd0;
                i2c_state   <= I_RXBIT;
                i2c_phase   <= 2'd0;
                i2c_divcnt  <= 8'd0;
                i2c_div_lat <= i2c_div;
            end else if (i2c_write_req && !i2c_busy) begin
                i2c_busy    <= 1'b1;
                i2c_done    <= 1'b0;
                i2c_ack     <= 1'b1;
                i2c_shift   <= i2c_tx;
                i2c_bitcnt  <= 4'd0;
                i2c_state   <= I_TXBIT;
                i2c_phase   <= 2'd0;
                i2c_divcnt  <= 8'd0;
                i2c_div_lat <= i2c_div;
            end else if (i2c_stop_req && !i2c_busy) begin
                i2c_busy    <= 1'b1;
                i2c_done    <= 1'b0;
                i2c_state   <= I_STOP;
                i2c_phase   <= 2'd0;
                i2c_divcnt  <= 8'd0;
                i2c_div_lat <= i2c_div;
            end else if (i2c_busy) begin
                if (i2c_divcnt >= i2c_div_lat) begin
                    i2c_divcnt <= 8'd0;
                    case (i2c_state)
                        I_START: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= 1'b0;
                                    i2c_scl_low <= 1'b0;
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_sda_low <= 1'b1; // start condition
                                    i2c_phase   <= 2'd2;
                                end
                                default: begin
                                    i2c_scl_low <= 1'b1;
                                    i2c_state   <= I_TXBIT;
                                    i2c_phase   <= 2'd0;
                                end
                            endcase
                        end
                        I_TXBIT: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= ~i2c_shift[7];
                                    i2c_scl_low <= 1'b1; // keep SCL low while SDA changes
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_scl_low <= 1'b0; // SCL high, slave samples SDA
                                    i2c_phase   <= 2'd2;
                                end
                                default: begin
                                    i2c_scl_low <= 1'b1;
                                    i2c_shift  <= {i2c_shift[6:0], 1'b0};
                                    if (i2c_bitcnt == 4'd7) begin
                                        i2c_bitcnt <= 4'd0;
                                        i2c_state  <= I_ACK;
                                    end else begin
                                        i2c_bitcnt <= i2c_bitcnt + 1'b1;
                                        i2c_phase  <= 2'd0;
                                    end
                                end
                            endcase
                        end
                        I_ACK: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= 1'b0;
                                    i2c_scl_low <= 1'b1;
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_scl_low <= 1'b0;
                                    i2c_phase <= 2'd2;
                                end
                                default: begin
                                    i2c_ack   <= i2c_sda_in;  // sample after SCL high is stable
                                    i2c_scl_low <= 1'b1;
                                    i2c_state   <= I_DONE;
                                    i2c_phase   <= 2'd0;
                                end
                            endcase
                        end
                        I_RXBIT: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= 1'b0;
                                    i2c_scl_low <= 1'b1;
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_scl_low <= 1'b0;
                                    i2c_phase <= 2'd2;
                                end
                                default: begin
                                    i2c_shift <= {i2c_shift[6:0], i2c_sda_in}; // sample before SCL falls
                                    i2c_scl_low <= 1'b1;
                                    if (i2c_bitcnt == 4'd7) begin
                                        i2c_bitcnt <= 4'd0;
                                        i2c_state  <= I_NACK;
                                    end else begin
                                        i2c_bitcnt <= i2c_bitcnt + 1'b1;
                                        i2c_phase  <= 2'd0;
                                    end
                                end
                            endcase
                        end
                        I_NACK: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= 1'b0;
                                    i2c_scl_low <= 1'b1;
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_scl_low <= 1'b0;
                                    i2c_phase <= 2'd2;
                                end
                                default: begin
                                    i2c_scl_low <= 1'b1;
                                    i2c_state   <= I_DONE;
                                    i2c_phase   <= 2'd0;
                                end
                            endcase
                        end
                        I_STOP: begin
                            case (i2c_phase)
                                2'd0: begin
                                    i2c_sda_low <= 1'b1;
                                    i2c_scl_low <= 1'b1;
                                    i2c_phase   <= 2'd1;
                                end
                                2'd1: begin
                                    i2c_scl_low <= 1'b0;
                                    i2c_phase   <= 2'd2;
                                end
                                default: begin
                                    i2c_sda_low <= 1'b0; // stop condition
                                    i2c_bus_active <= 1'b0;
                                    i2c_state   <= I_DONE;
                                    i2c_phase   <= 2'd0;
                                end
                            endcase
                        end
                        I_DONE: begin
                            i2c_busy <= 1'b0;
                            i2c_done <= 1'b1;
                            i2c_rx   <= i2c_shift;
                            if (!i2c_bus_active)
                                i2c_scl_low <= 1'b0;
                            i2c_state <= I_IDLE;
                        end
                        default: begin
                            i2c_state <= I_IDLE;
                            i2c_busy  <= 1'b0;
                        end
                    endcase
                end else begin
                    i2c_divcnt <= i2c_divcnt + 1'b1;
                end
            end
        end
    end

    assign i2c_scl = i2c_scl_low ? 1'b0 : 1'bz;
    assign i2c_sda = i2c_sda_low ? 1'b0 : 1'bz;
    wire i2c_done_pulse = i2c_done & ~i2c_done_d;

    // ------------------------------------------------------------------
    // PWM: four channels with 32-bit period/duty + CH0 edge capture
    // ------------------------------------------------------------------
    reg [31:0] pwm_period [0:3];
    reg [31:0] pwm_duty   [0:3];
    reg  [3:0] pwm_en;
    reg  [3:0] pwm_inv;
    reg [31:0] pwm_cnt    [0:3];
    reg  [3:0] pwm_out_r;
    reg        pwm_period_pulse;
    integer ch;

    wire pwm_wr = data_req && data_we && data_is_pwm && data_be[3:0];

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            for (ch = 0; ch < 4; ch = ch + 1) begin
                pwm_period[ch] <= 32'd50000;
                pwm_duty[ch]   <= 32'd0;
                pwm_cnt[ch]    <= 32'd0;
                pwm_out_r[ch]  <= 1'b0;
            end
            pwm_en   <= 4'b0000;
            pwm_inv  <= 4'b0000;
            pwm_period_pulse <= 1'b0;
        end else begin
            pwm_period_pulse <= 1'b0;

            if (pwm_wr) begin
                if (data_addr[3:0] == 4'h0) begin
                    case (data_addr[7:4])
                        4'h0: pwm_period[0] <= data_wdata;
                        4'h1: pwm_period[1] <= data_wdata;
                        4'h2: pwm_period[2] <= data_wdata;
                        4'h3: pwm_period[3] <= data_wdata;
                        default: ;
                    endcase
                end
                if (data_addr[3:0] == 4'h4) begin
                    case (data_addr[7:4])
                        4'h0: pwm_duty[0] <= data_wdata;
                        4'h1: pwm_duty[1] <= data_wdata;
                        4'h2: pwm_duty[2] <= data_wdata;
                        4'h3: pwm_duty[3] <= data_wdata;
                        default: ;
                    endcase
                end
                if (data_addr[3:0] == 4'h8) begin
                    case (data_addr[7:4])
                        4'h0: begin pwm_en[0] <= data_wdata[0]; pwm_inv[0] <= data_wdata[1]; end
                        4'h1: begin pwm_en[1] <= data_wdata[0]; pwm_inv[1] <= data_wdata[1]; end
                        4'h2: begin pwm_en[2] <= data_wdata[0]; pwm_inv[2] <= data_wdata[1]; end
                        4'h3: begin pwm_en[3] <= data_wdata[0]; pwm_inv[3] <= data_wdata[1]; end
                        default: ;
                    endcase
                end
            end

            for (ch = 0; ch < 4; ch = ch + 1) begin
                if (!pwm_en[ch] || pwm_period[ch] == 32'd0) begin
                    pwm_cnt[ch]   <= 32'd0;
                    pwm_out_r[ch] <= pwm_inv[ch];
                end else if (pwm_cnt[ch] >= pwm_period[ch] - 1'b1) begin
                    pwm_cnt[ch]   <= 32'd0;
                    pwm_out_r[ch] <= pwm_inv[ch] ? 1'b0 : 1'b1;
                    if (ch == 0)
                        pwm_period_pulse <= 1'b1;
                end else begin
                    pwm_cnt[ch]   <= pwm_cnt[ch] + 1'b1;
                    pwm_out_r[ch] <= (pwm_cnt[ch] < pwm_duty[ch]) ^ pwm_inv[ch];
                end
            end
        end
    end

    wire [3:0] pwm_out = pwm_out_r;

    reg [31:0] free_run;
    reg        pwm0_d;
    reg        cap_valid;
    reg [31:0] cap_last_rise;
    reg [31:0] cap_period;
    reg [31:0] cap_high;

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            free_run      <= 32'd0;
            pwm0_d        <= 1'b0;
            cap_valid     <= 1'b0;
            cap_last_rise <= 32'd0;
            cap_period    <= 32'd0;
            cap_high      <= 32'd0;
        end else begin
            free_run <= free_run + 1'b1;
            pwm0_d   <= pwm_out[0];

            if (pwm_out[0] && !pwm0_d) begin
                if (cap_valid)
                    cap_period <= free_run - cap_last_rise;
                cap_last_rise <= free_run;
                cap_valid     <= 1'b1;
            end
            if (!pwm_out[0] && pwm0_d)
                cap_high <= free_run - cap_last_rise;
        end
    end

    // ------------------------------------------------------------------
    // Bus monitor + interrupt aggregation
    // ------------------------------------------------------------------
    reg [31:0] bus_txn_cnt;
    reg [31:0] bus_rd_cnt;
    reg [31:0] bus_wr_cnt;
    reg [31:0] bus_wait_cnt;
    reg [31:0] bus_err_cnt;
    reg [31:0] bus_last_addr;
    reg        bus_pending;
    reg [31:0] bus_wait_run;

    reg [4:0]  irq_status;
    reg [4:0]  irq_enable;
    reg        periph_err_r;
    reg        periph_rvalid;
    reg [31:0] periph_rdata;

    wire bus_err_ev = data_err;
    wire [4:0] irq_set = {bus_err_ev, key_edge_pulse, pwm_period_pulse,
                          i2c_done_pulse, spi_done_pulse};
    wire       irq_clear_wr = data_req && data_we && data_is_bus &&
                              (data_addr[7:0] == 8'h1c) && data_be[0];
    assign irq_ext = |(irq_status & irq_enable);

    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            bus_txn_cnt  <= 32'd0;
            bus_rd_cnt   <= 32'd0;
            bus_wr_cnt   <= 32'd0;
            bus_wait_cnt <= 32'd0;
            bus_err_cnt  <= 32'd0;
            bus_last_addr<= 32'd0;
            bus_pending  <= 1'b0;
            bus_wait_run <= 32'd0;
            irq_status   <= 5'd0;
            irq_enable   <= 5'd0;
        end else begin
            if (data_req && data_gnt) begin
                bus_txn_cnt   <= bus_txn_cnt + 1'b1;
                bus_last_addr <= data_addr;
                bus_pending   <= 1'b1;
                bus_wait_run  <= 32'd0;
                if (data_we)
                    bus_wr_cnt <= bus_wr_cnt + 1'b1;
                else
                    bus_rd_cnt <= bus_rd_cnt + 1'b1;
            end else if (bus_pending) begin
                if (!data_rvalid) begin
                    bus_wait_cnt <= bus_wait_cnt + 1'b1;
                    bus_wait_run <= bus_wait_run + 1'b1;
                end else begin
                    bus_pending  <= 1'b0;
                end
            end

            if (bus_err_ev)
                bus_err_cnt <= bus_err_cnt + 1'b1;

            if (irq_clear_wr)
                irq_status <= irq_status & ~data_wdata[4:0];
            else
                irq_status <= irq_status | irq_set;

            if (data_req && data_we && data_is_bus && (data_addr[7:0] == 8'h18) && data_be[0])
                irq_enable <= data_wdata[4:0];
        end
    end

    // One-cycle peripheral response; unmatched addresses produce data_err.
    always @(posedge clk or negedge rst_ni) begin
        if (!rst_ni) begin
            periph_rdata  <= 32'b0;
            periph_rvalid <= 1'b0;
            periph_err_r  <= 1'b0;
        end else begin
            periph_rvalid <= data_req && !data_is_ram;
            if (data_req && !data_is_ram) begin
                periph_err_r <= !data_is_mapped;
                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_gpio)
                    periph_rdata <= (data_addr[7:0] == 8'h04) ? {16'b0, gpio_in} :
                                    (data_addr[7:0] == 8'h08) ? {16'b0, gpio_dir} :
                                    {16'b0, gpio_out};
                else if (data_is_spi)
                    periph_rdata <= (data_addr[3:0] == 4'h8) ? {24'b0, spi_rx} :
                                    (data_addr[3:0] == 4'hc) ? {28'b0, spi_cs_sd_n, spi_cs_flash_n, spi_done, spi_busy} :
                                    32'b0;
                else if (data_is_i2c)
                    periph_rdata <= (data_addr[3:0] == 4'h8) ? {24'b0, i2c_rx} :
                                    (data_addr[3:0] == 4'hc) ? {27'b0, i2c_bus_active, i2c_done, i2c_ack, i2c_busy} :
                                    32'b0;
                else if (data_is_pwm) begin
                    if (data_addr[7:0] == 8'h40)
                        periph_rdata <= cap_period;
                    else if (data_addr[7:0] == 8'h44)
                        periph_rdata <= cap_high;
                    else if (data_addr[7:0] == 8'h48)
                        periph_rdata <= {31'b0, cap_valid};
                    else
                        periph_rdata <= 32'b0;
                end
                else if (data_is_bus) begin
                    case (data_addr[7:0])
                        8'h00: periph_rdata <= bus_txn_cnt;
                        8'h04: periph_rdata <= bus_rd_cnt;
                        8'h08: periph_rdata <= bus_wr_cnt;
                        8'h0c: periph_rdata <= bus_wait_cnt;
                        8'h10: periph_rdata <= bus_err_cnt;
                        8'h14: periph_rdata <= {27'b0, irq_status};
                        8'h18: periph_rdata <= {27'b0, irq_enable};
                        8'h20: periph_rdata <= bus_last_addr;
                        8'h24: periph_rdata <= bus_wait_run;
                        default: periph_rdata <= 32'b0;
                    endcase
                end
                else if (data_is_dbg)
                    periph_rdata <= (data_addr[3:0] == 4'h4) ? 32'h4550_3034 :
                                    (data_addr[3:0] == 4'h8) ? i2c_scl_edges :
                                    (data_addr[3:0] == 4'hc) ? i2c_sda_edges :
                                    (data_addr[4:0] == 5'h10) ? i2c_scl_period : 32'b0;
                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;
    assign data_err    = data_is_ram ? 1'b0 : (periph_rvalid && periph_err_r);

    // ------------------------------------------------------------------
    // LED / Flash WP/HOLD / I2C pins
    // ------------------------------------------------------------------
    assign led_n        = ~(gpio_out[7:0] | {4'b0000, pwm_out});
    assign flash_wp_n   = gpio_out[8];
    assign flash_hold_n = gpio_out[9];

    // QSPI Flash clock must come from the dedicated CCLK 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.
    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  (spi_sclk_out),
        .USRCCLKTS (~cfg_ready),
        .USRDONEO  (1'b1),
        .USRDONETS (1'b1)
    );


endmodule

// ----------------------------------------------------------------------
// UART receiver with 16-byte FIFO. 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;

    (* 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;
                    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;
                    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
                        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;
    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};
                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
