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 IDLE  = 2'd0;
    localparam ACTIVE= 2'd1;
    localparam SUSP  = 2'd2;
    localparam REARM = 2'd3;

    reg [1:0]  state;
    reg [1:0]  cyc;      // cycle index within the current 3-cycle window
    reg [4:0]  widx;     // current word index (also parked index while suspended)
    reg [3:0]  count_r;  // latched count
    reg [7:0]  addr_r;   // latched base address
    reg [31:0] seed_r;   // latched seed
    reg        pending;  // pending suspend request

    reg [5:0]  nidx;     // next word index (helper)

    always @(posedge clk) begin
        if (rst) begin
            state         <= IDLE;
            cyc           <= 2'd0;
            widx          <= 5'd0;
            count_r       <= 4'd0;
            addr_r        <= 8'd0;
            seed_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
            // one-cycle 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;
                        addr_r        <= waddr_i;
                        seed_r        <= wseed_i;
                        widx          <= 5'd0;
                        cyc           <= 2'd0;
                        committed_o   <= 5'd0;
                        pending       <= 1'b0;
                        busy_o        <= 1'b1;
                        susp_active_o <= 1'b0;
                        cur_addr_o    <= waddr_i;             // word0: addr = waddr_i + 0
                        cur_data_o    <= wseed_i ^ 32'd1;     // word0: data = seed ^ (0+1)
                        state         <= ACTIVE;
                    end else begin
                        busy_o <= 1'b0;
                        // committed_o holds prior final count
                    end
                end

                ACTIVE: begin
                    if (cyc == 2'd2) begin
                        // closing edge: commit this word
                        committed_o <= committed_o + 5'd1;
                        if (widx == {1'b0, 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
                            state      <= IDLE;
                        end else begin
                            nidx = {1'b0, widx} + 6'd1;
                            if (pending | susp_req_i) begin
                                // suspend edge: 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;
                                widx          <= nidx[4:0];
                                state         <= SUSP;
                            end else begin
                                // open next word on this same edge
                                widx       <= nidx[4:0];
                                cyc        <= 2'd0;
                                cur_addr_o <= addr_r + nidx[7:0];
                                cur_data_o <= seed_r ^ {26'd0, (nidx + 6'd1)};
                                busy_o     <= 1'b1;
                            end
                        end
                    end else begin
                        // mid-window: hold address/data, sample suspend request
                        cyc <= cyc + 2'd1;
                        if (susp_req_i)
                            pending <= 1'b1;
                    end
                end

                SUSP: begin
                    // ignore start_i and susp_req_i while suspended
                    // busy_o, susp_active_o, and zeroed addr/data hold
                    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 elapsed; open parked word now
                    // ignore start_i and susp_req_i on this edge
                    cyc        <= 2'd0;
                    busy_o     <= 1'b1;
                    cur_addr_o <= addr_r + {3'd0, widx};
                    cur_data_o <= seed_r ^ {27'd0, (widx + 5'd1)};
                    state      <= ACTIVE;
                end

                default: state <= IDLE;
            endcase
        end
    end

endmodule