Subversion Repositories ht_tunnel

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

#include <cstdlib>

#include <iostream>

#include "../link_frame_rx_l3_tb/link_rx_transmitter.h"

#include "../link_frame_tx_l3_tb/link_tx_validator.h"

#include "../../core/require.h"

/**

        Note : this is far from being a full testbench.  The goal of this

        is to verify the basic fonctionnality.  Extensive testing of all

        possibilities is not yet a priority...

         The goals of this testbench are to check :

        -basic sequence without error (verify the correctness of sent CRC's)

        -basic with error on rx side (verify the correctness of sent CRC's)

        -ldtstop sequence

        -sync error

        -basic with error in CRC and retry mode enabled (should be ignored)

        -basic with error in CTL transition and retry mode

*/

link_l2_tb::link_l2_tb(sc_module_name name) : sc_module(name){

        SC_THREAD(manage_rx_transmission);

        sensitive_pos(clk);

        SC_THREAD(validate_rx_reception);

        sensitive_pos(clk);

        SC_THREAD(stimulus);

        sensitive_pos(clk);

        transmitter = new link_rx_transmitter("link_rx_transmitter");

        transmitter->clk(clk);

        transmitter->phy_ctl_lk(phy_ctl_lk);

        for(int n = 0; n < CAD_IN_WIDTH; n++){

                transmitter->phy_cad_lk[n](phy_cad_lk[n]);

        }

        transmitter->phy_available_lk(phy_available_lk);

#ifndef INTERNAL_SHIFTER_ALIGNMENT

        transmitter->lk_deser_stall_phy(lk_deser_stall_phy);

        transmitter->lk_deser_stall_cycles_phy(lk_deser_stall_cycles_phy);

#endif

        validator = new link_tx_validator("link_tx_validator");

        validator->clk(clk);

        validator->lk_ctl_phy(lk_ctl_phy);

        for(int n = 0; n < CAD_IN_WIDTH; n++){

                validator->lk_cad_phy[n](lk_cad_phy[n]);

        }

        validator->tx_consume_data(lk_consume_fc);

        validator->phy_consume_lk(phy_consume_lk);

        validator->cad_to_frame(fc_dword_lk);

        validator->lctl_to_frame(fc_lctl_lk);

        validator->hctl_to_frame(fc_hctl_lk);

        //A random seed value

        srand(23524);

        reset_rx_connection = false;

        check_rx_dword_reception = true;

        rx_number = 0;

        expecting_rx_crc_error = 0;

        rx_crc = 0xFFFFFFFF;

        tx_crc = 0xFFFFFFFF;

}

link_l2_tb::~link_l2_tb(){

        delete transmitter;

        delete validator;

}

