pluto_hdl_adi/library/axi_ad4858/axi_ad4858_cmos.v

// ***************************************************************************
// ***************************************************************************
// Copyright (C) 2023 Analog Devices, Inc. All rights reserved.
//
// In this HDL repository, there are many different and unique modules, consisting
// of various HDL (Verilog or VHDL) components. The individual modules are
// developed independently, and may be accompanied by separate and unique license
// terms.
//
// The user should read each of these license terms, and understand the
// freedoms and responsibilities that he or she has by using this source/core.
//
// This core is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
// A PARTICULAR PURPOSE.
//
// Redistribution and use of source or resulting binaries, with or without modification
// of this file, are permitted under one of the following two license terms:
//
//   1. The GNU General Public License version 2 as published by the
//      Free Software Foundation, which can be found in the top level directory
//      of this repository (LICENSE_GPL2), and also online at:
//      <https://www.gnu.org/licenses/old-licenses/gpl-2.0.html>
//
// OR
//
//   2. An ADI specific BSD license, which can be found in the top level directory
//      of this repository (LICENSE_ADIBSD), and also on-line at:
//      https://github.com/analogdevicesinc/hdl/blob/main/LICENSE_ADIBSD
//      This will allow to generate bit files and not release the source code,
//      as long as it attaches to an ADI device.
//
// ***************************************************************************
// ***************************************************************************

