Subversion Repositories ht_tunnel

//InterfaceLayer.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 InterfaceLayer_H

#define InterfaceLayer_H

#include "systemc.h"

#include <deque>

///forward declaration

class InterfaceLayer;

///Event handler class for received packet from the InterfaceLayer

class InterfaceLayerEventHandler{

public:

        ///Called when the InterfaceLayer receives a packet

        /**

                @param packet The received packet

                @param data The data associated with the packet.  If it does not contain data, it is

                        null.  Every int represents a dword of data

                @param directRoute If the packet was directRoute traffic

                @param side from which came the packet

                @param origin The InterfaceLayer that fired the event

        */

        virtual void receivedInterfacePacketEvent(const ControlPacket * packet,const int * data,

                bool directRoute,bool side,InterfaceLayer* origin)=0;

};

///Software interface to communication to HT hardware user interface

/**

        @class InterfaceLayer

        @author Ami Castonguay

        @description A software interface to send and received packets to a HT tunnel

                in hardware.  It breaks down packets queued to be sent into dwords that

                are sent to the tunnel.  Received dwords are reconstructed in packets.

*/

class InterfaceLayer : public sc_module {

        ///The packet, it's data and the side it came from 

        struct PacketAndData{

                ///Control packet

                ControlPacket * packet;

                ///Data associated with that control packet (NULL if none)

                int * data;

                ///Side the packet arrived from

                bool side;

        };

        ///State for packet transmission

        enum TransmitState{

                TX_SEND_DATA,

                TX_IDLE

        };

        ///State for packet reception

        enum ReceiveState{

                RX_RECEIVE_DATA,

                RX_IDLE

        };

public:

        ///Main clock of the system

        sc_in<bool>             clk;

        ///Main reset of the system (negative logic)

        sc_in<bool>             resetx;

        //******************************************

        //                      Signals to User

        //******************************************

        //------------------------------------------

        // Signals to send received packets to User

        //------------------------------------------

        /**The actual control/data packet to the user*/

        sc_in<sc_bv<64> >               ui_packet_usr;

        /**The virtual channel of the ctl/data packet*/

        sc_in<VirtualChannel>   ui_vc_usr;

        /**The side from which came the packet*/

        sc_in< bool >                   ui_side_usr;

        /**If the packet is a direct_route packet - only valid for

           requests (posted and non-posted) */

        sc_in<bool>                     ui_directroute_usr;

        /**If this is the last part of the packet*/

        sc_in< bool >                   ui_eop_usr;

        /**If there is another packet available*/

        sc_in< bool >                   ui_available_usr;

        /**If what is read is 64 bits or 32 bits*/

        sc_in< bool >                   ui_output_64bits_usr;

        /**To allow the user to consume the packets*/

        sc_out< bool >                  usr_consume_ui;

        //------------------------------------------

        // Signals to allow the User to send packets

        //------------------------------------------

        /**The actual control/data packet from the user*/

        sc_out<sc_bv<64> >              usr_packet_ui;

        /**If there is another packet available*/

        sc_out< bool >                  usr_available_ui;

        /**

        The side to send the packet if it is a response

        This bit is ignored if the packet is not a response

        since the side to send a request is determined automatically

        taking in acount DirectRoute functionnality.

        */

        sc_out< bool >                  usr_side_ui;

        /*

                Which what type of ctl packets can be sent

                bits.  Thos signals have the same value as

                the outputs, but they are here so that

                these signals can be used internally.

                5 POSTED,               no data

                4 POSTED,               data

                3 NON_POSTED,   no data

                2 NON_POSTED,   data

                1 RESPONSE,     no data

        */

        /**Which what type of ctl packets can be sent to side0*/

        sc_in<sc_bv<6> >                ui_freevc0_usr;

        /**Which what type of ctl packets can be sent to side0*/

        sc_in<sc_bv<6> >                ui_freevc1_usr;

        //------------------------------------------

        // Signals to affect CSR

        //------------------------------------------

        ///Activated when response error is received

        sc_out<bool> usr_receivedResponseError_csr;

        ///SystemC Macro

        SC_HAS_PROCESS(InterfaceLayer);

        ///Queue of packet to send on the interface

        std::deque<PacketAndData> packetQueue;

        ///Constructor

        InterfaceLayer(sc_module_name name);

        ///Destructor

        virtual ~InterfaceLayer();

        ///Set the interface handler that will be notified of received packet

        void setInterfaceLayerEventHandler(InterfaceLayerEventHandler *handler){

                this->handler = handler;

        };

        ///To send a packet (non-blocking, packet is simply buffered)

        void sendPacket(ControlPacket * packet,int * data,bool side = false);

        ///Blocks until all packets are sent out

    void flush();

protected:

        ///Process for reception of packets from the tunnel

        void rx_process();

        ///Process to send queued data to the tunnel

        void tx_process();

private:

        ///Event handler for received packet

        InterfaceLayerEventHandler * handler;

        ///The count of data sent

        int tx_data_sent;

        ///The count of data received

        int rx_received_data;

        ///State of packet transmission

        TransmitState tx_state;

        ///State of packet reception

        ReceiveState rx_state;

        ///Packet currently being received

        ControlPacket * receivePacket;

        ///Buffer for received data

        int receiveData[16];

        ///Side from which the packet was received

        bool receiveSide;

        ///If the packet is directRoute traffic

        bool receiveDirecRoute;

};

#endif