void link_l2_tb::stimulus(){

        init();

        link_tx_validator::LinkTransmission_TX tx_crc_transmission;

        tx_crc_transmission.lctl = true;

        tx_crc_transmission.hctl = true;

        LinkTransmission rx_crc_transmission;

        rx_crc_transmission.error = false;

        rx_crc_transmission.lctl = true;

        rx_crc_transmission.hctl = true;

        //////////////////////////////////////

        // First test, valid and nonvalid CRC

        //////////////////////////////////////

        init_fill_queues(272,false);

        tx_crc_transmission.dword = ~last_tx_crc;

        validator->expected_transmission.push(tx_crc_transmission);

        //cout << "Expected TX CRC : " << tx_crc_transmission.dword.to_string(SC_HEX) << endl;

        //rx_crc_transmission.dword = ~last_rx_crc;

        //Generate error!

        rx_crc_transmission.dword = 0x01234567;

        transmit_rx_queue.push(rx_crc_transmission);

        expecting_rx_crc_error++;

        fill_rx_qeues(16, true);

        fill_tx_qeues(16, true);

        link_tx_validator::LinkTransmission_TX nop_transmit;

        nop_transmit.dword = 0;

        nop_transmit.lctl = true;

        nop_transmit.hctl = true;

        validator->expect_tx_consume_data = 600;

        while(!(expected_rx_queue.empty() && validator->expected_transmission.empty())){

                if(validator->to_transmit.size() < 2){

                        validator->to_transmit.push(nop_transmit);

                        validator->checking_errors = false;

                }

                if(lk_crc_error_csr.read()){

                        if(!expecting_rx_crc_error)

                                cout << "CRC mismatch on reception" << endl;

                        else

                                expecting_rx_crc_error--;

                }

                wait();

        }

        cout << "Done basic sequence without CTL error " << endl;

        resetx = false;

        if(expecting_rx_crc_error){

                cout << "Some CRC transmission errors were not detected!" << endl;

        }

        //////////////////////////////////////

        // Test : LDTSTOP sequence

        //////////////////////////////////////

        cout << endl << "Start LDTSTOP test" << endl;

        empty_tx_queues(true);

        empty_rx_queues(true);

        init();

        cout << "LDTSTOP init done" << endl;

        init_fill_queues(272,true);

        validator->expect_tx_consume_data = 600;

        //Send part of the data

        while(validator->expected_transmission.size() > 114){

                if(lk_crc_error_csr.read()){

                        if(!expecting_rx_crc_error)

                                cout << "CRC mismatch on reception" << endl;

                        else

                                expecting_rx_crc_error--;

                }

                wait();

        }

        cout << "starting LDTSTOP sequence" << endl;

        //Start ldtstop sequence

        ldtstopx = false;

        cd_initiate_nonretry_disconnect_lk = true;

        while(validator->expected_transmission.size() > 0){

                if(lk_crc_error_csr.read()){

                        if(!expecting_rx_crc_error)

                                cout << "CRC mismatch on reception" << endl;

                        else

                                expecting_rx_crc_error--;

                }

                wait();

        }

        cout << "Sending disconnect nops" << endl;

        //Disconnect NOPs!

        link_tx_validator::LinkTransmission_TX t_tx;

        t_tx.dword = sc_uint<32>(0x00000020); t_tx.hctl = true; t_tx.lctl = true;

        for(int n = 0; n < 20; n++)

                validator->expected_transmission.push(t_tx);

        while(validator->expected_transmission.size() > 10){

                if(lk_crc_error_csr.read()){

                        if(!expecting_rx_crc_error)

                                cout << "CRC mismatch on reception" << endl;

                        else

                                expecting_rx_crc_error--;

                }

                wait();

        }

        cout << "Done LDTSTOP sequence test" << endl;

        //////////////////////////////////////

        // Test : SYNC sequence

        //////////////////////////////////////

        cout << endl << "Start SYNC test" << endl;

        empty_tx_queues(true);

        empty_rx_queues(true);

        init();

        init_fill_queues(400,true);

        validator->expect_tx_consume_data = 600;

        cout << "Start sending data" << endl;

        //Send part of the data

        while(validator->expected_transmission.size() > 1 || !phy_consume_lk.read()){

                if(lk_crc_error_csr.read()){

                        if(!expecting_rx_crc_error)

                                cout << "CRC mismatch on reception" << endl;

                        else

                                expecting_rx_crc_error--;

                }

                wait();

        }

        cout << "starting SYNC sequence" << endl;

        //Start sync sequence

        csr_sync = true;

        //Empty all expected packets

        for(int n = expected_rx_queue.size(); n != 0 ;n--)

                expected_rx_queue.pop();

        //Expect disconnect NOPs!

        t_tx.dword = sc_uint<32>(0xFFFFFFFF); t_tx.hctl = true; t_tx.lctl = true;

        for(int n = 0; n < 150; n++)

                validator->expected_transmission.push(t_tx);

        while(validator->expected_transmission.size() > 10){

                if(lk_crc_error_csr.read()){

                        cout << "CRC mismatch on reception" << endl;

                }

                wait();

        }

        csr_sync = false;

        cout << "Done SYNC sequence test" << endl;

        //////////////////////////////////////

        // Test : CRC Error in retry mode (should be ignored)

        //////////////////////////////////////

        cout << endl << "Start Retry CRC error test" << endl;

        empty_tx_queues(true);

        empty_rx_queues(true);

        init();

        init_fill_queues(272,false);

        validator->checking_errors = false;

        //rx_crc_transmission.dword = ~last_rx_crc;

        //Generate error!

        transmit_rx_queue.push(rx_crc_transmission);

        fill_rx_qeues(16, true);

        fill_tx_qeues(16, true);

        validator->expect_tx_consume_data = 600;

        csr_retry = true;

        while(!(expected_rx_queue.empty() && validator->expected_transmission.empty())){

                if(validator->to_transmit.size() < 2){

                        validator->to_transmit.push(nop_transmit);

                }

                if(lk_crc_error_csr.read())

                        cout << "ERROR : CRC mismatch signaled in retry mode" << endl;

                if(lk_initiate_retry_disconnect.read())

                        cout << "Error, retry sequence started incorrectly!" << endl;

                wait();

        }

        cout << "Done retry sequence with periodic CRC error " << endl;

        resetx = false;

        csr_retry = false;

        //validator->checking_errors = true;

        //////////////////////////////////////

        // Test : CTL transition error in retry mode

        //////////////////////////////////////

        cout << endl << "Start Retry CTL error test" << endl;

        empty_tx_queues(true);

        empty_rx_queues(true);

        init();

        init_fill_queues(50,false);

        csr_retry = true;

        validator->checking_errors = false;

        LinkTransmission rx_ctl_error_t;

        rx_ctl_error_t.error = true;

        rx_ctl_error_t.lctl = true;

        rx_ctl_error_t.hctl = true;

        rx_ctl_error_t.dword = 0x01234567;

        transmit_rx_queue.push(rx_ctl_error_t);

        fill_rx_qeues(16, true);

        fill_tx_qeues(16, true);

        validator->expect_tx_consume_data = 600;

        csr_retry = true;

        while(!expected_rx_queue.empty() && !lk_initiate_retry_disconnect.read())

                wait();

        if(!lk_initiate_retry_disconnect.read())

                cout << "Error, retry sequence not started correctly!" << endl;

        csr_retry = false;

        cout << "Done retry sequence CTL error " << endl;

        //////////////////////////////////////

        // Test : initiate an external retry sequence

        //////////////////////////////////////

        /*cout << "Start initiate Retry test" << endl;

        empty_tx_queues(true);

        empty_rx_queues(true);

        init();

        init_fill_queues(50,false);

        csr_retry = true;

        while(validator->expected_transmission.size() > 10)

                wait();*/

        resetx = false;

        validator->checking_errors = false;

        validator->reset();

        //Inifinite loop

        while(true) wait();

}

