Subversion Repositories ht_tunnel

//flow_control_l2.cpp
 
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is HyperTransport Tunnel IP Core.
 *
 * The Initial Developer of the Original Code is
 * Ecole Polytechnique de Montreal.
 * Portions created by the Initial Developer are Copyright (C) 2005
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Jean-Francois Belanger
 *   Ami Castonguay <acastong@grm.polymtl.ca>
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the Polytechnique HyperTransport Tunnel IP Core Source Code License 
 * (the  "PHTICSCL License", see the file PHTICSCL.txt), in which case the
 * provisions of PHTICSCL License are applicable instead of those
 * above. If you wish to allow use of your version of this file only
 * under the terms of the PHTICSCL License and not to allow others to use
 * your version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice and
 * other provisions required by the PHTICSCL License. If you do not delete
 * the provisions above, a recipient may use your version of this file
 * under either the MPL or the PHTICSCL License."
 *
 * ***** END LICENSE BLOCK ***** */
 
#include "flow_control_l2.h"
#include "flow_control_l3.h"
#include "nop_framer_l3.h"
#include "multiplexer_l3.h"
#include "rx_farend_cnt_l3.h"
#include "user_fifo_l3.h"
#include "fairness_l3.h"
 
#ifdef RETRY_MODE_ENABLED
#include "history_buffer_l3.h"
#include "fc_packet_crc_l3.h"
#endif
/**  *************************************************************
This file contain the linking of all submodule of flow_control
*************************************************************
**/
 
