// EP08: DDR3 native-UI DMA / pattern / CRC / latency engine.
//
// One transaction covers a contiguous byte range:
//   1. (wr_en)  write an address-derived 128-bit pattern, one BL8 per accepted command
//   2. (rd_en)  read the range back and compare every 128-bit beat
//   3. (crc_en) read the range again while computing CRC-32 byte by byte
// wr_en / rd_en / crc_en are independent, so write-only and read-only
// transfers can be measured separately.
//
// A ping mode issues a single read at an address that walks across banks and
// rows, and records the command-to-data latency in ui_clk cycles.
//
// The native UI has no AXI4. This block is the DMA master; the CPU sees a
// small CSR window. The MIG is configured for 4:1, 16-bit DDR3 at 400 MHz,
// giving a 128-bit user interface at 100 MHz.
module ddr3_dma (
    input  wire         ui_clk,
    input  wire         ui_rst,          // active high, from MIG ui_clk_sync_rst
    input  wire         calibrated,
    input  wire         start_toggle,
    input  wire [1:0]   size_sel,
    input  wire         wr_en,
    input  wire         rd_en,
    input  wire         crc_en,
    input  wire         ping_toggle,

    output reg          busy,
    output reg          done,
    output reg          failed,
    output reg  [3:0]   state_dbg,
    output reg  [31:0]  ping_latency,
    output reg  [31:0]  ping_addr_used,

    // Native UI master
    output wire [27:0]  app_addr,
    output wire [2:0]   app_cmd,
    output wire         app_en,
    output wire [127:0] app_wdf_data,
    output wire         app_wdf_end,
    output wire [15:0]  app_wdf_mask,
    output wire         app_wdf_wren,
    input  wire [127:0] app_rd_data,
    input  wire         app_rd_data_end,
    input  wire         app_rd_data_valid,
    input  wire         app_rdy,
    input  wire         app_wdf_rdy,

    output reg  [31:0]  wr_cycles,
    output reg  [31:0]  rd_cycles,
    output reg  [31:0]  crc_cycles,
    output reg  [31:0]  rd_beats,
    output reg  [31:0]  err_count,
    output reg  [31:0]  first_err_addr,
    output reg  [31:0]  crc_data,
    output reg  [31:0]  crc_expected
);

    localparam [3:0] S_IDLE  = 4'd0,
                     S_WDATA = 4'd1,
                     S_WCMD  = 4'd2,
                     S_READ  = 4'd3,
                     S_CRC_I = 4'd4,
                     S_CRC_W = 4'd5,
                     S_CRC_P = 4'd6,
                     S_FIN   = 4'd7,
                     S_PING_I= 4'd8,
                     S_PING_W= 4'd9;

    localparam [5:0] MAX_PENDING = 6'd32;

    reg [3:0]  state;
    reg [23:0] issue_index;
    reg [23:0] return_index;
    reg [23:0] last_index;
    reg [5:0]  pending;
    reg        all_issued;
    reg        rd_active;
    reg [31:0] cycle_cnt;
    reg [31:0] rd_start;
    reg [31:0] crc_start;

    reg [2:0]  start_sync;
    reg        start_seen;
    wire       start_pulse = start_sync[2] ^ start_sync[1];

    // Single-beat read ping: address walks across banks/rows, latency is
    // measured from command acceptance to app_rd_data_valid.
    reg [2:0]  ping_sync;
    reg        ping_seen;
    wire       ping_pulse = ping_sync[2] ^ ping_sync[1];
    reg [3:0]  ping_seq;
    reg [27:0] ping_addr;
    reg [31:0] ping_cmd_cycle;

    // CRC pass: one read outstanding at a time, 16 bytes processed per beat.
    reg [23:0] crc_index;
    reg [23:0] crc_wait_index;
    reg        crc_waiting;
    reg [127:0] crc_shift_data;
    reg [127:0] crc_shift_exp;
    reg [3:0]  crc_byte;
    reg [31:0] crc_data_r;
    reg [31:0] crc_exp_r;

    reg [31:0] stall_cycles;

    function automatic [27:0] beat_addr(input [23:0] idx);
        begin
            // 16 bytes per beat: app_addr[27]=0, [26:24]=bank, [23:10]=row,
            // [9:3]=column[9:3], [2:0]=0. A linear +16 walk covers all banks.
            beat_addr = {1'b0, idx, 3'b000};
        end
    endfunction

    function automatic [27:0] ping_beat_addr(input [3:0] seq);
        begin
            // 16 MiB apart: walks bank bits and the high row bits, still
            // inside the 256 MiB device and 16-byte aligned.
            ping_beat_addr = {seq, 20'b0, 3'b000};
        end
    endfunction

    function automatic [127:0] pattern(input [27:0] addr);
        reg [31:0] tag;
        begin
            tag = {4'hA, addr};
            pattern = {tag, ~tag, tag ^ 32'h55AA33CC, tag ^ 32'hF00F9696};
        end
    endfunction

    function automatic [31:0] crc32_byte(input [31:0] crc, input [7:0] b);
        integer i;
        reg [31:0] c;
        begin
            c = crc ^ {24'h000000, b};
            for (i = 0; i < 8; i = i + 1)
                c = c[0] ? ((c >> 1) ^ 32'hEDB88320) : (c >> 1);
            crc32_byte = c;
        end
    endfunction

    wire rst = ui_rst | ~calibrated;

    // 3FF synchroniser, edge detect in the ui_clk domain.
    always @(posedge ui_clk) begin
        if (rst) begin
            start_sync <= 3'b000;
            ping_sync  <= 3'b000;
        end else begin
            start_sync <= {start_sync[1:0], start_toggle};
            ping_sync  <= {ping_sync[1:0], ping_toggle};
        end
    end

    wire [23:0] selected_last =
        (size_sel == 2'd0) ? 24'h00FFFF :   // 1 MiB  = 65,536 beats
        (size_sel == 2'd1) ? 24'h0FFFFF :   // 16 MiB = 1,048,576 beats
        (size_sel == 2'd2) ? 24'hFFFFFF :   // 256 MiB = 16,777,216 beats
                            24'h3FFFFF;     // 64 MiB = 4,194,304 beats

    // Native UI command/address mux.
    reg [27:0] addr_mux;
    reg        cmd_valid;
    reg        wdf_valid;

    always @* begin
        addr_mux  = beat_addr(issue_index);
        cmd_valid = 1'b0;
        wdf_valid = 1'b0;
        if (state == S_WDATA) begin
            addr_mux  = beat_addr(issue_index);
            wdf_valid = 1'b1;
        end else if (state == S_WCMD) begin
            addr_mux  = beat_addr(issue_index);
            cmd_valid = 1'b1;
        end else if (state == S_READ) begin
            addr_mux  = beat_addr(issue_index);
            cmd_valid = !all_issued && (pending < MAX_PENDING);
        end else if (state == S_CRC_I) begin
            addr_mux  = beat_addr(crc_index);
            cmd_valid = !crc_waiting;
        end else if (state == S_PING_I || state == S_PING_W) begin
            addr_mux  = ping_addr;
            cmd_valid = (state == S_PING_I);
        end
    end

    assign app_addr       = addr_mux;
    assign app_cmd        = (state == S_READ || state == S_CRC_I || state == S_CRC_W ||
                             state == S_PING_I || state == S_PING_W) ? 3'd1 : 3'd0;
    assign app_en         = cmd_valid && app_rdy;
    assign app_wdf_data   = pattern(addr_mux);
    assign app_wdf_end    = 1'b1;
    assign app_wdf_mask   = 16'h0000;
    assign app_wdf_wren   = wdf_valid && app_wdf_rdy;

    wire cmd_accepted = cmd_valid && app_rdy;
    wire wdf_accepted = wdf_valid && app_wdf_rdy;
    wire rd_returned  = app_rd_data_valid && (state == S_READ) && (pending != 0);
    wire crc_returned = app_rd_data_valid && (state == S_CRC_W);
    wire ping_returned= app_rd_data_valid && (state == S_PING_W);

    wire progress = cmd_accepted || wdf_accepted || rd_returned || crc_returned ||
                    ping_returned || (state == S_CRC_P);

    // CRC byte processing.
    wire [31:0] next_crc_data = crc32_byte(crc_data_r, crc_shift_data[crc_byte*8 +: 8]);
    wire [31:0] next_crc_exp  = crc32_byte(crc_exp_r,  crc_shift_exp [crc_byte*8 +: 8]);

    always @(posedge ui_clk) begin
        if (rst) begin
            state          <= S_IDLE;
            issue_index    <= 24'd0;
            return_index   <= 24'd0;
            last_index     <= 24'd0;
            pending        <= 6'd0;
            all_issued     <= 1'b0;
            rd_active      <= 1'b0;
            cycle_cnt      <= 32'd0;
            rd_start       <= 32'd0;
            crc_start      <= 32'd0;
            busy           <= 1'b0;
            done           <= 1'b0;
            failed         <= 1'b0;
            state_dbg      <= 3'd0;
            wr_cycles      <= 32'd0;
            rd_cycles      <= 32'd0;
            crc_cycles     <= 32'd0;
            rd_beats       <= 32'd0;
            err_count      <= 32'd0;
            first_err_addr <= 32'd0;
            crc_data       <= 32'd0;
            crc_expected   <= 32'd0;
            crc_index      <= 24'd0;
            crc_wait_index <= 24'd0;
            crc_waiting    <= 1'b0;
            crc_shift_data <= 128'd0;
            crc_shift_exp  <= 128'd0;
            crc_byte       <= 4'd0;
            crc_data_r     <= 32'hFFFFFFFF;
            crc_exp_r      <= 32'hFFFFFFFF;
            stall_cycles   <= 32'd0;
            start_seen     <= 1'b0;
            ping_seen      <= 1'b0;
            ping_seq       <= 4'd0;
            ping_addr      <= 28'd0;
            ping_cmd_cycle <= 32'd0;
            ping_latency   <= 32'd0;
            ping_addr_used <= 32'd0;
        end else begin
            state_dbg <= state;

            if (busy)
                cycle_cnt <= cycle_cnt + 32'd1;

            if (progress || state == S_IDLE)
                stall_cycles <= 32'd0;
            else if (state != S_FIN)
                stall_cycles <= stall_cycles + 32'd1;

            if (start_pulse && !ping_pulse && !start_seen) begin
                start_seen   <= 1'b1;
                busy         <= 1'b1;
                done         <= 1'b0;
                failed       <= 1'b0;
                last_index   <= selected_last;
                issue_index  <= 24'd0;
                return_index <= 24'd0;
                pending      <= 6'd0;
                all_issued   <= 1'b0;
                rd_active    <= 1'b0;
                cycle_cnt    <= 32'd0;
                wr_cycles    <= 32'd0;
                rd_cycles    <= 32'd0;
                crc_cycles   <= 32'd0;
                rd_start     <= 32'd0;
                rd_beats     <= 32'd0;
                err_count    <= 32'd0;
                first_err_addr <= 32'd0;
                crc_index    <= 24'd0;
                crc_waiting  <= 1'b0;
                crc_byte     <= 4'd0;
                crc_data_r   <= 32'hFFFFFFFF;
                crc_exp_r    <= 32'hFFFFFFFF;
                stall_cycles <= 32'd0;
                if (!wr_en)
                    state <= S_READ;          // read-only pass starts at index 0
                else
                    state <= S_WDATA;
            end else if (ping_pulse && !ping_seen && !busy) begin
                ping_seen      <= 1'b1;
                busy           <= 1'b1;
                done           <= 1'b0;
                failed         <= 1'b0;
                cycle_cnt      <= 32'd0;
                ping_addr      <= ping_beat_addr(ping_seq);
                ping_addr_used <= {4'b0, ping_beat_addr(ping_seq)};
                ping_seq       <= ping_seq + 4'd1;
                ping_cmd_cycle <= 32'd0;
                ping_latency   <= 32'd0;
                stall_cycles   <= 32'd0;
                state          <= S_PING_I;
            end else begin
                if (!start_pulse)
                    start_seen <= 1'b0;
                if (!ping_pulse)
                    ping_seen <= 1'b0;

                if (state != S_IDLE && state != S_FIN && stall_cycles[31]) begin
                    failed <= 1'b1;
                    done   <= 1'b1;
                    busy   <= 1'b0;
                    state  <= S_FIN;
                end else begin
                    case (state)
                    S_IDLE: begin
                        if (start_pulse)
                            state <= wr_en ? S_WDATA : S_READ;
                    end

                    S_WDATA: begin
                        if (wdf_accepted)
                            state <= S_WCMD;
                    end

                    S_WCMD: begin
                        if (cmd_accepted) begin
                            if (issue_index == last_index) begin
                                wr_cycles <= cycle_cnt + 32'd1;
                                rd_start  <= cycle_cnt + 32'd1;
                                issue_index <= 24'd0;
                                return_index <= 24'd0;
                                pending <= 6'd0;
                                all_issued <= 1'b0;
                                rd_active <= 1'b1;
                                if (rd_en) begin
                                    state <= S_READ;
                                end else begin
                                    done <= 1'b1;
                                    busy <= 1'b0;
                                    state <= S_FIN;
                                end
                            end else begin
                                issue_index <= issue_index + 24'd1;
                                state <= S_WDATA;
                            end
                        end
                    end

                    S_READ: begin
                        case ({cmd_accepted, rd_returned})
                            2'b10: pending <= pending + 6'd1;
                            2'b01: pending <= pending - 6'd1;
                            default: ;
                        endcase

                        if (cmd_accepted) begin
                            if (issue_index == last_index)
                                all_issued <= 1'b1;
                            else
                                issue_index <= issue_index + 24'd1;
                        end

                        if (rd_returned) begin
                            if (app_rd_data != pattern(beat_addr(return_index))) begin
                                err_count <= err_count + 32'd1;
                                if (err_count == 32'd0)
                                    first_err_addr <= {4'b0, beat_addr(return_index)};
                                failed <= 1'b1;
                            end
                            rd_beats <= {8'd0, return_index} + 32'd1;
                            if (return_index == last_index) begin
                                rd_cycles <= cycle_cnt - rd_start;
                                crc_start <= cycle_cnt;
                                crc_index <= 24'd0;
                                crc_waiting <= 1'b0;
                                crc_data_r <= 32'hFFFFFFFF;
                                crc_exp_r  <= 32'hFFFFFFFF;
                                state <= crc_en ? S_CRC_I : S_FIN;
                                if (!crc_en) begin
                                    done <= 1'b1;
                                    busy <= 1'b0;
                                end
                            end else begin
                                return_index <= return_index + 24'd1;
                            end
                        end
                    end

                    S_CRC_I: begin
                        if (cmd_accepted) begin
                            crc_wait_index <= crc_index;
                            crc_waiting <= 1'b1;
                            state <= S_CRC_W;
                        end
                    end

                    S_CRC_W: begin
                        if (crc_returned) begin
                            crc_shift_data <= app_rd_data;
                            crc_shift_exp  <= pattern(beat_addr(crc_wait_index));
                            crc_byte <= 4'd0;
                            crc_waiting <= 1'b0;
                            state <= S_CRC_P;
                        end
                    end

                    S_CRC_P: begin
                        crc_data_r <= next_crc_data;
                        crc_exp_r  <= next_crc_exp;
                        if (crc_byte == 4'd15) begin
                            if (crc_index == last_index) begin
                                crc_data     <= next_crc_data ^ 32'hFFFFFFFF;
                                crc_expected <= next_crc_exp  ^ 32'hFFFFFFFF;
                                if ((next_crc_data ^ 32'hFFFFFFFF) !=
                                    (next_crc_exp  ^ 32'hFFFFFFFF))
                                    failed <= 1'b1;
                                crc_cycles <= cycle_cnt - crc_start;
                                done <= 1'b1;
                                busy <= 1'b0;
                                state <= S_FIN;
                            end else begin
                                crc_index <= crc_index + 24'd1;
                                state <= S_CRC_I;
                            end
                        end else begin
                            crc_byte <= crc_byte + 4'd1;
                        end
                    end

                    S_PING_I: begin
                        if (cmd_accepted) begin
                            ping_cmd_cycle <= cycle_cnt;
                            state <= S_PING_W;
                        end
                    end

                    S_PING_W: begin
                        if (ping_returned) begin
                            ping_latency <= cycle_cnt - ping_cmd_cycle;
                            done <= 1'b1;
                            busy <= 1'b0;
                            state <= S_FIN;
                        end
                    end

                    S_FIN: begin
                        busy <= 1'b0;
                    end

                        default: state <= S_FIN;
                    endcase
                end
            end
        end
    end
endmodule
