Subversion Repositories ht_tunnel

//errorhandler_sim.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 "errorhandler_sim.h"

#include <math.h>

namespace

{

        // number that shall come from a random generator to apply

        // signals that are considered don't cares

        int randomNb = 6455;

        // option for selecting a particular test vector

        int testOption = 0;

        sc_bv<32> ZERO_BV32 = "00000000000000000000000000000000";

};

ht_errorHandler_sim::ht_errorHandler_sim( sc_module_name name ) :

        sc_module(name)

{

        // Thread where processes are notified

        SC_THREAD(simulate);

        SC_METHOD(coldReset);

        sensitive(activate_coldReset);

        dont_initialize();

        SC_METHOD(warmReset);

        sensitive(activate_warmReset);

        dont_initialize();

        SC_METHOD(sendRequest);

        sensitive(activate_sendRequest);

        dont_initialize();

        SC_METHOD(receiveResponse);

        sensitive(activate_receiveResponse);

        dont_initialize();

}

/// Deactivate all the flag signals

void

ht_errorHandler_sim::dropFlagSignals()

{

        ro_available_eh.write( false );

        fc_consume_eh.write( false );

        csr_eoc.write( sc_bit(0) );

        csr_initcomplete.write( sc_bit(0) );

        csr_drop_uninit_link.write( sc_bit(0) );

}

/// On triggering, activate a cold reset for 20 ns

void

ht_errorHandler_sim::coldReset()

{

        next_trigger(activate_coldReset);

        cout << "ht_errorHandler_sim::coldReset" << endl;

        pwrok.write(false);

        resetx.write(false);

        next_trigger(20,SC_NS);

        pwrok.write(true);

        next_trigger(20,SC_NS);

        resetx.write(true);

        next_trigger(activate_coldReset);

}

/// On triggering, activate a warm reset for 20 ns

void

ht_errorHandler_sim::warmReset()

{

        next_trigger(activate_warmReset);

        cout << "ht_errorHandler_sim::warmReset" << endl;

        resetx.write(false);

        next_trigger(20,SC_NS);

        resetx.write(true);

        next_trigger(activate_warmReset);

}

/// On triggering, send signals corresponding to a test vector for 

/// testing the Request Packet reception interface of ht_errorHandler module

void

ht_errorHandler_sim::sendRequest()

