b210-k7-fpga/lib/vita_200/chdr_16sc_to_12sc.v

//
// Copyright 2013 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: LGPL-3.0-or-later
//


module chdr_16sc_to_12sc
  #(parameter BASE=0)
  (
    // Clocks and resets
    input               clk,
    input               reset,
    // Settings bus
    input               set_stb,
    input [7:0]         set_addr,
    input [31:0]        set_data,
    // Input CHDR bus
    input [63:0]        i_tdata,
    input               i_tlast,
    input               i_tvalid,
    output              i_tready,
    // Output CHDR bus
    output reg [63:0]   o_tdata,
    output              o_tlast,
    output              o_tvalid,
    input               o_tready,
    // Debug
    output [31:0]       debug
  );

  wire 		chdr_has_time = i_tdata[61];

  wire [11:0]   q0;
  wire [11:0]   i0;
  wire [11:0]   q1;
  wire [11:0]   i1;
  wire [11:0]   q2;
  wire [11:0]   i2;

  wire [16:0]   round_q0;
  wire [16:0]   round_i0;
  wire [16:0]   round_q1;
  wire [16:0]   round_i1;
  wire [16:0]   round_q2;
  wire [16:0]   round_i2;

  // Pipeline register
  reg [63:0]    line_buff;

  // CHDR has either 8 bytes of header or 16 if VITA time is included.
  wire [15:0]   chdr_header_lines = chdr_has_time? 16 : 8;
  // Calculate size of samples input in bytes by taking CHDR size filed and subtracting header length.
  wire [15:0]   sample_byte_count_in = i_tdata[47:32] - chdr_header_lines;
  // Calculate size of samples to be output by taking input size and scaling by 3/4
  wire [15:0]   sample_byte_count_out = (sample_byte_count_in*3) >> 2;
  // Calculate size of output CHDR packet by adding back header size to new payload size.
  wire [15:0]   output_chdr_pkt_size = sample_byte_count_out + chdr_header_lines;

  reg           odd;

  wire          set_sid;
  wire [15:0]   new_sid_dst;

  setting_reg #(.my_addr(BASE), .width(17)) new_destination
    (.clk(clk), .rst(reset), .strobe(set_stb), .addr(set_addr), .in(set_data),
    .out({set_sid, new_sid_dst[15:0]}));

  // state machine

  localparam    HEADER    = 3'd0;
  localparam    TIME      = 3'd1;
  localparam    SAMPLE1   = 3'd2;
  localparam    SAMPLE2   = 3'd3;
  localparam    SAMPLE3   = 3'd4;
  localparam    SAMPLE4   = 3'd5;
  localparam    RESIDUAL  = 3'd6;

  reg [2:0]     state;

  always @(posedge clk)
    if (reset) begin
      state <= HEADER;
      line_buff <= 0;
    end else begin
      case(state)
        //
        // Process header
        // Check for timestamp.  Byte count conversion is done above.
        //
        HEADER: begin
          if (i_tvalid & i_tready) begin
            odd <= sample_byte_count_in [2];
            // If the input packet had time, then add time to output packet
            state <= (i_tdata[61])? TIME: SAMPLE1;
          end
        end
        //
        // Process time field
        //
        TIME: begin
          if (i_tvalid & i_tready) begin
            // If we get a premature end of line go back to searching for start of new packet.
            state <= (i_tlast) ? HEADER: SAMPLE1;
          end
        end
        //
        // There are 3 lines of output data for each 4 lines of input data.
        // The 4 sample states below represent the 4 lines of input.
        // They are repeatedly cycled until all data is consumed.
        //
        // Process first line
        // The 8 bytes are converted to 6 bytes, so there is not enough for an
        // 8-byte output line.  Store the data unless this is the last line in
        // the packet.
        //
        SAMPLE1: begin
          if (i_tvalid & i_tready) begin
            if (i_tlast) begin
              line_buff <= 0;
              state <= HEADER;
            end else begin
              // Save data to buffer - no output
              line_buff <= {q0,i0,q1,i1,16'd0};
              state <= SAMPLE2;
            end
          end
        end
        //
        // Process second line
        // Output a line comprised of the 6 bytes from the fist line and
        // 2 bytes from this line.  Store the remaining 4 bytes.
        //
        SAMPLE2: begin
          if (i_tvalid & i_tready) begin
            line_buff <= {i0[7:0],q1,i1,32'd0};
            state <= i_tlast ? RESIDUAL : SAMPLE3;
          end
        end
        //
        // Process third line
        // Output line comprised of the 4 remaining bytes from the second line
        // and 4 bytes from this line.  Store the remaining 2 bytes unless this
        // is the last line in the packet and the number of samples is odd.
        //
        SAMPLE3: begin
          if (i_tvalid & i_tready) begin
            line_buff <= (i_tlast & odd) ? 0 : {q1[3:0],i1,48'd0};
            if (i_tlast)
                state <= odd ? HEADER : RESIDUAL;
            else
              state <= SAMPLE4;
          end
        end
        //
        // Process fourth line
        // Output line comprised of the remaining 2 bytes from the third line
        // and the 6 bytes from this line.
        //
        SAMPLE4: begin
          if (i_tvalid & i_tready) begin
            line_buff <= 0;
            state <= i_tlast ? HEADER : SAMPLE1;
          end
        end
        //
        // Pause input to output residual data in buffer
        //
        RESIDUAL: begin
          if (o_tvalid & o_tready) begin
            line_buff <= 0;
            state <= HEADER;
          end
        end
        //
        // Should never get here.
        //
        default: state <= HEADER;

       endcase
     end


  // Add rounding value into 16bit samples before trunctaion
  assign	round_q0 = ({i_tdata[63],i_tdata[63:48]} + 'h0008);
  assign	round_i0 = ({i_tdata[47],i_tdata[47:32]} + 'h0008);
  // Truncate with saturation to 12bits precision.
  assign 	q0 = (round_q0[16:15] == 2'b01) ? 12'h7FF : ((round_q0[16:15] == 2'b10) ? 12'h800 : round_q0[15:4]);
  assign	i0 = (round_i0[16:15] == 2'b01) ? 12'h7FF : ((round_i0[16:15] == 2'b10) ? 12'h800 : round_i0[15:4]);
  // Add rounding value into 16bit samples before trunctaion
  assign 	round_q1 = ({i_tdata[31],i_tdata[31:16]} + 'h0008);
  assign 	round_i1 = ({i_tdata[15],i_tdata[15:0]} + 'h0008);
  // Truncate with saturation to 12bits precision.
  assign 	q1 = (round_q1[16:15] == 2'b01) ? 12'h3FF : ((round_q1[16:15] == 2'b10) ? 12'h800 : round_q1[15:4]);
  assign	i1 = (round_i1[16:15] == 2'b01) ? 12'h3FF : ((round_i1[16:15] == 2'b10) ? 12'h800 : round_i1[15:4]);

  //
  // Mux Output data
  //
  always @(*)
    case(state)
      // Populate header with CHDR fields
      HEADER: o_tdata = {i_tdata[63:48], output_chdr_pkt_size,
        set_sid ? {i_tdata[15:0], new_sid_dst[15:0]}:i_tdata[31:0]};
      // Add 64bit VITA time to packet
      TIME: o_tdata = i_tdata;
      // Only output if i_tlast in SAMPLE1 state
      SAMPLE1: o_tdata = {q0,i0,q1, i1, 16'b0};
      SAMPLE2: o_tdata = {line_buff[63:16], q0, i0[11:8]};
      SAMPLE3: o_tdata = {line_buff[63:32], q0, i0,q1[11:4]};
      SAMPLE4: o_tdata = {line_buff[63:48], q0, i0, q1, i1};
      RESIDUAL: o_tdata = line_buff;
      default : o_tdata = i_tdata;
    endcase // case(state)


  assign  o_tvalid = state == RESIDUAL || (i_tvalid &&
                        (state != SAMPLE1 || state == SAMPLE1 && i_tlast));

  assign  i_tready = (o_tready && state != RESIDUAL);

  wire need_extra_line = state == SAMPLE1 || state == SAMPLE2 ||
                          (state == SAMPLE3 && ~odd);
  assign  o_tlast = state == RESIDUAL || (i_tlast & ~need_extra_line);

endmodule