void link_l2_tb::init(){

        cout << "TB: Init" << endl;

        /**

                Start reset and initialist internal variables and signals sent

                to the link

        */

        resetx = false;

        pwrok = false;

        ldtstopx = false;

        csr_rx_link_width_lk = "000";

        csr_tx_link_width_lk = "000";

        csr_sync = false;

        csr_end_of_chain = false;

        csr_crc_force_error_lk = false;

        csr_transmitter_off_lk = false;

        csr_extented_ctl_lk = false;

        csr_extended_ctl_timeout_lk = false;

        csr_ldtstop_tristate_enable_lk = false;

#ifdef RETRY_MODE_ENABLED

        cd_initiate_retry_disconnect = false;

        fc_disconnect_lk = false;

        csr_retry = false;

#endif

        cd_initiate_nonretry_disconnect_lk = false;

        //Reset validator to initial state

        validator->reset();

        //Wait some cycles for reset to have effect

        for(int n = 0; n < 5; n++) wait();

        validator->reset();//Not sure this call is necessary...

        //Stop cold reset and make sure no in ldtstop sequence

        pwrok = true;

        ldtstopx = true;

        transmitter->send_initial_value(5);

        for(int n = 0; n < 5; n++) wait();

        //stop reset

        resetx = true;

        //Reset the rx connection (it will reconnect automatically)

        reset_rx_connection = true;

}

