Subversion Repositories ht_tunnel

//LogicalLayer.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 LogicalLayer_H

#define LogicalLayer_H

#include "systemc.h"

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

#include "PhysicalLayer.h"

#include <deque>

//Forward declaration

class ControlPacket;

class LogicalLayer;

///Event handler interface for the LogicalLayer module

class LogicalLayerInterface{

public:

        /**

                @description Called when a packet is received by the

                        LogicalLayer

                @param packet The received packet

                @param data The data associated with the packet.  It is an

                        array of dwords.  If the packet has data associated with

                        it, the size of the array is the number of dwords associated

                        with the packet (1-16).  Otherwise, it is NULL.

                @param origin The LogicalLayer that launchde the event

        */

        virtual void receivedHtPacketEvent(const ControlPacket * packet,

                const int * data,LogicalLayer* origin)=0;

        /**

                Called when a periodic CRC error is detected

        */

    virtual void crcErrorDetected()=0;

};

///Module that handles logical level of the HyperTransport link.

/**

        @author Ami Castonguay

        @description    It takes packets and breaks it in

                dwords to send to the Physical layer.  It also handles the retry

                mode : it will send appropriate per-packet CRC's and also store

                a history of sent packet so that packets not sent correctly

                can be reset.

                It also handles NOPs both for transmission and for reception.  When

                nops are received, the buffer count of the next HT node is updated.

                The local buffer count is also maintained and nops are sent when

                necessary.

                When ::sendPacket is called, the packet to be sent it stored in

                a buffer but is not sent immediately.  It will be sent out as

                the simulation progresses.  If the flush function is called, it

                will only return when all packets in the buffer are sent.  If the

                next node does not have the necessary buffers to accept a packet,

                it is not sent unril the buffer is free.

                When a new packet is received, an event is generated.  A listener

                simply has to implement the LogicalLayerInterface and register

                as the interface to the LogicalLayer to be notified of received

                packets.

                The class also implements the PhysicalLayerInterface to be notified

                by the PhysicalLayer of the link whenever a dword is received.

*/

class LogicalLayer : public sc_module, public PhysicalLayerInterface{

        ///List of possible states for receiving packets

        enum ReceiveState{

                RECEIVE_IDLE,

                RECEIVE_SECOND_DWORD,

                RECEIVE_DATA,

                RECEIVE_NOP_CRC,

                RECEIVE_CRC

        };

        ///List of possible states to transmit packets

        enum SendState{

                SEND_IDLE,

                SEND_SECOND_DWORD,

                SEND_ADDR_EXT,

                SEND_DATA,

                SEND_NOP_CRC,

                SEND_CRC

        };

        ///Structure combining a packet, it's data and it's ack value

        struct PacketAndData{

                ///The packet

                ControlPacket * packet;

                ///Data associated with the packet (NULL if none)

                int * data;

                ///Ack value of the packet (for the retry mode)

                int id;

        };

        ///The retry CRC polynomial

        static const int PER_PACKET_CRC_POLY;

        ///The number of simulated buffers of thie module

        static const int MAX_BUFFERS;

public:

        ///SystemC Macro

        SC_HAS_PROCESS(LogicalLayer);

        ///To debug, will display all received dwords

        bool displayReceivedDword;

        ///Clock of the system

        sc_in<bool>     clk;

        ///reset of the system (negative logic)

        sc_in<bool> resetx;

        ///consctructor

        LogicalLayer(sc_module_name name);

        ///destructor

        virtual ~LogicalLayer();

        /**

                @description This is a PhysicalLayerInterface function called by the

                PhysicalLayer when a dword is received.

                @param dword The dword that was received

                @param lctl The CTL value for the lower part of the dword transmission

                @param hctl The CTL value for the higher part of the dword transmission

        */

        virtual void receivedDwordEvent(sc_bv<32> &dword,bool lctl,bool hctl);

        /**

                @description This is a PhysicalLayerInterface function called by the

                PhysicalLayer when a dword is needed to be sent out.

                @param dword The dword to send (return by address)

                @param lctl The CTL value for the lower part of the dword transmission (return by address)

                @param hctl The CTL value for the higher part of the dword transmission (return by address)

        */

    virtual void dwordToSendRequested(sc_bv<32> &dword,bool &lctl,bool &hctl);

        /**

                @description This is a PhysicalLayerInterface function called by the PhysicalLayer

                when periodic CRC error occurs

        */

    virtual void crcErrorDetected();

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

        /**

                The function will store the packet and send it as soon as it can as the simulation

                advances.  Packets and the data will then be deleted by the LogicalLayer.

                @param packet The packet to send (memory control is given to LogicalLayer)

                @param data The dwords of data associated the the packet (NULL if no data to send)

                                (memory control is given to LogicalLayer)

        */