{

        next_trigger(activate_sendRequest);

        cout << "ht_errorHandler_sim::sendRequest" << endl;

        syn_ControlPacketComplete dummyCtrlPkt; // defaults to NOP packet

        syn_ControlPacketComplete ctrlPkt;

        switch( testOption )

        {

/*

Tableau 60 - Tests pour le Reordering (RO)

Vecteur d'entrée        Actions / États intermédiaires  Vecteur de sortie

ro_command_eh = X

ro_available_eh = X

RO_data_associated = 1

RO_data_addr = X

RO_addr_error = X       Ne rien faire.

Erreur: données manquantes. Un paquet de commande n'a pas été envoyé. Une donnée ne peut donc pas y être associée.      ack_RO = 0

*/

        case 0:

        ro_command_eh.write( dummyCtrlPkt );

        ro_available_eh.write( false );

        break;

/*

ro_command_eh = X

ro_available_eh = X

RO_data_associated = 0

RO_data_addr = X

RO_addr_error = 1       Ne rien faire.

Erreur: données manquantes. Un paquet de commande n'a pas été envoyé. L'erreur d'adressage ne peut pas y être associée. ack_RO = 0

*/

        case 1:

        dummyCtrlPkt.error64BitExtension = true;

        ro_command_eh.write( dummyCtrlPkt );

        ro_available_eh.write( false );

        break;

/*

ro_command_eh = X

ro_available_eh = X

RO_data_associated = 0

RO_data_addr = X

RO_addr_error = 0       Ne rien faire.

Erreur: données manquantes. Un paquet de commande n'a pas été envoyé. L'erreur EOC ne peut y être associée.     ack_RO = 0

*/

        case 2:

        dummyCtrlPkt.error64BitExtension = false;

        ro_command_eh.write( dummyCtrlPkt );

        ro_available_eh.write( false );

        break;

/*

ro_command_eh = command ro_available_eh = 1

RO_data_associated = 0

RO_data_addr = X

RO_addr_error = 0       Pas d'erreur de type EOC. Donc on ne lit pas la commande.       ack_RO = 0

*/

        case 3:

        ro_command_eh.write( dummyCtrlPkt );

        ro_available_eh.write( true );

        break;

/*

ro_command_eh = command

ro_available_eh = 1

RO_data_associated = 0

RO_data_addr = X

RO_addr_error = 0       Oui une erreur de type EOC. On lit la commande. ack_RO = 1

*/

        case 4:

        {

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        BroadcastPacket bp( "0000", "0001" );

        ctrlPkt.packet = bp;

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

ro_command_eh = command

ro_available_eh = 0

RO_data_associated = 0

RO_data_addr = X

RO_addr_error = 0       Ne rien faire.  ack_RO = 0

*/

        case 5:

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( false );

        break;

/*

ro_command_eh = command

ro_available_eh = 1

RO_data_associated = 1

RO_data_addr = "0000"

RO_addr_error = 0

RO_EOC_error = 0        Oui une erreur de type EOC. On lit la commande. Lui associer l'adresse 0 pour la donnée associée.       ack_RO = 1

*/

        case 6:

        {

        // Has data and is posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000101000";

        ReadPacket rp( bv );

        ctrlPkt.packet = rp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(0);

        ctrlPkt.error64BitExtension = false;

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

ro_command_eh = command

ro_available_eh = 1

RO_data_associated = X

RO_data_addr = X

RO_addr_error = 1

RO_EOC_error = 0        Oui une erreur de type EOC. On lit la commande. Lui associer une erreur d'adressage 64 bits.    ack_RO = 1

*/

        case 7:

        {

        // Has data and is posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000101000";

        ReadPacket rp( bv );

        ctrlPkt.packet = rp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        ctrlPkt.error64BitExtension = true;

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

ro_command_eh = command

ro_available_eh = 1

RO_data_associated = X

RO_data_addr = X

RO_addr_error = 1

RO_EOC_error = 1        Oui une erreur de type EOC. On lit la commande. Lui associer une erreur de type EOC et une erreur d'adressage 64 bits.  ack_RO = 1

*/

        case 8:

        {

        // Has data and is non posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000001000";

        WritePacket wp( bv );

        ctrlPkt.packet = wp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        ctrlPkt.error64BitExtension = false;

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

        }

        next_trigger(activate_sendRequest);

}

/// On triggering, send signals corresponding to a test vector for 

/// testing the Response Packet sending interface of ht_errorHandler module

void

ht_errorHandler_sim::receiveResponse()

{

        next_trigger(activate_receiveResponse);

        cout << "ht_errorHandler_sim::receiveResponse" << endl;

        ControlPacketComplete ctrlPkt;

        switch( testOption )

        {

        /*

Tableau 61 - Tests pour le Flow Control et Data Buffer (FC,DB)

Vecteur d'entrée        Actions / États intermédiaires  Vecteur de sortie

fc_consume_eh = X

        Ne rien faire.

        eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = X

eh_drop_db = 0

eh_vctype_db = X

*/

        case 0:

        {

//      fc_consume_eh.write( randomNb );

        }

        break;

/*

fc_consume_eh = 1       Ne rien faire.

        eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = X

eh_drop_db = 0

eh_vctype_db = X

*/

        case 1:

        {

        fc_consume_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un Broadcast. Ne rien faire.    eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = X

eh_drop_db = 0

eh_vctype_db = X

*/

        case 2:

        {

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        BroadcastPacket bp( "0000", "0001" );

        ctrlPkt.packet = bp;

        ctrlPkt.error64BitExtension = false;

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un NonPosted Write. Envoyer un message TgtDone. eh_datacommand_fc = command

eh_available_fc = 1,0

eh_address_db = X

eh_drop_db = 0

eh_vctype_db = X

*/

        case 3:

        {

        // Has data and is non posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000001000";

        WritePacket wp( bv );

        ctrlPkt.packet = wp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0,1,0   La commande est un NonPosted Read. Envoyer un message RdResponse. Attendre que le ack tombe à vrai puis à faux, puis envoyer le data associé.   eh_datacommand_fc = command, data

eh_available_fc = 1,0,1,0

eh_address_db = X

eh_drop_db = 0

eh_vctype_db = X

*/

        case 4:

        {

        // Has data and is non posted

        sc_bv<64> bv;

        ReadPacket rp(  "0000","10000","01010","0111",0,true);

        ctrlPkt.packet = rp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(0);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

//      fc_consume_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un Posted Write. Si du data lui est associé, écrire l'adresse ainsi que le canal de la commande. Attendre un front et mettre drop à vrai.       eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = "0000"

eh_drop_db = 0,1

eh_vctype_db = "00"

*/

        case 5:

        {

        // Has data and is posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000101000";

        WritePacket wp( bv );

        ctrlPkt.packet = wp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(0);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un Posted Read. Si du data lui est associé, écrire l'adresse ainsi que le canal de la commande. Attendre un front et mettre drop à vrai.        eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = "0000"

eh_drop_db = 0,1

eh_vctype_db = "00"

*/

        case 6:

        {

        // Has data and is posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = "00000000000000000000000000101000";

        ReadPacket rp( bv );

        ctrlPkt.packet = rp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(0);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        fc_consume_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un Atomic. Si du data lui est associé, écrire l'adresse ainsi que le canal de la commande. Attendre un front et mettre drop à vrai.     eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = X

eh_drop_db = X

eh_vctype_db = X

*/

        case 7:

        {

        // Does not have data and is non posted

        sc_bv<64> bv;

        bv.range(63,32) = ZERO_BV32;

        bv.range(31,0) = ZERO_BV32;

        AtomicPacket ap( bv );

        ctrlPkt.packet = ap;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

/*

fc_consume_eh = 0       La commande est un Flush.       eh_datacommand_fc = X

eh_available_fc = 0

eh_address_db = X

eh_drop_db = X

eh_vctype_db = X

*/

        case 8:

        {

        // Does not have data and is non posted

        FlushPacket fp( "0001", "0000" );

        ctrlPkt.packet = fp;

        ctrlPkt.data_address = sc_uint<BUFFERS_ADDRESS_WIDTH>(randomNb);

        csr_eoc.write( sc_bit(1) );

        ro_command_eh.write( ctrlPkt );

        ro_available_eh.write( true );

        }

        break;

        }

        next_trigger(activate_receiveResponse);

}

/// Thread for activating the processes. Deal with timing issues.

void

ht_errorHandler_sim::simulate()

{

        while( true )

        {

                testOption = 4;

                cout << "ht_errorHandler_sim::simulate1" << endl;

                //activate_coldReset.notify();

                resetx.write(true);

                pwrok.write(true);

                dropFlagSignals();

                wait( 35, SC_NS );

                cout << "ht_errorHandler_sim::simulate2" << endl;

                activate_sendRequest.notify();

                wait( 40, SC_NS );

                cout << "ht_errorHandler_sim::simulate3" << endl;

                dropFlagSignals();

                wait( 40, SC_NS );

                cout << "ht_errorHandler_sim::simulate4" << endl;

                activate_receiveResponse.notify();

                wait( 40, SC_NS );

                fc_consume_eh.write( true );

                wait( 40, SC_NS );

                ro_available_eh.write( false );

                wait( 40, SC_NS );

                fc_consume_eh.write( false );

                wait( 20, SC_NS );

                fc_consume_eh.write( true );

                wait();

        }

}