page-program-suspend

module TopModule(
    input             clk,
    input             rst,
    input             start_i,
    input      [3:0]  count_i,
    input      [7:0]  waddr_i,
    input      [31:0] wseed_i,
    input             susp_req_i,
    input             resume_i,
    output reg        busy_o,
    output reg        done_o,
    output reg        susp_active_o,
    output reg        susp_ack_o,
    output reg [4:0]  committed_o,
    output reg [7:0]  cur_addr_o,
    output reg [31:0] cur_data_o
);

    localparam S_IDLE   = 2'd0,
               S_ACTIVE = 2'd1,
               S_SUSP   = 2'd2,
               S_REARM  = 2'd3;

    reg [1:0]  st;
    reg [3:0]  word_idx;    // index of the currently open / parked word
    reg [3:0]  count_l;     // latched count_i (words = count_l + 1)
    reg [7:0]  base_addr;   // latched waddr_i
    reg [31:0] seed;        // latched wseed_i
    reg [1:0]  wcnt;        // cycles elapsed in current window (0..2)
    reg        pending;     // pending suspend request

    wire [3:0] nidx = word_idx + 4'd1;   // next word index

    always @(posedge clk) begin
        if (rst) begin
            st            <= S_IDLE;
            busy_o        <= 1'b0;
            done_o        <= 1'b0;
            susp_active_o <= 1'b0;
            susp_ack_o    <= 1'b0;
            committed_o   <= 5'd0;
            cur_addr_o    <= 8'd0;
            cur_data_o    <= 32'd0;
            word_idx      <= 4'd0;
            count_l       <= 4'd0;
            base_addr     <= 8'd0;
            seed          <= 32'd0;
            wcnt          <= 2'd0;
            pending       <= 1'b0;
        end else begin
            // pulse defaults
            done_o     <= 1'b0;
            susp_ack_o <= 1'b0;

            case (st)
                S_IDLE: begin
                    // idle suspend/resume ignored
                    if (start_i) begin
                        count_l     <= count_i;
                        base_addr   <= waddr_i;
                        seed        <= wseed_i;
                        word_idx    <= 4'd0;
                        committed_o <= 5'd0;
                        wcnt        <= 2'd0;
                        pending     <= 1'b0;
                        busy_o      <= 1'b1;
                        cur_addr_o  <= waddr_i;
                        cur_data_o  <= wseed_i ^ 32'd1;
                        st          <= S_ACTIVE;
                    end
                end

                S_ACTIVE: begin
                    if (wcnt == 2'd2) begin
                        // closing edge: commit the word
                        committed_o <= committed_o + 5'd1;
                        if (word_idx == count_l) begin
                            // final close: discards any pending suspend
                            done_o     <= 1'b1;
                            busy_o     <= 1'b0;
                            cur_addr_o <= 8'd0;
                            cur_data_o <= 32'd0;
                            pending    <= 1'b0;
                            wcnt       <= 2'd0;
                            st         <= S_IDLE;
                        end else begin
                            word_idx <= nidx;
                            if (pending || susp_req_i) begin
                                // non-final close with suspend: park before next word
                                susp_active_o <= 1'b1;
                                susp_ack_o    <= 1'b1;
                                busy_o        <= 1'b1;
                                cur_addr_o    <= 8'd0;
                                cur_data_o    <= 32'd0;
                                pending       <= 1'b0;
                                st            <= S_SUSP;
                            end else begin
                                // open next word on this same edge
                                wcnt       <= 2'd0;
                                cur_addr_o <= base_addr + {4'd0, nidx};
                                cur_data_o <= seed ^ ({28'd0, nidx} + 32'd1);
                                st         <= S_ACTIVE;
                            end
                        end
                    end else begin
                        wcnt    <= wcnt + 2'd1;
                        pending <= pending | susp_req_i;   // sample within window
                    end
                end

                S_SUSP: begin
                    // ignore start_i and susp_req_i while suspended
                    if (resume_i) begin
                        susp_active_o <= 1'b0;
                        pending       <= 1'b0;
                        busy_o        <= 1'b1;
                        cur_addr_o    <= 8'd0;
                        cur_data_o    <= 32'd0;
                        st            <= S_REARM;   // one re-arm edge
                    end
                end

                S_REARM: begin
                    // parked word opens on this edge with a full window
                    wcnt          <= 2'd0;
                    busy_o        <= 1'b1;
                    susp_active_o <= 1'b0;
                    cur_addr_o    <= base_addr + {4'd0, word_idx};
                    cur_data_o    <= seed ^ ({28'd0, word_idx} + 32'd1);
                    st            <= S_ACTIVE;
                end

                default: st <= S_IDLE;
            endcase
        end
    end

endmodule