`timescale 1ns/100ps

module axi_ad4858_cmos #(

  parameter FPGA_TECHNOLOGY = 0,
  parameter DELAY_REFCLK_FREQ = 200,
  parameter IODELAY_ENABLE = 1,
  parameter IODELAY_GROUP = "dev_if_delay_group",
  parameter ACTIVE_LANE = 8'b11111111
) (

  input                   rst,
  input                   clk,
  input        [ 7:0]     adc_enable,
  input                   adc_crc_enable,

  // physical interface

  output                  scki,
  input                   scko,
  input       [ 7:0]      db_i,
  input                   busy,
  input                   cnvs,

  // format

  input       [ 1:0]      packet_format,
  input                   oversampling_en,

  // channel interface

  output     [255:0]      adc_data,
  output reg              adc_valid,
  output reg              crc_error,
  output      [ 7:0]      dev_status,

  // delay interface (for IDELAY macros)

  input                   up_clk,
  input       [ 7:0]      up_adc_dld,
  input       [39:0]      up_adc_dwdata,
  output      [39:0]      up_adc_drdata,
  input                   delay_clk,
  input                   delay_rst,
  output                  delay_locked
);

  localparam NEG_EDGE = 1;
  localparam DW = 32;
  localparam BW = DW - 1;
  localparam PACKET_1_BITS = 20;
  localparam PACKET_2_BITS = 24;
  localparam PACKET_3_BITS = 32;

  // internal registers

  reg         [BW:0]  adc_lane_0;
  reg         [BW:0]  adc_lane_1;
  reg         [BW:0]  adc_lane_2;
  reg         [BW:0]  adc_lane_3;
  reg         [BW:0]  adc_lane_4;
  reg         [BW:0]  adc_lane_5;
  reg         [BW:0]  adc_lane_6;
  reg         [BW:0]  adc_lane_7;

  reg         [ 5:0]  data_counter = 6'h0;
  reg         [ 5:0]  scki_counter = 6'h0;

  reg                 scki_i;
  reg                 scki_d;

  reg         [BW:0]  adc_data_store[8:0];
  reg         [BW:0]  adc_data_init[7:0];
  reg                 adc_valid_init;
  reg                 adc_valid_init_d;

  reg         [ 8:0]  ch_capture;
  reg         [ 8:0]  ch_captured;

  reg         [ 4:0]  adc_ch0_shift;
  reg         [ 4:0]  adc_ch1_shift;
  reg         [ 4:0]  adc_ch2_shift;
  reg         [ 4:0]  adc_ch3_shift;
  reg         [ 4:0]  adc_ch4_shift;
  reg         [ 4:0]  adc_ch5_shift;
  reg         [ 4:0]  adc_ch6_shift;
  reg         [ 4:0]  adc_ch7_shift;

  reg         [ 4:0]  adc_ch0_shift_d;
  reg         [ 4:0]  adc_ch1_shift_d;
  reg         [ 4:0]  adc_ch2_shift_d;
  reg         [ 4:0]  adc_ch3_shift_d;
  reg         [ 4:0]  adc_ch4_shift_d;
  reg         [ 4:0]  adc_ch5_shift_d;
  reg         [ 4:0]  adc_ch6_shift_d;
  reg         [ 4:0]  adc_ch7_shift_d;

  reg         [ 3:0]  lane_0_data = 'd0;
  reg         [ 3:0]  lane_1_data = 'd0;
  reg         [ 3:0]  lane_2_data = 'd0;
  reg         [ 3:0]  lane_3_data = 'd0;
  reg         [ 3:0]  lane_4_data = 'd0;
  reg         [ 3:0]  lane_5_data = 'd0;
  reg         [ 3:0]  lane_6_data = 'd0;
  reg         [ 3:0]  lane_7_data = 'd0;
  reg         [ 8:0]  ch_data_lock = 'h1ff;

  reg                 busy_m1;
  reg                 busy_m2;
  reg                 cnvs_d;
  reg         [31:0]  period_cnt;

  reg                 conversion_quiet_time;
  reg                 run_busy_period_cnt;
  reg         [31:0]  busy_conversion_cnt;
  reg         [31:0]  busy_measure_value;
  reg                 start_transfer;

  reg                 crc_enable_window;
  reg                 run_crc;
  reg                 run_crc_d;
  reg        [288:0]  crc_data_in;
  reg         [15:0]  crc_cnt;
  reg         [ 7:0]  data_in_byte;

  // internal wires

  wire        [ 7:0]  db_s;

  wire        [31:0]  status_and_crc_data;

  wire                aquire_data;
  wire                scki_cnt_rst;
  wire                adc_cnvs_redge;
  wire                conversion_completed;
  wire                conversion_quiet_time_s;

  wire        [ 5:0]  packet_lenght;

  wire                crc_reset;
  wire                crc_enable;
  wire                crc_valid;
  wire        [15:0]  crc_res;
  wire        [15:0]  crc_data_lenght;

  // packet format selection

  assign packet_lenght = packet_format == 2'd0 ? 6'd20 :
                         packet_format == 2'd1 ? 6'd24 : 6'd32;

  always @(posedge clk) begin
    if (rst == 1'b1) begin
      busy_m1 <= 1'b0;
      busy_m2 <= 1'b0;
      start_transfer <= 1'b0;
    end else begin
      busy_m1 <= busy;
      busy_m2 <= busy_m1;
      start_transfer <= busy_m2 & !busy_m1;
    end
  end

  always @(posedge clk) begin
    if (start_transfer) begin
      crc_enable_window <= adc_crc_enable;
    end
  end

  always @(posedge clk) begin
    if (rst) begin
      scki_counter <= 5'h0;
      scki_i <= 1'b1;
      scki_d <=  1'b0;
    end else begin
      scki_d <= scki_i;
      if (aquire_data == 1'b0) begin
        scki_counter <= 5'h0;
        scki_i <= 1'b1;
      end else if (scki_cnt_rst & (scki_d & ~scki_i)) begin // end of a capture
        scki_counter <= 5'h1;
        scki_i <= 1'b1;
      end else if (scki_i == 1'b0) begin
        scki_counter <= scki_counter + 1;
        scki_i <= 1'b1;
      end else if (conversion_quiet_time_s == 1'b1) begin
        scki_counter <= scki_counter;
        scki_i <= scki_i;
      end else begin
        scki_counter <= scki_counter;
        scki_i <= ~scki_i;
      end
    end
  end

  // busy period counter
  always @(posedge clk) begin
    if (rst == 1'b1) begin
      run_busy_period_cnt <= 1'b0;
      busy_conversion_cnt <= 'd0;
      busy_measure_value <= 'd0;
    end else begin
      if (cnvs == 1'b1 && busy_m2 == 1'b1) begin
        run_busy_period_cnt <= 1'b1;
      end else if (start_transfer == 1'b1) begin
        run_busy_period_cnt <= 1'b0;
      end

      if (adc_cnvs_redge == 1'b1) begin
        busy_conversion_cnt <= 'd0;
      end else if (start_transfer == 1'b1) begin
        busy_measure_value <= busy_conversion_cnt;
      end else if (run_busy_period_cnt == 1'b1) begin
        busy_conversion_cnt <= busy_conversion_cnt + 'd1;
      end
    end
  end

  always @(posedge clk) begin
    if (rst) begin
      period_cnt <= 'd0;
      cnvs_d <= 'd0;
      conversion_quiet_time <= 1'b0;
    end else begin
      cnvs_d <= cnvs;
      if (oversampling_en == 1 && adc_cnvs_redge == 1'b1) begin
        conversion_quiet_time <= 1'b1;
      end else begin
        conversion_quiet_time <= conversion_quiet_time & ~conversion_completed;
      end
      if (adc_cnvs_redge == 1'b1) begin
        period_cnt <= 'd0;
      end else begin
        period_cnt <= period_cnt + 1;
      end
    end
  end

  assign conversion_quiet_time_s = (oversampling_en == 1) ? conversion_quiet_time | cnvs : 1'b0;
  assign conversion_completed = (period_cnt == busy_measure_value) ? 1'b1 : 1'b0;
  assign adc_cnvs_redge = ~cnvs_d & cnvs;
  assign scki_cnt_rst = (scki_counter == packet_lenght) ? 1'b1 : 1'b0;
  assign scki = scki_i | ~aquire_data;

  /*
  The device sends each channel data on one of the 8 lines.
  Data is stored in the device in a ring buffer. After the first packet is read
  and no new conversion is activated if the reading process restarted,
  the new data on the lines will be from the next index from the ring buffer.
  e.g For second read process without a conversion start
  line 0 = channel 1, line 1 = channel 2, line 2 = channel 3; so on and so forth.
  */

  always @(posedge clk) begin
    if (start_transfer) begin
      lane_0_data <= 4'd0;
      lane_1_data <= 4'd1;
      lane_2_data <= 4'd2;
      lane_3_data <= 4'd3;
      lane_4_data <= 4'd4;
      lane_5_data <= 4'd5;
      lane_6_data <= 4'd6;
      lane_7_data <= 4'd7;
      ch_data_lock <= 9'd0;
    end else if (aquire_data == 1'b1 && (scki_cnt_rst & (~scki_d & scki_i))) begin
      lane_0_data <= lane_0_data[3] == 1'b1 ? 4'd0 : lane_0_data + 1;
      lane_1_data <= lane_1_data[3] == 1'b1 ? 4'd0 : lane_1_data + 1;
      lane_2_data <= lane_2_data[3] == 1'b1 ? 4'd0 : lane_2_data + 1;
      lane_3_data <= lane_3_data[3] == 1'b1 ? 4'd0 : lane_3_data + 1;
      lane_4_data <= lane_4_data[3] == 1'b1 ? 4'd0 : lane_4_data + 1;
      lane_5_data <= lane_5_data[3] == 1'b1 ? 4'd0 : lane_5_data + 1;
      lane_6_data <= lane_6_data[3] == 1'b1 ? 4'd0 : lane_6_data + 1;
      lane_7_data <= lane_7_data[3] == 1'b1 ? 4'd0 : lane_7_data + 1;
      ch_data_lock[lane_0_data[3:0]] <= ACTIVE_LANE[0] ? 1'b1 : ch_data_lock[lane_0_data[2:0]];
      ch_data_lock[lane_1_data[3:0]] <= ACTIVE_LANE[1] ? 1'b1 : ch_data_lock[lane_1_data[2:0]];
      ch_data_lock[lane_2_data[3:0]] <= ACTIVE_LANE[2] ? 1'b1 : ch_data_lock[lane_2_data[2:0]];
      ch_data_lock[lane_3_data[3:0]] <= ACTIVE_LANE[3] ? 1'b1 : ch_data_lock[lane_3_data[2:0]];
      ch_data_lock[lane_4_data[3:0]] <= ACTIVE_LANE[4] ? 1'b1 : ch_data_lock[lane_4_data[2:0]];
      ch_data_lock[lane_5_data[3:0]] <= ACTIVE_LANE[5] ? 1'b1 : ch_data_lock[lane_5_data[2:0]];
      ch_data_lock[lane_6_data[3:0]] <= ACTIVE_LANE[6] ? 1'b1 : ch_data_lock[lane_6_data[2:0]];
      ch_data_lock[lane_7_data[3:0]] <= ACTIVE_LANE[7] ? 1'b1 : ch_data_lock[lane_7_data[2:0]];
    end else begin
      lane_0_data <= lane_0_data;
      lane_1_data <= lane_1_data;
      lane_2_data <= lane_2_data;
      lane_3_data <= lane_3_data;
      lane_4_data <= lane_4_data;
      lane_5_data <= lane_5_data;
      lane_6_data <= lane_6_data;
      lane_7_data <= lane_7_data;
      ch_data_lock <= ch_data_lock;
    end
  end

  assign aquire_data = ~((ch_data_lock[0] | ~adc_enable[0]) &
                         (ch_data_lock[1] | ~adc_enable[1]) &
                         (ch_data_lock[2] | ~adc_enable[2]) &
                         (ch_data_lock[3] | ~adc_enable[3]) &
                         (ch_data_lock[4] | ~adc_enable[4]) &
                         (ch_data_lock[5] | ~adc_enable[5]) &
                         (ch_data_lock[6] | ~adc_enable[6]) &
                         (ch_data_lock[7] | ~adc_enable[7]) &
                         (ch_data_lock[8] | ~crc_enable_window));

  // capture data

  genvar i;
  generate
    if (IODELAY_ENABLE == 1) begin
      ad_data_in #(
        .SINGLE_ENDED (1),
        .DDR_SDR_N (0),
        .FPGA_TECHNOLOGY (FPGA_TECHNOLOGY),
        .IODELAY_CTRL (1),
        .IODELAY_ENABLE (IODELAY_ENABLE),
        .IODELAY_GROUP (IODELAY_GROUP),
        .REFCLK_FREQUENCY (DELAY_REFCLK_FREQ)
      ) i_rx_data (
        .rx_clk (scko),
        .rx_data_in_p (db_i[0]),
        .rx_data_in_n (1'd0),
        .rx_data_p (db_s[0]),
        .rx_data_n (),
        .up_clk (up_clk),
        .up_dld (up_adc_dld[0]),
        .up_dwdata (up_adc_dwdata[4:0]),
        .up_drdata (up_adc_drdata[4:0]),
        .delay_clk (delay_clk),
        .delay_rst (delay_rst),
        .delay_locked (delay_locked));
    end
    for (i = 1; i < 8; i = i + 1) begin: g_rx_lanes
      ad_data_in #(
        .SINGLE_ENDED (1),
        .DDR_SDR_N (0),
        .FPGA_TECHNOLOGY (FPGA_TECHNOLOGY),
        .IODELAY_CTRL (0),
        .IODELAY_ENABLE (IODELAY_ENABLE),
        .IODELAY_GROUP (IODELAY_GROUP),
        .REFCLK_FREQUENCY (DELAY_REFCLK_FREQ)
      ) i_rx_data (
        .rx_clk (scko),
        .rx_data_in_p (db_i[i]),
        .rx_data_in_n (1'd0),
        .rx_data_p (db_s[i]),
        .rx_data_n (),
        .up_clk (up_clk),
        .up_dld (up_adc_dld[i]),
        .up_dwdata (up_adc_dwdata[((i*5)+4):(i*5)]),
        .up_drdata (up_adc_drdata[((i*5)+4):(i*5)]),
        .delay_clk (delay_clk),
        .delay_rst (delay_rst),
        .delay_locked ());
    end
  endgenerate

  // the most significant bits of the adc_lane_x will remaind from the
  // previous sample for packet formats other than 32.

  always @(negedge scko) begin
    adc_lane_0 <= {adc_lane_0[BW-1:0], db_s[0]};
    adc_lane_1 <= {adc_lane_1[BW-1:0], db_s[1]};
    adc_lane_2 <= {adc_lane_2[BW-1:0], db_s[2]};
    adc_lane_3 <= {adc_lane_3[BW-1:0], db_s[3]};
    adc_lane_4 <= {adc_lane_4[BW-1:0], db_s[4]};
    adc_lane_5 <= {adc_lane_5[BW-1:0], db_s[5]};
    adc_lane_6 <= {adc_lane_6[BW-1:0], db_s[6]};
    adc_lane_7 <= {adc_lane_7[BW-1:0], db_s[7]};
  end

  always @(posedge clk) begin
    if (rst == 1'b1) begin
      adc_valid_init <= 1'b0;
    end else begin
      if (data_counter == packet_lenght && adc_valid_init == 1'b0) begin
        adc_valid_init <= 1'b1;
      end else begin
        adc_valid_init <= 1'b0;
      end
    end
  end

  always @(posedge clk) begin
    if (rst == 1'b1) begin
      adc_data_init[0] <= 'h0;
      adc_data_init[1] <= 'h0;
      adc_data_init[2] <= 'h0;
      adc_data_init[3] <= 'h0;
      adc_data_init[4] <= 'h0;
      adc_data_init[5] <= 'h0;
      adc_data_init[6] <= 'h0;
      adc_data_init[7] <= 'h0;
      data_counter <= 'h0;
    end else begin
      data_counter <= scki_counter;
      if (data_counter == packet_lenght) begin
        adc_data_init[0] <= adc_lane_0;
        adc_data_init[1] <= adc_lane_1;
        adc_data_init[2] <= adc_lane_2;
        adc_data_init[3] <= adc_lane_3;
        adc_data_init[4] <= adc_lane_4;
        adc_data_init[5] <= adc_lane_5;
        adc_data_init[6] <= adc_lane_6;
        adc_data_init[7] <= adc_lane_7;
      end else begin
        adc_data_init[0] <= adc_data_init[0];
        adc_data_init[1] <= adc_data_init[1];
        adc_data_init[2] <= adc_data_init[2];
        adc_data_init[3] <= adc_data_init[3];
        adc_data_init[4] <= adc_data_init[4];
        adc_data_init[5] <= adc_data_init[5];
        adc_data_init[6] <= adc_data_init[6];
        adc_data_init[7] <= adc_data_init[7];
      end
    end
  end

  always @(posedge clk) begin
    if (rst == 1'b1 || adc_valid == 1'b1) begin
      adc_valid <= 1'b0;
      adc_valid_init_d <= 1'b0;
      ch_capture <= 9'd0;
      ch_captured <= 9'd0;

      adc_ch0_shift <= 4'd0;
      adc_ch1_shift <= 4'd0;
      adc_ch2_shift <= 4'd0;
      adc_ch3_shift <= 4'd0;
      adc_ch4_shift <= 4'd0;
      adc_ch5_shift <= 4'd0;
      adc_ch6_shift <= 4'd0;
      adc_ch7_shift <= 4'd0;
      adc_ch0_shift_d <= 4'd0;
      adc_ch1_shift_d <= 4'd0;
      adc_ch2_shift_d <= 4'd0;
      adc_ch3_shift_d <= 4'd0;
      adc_ch4_shift_d <= 4'd0;
      adc_ch5_shift_d <= 4'd0;
      adc_ch6_shift_d <= 4'd0;
      adc_ch7_shift_d <= 4'd0;
    end else begin
      ch_capture <= ch_data_lock;
      ch_captured <= ch_capture;
      adc_valid_init_d <= adc_valid_init;

      adc_ch0_shift <= {ACTIVE_LANE[0],lane_0_data};
      adc_ch1_shift <= {ACTIVE_LANE[1],lane_1_data};
      adc_ch2_shift <= {ACTIVE_LANE[2],lane_2_data};
      adc_ch3_shift <= {ACTIVE_LANE[3],lane_3_data};
      adc_ch4_shift <= {ACTIVE_LANE[4],lane_4_data};
      adc_ch5_shift <= {ACTIVE_LANE[5],lane_5_data};
      adc_ch6_shift <= {ACTIVE_LANE[6],lane_6_data};
      adc_ch7_shift <= {ACTIVE_LANE[7],lane_7_data};
      adc_ch0_shift_d <= adc_ch0_shift;
      adc_ch1_shift_d <= adc_ch1_shift;
      adc_ch2_shift_d <= adc_ch2_shift;
      adc_ch3_shift_d <= adc_ch3_shift;
      adc_ch4_shift_d <= adc_ch4_shift;
      adc_ch5_shift_d <= adc_ch5_shift;
      adc_ch6_shift_d <= adc_ch6_shift;
      adc_ch7_shift_d <= adc_ch7_shift;
      adc_valid <= adc_valid_init_d &
                     (ch_captured[0] | ~adc_enable[0]) &
                     (ch_captured[1] | ~adc_enable[1]) &
                     (ch_captured[2] | ~adc_enable[2]) &
                     (ch_captured[3] | ~adc_enable[3]) &
                     (ch_captured[4] | ~adc_enable[4]) &
                     (ch_captured[5] | ~adc_enable[5]) &
                     (ch_captured[6] | ~adc_enable[6]) &
                     (ch_captured[7] | ~adc_enable[7]) &
                     (ch_captured[8] | ~crc_enable_window);
    end
  end

  always @(posedge clk) begin
    if (rst == 1'b1) begin
      adc_data_store[0] <= 'd0;
      adc_data_store[1] <= 'd0;
      adc_data_store[2] <= 'd0;
      adc_data_store[3] <= 'd0;
      adc_data_store[4] <= 'd0;
      adc_data_store[5] <= 'd0;
      adc_data_store[6] <= 'd0;
      adc_data_store[7] <= 'd0;
      adc_data_store[8] <= 'd0;
    end else begin
      if (!adc_valid_init_d & adc_valid_init) begin
        if (adc_ch0_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch0_shift_d[3:0]] <= adc_data_init[0];
        end
        if (adc_ch1_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch1_shift_d[3:0]] <= adc_data_init[1];
        end
        if (adc_ch2_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch2_shift_d[3:0]] <= adc_data_init[2];
        end
        if (adc_ch3_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch3_shift_d[3:0]] <= adc_data_init[3];
        end
        if (adc_ch4_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch4_shift_d[3:0]] <= adc_data_init[4];
        end
        if (adc_ch5_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch5_shift_d[3:0]] <= adc_data_init[5];
        end
        if (adc_ch6_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch6_shift_d[3:0]] <= adc_data_init[6];
        end
        if (adc_ch7_shift_d[4] == 1'b1) begin
          adc_data_store[adc_ch7_shift_d[3:0]] <= adc_data_init[7];
        end
      end
    end
  end

  assign dev_status = packet_format == 0 ? adc_data_store[8][23:16] << 4 :
                                           adc_data_store[8][23:16];
  assign crc_data = adc_data_store[8][15:0];
  assign adc_data = {adc_data_store[7],
                     adc_data_store[6],
                     adc_data_store[5],
                     adc_data_store[4],
                     adc_data_store[3],
                     adc_data_store[2],
                     adc_data_store[1],
                     adc_data_store[0]};

  // CRC checker logic

  always @(posedge clk) begin
    if (rst == 1) begin
      crc_data_in <= 0;
    end else begin
      if (adc_valid == 1) begin
        if (packet_format == 0) begin
          crc_data_in <= {104'd0,
                          adc_data_store[0][19:0],
                          adc_data_store[1][19:0],
                          adc_data_store[2][19:0],
                          adc_data_store[3][19:0],
                          adc_data_store[4][19:0],
                          adc_data_store[5][19:0],
                          adc_data_store[6][19:0],
                          adc_data_store[7][19:0],
                          adc_data_store[8][19:0],
                          4'd0};
        end else if (packet_format == 1) begin
          crc_data_in <= {72'd0,
                          adc_data_store[0][23:0],
                          adc_data_store[1][23:0],
                          adc_data_store[2][23:0],
                          adc_data_store[3][23:0],
                          adc_data_store[4][23:0],
                          adc_data_store[5][23:0],
                          adc_data_store[6][23:0],
                          adc_data_store[7][23:0],
                          adc_data_store[8][23:0]};
        end else  begin
          crc_data_in <= {adc_data_store[0],
                          adc_data_store[1],
                          adc_data_store[2],
                          adc_data_store[3],
                          adc_data_store[4],
                          adc_data_store[5],
                          adc_data_store[6],
                          adc_data_store[7],
                          adc_data_store[8]};
        end
      end
    end
  end

  // As an optimization, a crc checker with 8 parallel operations per clk cycle
  // will be used for all packet formats.
  // The channel plus status and crc data will be feed in byte packets to the
  // crc checker.
  // When packet_format is 20 bits, 20x8+20(st and crc) = 180 which is not a
  // multiple of 8. So, we will feed 184 bits, which is a multiple of 8.
  // First extra 4 bits entering the checker being 0, will not affect the result
  // since the initial value of the LFSR is 0x0000.
  assign crc_data_lenght = packet_format == 2'd0 ? 16'd176 : // 184-8
                           packet_format == 2'd1 ? 16'd208 : 16'd280;

  always @(posedge clk) begin
    if (crc_enable_window == 0 || adc_valid == 1) begin
      crc_cnt <= crc_data_lenght;
      data_in_byte <= 0;
      run_crc <= adc_valid;
    end else begin
      if (run_crc == 1'b1) begin
        if (crc_cnt == 0) begin
          run_crc <= 1'b0;
        end else begin
          crc_cnt <= crc_cnt - 8;
        end
        data_in_byte <= crc_data_in[crc_cnt +: 8];
      end else begin
      end
    end
    // the counter is initialized with n-1 to accommodate the byte shifter
    run_crc_d <= run_crc;
  end

  assign crc_reset = adc_valid;
  assign crc_enable = run_crc | run_crc_d;

  always @(posedge clk) begin
    if (crc_valid == 1) begin
      if (crc_res == 16'd0) begin
        crc_error <= 1'd0;
      end else begin
        crc_error <= 1'd1;
      end
    end
  end

  axi_ad4858_crc i_ad4858_crc_8 (
    .rst (crc_reset),
    .clk (clk),
    .crc_en (crc_enable),
    .d_in (data_in_byte),
    .crc_valid (crc_valid),
    .crc_res (crc_res));

endmodule