Subversion Repositories ht_tunnel

//fetch_packet_l3.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):

 *   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 "fetch_packet_l3.h"

fetch_packet_l3::fetch_packet_l3(sc_module_name name) : sc_module(name){

        SC_METHOD(register_signals);

        sensitive_pos(clk);

        sensitive_neg(resetx);

        SC_METHOD(select_and_ack_packet);

        for(int destination = 0; destination < 2; destination++){

                sensitive << posted_available[destination]

                                  << nposted_available[destination]

                                  << response_available[destination]

                                  << posted_requested[destination]

                                  << nposted_requested[destination]

                                  << response_requested[destination]

                                  << posted_packet_addr[destination]

                                  << nposted_packet_addr[destination]

                                  << response_packet_addr[destination];

        }

        SC_METHOD(reconstruct_packet);

        sensitive << command_packet_rd_data_ro[0] << command_packet_rd_data_ro[1]

#ifdef ENABLE_REORDERING

                          << packet_passpw[0] << packet_passpw[1]

                          << packet_seqid[0] << packet_seqid[1]

                          << packet_chain[0] << packet_chain[1]

#endif

                          << packet_vc[0] << packet_vc[0]

                          << packet_fetched[0] << packet_fetched[1];

}

void fetch_packet_l3::select_and_ack_packet(){

        for(int destination = 0; destination < 2; destination++){

                sc_uint<LOG2_NB_OF_BUFFERS+2> ro_command_packet_rd_addr_tmp;

                //Some default values for outputs

                ack_posted[destination] = false;

                ack_nposted[destination] = false;

                ack_response[destination] = false;

                selected_vc[destination] = VC_NONE;

                packet_selected[destination] = false;

                ro_command_packet_rd_addr_tmp = 0;

                //Retrieve posted packets first, if there is a packet of that type available

                //and it is being requested

                if(posted_requested[destination].read() && posted_available[destination].read()){

                        ack_posted[destination] = true;

                        selected_vc[destination] = VC_POSTED;

                        packet_selected[destination] = true;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS+1,LOG2_NB_OF_BUFFERS) = VC_POSTED;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS-1,0) = posted_packet_addr[destination];

                }

                //Then responses

                else if(response_requested[destination].read() && response_available[destination].read()){

                        ack_response[destination] = true;

                        selected_vc[destination] = VC_RESPONSE;

                        packet_selected[destination] = true;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS+1,LOG2_NB_OF_BUFFERS) = VC_RESPONSE;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS-1,0) = response_packet_addr[destination];

                }

                //Finally nposted packets

                else if(nposted_requested[destination].read() && nposted_available[destination].read()){

                        ack_nposted[destination] = true;

                        selected_vc[destination] = VC_NON_POSTED;

                        packet_selected[destination] = true;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS+1,LOG2_NB_OF_BUFFERS) = VC_NON_POSTED;

                        ro_command_packet_rd_addr_tmp.range(LOG2_NB_OF_BUFFERS-1,0) = nposted_packet_addr[destination];

                }

                //Output the result

                ro_command_packet_rd_addr[destination] = ro_command_packet_rd_addr_tmp;

        }

}

void fetch_packet_l3::register_signals(){

        if(!resetx.read()){

                for(int destination = 0; destination < 2; destination++){

#ifdef ENABLE_REORDERING

                        packet_passpw[destination] = false;

                        packet_seqid[destination] = 0;

                        packet_chain[destination] = false;

#else

                        currently_posted_chain[destination] = false;

#endif

                        packet_vc[destination] = VC_NONE;

                        packet_fetched[destination] = false;

                }

        }

        else{

                for(int destination = 0; destination < 2; destination++){

                        //Register the decision from the other combinatorial process

                        packet_vc[destination] = selected_vc[destination].read();

                        packet_fetched[destination] = packet_selected[destination].read();

#ifdef ENABLE_REORDERING

                        //Register information about the packet depending on the virtual channel

                        //of the packet

                        switch(selected_vc[destination].read()){

                                case VC_NON_POSTED:

                                        packet_passpw[destination] = nposted_packet_passpw[destination].read();

                                        packet_seqid[destination] = nposted_packet_seqid[destination].read();

                                        packet_chain[destination] = false;

                                        break;

                                case VC_RESPONSE:

                                        packet_passpw[destination] = response_packet_passpw[destination].read();

                                        packet_seqid[destination] = 0;

                                        packet_chain[destination] = false;

                                        break;

                                default:

                                        packet_passpw[destination] = posted_packet_passpw[destination].read();

                                        packet_seqid[destination] = posted_packet_seqid[destination].read();

                                        packet_chain[destination] = posted_packet_chain[destination].read();

                        }

#else

                        if(packet_vc[destination].read() == VC_POSTED)

                                currently_posted_chain[destination] = (sc_bit)command_packet_rd_data_ro[destination].read()[19];

#endif

                }

        }

}

