Subversion Repositories ht_tunnel

//reordering_l2_tb.h

/* ***** 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 ***** */

#ifndef REORDERING_L2_TB_H

#define REORDERING_L2_TB_H

#include "../../rtl/systemc/core_synth/synth_datatypes.h"

#include <deque>

///Testbench for reordering_l2 module

class reordering_l2_tb : public sc_module{

        //Structure containing all necessary information about a packet sent to reordering

        /**

                A packet might be for both accepted and forward (broadcast packet).

                A packet for the CSR will have both the csr and accepted set to true

        */

        struct ReorderTBPacket{

                syn_ControlPacketComplete pkt;//The packet that was sent

                VirtualChannel vc;//It's VirtualChannel

                bool accepted;//If it is for accepted destination

                bool forward;//If it is for forward destination

                bool csr;//If it is for csr destination

        };

        ///The different type of posted packet that can be requested

        enum PostedType{

                POSTED_ANY,

                POSTED_ACCEPTED,

                POSTED_FORWARD

        };

        ///The different type of non-posted packet that can be requested

        enum NPostedType{

                NPOSTED_ANY,

                NPOSTED_ACCEPTED,

                NPOSTED_FORWARD

        };

        ///The different type of response packet that can be requested

        enum ResponseType{

                RESPONSE_ANY,

                RESPONSE_ACCEPTED,

                RESPONSE_FORWARD

        };

        ///The different type of destination and type of paccket chain posted packet can go

        enum PostedDestination{

                POSTED_DESTINATION_CSR = 0,

                POSTED_DESTINATION_USER = 1,

                POSTED_DESTINATION_FORWARD = 2,

                POSTED_DESTINATION_USER_DEVICE_MSG = 3

        };

public:

        ///clk signal

        sc_in<bool> clk;

        /// Reset signal 

        sc_out<bool> resetx;

        /// Packet sent to CSR module

        sc_in<syn_ControlPacketComplete> ro_packet_csr;

        /// Packet sent to User module

        sc_in<syn_ControlPacketComplete> ro_packet_ui;

        /// Packet sent to FC module

        sc_in<syn_ControlPacketComplete> ro_packet_fwd;

        /// Indicates if a packet is available on the RO_ControlPacketComplete_CSR port

        sc_in<bool> ro_available_csr;

        /// Indicates if a packet is available on the RO_ControlPacketComplete_User port

        sc_in<bool> ro_available_ui;

        /// Indicates if a packet is available on the RO_ControlPacketComplete_FC port

        sc_in<bool> ro_available_fwd;

        /// Acknowledge signal from the CSR module

        sc_out<bool> csr_ack_ro;

        /// Acknowledge signal from the User module

        sc_out<bool> ui_ack_ro;

        /// Acknowledge signal from the FC module

        /** fwd_ack_ro and eh_ack_ro do the same thing*/

        sc_out<bool> fwd_ack_ro;

        /// Acknowledge signal from the Error Handler module

        sc_out<bool> eh_ack_ro;

        /// Indicates that a NOP was sent

        sc_out<bool> fc_nop_sent;

        /// New packet from Command Decode

        sc_out<syn_ControlPacketComplete> cd_packet_ro;

        /// Indicates if a packet is available on the CD_ControlPacketComplete_RO port

        sc_out<bool> cd_available_ro;

        /**If the cd is currently receiving data.  This is used to know if a packet

                that has associated data can be sent*/

        sc_out<bool>                                            cd_data_pending_ro;

        /**Where the cd is storing data.   This is used to know if a packet

                that has associated data can be sent*/

        sc_out<sc_uint<BUFFERS_ADDRESS_WIDTH> > cd_data_pending_addr_ro;

        /// UnitID of the current module

        sc_out<sc_bv<5> > csr_unit_id;

        /// Address Range reserved for the module.

        sc_out<sc_bv<40> >      csr_bar[NbRegsBars];

        ///If we accept writes or reads to the memory space

        sc_out<bool>                    csr_memory_space_enable;

        ///If we accept writes or reads to the io space

        sc_out<bool>                    csr_io_space_enable;

        /** Indicates which unitID enables DirectRoute*/

        sc_out<sc_bv<32> > csr_direct_route_enable;

        /// Indicates the clumping configuration

        sc_out<sc_bv<5> > clumped_unit_id[32];

        ///If the link is currently sync flooding

        sc_out<bool> csr_sync;

#ifdef ENABLE_REORDERING

        /// this flag disables the reordering.

        /**See chapter 7.5.10.6 of hyperTransport specs 1.10*/

        sc_out<bool> csr_unitid_reorder_disable;

#endif

        /**Indicates whether the VC is upstream(=true) or downstream(=false)*/

        /// Contains information about the Command buffers of the upper module. 

        /**A set bit indicates:

        bit 5 = There is space in the PC VC

        bit 4 = There is space in the PC data VC

        bit 3 = There is space in the NPC VC

        bit 2 = There is space in the NPC data VC

        bit 1 = There is space in the R VC

        bit 0 = There is space in the R data VC

        A command packet cannot be sent if there is room in both data and command

        buffers of the upper module*/

