alt_avalonst_pfc_0.v

ddc的vhdl源代码

      
      end
   end
   
   always @* begin

      //----------------------------------------
      // Data is Available for P2 if all of the
      // inputs have data
      p2_data_available = 1;	
      if ( in0_beats_equals_out0_beats )      
         p2_data_available = 0;
      if ( in0_beats_equals_out1_beats )      
         p2_data_available = 0;


      //----------------------------------------
      // upstream backpressure
      p1_out0_in0_space_difference = p1_out0_in0_space_available - in0_space_used;
      p1_out1_in0_space_difference = p1_out1_in0_space_available - in0_space_used;


      //------	----------------------------------
      // tofifo_out_ready is 1 if all the 
      // outfifo readys are 1.
      tofifo_out_ready = 1;
      if (~tofifo_out0_ready )
         tofifo_out_ready = 0;
      if (~tofifo_out1_ready )
         tofifo_out_ready = 0;

      //----------------------------------------
      // Calculate new beats_used
      p2_out0_new_beats_used = p2_out0_beats_used;
      if (tofifo_out_ready && p2_data_available	) 
        p2_out0_new_beats_used = p2_out0_beats_used + 1; 
      p2_out1_new_beats_used = p2_out1_beats_used;
      if (tofifo_out_ready && p2_data_available	) 
        p2_out1_new_beats_used = p2_out1_beats_used + 1; 
 
   end  

   // ----------------------------------------------------------------------
   //| Main Output Counter
   // ----------------------------------------------------------------------
   always @ (negedge internal_reset_n, posedge clk) begin
      if (!internal_reset_n) begin

         p2_beat_counter <= 0;
         p2_out0_valid <= 0;
         p2_out0_startofpacket <= 0;
         p2_out0_endofpacket <= 0;
         p2_out0_empty <= 0;
         p2_out0_beats_used <= 0;         

         p2_out0_s0_select               <= 0;
         p2_out0_s0_in0_rd_ptr    <= -2;
 
         p2_out0_in0_space_available <= 15;
         p2_out1_valid <= 0;
         p2_out1_startofpacket <= 0;
         p2_out1_endofpacket <= 0;
         p2_out1_empty <= 0;
         p2_out1_beats_used <= 0;         

         p2_out1_s0_select               <= 0;
         p2_out1_s0_in0_rd_ptr    <= -1;
 
         p2_out1_in0_space_available <= 15;

         p1_out0_valid <= 0;
         p1_out0_startofpacket <= 0;
         p1_out0_endofpacket <= 0;
         p1_out0_empty <= 0;

         p1_out0_s0_select   <= 0;
 
         p1_out0_in0_space_available <= 15;
         p1_out1_valid <= 0;
         p1_out1_startofpacket <= 0;
         p1_out1_endofpacket <= 0;
         p1_out1_empty <= 0;

         p1_out1_s0_select   <= 0;
 
         p1_out1_in0_space_available <= 15;

         p0_out0_valid <= 0;
         p0_out0_startofpacket <= 0;
         p0_out0_endofpacket <= 0;
         p0_out0_empty <= 0;

         p0_out0_s0_select   <= 0;
          p0_out1_valid <= 0;
         p0_out1_startofpacket <= 0;
         p0_out1_endofpacket <= 0;
         p0_out1_empty <= 0;

         p0_out1_s0_select   <= 0;
 
         tofifo_out0_valid <= 0;
         tofifo_out0_data <= 0;
         tofifo_out0_empty <= 0;
         tofifo_out0_error <= 0;
         tofifo_out0_endofpacket <= 0;
         tofifo_out0_startofpacket <= 0;                  
         tofifo_out1_valid <= 0;
         tofifo_out1_data <= 0;
         tofifo_out1_empty <= 0;
         tofifo_out1_error <= 0;
         tofifo_out1_endofpacket <= 0;
         tofifo_out1_startofpacket <= 0;                  

         in0_beats_equals_out0_beats <= 1;
         in0_beats_equals_out1_beats <= 1;

      end else begin
         //----------------------------------------
         // Cancel each valid once it's been taken.  
         // If p2_data_available is true, this might
         // get overridden in the output stage.
         tofifo_out0_valid <= 0;	
         tofifo_out1_valid <= 0;	

         //----------------------------------------
         // p2 Stage - Before Memory
         in0_beats_equals_out0_beats <= (in0_beats_available == p2_out0_new_beats_used );
         p2_out0_beats_used <= p2_out0_new_beats_used;
         in0_beats_equals_out1_beats <= (in0_beats_available == p2_out1_new_beats_used );
         p2_out1_beats_used <= p2_out1_new_beats_used;
	
         if (p2_enable) begin

            //----------------------------------------
            // Update Counters
            
            p2_beat_counter <= p2_beat_counter + 1'b1;
            if (p2_beat_counter == 0 )
               p2_beat_counter <= 0;

            //----------------------------------------
            // The Main Event
            p2_out0_startofpacket <= 0;
            p2_out0_endofpacket <= 0;
            p2_out0_empty <= 0;
            
            p2_out0_in0_space_available <= p2_out0_in0_space_available;
            p2_out1_startofpacket <= 0;
            p2_out1_endofpacket <= 0;
            p2_out1_empty <= 0;
            
            p2_out1_in0_space_available <= p2_out1_in0_space_available;
            case (p2_beat_counter)
               0 : begin
                  p2_out0_valid <= 1;
                  p2_out0_startofpacket <= 1;
                  p2_out0_endofpacket <= 1;
                  p2_out0_empty <= 0;

                  p2_out0_s0_select   <= 0;
                  
                  p2_out0_s0_in0_rd_ptr <= p2_out0_s0_in0_rd_ptr + (2); // out0 beat 0, symbol 0 is "I": From input in0, beat 0, symbol 0 (position 0, readpointer 0) 
                  p2_out0_in0_space_available <= p2_out0_in0_space_available  + 2;
                  p2_out1_valid <= 1;
                  p2_out1_startofpacket <= 1;
                  p2_out1_endofpacket <= 1;
                  p2_out1_empty <= 0;

                  p2_out1_s0_select   <= 0;
                  
                  p2_out1_s0_in0_rd_ptr <= p2_out1_s0_in0_rd_ptr + (2); // out1 beat 0, symbol 0 is "Q": From input in0, beat 1, symbol 0 (position 1, readpointer 1) 
                  p2_out1_in0_space_available <= p2_out1_in0_space_available  + 2;
               end // 0
            endcase
         end
         
         //----------------------------------------
         // p1 Stage - After Memory
         if (p1_enable) begin
            p1_out0_valid <= p2_out0_valid;
            p1_out0_startofpacket <= p2_out0_startofpacket;
            p1_out0_endofpacket <= p2_out0_endofpacket;            
            p1_out0_empty <= p2_out0_empty;
            p1_out0_s0_select   <= p2_out0_s0_select;
             p1_out0_in0_space_available <= p2_out0_in0_space_available;
            p1_out1_valid <= p2_out1_valid;
            p1_out1_startofpacket <= p2_out1_startofpacket;
            p1_out1_endofpacket <= p2_out1_endofpacket;            
            p1_out1_empty <= p2_out1_empty;
            p1_out1_s0_select   <= p2_out1_s0_select;
             p1_out1_in0_space_available <= p2_out1_in0_space_available;
         end 


         //----------------------------------------
         // p0 Stage - Post-memory registers
         if (p0_enable) begin
            p0_out0_valid         <= p1_out0_valid;
            p0_out0_startofpacket <= p1_out0_startofpacket;
            p0_out0_endofpacket   <= p1_out0_endofpacket;
            p0_out0_empty         <= p1_out0_empty;
            p0_out0_s0_select   <= p1_out0_s0_select;
             p0_out1_valid         <= p1_out1_valid;
            p0_out1_startofpacket <= p1_out1_startofpacket;
            p0_out1_endofpacket   <= p1_out1_endofpacket;
            p0_out1_empty         <= p1_out1_empty;
            p0_out1_s0_select   <= p1_out1_s0_select;
          end //if (p0_enable) begin	

         //----------------------------------------
         // Data Out Stage
         if (tofifo_out_enable) begin
            tofifo_out0_valid         <= p0_out0_valid;
            tofifo_out0_startofpacket <= p0_out0_startofpacket;
            tofifo_out0_endofpacket   <= p0_out0_endofpacket;
            tofifo_out0_empty <= p0_out0_empty;
    

            case ( p0_out0_s0_select )
                  0 : tofifo_out0_data[15: 0] <= p0_out0_s0_in0_rd_data [15: 0]; // 0 16
            endcase
 

            tofifo_out1_valid         <= p0_out1_valid;
            tofifo_out1_startofpacket <= p0_out1_startofpacket;
            tofifo_out1_endofpacket   <= p0_out1_endofpacket;
            tofifo_out1_empty <= p0_out1_empty;
    

            case ( p0_out1_s0_select )
                  0 : tofifo_out1_data[15: 0] <= p0_out1_s0_in0_rd_data [15: 0]; // 0 16
            endcase
 

          end // if (tofifo_out_ready) begin
         
         //----------------------------------------
         // Error Output
         if (tofifo_out0_error_reported)  begin
            tofifo_out0_valid <= 0;
         end
 	     if (tofifo_out0_error[0] && tofifo_out0_valid && tofifo_out0_ready && tofifo_out0_endofpacket) begin
            tofifo_out0_valid <= 0;
         end
         tofifo_out0_error[0] <= error_detected;	
         if (tofifo_out1_error_reported)  begin
            tofifo_out1_valid <= 0;
         end
 	     if (tofifo_out1_error[0] && tofifo_out1_valid && tofifo_out1_ready && tofifo_out1_endofpacket) begin
            tofifo_out1_valid <= 0;
         end
         tofifo_out1_error[0] <= error_detected;	
      end // ~reset
   end // always


   //----------------------------------------
   // Error Reported
   //----------------------------------------
   always @ (negedge internal_reset_n, posedge clk) begin
      if (!internal_reset_n) begin
         tofifo_out0_error_reported <= 0;      
         tofifo_out1_error_reported <= 0;      
      end else begin
 	     if (tofifo_out0_error[0] && tofifo_out0_valid && tofifo_out0_ready && tofifo_out0_endofpacket) begin
            tofifo_out0_error_reported <= 1;
         end
 	     if (tofifo_out1_error[0] && tofifo_out1_valid && tofifo_out1_ready && tofifo_out1_endofpacket) begin
            tofifo_out1_error_reported <= 1;
         end
      end // ~reset
   end // always



   // ---------------------------------------------------------------------
   //| Output Buffers
   // ---------------------------------------------------------------------
   alt_avalonst_pfc_0_fifo_out0 fifo_out0
     ( 
       .clk       (clk),
       .reset_n   (reset_n),
       .in_ready (tofifo_out0_ready),
       .in_valid (tofifo_out0_valid),      
       .in_data  ( {tofifo_out0_data,
       	            tofifo_out0_startofpacket,
       	            tofifo_out0_endofpacket,
       	            tofifo_out0_error } ),
       .out_ready (  fromfifo_out0_ready),
       .out_valid (  fromfifo_out0_valid),      
       .out_data  ( {fromfifo_out0_data,
       	             fromfifo_out0_startofpacket,
       	             fromfifo_out0_endofpacket,
       	             fromfifo_out0_error } )
       );
   alt_avalonst_pfc_0_fifo_out1 fifo_out1
     ( 
       .clk       (clk),
       .reset_n   (reset_n),
       .in_ready (tofifo_out1_ready),
       .in_valid (tofifo_out1_valid),      
       .in_data  ( {tofifo_out1_data,
       	            tofifo_out1_startofpacket,
       	            tofifo_out1_endofpacket,
       	            tofifo_out1_error } ),
       .out_ready (  fromfifo_out1_ready),
       .out_valid (  fromfifo_out1_valid),      
       .out_data  ( {fromfifo_out1_data,
       	             fromfifo_out1_startofpacket,
       	             fromfifo_out1_endofpacket,
       	             fromfifo_out1_error } )
       );

   always @ (negedge reset_n, posedge clk) begin
      if (!reset_n) begin
         out0_valid <= 0;
         out0_data <= 0;
         out0_startofpacket <= 0;
         out0_endofpacket <= 0;
         out0_empty <= 0;
         out0_error <= 0;
         out1_valid <= 0;
         out1_data <= 0;
         out1_startofpacket <= 0;
         out1_endofpacket <= 0;
         out1_empty <= 0;
         out1_error <= 0;
      end else begin
      if (out0_ready || !out0_valid) begin
         out0_valid <= fromfifo_out0_valid;
         out0_data <= fromfifo_out0_data;
         out0_startofpacket <= fromfifo_out0_startofpacket;
         out0_endofpacket <= fromfifo_out0_endofpacket;
         out0_empty <= fromfifo_out0_empty;
         out0_error <= fromfifo_out0_error;
      end
      if (out1_ready || !out1_valid) begin
         out1_valid <= fromfifo_out1_valid;
         out1_data <= fromfifo_out1_data;
         out1_startofpacket <= fromfifo_out1_startofpacket;
         out1_endofpacket <= fromfifo_out1_endofpacket;
         out1_empty <= fromfifo_out1_empty;
         out1_error <= fromfifo_out1_error;
      end

    end
  end

  always @* begin
    fromfifo_out0_ready = out0_ready || !out0_valid;
    fromfifo_out1_ready = out1_ready || !out1_valid;
  end

  
endmodule