void link_l2_tb::init_fill_queues(const unsigned quantity,bool insertLastCrc){

        //First, push a maximum of 128 in

        int q_max128 = quantity > 128 ? 128 : quantity;

        fill_rx_qeues(q_max128, true);

        fill_tx_qeues(q_max128, true);

        //Check how many are to add

        int quantity_remaining = quantity - q_max128;

        //if none, we're done

        if(!quantity_remaining) return;

        //128 is the first window 

        last_rx_crc = rx_crc;

        last_tx_crc = tx_crc;

        rx_crc = 0xFFFFFFFF;

        tx_crc = 0xFFFFFFFF;

        //Transmission object that will hold tx CRC

        link_tx_validator::LinkTransmission_TX tx_crc_transmission;

        tx_crc_transmission.lctl = true;

        tx_crc_transmission.hctl = true;

        //Transmission object that will hold rx CRC

        LinkTransmission rx_crc_transmission;

        rx_crc_transmission.error = false;

        rx_crc_transmission.lctl = true;

        rx_crc_transmission.hctl = true;

        while(true){

                //Send a max of 16 dwords

                int q_max16 = quantity_remaining > 16 ? 16 : quantity_remaining;

                //substract the number sent to the quantity remaining

                quantity_remaining -= q_max16;

                //Fill the queues

                fill_rx_qeues(q_max16, true);

                fill_tx_qeues(q_max16, true);

                //Break if done

                //If less than 16 were pushed in, we reached our quantity

                //If 16 were pushed and none left, we're done if we don't want

                //to add the last CRC

                if(!quantity_remaining && !insertLastCrc || q_max16 != 16) break;

                //Insert the CRC

                tx_crc_transmission.dword = ~last_tx_crc;

                rx_crc_transmission.dword = ~last_rx_crc;

                validator->expected_transmission.push(tx_crc_transmission);

                transmit_rx_queue.push(rx_crc_transmission);

                //cout << "TX CRC inserted : " << tx_crc_transmission.dword.to_string(SC_HEX)

                //      << " Size now : " << validator->expected_transmission.size() << endl;

                if(!quantity_remaining) break;

                //Insert the next 112 dwords of the window

                int q_max112 = quantity_remaining > 112 ? 112 : quantity_remaining;

                quantity_remaining -= q_max112;

                fill_rx_qeues(q_max112, true);

                fill_tx_qeues(q_max112, true);

                last_rx_crc = rx_crc;

                last_tx_crc = tx_crc;

                rx_crc = 0xFFFFFFFF;

                tx_crc = 0xFFFFFFFF;

                if(!quantity_remaining) break;

        }

}

void link_l2_tb::fill_tx_qeues(const unsigned quantity, bool updateCRC){

        LinkTransmission t;

        link_tx_validator::LinkTransmission_TX t_tx;

        //Add the requested number of transmissions

        for(unsigned n = 0; n < quantity; n++){

                //Generate a transmission

                generate_random_transmission(t);

                //Simply copy it into a TX transmission

                t_tx.dword = t.dword; t_tx.hctl = t.hctl; t_tx.lctl = t.lctl;

                //Put it in the expected and to_transmit queues

                validator->expected_transmission.push(t_tx);

                validator->to_transmit.push(t_tx);

                if(updateCRC) {

                        update_crc(tx_crc,t.dword,t.lctl,t.hctl);

                        //cout << "CRC after " << n << " : " << tx_crc << "Hex " << sc_uint<32>(tx_crc).to_string(SC_HEX) << endl;

                }

        }

}

void link_l2_tb::empty_tx_queues(bool reset_crc){

        for(int n = validator->expected_transmission.size(); n > 0; n--)

                validator->expected_transmission.pop();

        for(int n = validator->to_transmit.size(); n > 0; n--)

                validator->to_transmit.pop();

        if(reset_crc){

                last_tx_crc = 0;

                tx_crc = 0xFFFFFFFF;

        }

}

void link_l2_tb::fill_rx_qeues(const unsigned quantity, bool updateCRC){

        LinkTransmission t;

        t.error = false;

        for(int n = quantity; n != 0; n--){

                generate_random_transmission(t);

                transmit_rx_queue.push(t);

                expected_rx_queue.push(t);

                if(updateCRC)

                        update_crc(rx_crc,t.dword,t.lctl,t.hctl);

        }

}

