page-program-suspend

module TopModule (
    input  wire        clk,
    input  wire        rst,
    input  wire        start_i,
    input  wire [3:0]  count_i,
    input  wire [7:0]  waddr_i,
    input  wire [31:0] wseed_i,
    input  wire        susp_req_i,
    input  wire        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
);

    // State encoding
    localparam [1:0] IDLE   = 2'd0,
                     ACTIVE = 2'd1,
                     SUSP   = 2'd2,
                     REARM  = 2'd3;

    reg [1:0]  state;
    reg [1:0]  cnt;      // cycles elapsed in current 3-cycle window (0,1,2)
    reg [3:0]  k;        // current/parked word index
    reg [3:0]  count_r;  // latched count_i (words = count_r+1)
    reg [7:0]  waddr_r;  // latched base address
    reg [31:0] wseed_r;  // latched seed
    reg        pending;  // pending suspend request

    always @(posedge clk) begin
        if (rst) begin
            state         <= IDLE;
            cnt           <= 2'd0;
            k             <= 4'd0;
            count_r       <= 4'd0;
            waddr_r       <= 8'd0;
            wseed_r       <= 32'd0;
            pending       <= 1'b0;
            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;
        end else begin
            // Pulses default low
            done_o     <= 1'b0;
            susp_ack_o <= 1'b0;

            case (state)
                // ------------------------------------------------------------
                IDLE: begin
                    // Suspend/resume ignored while idle
                    if (start_i) begin
                        count_r       <= count_i;
                        waddr_r       <= waddr_i;
                        wseed_r       <= wseed_i;
                        busy_o        <= 1'b1;
                        committed_o   <= 5'd0;
                        k             <= 4'd0;
                        cnt           <= 2'd0;
                        cur_addr_o    <= waddr_i;
                        cur_data_o    <= wseed_i ^ 32'd1;
                        susp_active_o <= 1'b0;
                        pending       <= 1'b0;
                        state         <= ACTIVE;
                    end
                end
                // ------------------------------------------------------------
                ACTIVE: begin
                    if (cnt == 2'd2) begin
                        // Closing edge: commit the word
                        committed_o <= committed_o + 5'd1;
                        if (k == count_r) begin
                            // Final close
                            done_o     <= 1'b1;
                            busy_o     <= 1'b0;
                            cur_addr_o <= 8'd0;
                            cur_data_o <= 32'd0;
                            pending    <= 1'b0;   // final close discards pending
                            cnt        <= 2'd0;
                            state      <= IDLE;
                        end else if (pending | susp_req_i) begin
                            // Non-final close with suspend taking effect
                            susp_active_o <= 1'b1;
                            susp_ack_o    <= 1'b1;
                            cur_addr_o    <= 8'd0;
                            cur_data_o    <= 32'd0;
                            k             <= k + 4'd1;   // park before next word
                            pending       <= 1'b0;
                            state         <= SUSP;
                        end else begin
                            // Non-final close: open the next word
                            k          <= k + 4'd1;
                            cnt        <= 2'd0;
                            cur_addr_o <= waddr_r + {4'b0, k} + 8'd1;
                            cur_data_o <= wseed_r ^ ({28'b0, k} + 32'd2);
                            pending    <= 1'b0;
                        end
                    end else begin
                        // Window still open
                        cnt     <= cnt + 2'd1;
                        pending <= pending | susp_req_i;
                    end
                end
                // ------------------------------------------------------------
                SUSP: begin
                    // start_i and susp_req_i ignored while suspended
                    if (resume_i) begin
                        susp_active_o <= 1'b0;
                        pending       <= 1'b0;
                        state         <= REARM;
                    end
                end
                // ------------------------------------------------------------
                REARM: begin
                    // Re-arm edge: open the parked word with a full window
                    cur_addr_o <= waddr_r + {4'b0, k};
                    cur_data_o <= wseed_r ^ ({28'b0, k} + 32'd1);
                    cnt        <= 2'd0;
                    state      <= ACTIVE;
                end
                // ------------------------------------------------------------
                default: state <= IDLE;
            endcase
        end
    end

endmodule