flow_control_l2::flow_control_l2(sc_module_name name) : sc_module(name)
{
 
#ifdef RETRY_MODE_ENABLED
	SC_METHOD(send_clear_single_error_and_stomp);
	sensitive << clear_crc << clear_nop_crc;
#endif
 
	the_flow_control = new flow_control_l3("the_flow_control_l3");
 
	//	Linking of the flow control state-machine sub module
 
 
	//************ THE FLOW CONTROL ******************
 
	//Signals to internal FIFO
	the_flow_control->fifo_user_available(fifo_user_available);  				//fifo have a packet to send
	the_flow_control->fifo_user_packet(fifo_user_packet); 
 	the_flow_control->fifo_user_packet_vc(fifo_user_packet_vc);
	the_flow_control->fifo_user_packet_dword(fifo_user_packet_dword);
	the_flow_control->fifo_user_packet_data_asociated(fifo_user_packet_data_asociated);
#ifdef RETRY_MODE_ENABLED
	the_flow_control->fifo_user_packet_command(fifo_user_packet_command);
#endif
	the_flow_control->fifo_user_packet_data_count_m1(fifo_user_packet_data_count_m1);
	the_flow_control->fifo_user_packet_isChain(fifo_user_packet_isChain);
	the_flow_control->consume_user_fifo(consume_user_fifo);   		//acknowledge signal 	
	the_flow_control->hold_user_fifo(hold_user_fifo);   		//acknowledge signal 	
 
	//Signals to error handler
	the_flow_control->fc_ack_eh(fc_ack_eh);
	the_flow_control->eh_cmd_data_fc(eh_cmd_data_fc);
	the_flow_control->eh_available_fc(eh_available_fc);
 
 
	//Signals to CSR
	the_flow_control->fc_ack_csr(fc_ack_csr);
	the_flow_control->csr_dword_fc(csr_dword_fc);
	the_flow_control->csr_available_fc(csr_available_fc);
 
 
 
	//Signals to Reordering
	the_flow_control->ro_available_fwd(ro_available_fwd);		//RO have a packet to send
	the_flow_control->ro_nop_req_fc(ro_nop_req_fc);
	the_flow_control->ro_packet_fwd(ro_packet_fwd);
	the_flow_control->ro_packet_vc_fwd(ro_packet_vc_fwd);
	the_flow_control->fwd_ack_ro(fwd_ack_ro);  		//acknowledge signal
 
 
	//Signals to User Interface
	the_flow_control->fc_data_vc_ui(fc_data_vc_ui);		//dant state Local_cmd_sent
	the_flow_control->fc_consume_data_ui(fc_consume_data_ui);				//data consumme
 
 
	//Signals from databuffer from this side   
	the_flow_control->db_nop_req_fc(db_nop_req_fc);
 
 
	//Signals from databuffer from other side   
	the_flow_control->fwd_address_db(fwd_address_db);
	the_flow_control->fwd_vctype_db(fwd_vctype_db);
	the_flow_control->fwd_read_db(fwd_read_db);
	the_flow_control->fwd_erase_db(fwd_erase_db);
 
	//Signals from nop_framer
	the_flow_control->nop_next_to_send(nop_next_to_send);
	the_flow_control->generate_disconnect_nop(generate_disconnect_nop);
	the_flow_control->has_nop_buffers_to_send(has_nop_buffers_to_send);
 
 
	//Signals to rx_farend_cnt
	the_flow_control->current_sent_type(current_sent_type);
	the_flow_control->fwd_next_node_buffer_status_ro(fwd_next_node_buffer_status_ro);
#ifdef RETRY_MODE_ENABLED
	the_flow_control->clear_farend_count(clear_farend_count);
#endif
 
	//Signal for output selection (Multiplexer)
	the_flow_control->fc_ctr_mux(fc_ctr_mux);  
 
	//Signals to link
	the_flow_control->fc_lctl_lk(fc_lctl_lk);    	
	the_flow_control->fc_hctl_lk(fc_hctl_lk);    	
	the_flow_control->lk_consume_fc(lk_consume_fc);    
#ifdef RETRY_MODE_ENABLED
	the_flow_control->lk_rx_connected(lk_rx_connected);
	the_flow_control->fc_disconnect_lk(fc_disconnect_lk);
	the_flow_control->lk_initiate_retry_disconnect(lk_initiate_retry_disconnect);
	//Signals to command decoder
	the_flow_control->cd_initiate_retry_disconnect(cd_initiate_retry_disconnect);
	the_flow_control->csr_retry(csr_retry);
#endif	
 
	//Signals to fairness
	the_flow_control->local_priority(local_priority);
	the_flow_control->local_packet_issued(local_packet_issued);
 
 
	//Misc signals
	the_flow_control->clock(clk);
	the_flow_control->resetx(resetx);
	the_flow_control->ldtstopx(ldtstopx);
	the_flow_control->fc_nop_sent(fc_nop_sent);
	the_flow_control->nop_received(cd_nop_received_fc);
 
 
 
 
#ifdef RETRY_MODE_ENABLED
	//History signals
	the_flow_control->history_packet(history_packet);
 
	the_flow_control->history_playback_done(history_playback_done);
	the_flow_control->begin_history_playback(begin_history_playback);
	the_flow_control->stop_history_playback(stop_history_playback);
	the_flow_control->consume_history(consume_history);
 
	the_flow_control->room_available_in_history(room_available_in_history);
 
	the_flow_control->add_to_history(add_to_history);
	the_flow_control->new_history_entry(new_history_entry);
	the_flow_control->new_history_entry_size_m1(new_history_entry_size_m1);
	the_flow_control->history_playback_ready(history_playback_ready);
 
	//Signals to CRC unit
	the_flow_control->calculate_crc(calculate_crc);
	the_flow_control->clear_crc(clear_crc);
	the_flow_control->calculate_nop_crc(calculate_nop_crc);
	the_flow_control->clear_nop_crc(clear_nop_crc);
 
	the_flow_control->select_crc_output(select_crc_output);
	the_flow_control->select_nop_crc_output(select_nop_crc_output);
#endif	
 
 
 
 
	//*********************************
	//Linking of the nop_framer module
	//*********************************
 
	the_nop_framer = new nop_framer_l3("the_nop_framer");
 
	the_nop_framer->db_buffer_cnt_fc(db_buffer_cnt_fc);
	the_nop_framer->ro_buffer_cnt_fc(ro_buffer_cnt_fc);
	the_nop_framer->ro_nop_req_fc(ro_nop_req_fc);
	the_nop_framer->db_nop_req_fc(db_nop_req_fc);
	the_nop_framer->generate_disconnect_nop(generate_disconnect_nop);
	the_nop_framer->has_nop_buffers_to_send(has_nop_buffers_to_send);
	the_nop_framer->ht_nop_pkt(ht_nop_pkt);
	the_nop_framer->fc_nop_sent(fc_nop_sent);
#ifdef RETRY_MODE_ENABLED
	the_nop_framer->cd_rx_next_pkt_to_ack_fc(cd_rx_next_pkt_to_ack_fc);
	the_nop_framer->csr_retry(csr_retry);
#endif	
	the_nop_framer->resetx(resetx);
	the_nop_framer->clock(clk);
	the_nop_framer->nop_next_to_send(nop_next_to_send);
 
	//Linking of the multiplexer module
 
	the_multiplexer = new multiplexer_l3("the_multiplexer");
	the_multiplexer->fc_ctr_mux(fc_ctr_mux);
	the_multiplexer->resetx(resetx);
	the_multiplexer->clk(clk);
	the_multiplexer->fc_dword_lk(fc_dword_lk);
	the_multiplexer->ht_nop_pkt(ht_nop_pkt);  						//0
	the_multiplexer->fwd_packet(ro_packet_fwd);			//1-2
	the_multiplexer->db_data_fwd(db_data_fwd);  						//3
	the_multiplexer->eh_cmd_data_fc(eh_cmd_data_fc);  			//4
	the_multiplexer->csr_dword_fc(csr_dword_fc);  			//5
	the_multiplexer->user_packet(fifo_user_packet);			 //6-7
	the_multiplexer->ui_data_fc(ui_data_fc);
#ifdef RETRY_MODE_ENABLED
	the_multiplexer->history_packet(history_packet);
	the_multiplexer->crc_output(crc_output);
	the_multiplexer->nop_crc_output(nop_crc_output);
	the_multiplexer->select_crc_output(select_crc_output);
	the_multiplexer->select_nop_crc_output(select_nop_crc_output);
	the_multiplexer->registered_output(mux_registered_output);
#endif
 
	/** 
	Linking of the rx_farend_cnd module
	This module is used to trace the amount of buffer that are free
	in the command and data buffer of a far end HT interface.
 
	**/	
 
	the_rx_farend_cnt = new rx_farend_cnt_l3("the_rx_farend_cnt");
 
	the_rx_farend_cnt->cd_nopinfo_fc(cd_nopinfo_fc);
	the_rx_farend_cnt->cd_nop_received_fc(cd_nop_received_fc);
	the_rx_farend_cnt->resetx(resetx);
	the_rx_farend_cnt->clock(clk);
	the_rx_farend_cnt->fwd_next_node_buffer_status_ro(fwd_next_node_buffer_status_ro);
	the_rx_farend_cnt->current_sent_type(current_sent_type);
#ifdef RETRY_MODE_ENABLED
	the_rx_farend_cnt->clear_farend_count(clear_farend_count);
#endif	
 
	/** 
	Linking of the user_fifo module
 
	**/
	the_user_fifo = new user_fifo_l3("the_user_fifo");
 
 
	the_user_fifo->fc_user_fifo_ge2_ui(fc_user_fifo_ge2_ui);
	the_user_fifo->ui_available_fc(ui_available_fc);
	the_user_fifo->ui_packet_fc(ui_packet_fc);
	the_user_fifo->clock(clk);
	the_user_fifo->resetx(resetx);
	the_user_fifo->fifo_user_packet(fifo_user_packet);
 	the_user_fifo->fifo_user_packet_vc(fifo_user_packet_vc);
	the_user_fifo->fifo_user_packet_dword(fifo_user_packet_dword);
	the_user_fifo->fifo_user_packet_data_asociated(fifo_user_packet_data_asociated);
#ifdef RETRY_MODE_ENABLED
	the_user_fifo->fifo_user_packet_command(fifo_user_packet_command);
#endif
	the_user_fifo->fifo_user_packet_data_count_m1(fifo_user_packet_data_count_m1);
	the_user_fifo->fifo_user_packet_isChain(fifo_user_packet_isChain);
 
	the_user_fifo->fwd_next_node_buffer_status_ro(fwd_next_node_buffer_status_ro);
	the_user_fifo->fifo_user_available(fifo_user_available);
	the_user_fifo->consume_user_fifo(consume_user_fifo);
	the_user_fifo->hold_user_fifo(hold_user_fifo);
 
	/**
	Linking of the fairness algorithm module
	*/
 
	the_fairness = new fairness_l3("the_fairness_l3");
	the_fairness->clk(clk);
	the_fairness->resetx(resetx);
	the_fairness->ro_available_fwd(ro_available_fwd);
	the_fairness->ro_packet_fwd(ro_packet_fwd);
	the_fairness->fwd_ack_ro(fwd_ack_ro);
	the_fairness->local_priority(local_priority);
	the_fairness->local_packet_issued(local_packet_issued);
 
 
#ifdef RETRY_MODE_ENABLED
	/** Link to the CRC unit */
	the_fc_packet_crc = new fc_packet_crc_l3("the_fc_packet_crc");
 
	the_fc_packet_crc->clk(clk);
	the_fc_packet_crc->resetx(resetx);
 
	the_fc_packet_crc->data_in(mux_registered_output);
	the_fc_packet_crc->fc_hctl_lk(fc_hctl_lk);
	the_fc_packet_crc->fc_lctl_lk(fc_lctl_lk);
 
	the_fc_packet_crc->calculate_crc(calculate_crc);
	the_fc_packet_crc->clear_crc(clear_crc);
	the_fc_packet_crc->calculate_nop_crc(calculate_nop_crc);
	the_fc_packet_crc->clear_nop_crc(clear_nop_crc);
	the_fc_packet_crc->crc_output(crc_output);
	the_fc_packet_crc->nop_crc_output(nop_crc_output);
	the_fc_packet_crc->csr_force_single_stomp_fc(csr_force_single_stomp_fc);
	the_fc_packet_crc->csr_force_single_error_fc(csr_force_single_error_fc);
 
 
	/** Link to the history buffer */
	the_history_buffer = new history_buffer_l3("the_history_buffer");
 
	the_history_buffer->ack_value(cd_nop_ack_value_fc);
	the_history_buffer->add_to_history(add_to_history);
	the_history_buffer->begin_history_playback(begin_history_playback);
	the_history_buffer->stop_history_playback(stop_history_playback);
	the_history_buffer->clk(clk);
	the_history_buffer->consume_history(consume_history);
	the_history_buffer->fc_dword_lk(fc_dword_lk);
	the_history_buffer->history_packet(history_packet);
	the_history_buffer->history_playback_done(history_playback_done);
	the_history_buffer->new_history_entry(new_history_entry);
	the_history_buffer->new_history_entry_size_m1(new_history_entry_size_m1);
	the_history_buffer->nop_received(cd_nop_received_fc);
	the_history_buffer->resetx(resetx);
	the_history_buffer->room_available_in_history(room_available_in_history);
	the_history_buffer->history_memory_write(history_memory_write);
	the_history_buffer->history_memory_write_address(history_memory_write_address);
	the_history_buffer->history_memory_write_data(history_memory_write_data);
	the_history_buffer->history_memory_read_address(history_memory_read_address);
	the_history_buffer->history_memory_output(history_memory_output);
	the_history_buffer->history_playback_ready(history_playback_ready);
#endif	
}
 
#ifdef RETRY_MODE_ENABLED
void flow_control_l2::send_clear_single_error_and_stomp(){
	fc_clear_single_error_csr = clear_crc.read() || clear_nop_crc.read();
	fc_clear_single_stomp_csr =	clear_crc.read();
}
#endif	
 
 
#ifdef SYSTEMC_SIM
flow_control_l2::~flow_control_l2(){
		delete the_flow_control; 
		delete the_nop_framer;
		delete the_multiplexer;
		delete the_rx_farend_cnt;
		delete the_user_fifo; 
#ifdef RETRY_MODE_ENABLED
		delete the_fc_packet_crc;
		delete the_history_buffer;
#endif	
	}
#endif