void link_l2_tb::empty_rx_queues(bool reset_crc){

        for(int n = transmit_rx_queue.size();n>0;n--)

                transmit_rx_queue.pop();

        for(int n = expected_rx_queue.size();n>0;n--)

                expected_rx_queue.pop();

        if(reset_crc){

                last_rx_crc = 0;

                rx_crc = 0xFFFFFFFF;

        }

}

void link_l2_tb::generate_random_transmission(LinkTransmission & t){

        //15 bit used for rand because some implementations of rand

        //have a max of 32K

        sc_uint<15> r = rand();

        t.dword.range(31,24) = r.range(7,0);

        r = rand();

        t.dword.range(23,16) = r.range(7,0);

        r = rand();

        t.dword.range(15,8) = r.range(7,0);

        r = rand();

        t.dword.range(7,0) = r.range(7,0);

        t.lctl = (rand() << 1) / (RAND_MAX);

        t.hctl = (rand() << 1) / (RAND_MAX);

}

void link_l2_tb::update_crc(int & crc,const sc_bv<32> &dword, bool lctl, bool hctl){

        //There is a total of 36 bits to throw in CRC.  Since it's higher

        //than 32 bits, do it in two passes of 18 bits

        unsigned dword_int = (unsigned)sc_uint<32>(dword);

        //Put data in integers

        int data[2] = {

                (dword_int & 0xFF) | ((dword_int & 0xFF00) << 1),

                ((dword_int & 0xFF0000) >> 16) | ((dword_int & 0xFF000000) >> 15)

        };

        //Add the lctl values to the CRC

        if(lctl) data[0] |= 0x20100;

        if(hctl) data[1] |= 0x20100;

        sc_uint<18> d0 = data[0];

        sc_uint<18> d1 = data[1];

        sc_bv<36> complete_data;

        complete_data.range(17,0) = data[0];

        complete_data.range(35,18) = data[1];

        //cout << "TB CRC DATA " << complete_data.to_string(SC_HEX) << endl;

        //Do the two passes 

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

                //- taken exactly from the HT spec (10.1.1)

                for(int i = 0; i < 18; i++){

                        int tmp = crc >> 31; /* store highest bit */

                        crc = (crc << 1) | ((data[n] >> i) & 1); /* shift message in */

                        crc = (tmp) ? crc ^ poly : crc; /* substract poly if greater */

                }

        }

}

void link_l2_tb::manage_rx_transmission(){

        while(true){

                if(reset_rx_connection){

                        transmitter->send_initial_value(5);

                        transmitter->send_init_sequence(0,0);

                        reset_rx_connection = false;

                }

                if(!transmit_rx_queue.empty()){

                        transmitter->send_dword_link(

                                transmit_rx_queue.front().dword,

                                transmit_rx_queue.front().lctl,

                                transmit_rx_queue.front().hctl,

                                transmit_rx_queue.front().error);

                        transmit_rx_queue.pop();

                }

                else

                        wait();

        }

}

void link_l2_tb::validate_rx_reception(){

        while(true){

                wait();

                //Test reception of data

                if(lk_available_cd.read() && check_rx_dword_reception){

                        verify(!(expected_rx_queue.empty()),

                                "RX : Unexpected data reception");

                        if(!expected_rx_queue.empty()){

                                LinkTransmission t = expected_rx_queue.front();

                                /*cout << "RX Data in front : L=" << t.lctl << " H=" <<

                                        t.hctl << " D=" << t.dword.to_string(SC_HEX) << "  Number: " << rx_number++ << endl;

                                cout << "RX Data received : L=" << lk_lctl_cd.read() << " H=" <<

                                        lk_hctl_cd.read() << " D=" << lk_dword_cd.read().to_string(SC_HEX) << endl;*/

                                expected_rx_queue.pop();

                                verify((t.dword == lk_dword_cd.read() &&

                                                t.lctl == lk_lctl_cd.read() &&

                                                t.hctl == lk_hctl_cd.read()),

                                        "RX Invalid data received");

                        }

                }

        }

}