        sc_out<sc_bv <6> > fwd_next_node_buffer_status_ro;

        ///Buffers to advertise as free when a nop is sent

        /** [5,4]: nonposted;  [3,2]: response. [1,0]: posted;*/

        sc_in<sc_bv <6> > ro_buffer_cnt_fc;

        /// Asks to send a NOP

        sc_in<bool> ro_nop_req_fc;

        ///More packets than can be stored are received

        sc_in<bool> ro_overflow_csr;

#ifdef RETRY_MODE_ENABLED

        /// If the RX link is connected

        sc_out< bool >                                                          lk_rx_connected;

        ///If retry mode is active

        sc_out< bool >                                                          csr_retry;

#endif

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

        // Interface to memory

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

        sc_in<sc_bv<CMD_BUFFER_MEM_WIDTH> > ro_command_packet_wr_data;

        sc_in<bool > ro_command_packet_write;

        sc_in<sc_uint<LOG2_NB_OF_BUFFERS+2> > ro_command_packet_wr_addr;

        sc_in<sc_uint<LOG2_NB_OF_BUFFERS+2> > ro_command_packet_rd_addr[2];

        sc_out<sc_bv<CMD_BUFFER_MEM_WIDTH> > command_packet_rd_data_ro[2];

        ///Command memory

        sc_bv<CMD_BUFFER_MEM_WIDTH> command_memory[4*NB_OF_BUFFERS];

        /** @see ::consume_data()

        */

        //@{

        ///Read packet to configuration space registers if available

        sc_signal<bool> read_csr;

        ///Read packet to forward if available

        sc_signal<bool> read_fwd;

        ///Read packet to user interface if available

        sc_signal<bool> read_ui;

        //@}

        ///Queue of packets sent in the reordering

        std::deque<ReorderTBPacket>     packet_sent;

        ///If the packets currently being sent to the reordering are part of a chain

        bool curently_sending_chain;

        ///The destination the chain is going so that following packets to the same way

        PostedDestination chain_destination;

        ///SystemC Macro

        SC_HAS_PROCESS(reordering_l2_tb);

        ///Constructor

        reordering_l2_tb(sc_module_name name);

        ///Main testbench control thread

        void simulate();

        /** The testbench is synchronous, so there is no way to know if during the

                next cycle there will be data available from the reordering.  Different

                read signals(::read_csr,::read_fwd,::read_ui) can be read synchronously and

                this process will read from the destination if there is data available.

        */

        void consume_data();

        void manage_memories();

        /** @description Generate an random address that is not part of the

                        BAR addresses.

                @param addr The generated address returned by address

        */

        void generate_random_not_bar_address(sc_bv<40> &addr);

        /** @description Generate an random posted packet going to the

                        specified destination

                @param tb_pkt The generated packet and associated informations

                        returned by address

                @param posted_type The destination where the packet should go

        */

        void generate_random_posted_pkt(ReorderTBPacket &tb_pkt,

                                                                        PostedType posted_type);

        /** @description Generate an random posted packet going to the

                        accepted destination

                @param pkt The generated packet returned by address

                @param chain If the packet is part of a chain

        */

        bool generate_random_accepted_posted_pkt(sc_bv<64> &pkt,

                                                                                         bool chain);

        /** @description Generate an random posted packet going to the

                        forward destination

                @param pkt The generated packet returned by address

                @param chain If the packet is part of a chain

        */

        void generate_random_forward_posted_pkt(sc_bv<64> &pkt, bool chain);

        /** @description Generate an random broadcast packet

                @param tb_pkt The generated packet returned by address

        */

        void generate_random_broadcast_posted_pkt(sc_bv<64> &tb_pkt);

        /** @description Generate an random 64-bit vector

                @param pkt The generated vector returned by address

        */

        void generate_random_64b_vector(sc_bv<64> &pkt);

        /** @description Generate an random non posted packet going to the

                        specified destination

                @param tb_pkt The generated packet and associated informations

                        returned by address

                @param nposted_type The destination where the packet should go

        */

        void generate_random_nposted_pkt(ReorderTBPacket &tb_pkt,

                                                                        NPostedType nposted_type);

        /** @description Generate an random non posted packet going to the

                        accepted destination

                @param pkt The generated packet returned by address

        */

        bool generate_random_accepted_nposted_pkt(sc_bv<64> &pkt);

        /** @description Generate an random non posted packet going to the

                        forward destination

                @param pkt The generated packet returned by address

        */

        void generate_random_forward_nposted_pkt(sc_bv<64> &pkt);

        /** @description Generate an random response packet going to the

                        specified destination

                @param tb_pkt The generated packet and associated informations

                        returned by address

                @param response_type The destination where the packet should go

        */

        void generate_random_response_pkt(ReorderTBPacket &tb_pkt,

                                                                        ResponseType response_type);

        /** @description Generate an random response packet going to the

                        accepted destination

                @param pkt The generated packet returned by address

        */

        void generate_random_accepted_response_pkt(sc_bv<64> &pkt);

        /** @description Generate an random response packet going to the

                        forward destination

                @param pkt The generated packet returned by address

        */

        void generate_random_forward_response_pkt(sc_bv<64> &pkt);

};

#endif