void fetch_packet_l3::reconstruct_packet(){

        //The role of this function is to reconstruct packets for output by merging

        //the information coming from the buffers and the information from the

        //embedded memory.  The reconstruction is exactly the inverse of what was

        //done in the entrance reordering.  There is a better explanation about what

        //is going on in that module (entrance reordering) if it is needed to understand 

        //this code.

        for(int destination = 0; destination < 2; destination++){

                fetched_packet_available[destination] = packet_fetched[destination];

                fetched_packet_vc[destination] = packet_vc[destination];

                syn_ControlPacketComplete fetched_packet_tmp;

                //A default value, might be mofidied below depending on preprocessor directives

                fetched_packet_tmp.packet = command_packet_rd_data_ro[destination].read().range(63,0);

#ifndef ENABLE_REORDERING

                bool posted_part_of_chain = packet_vc[destination].read() == VC_POSTED &&

                        ((sc_bit)command_packet_rd_data_ro[destination].read()[19] ||

                         (sc_bit)currently_posted_chain[destination].read());

                fetched_packet_tmp.error64BitExtension = (sc_bit)command_packet_rd_data_ro[destination].read()[64];

                fetched_packet_tmp.data_address = (sc_bv<BUFFERS_ADDRESS_WIDTH>)command_packet_rd_data_ro[destination].read().range(LOG2_NB_OF_BUFFERS+64,65);

                fetched_packet_tmp.isPartOfChain = posted_part_of_chain;

                if(destination == FWD_DEST){

                        fetched_packet_nposted_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+65,BUFFERS_ADDRESS_WIDTH+65);

                        fetched_packet_response_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(2 * LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+66,LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+66);

                }

                else{

                        fetched_packet_nposted_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(3*LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+67,2*LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+67);

                        fetched_packet_response_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(4 * LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+68,3*LOG2_NB_OF_BUFFERS+BUFFERS_ADDRESS_WIDTH+68);

                }

#else

                //Recover error64bit at passPW position

                fetched_packet_tmp.error64BitExtension = (sc_bit)command_packet_rd_data_ro[destination].read()[15];

                fetched_packet_tmp.packet[15] = packet_passpw[destination].read();

                //Recover the refid

                if(packet_vc[destination].read() == VC_POSTED){

                        fetched_packet_nposted_refid[destination] =  posted_packet_nposted_refid[destination];

                        fetched_packet_response_refid[destination] =  posted_packet_response_refid[destination];

                }

                else{

                        //If the packet is NPOSTED, only the nposted_refid will be read

                        //If the packet is RESPONSE, only the response_refid will be read

                        //This is why we output the same thing for both values (simplifies logic)

#if BUFFERS_ADDRESS_WIDTH < 5

                        fetched_packet_nposted_refid[destination] =  (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(LOG2_NB_OF_BUFFERS+64,64);

                        fetched_packet_response_refid[destination] =  (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(LOG2_NB_OF_BUFFERS+64,64);

  #else

                        fetched_packet_nposted_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(60+LOG2_NB_OF_BUFFERS + BUFFERS_ADDRESS_WIDTH,60+BUFFERS_ADDRESS_WIDTH);

                        fetched_packet_response_refid[destination] = (sc_bv<LOG2_NB_OF_BUFFERS+1>)command_packet_rd_data_ro[destination].read().range(60+LOG2_NB_OF_BUFFERS + BUFFERS_ADDRESS_WIDTH,60+BUFFERS_ADDRESS_WIDTH);

  #endif

                }

                //For other field, place differently depending on if it is a response or not

                if(packet_vc[destination].read() == VC_RESPONSE){

                        fetched_packet_tmp.packet.range(5,2) = "1100";

  #if BUFFERS_ADDRESS_WIDTH < 5

                        fetched_packet_tmp.data_address = (sc_bv<BUFFERS_ADDRESS_WIDTH>)command_packet_rd_data_ro[destination].read().range(1 + BUFFERS_ADDRESS_WIDTH,2);

  #else

                        fetched_packet_tmp.data_address.range(3,0) = command_packet_rd_data_ro[destination].read().range(5,2);

                        fetched_packet_tmp.data_address.range(BUFFERS_ADDRESS_WIDTH-1,4)

                                = command_packet_rd_data_ro[destination].read().range(27 + BUFFERS_ADDRESS_WIDTH,32);

  #endif

                }

                else{

        //              -seqID is sent to registers : bits 7..6 and 14..13

  #if BUFFERS_ADDRESS_WIDTH < 3

                        fetched_packet_tmp.data_address = (sc_bv<BUFFERS_ADDRESS_WIDTH>)command_packet_rd_data_ro[destination].read().range(BUFFERS_ADDRESS_WIDTH+5,6);

                        fetched_packet_tmp.packet.range(7,6) = packet_seqid[destination].read().range(3,2);

  #elif BUFFERS_ADDRESS_WIDTH < 5

                        fetched_packet_tmp.data_address.range(1,0) = (sc_bv<2>)command_packet_rd_data_ro[destination].read().range(7,6);

                        fetched_packet_tmp.packet.range(7,6) = packet_seqid[destination].read().range(3,2);

                        fetched_packet_tmp.data_address.range(BUFFERS_ADDRESS_WIDTH-1,2) = (sc_bv<BUFFERS_ADDRESS_WIDTH-2>)command_packet_rd_data_ro[destination].read().range(BUFFERS_ADDRESS_WIDTH+10,13);

                        fetched_packet_tmp.packet.range(14,13) = packet_seqid[destination].read().range(1,0);

  #else

                        fetched_packet_tmp.data_address.range(1,0) = (sc_bv<2>)command_packet_rd_data_ro[destination].read().range(7,6);

                        fetched_packet_tmp.packet.range(7,6) = packet_seqid[destination].read().range(3,2);

                        fetched_packet_tmp.data_address.range(3,2) = command_packet_rd_data_ro[destination].read().range(14,13);

                        fetched_packet_tmp.packet.range(14,13) = packet_seqid[destination].read().range(1,0);

                        fetched_packet_tmp.data_address.range(BUFFERS_ADDRESS_WIDTH-1,4) = command_packet_rd_data_ro[destination].read().range(59+BUFFERS_ADDRESS_WIDTH,64);

  #endif

                }

#endif

                fetched_packet[destination] = fetched_packet_tmp;

        }

}