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

    localparam [1:0] IDLE  = 2'd0,
                     BUSY  = 2'd1,
                     SUSP  = 2'd2,
                     REARM = 2'd3;

    reg [1:0]  state;
    reg [1:0]  ph;       // window phase: 0,1,2 -> close on the edge where ph==2
    reg [4:0]  k;        // current word index (0..count)
    reg [3:0]  count;    // latched count_i
    reg [7:0]  waddr;    // latched base address
    reg [31:0] wseed;    // latched seed
    reg        pending;  // pending suspend request

    always @(posedge clk) begin
        if (rst) begin
            state         <= IDLE;
            ph            <= 2'd0;
            k             <= 5'd0;
            count         <= 4'd0;
            waddr         <= 8'd0;
            wseed         <= 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
            // one-cycle pulse defaults
            done_o     <= 1'b0;
            susp_ack_o <= 1'b0;

            case (state)
                IDLE: begin
                    if (start_i) begin
                        count         <= count_i;
                        waddr         <= waddr_i;
                        wseed         <= wseed_i;
                        k             <= 5'd0;
                        committed_o   <= 5'd0;
                        pending       <= 1'b0;
                        ph            <= 2'd0;
                        busy_o        <= 1'b1;
                        susp_active_o <= 1'b0;
                        cur_addr_o    <= waddr_i;              // word 0 address
                        cur_data_o    <= wseed_i ^ 32'd1;      // word 0 data
                        state         <= BUSY;
                    end
                end

                BUSY: begin
                    if (ph == 2'd2) begin
                        // closing edge: commit the word
                        committed_o <= committed_o + 5'd1;
                        if (k == count) begin
                            // final close
                            done_o     <= 1'b1;
                            busy_o     <= 1'b0;
                            cur_addr_o <= 8'd0;
                            cur_data_o <= 32'd0;
                            pending    <= 1'b0;
                            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;
                            busy_o        <= 1'b1;
                            cur_addr_o    <= 8'd0;
                            cur_data_o    <= 32'd0;
                            pending       <= 1'b0;
                            k             <= k + 5'd1;   // park before next word
                            state         <= SUSP;
                        end else begin
                            // non-final close: open next word this same edge
                            k          <= k + 5'd1;
                            ph         <= 2'd0;
                            cur_addr_o <= waddr + k + 5'd1;
                            cur_data_o <= wseed ^ ({27'd0, k} + 32'd2);
                            state      <= BUSY;
                        end
                    end else begin
                        ph <= ph + 2'd1;
                        if (susp_req_i)
                            pending <= 1'b1;
                    end
                end

                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;
                        state         <= REARM;
                    end
                end

                REARM: begin
                    // one re-arm edge already passed; open the parked word now
                    ph         <= 2'd0;
                    busy_o     <= 1'b1;
                    cur_addr_o <= waddr + k;
                    cur_data_o <= wseed ^ ({27'd0, k} + 32'd1);
                    state      <= BUSY;
                end

                default: state <= IDLE;
            endcase
        end
    end

endmodule