module PRBS_CHK(CLK, RESET, DIN, DVAL, LOCK);

parameter ST_IDLE    = 0;
parameter ST_LOAD0   = 1;
parameter ST_LOAD1   = 2;
parameter ST_LOAD2   = 3;
parameter ST_LOAD3   = 4;
parameter ST_LOAD4   = 5;
parameter ST_MATCH   = 6;

// LFSR size
parameter N = 5;


input          CLK;
input          RESET;      // Asynchronous reset (active-high)
input          DIN;        // Input data
input          DVAL;       // Data valid strobe
                          //    1 => DIN is PRBS
                          //    0 => DIN needs to be disregarded


output         LOCK;       // PRBS lock indicator
                          //    1 => Sequence lock achieved
                          //    0 => DIN is not a valid sequence


reg            LOCK, LOCK_N;        // Next state of LOCK output
reg   [2:0]    STATE, STATE_N;      // State variable for checker FSM
reg            LOAD_EN, LOAD_EN_N;  // Enables LFSR load signal
reg            DEL_DIN;             // DIN delayed by 1 clock cycle
reg            DEL_DVAL;            // DVAL delayed by 1 clock cycle
reg            LFSR_SHIFT, LFSR_SHIFT_N;  // LFSR's SHIFT
wire  [N-1:0]  LFSR_DOUT;           // LFSR output
wire           LFSR_LOAD;           // LFSR's LOAD



// Instantiate the LFSR with parameters
defparam lfsr.N = N;       // N-bit LFSR
defparam lfsr.tap0 = 0;
defparam lfsr.tap1 = 2;
defparam lfsr.tap2 = 2;
defparam lfsr.tap3 = 2;

LFSR lfsr (
  .CLK(CLK),
  .RESET(RESET),
  .DIN(DIN),
  .LOAD(LFSR_LOAD),
  .SHIFT(LFSR_SHIFT),
  .Q(LFSR_DOUT)
);


always @ (posedge CLK or posedge RESET)
begin
  if (RESET) begin
     DEL_DIN  <= #1 1'b0;
     LOCK     <= #1 1'b0;
     STATE    <= #1 ST_IDLE;
     LOAD_EN  <= #1 1'b0;
     LFSR_SHIFT <= #1 1'b0;
   end
  else begin
     DEL_DIN  <= #1 DIN;
     DEL_DVAL <= #1 DVAL;
     LOCK     <= #1 LOCK_N;
     STATE    <= #1 STATE_N;
     LOAD_EN  <= #1 LOAD_EN_N;
     LFSR_SHIFT <= #1 LFSR_SHIFT_N;
   end
end



// LFSR control signals
assign LFSR_LOAD = DVAL & LOAD_EN;

// Checker FSM
always @ (  DIN or DEL_DIN or DVAL or LFSR_DOUT[4] or LOCK or
           STATE or LOAD_EN or SHIFT_EN)
begin
  // Keep things in a known state by default
  STATE_N    = STATE;
  LOCK_N     = LOCK;
  LOAD_EN_N  = LOAD_EN;
  LFSR_SHIFT_N = 1'b0;
 
  // FSM
  case (STATE)
     // Idle until valid data arrives. Go to LOAD0 state then.
     ST_IDLE : begin
        if (DVAL) begin
           STATE_N = ST_LOAD0;
           LOAD_EN_N  = 1'b1;
        end
     end
     
     // Load received bit into the LFSR, wait till next valid bit.
     ST_LOAD0 : begin
        if (DVAL) begin
           STATE_N = ST_LOAD1;
           LOAD_EN_N = 1'b1;
        end
     end
     
     // Load received bit into the LFSR, wait till next valid bit.
     ST_LOAD1 : begin
        if (DVAL) begin
           STATE_N = ST_LOAD2;
           LOAD_EN_N = 1'b1;
        end
     end
     
     // Load received bit into the LFSR, wait till next valid bit.
     ST_LOAD2 : begin
        if (DVAL) begin
           STATE_N = ST_LOAD3;
           LOAD_EN_N = 1'b1;
        end
     end
     
     // Load received bit into the LFSR, wait till next valid bit.
     ST_LOAD3 : begin
        if (DVAL) begin
           STATE_N = ST_LOAD4;
           LOAD_EN_N = 1'b1;
        end
     end

     // Load received bit into the LFSR, wait till next valid bit.
     ST_LOAD4 : begin
        if (DVAL) begin
           STATE_N = ST_MATCH;
           LFSR_SHIFT_N = 1'b1;
           LOAD_EN_N = 1'b0;
        end
     end
     
     ST_MATCH : begin
        if (DVAL) begin
           LFSR_SHIFT_N = 1'b1;
           LOCK_N = LFSR_DOUT[4] == DEL_DIN;
           if (LFSR_DOUT[4] != DEL_DIN)
              STATE_N = ST_IDLE;
        end
     end
     
     default:
        STATE_N = ST_IDLE;
  endcase      
end

endmodule