        void sendPacket(ControlPacket * packet,int * data);

        ///Blocks until all packets are sent out

    void flush();

        ///Set if the retry mode should be activated.  Will take effect after warm reset

        void setRetryMode(bool retry){retry_mode_after_reset = retry;};

        ///This will initiate a retry sequence as soon as the current packet has done sending

        void initiateRetrySequence();

        ///Sets the interface handler so that it can be notified of received packets

        void setInterface(LogicalLayerInterface * i){inter = i;};

        ///Sets the physical layer to send and receive packet to and from

        /**

                Registers the PhysicalLayer as a the PhysicalLayer to send data to and registers

                this object as PhysicalLayer received dword event listener

        */

        void setPhysicalLayer(PhysicalLayer * pl){

                physicalLayer = pl;

                physicalLayer->setInterface(this);

        };

        ///Allows to ignore incoming packets

        void setIgnoreIncoming(bool ignore){ignoreIncoming = ignore;};

protected:

        ///A process that re-initializes things when reset is asserted

        void reset_thread();

private:

        ///Updates buffers and ack value contained in a received NOP

        /**

                If in retry mode, acked history entries are deleted

        */

        void handleNopPacket(sc_bv<32> &dword);

        ///Calculate a CRC for the packet and it's data

        int calcultatePacketCrc(ControlPacket * pkt,int * data);

        ///Update a CRC with the dword and ctl value

        /**

                @param crc The current CRC value to update

                @param dword The dword to feed as input to the CRC unit

                @param ctl The ctl value to feed as input to the CRC unit

        */

        void calcultateDwordCrc(int &crc,sc_bv<32> &dword,bool ctl);

        ///Verifies the state of advertised buffers and checks if a sending a nop is required

        bool isSendingNopRequired();

        ///Update the value of advertised buffers when a packet is received

        void updateRxBufferCount(ControlPacket * receivedPacket);

        ///Generates a nop packet with the current ack value

        NopPacket * generateNopPacket();

        ///Queue of packets to send

        /**

                When packet are to be sent, they are added to the queue.  When the packet is sent,

                it is deleted from the packetQueue.  The queue is also cleared when a retry sequence

                is initiated or under a reset

        */

        std::deque<PacketAndData> packetQueue;

        ///History of packet sent (and to send)

        /**

                When packet are to be sent, they are added to the packetHistory (just like with the

                ::packetQueue ).  The packet from the history is deleted when it is acked.  It is

                cleared during reset.

        */

        std::deque<PacketAndData> packetHistory;

        ///The interface to notify when packets are received

        LogicalLayerInterface * inter;

        ///The physical layer to send dwords to

        PhysicalLayer * physicalLayer;

        ///The ID counter for sent packet

        int packetIdCounter;

        ///Wether or not to ignore incoming dwords

        bool ignoreIncoming;

        ///If we are currently in the retry mode

        bool retry_mode;

        ///If we should enter the retry mode after a reset

        bool retry_mode_after_reset;

        ///If a retry sequence should be initiated as soon as possible

        bool initiate_retry_disconnect;

        ///The first dword of a received packet (useful for calculating inserted NOP CRC's)

        sc_bv<32> firstReceivedDword;

        ///Current packet being received.

        /**  NULL at the beggining, it is always deleted before being set to a new value

                Created as soon as a first dword is received.  NOP's inserted in data packets

                are not stored here.

        */

        ControlPacket * receivedPacket;

        ///Data received

        int receivedData[16];

        ///The count of received data

        int receivedDataCount;

        ///The state for the reception of packets (

        ReceiveState receive_state;

        ///The ack value of received packets.  Incremented when packets are received

        int rx_ack_value;

        ///If we are currently waiting for a nop to start replaying the history

        bool rx_retry_waiting_for_nop;

        ///The state for the transmission of data

        SendState send_state;

        ///The packet currently being sent

        PacketAndData currentSendPacket;

        ///The nop packet currently being sent

        ControlPacket * nopSendPacket;

        ///Where we are in sending data

        int sendDataCount;

        ///If what is currently being sent is a disconnect nop

        bool disconNop;

        ///The state of the command buffers of the next node

        int nextNodeCommandBuffersFree[3];

        ///The state of the data buffers of the next node

        int nextNodeDataBuffersFree[3];

        ///The number of command buffers which have been advertised as free

        int commandBuffersAdvertised[3];

        ///The number of data buffers which have been advertised as free

        int dataBuffersAdvertised[3];

        ///The number of command buffers that are free

        int commandBuffersFree[3];

        ///The number of data buffers that are free

        int dataBuffersFree[3];

};

#endif