Subversion Repositories ht_tunnel

//PhysicalLayer.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 PhysicalLayer_H

#define PhysicalLayer_H

#include "systemc.h"

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

//Forward decleration

class PhysicalLayer;

///Event handler interface for the PhysicalLayer module

class PhysicalLayerInterface{

public:

        /**

                @description 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)=0;

        /**

                @description 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)=0;

        /**

                @description This is a PhysicalLayerInterface function called by the PhysicalLayer

                when periodic CRC error occurs

        */

    virtual void crcErrorDetected()=0;

};

///Handles low level communication with an HT link

/**

        @class PhysicalLayer

        @author Ami Castonguay

        @description This SystemC module handles very low level communication of a HT link.

                It does the initialization of the link, serialization and de-serialization.  It

                also handles periodic CRC insertions.

                When a valid dword is received which is not part of an init sequence or a periodic

                CRC, an event is generated.  Since every cycle, the link must output valid data,

                an event is also generated whenever a dword to send is requested.

                This physical layer is not complete in terms of HT (it would not work with a

                variety of HT links) but is compatible with the current HT core being tested.

*/

class PhysicalLayer : public sc_module{

        ///The event handler for when dwords are received and needs to be sent

        PhysicalLayerInterface * inter;

        ///The periodic CRC polynomial to use

        static const int PHYSICAL_LAYER_CRC_POLY;

public:

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

        //  Signals

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

        /// Clock signal

        sc_in<bool>                     clk;

        ///Reset signal

        sc_in<bool>                     resetx;

        ///When we have data available for the link

        sc_out<bool>                                            phy_available_lk;

        ///TX CTL Higher is sent later (MSB), lower is sent first (LSB)

        sc_out<sc_bv<CAD_IN_DEPTH> >            phy_ctl_lk;

        ///TX CAD Higher is sent later (MSB), lower is sent first (LSB)

        sc_out<sc_bv<CAD_IN_DEPTH> >            phy_cad_lk[CAD_IN_WIDTH];

        ///RX CTL - Higher is newer (MSB), lower is older (LSB)

        sc_in<sc_bv<CAD_OUT_DEPTH> >    lk_ctl_phy;

        ///RX CAD - Higher is newer (MSB), lower is older (LSB)

        sc_in<sc_bv<CAD_OUT_DEPTH> >    lk_cad_phy[CAD_OUT_WIDTH];

        ///When there is data available for us

        sc_out<bool>                                    phy_consume_lk;

        ///If the tested link wants the drivers to be disabled

        sc_in<bool>             lk_disable_drivers_phy;

        ///If the tested link wants the receivers to be disabled

        sc_in<bool>             lk_disable_receivers_phy;

        ///SystemC Macro

        SC_HAS_PROCESS(PhysicalLayer);

        ///Constructor

        PhysicalLayer(sc_module_name name);

        ///Destructor

        virtual ~PhysicalLayer(){};

        ///Will disconnect when the CRC windows is done

        void ldtstopDisconnect();

        ///Reconnect the link ASAP

        void ldtstopConnect();

        ///Causes an immediate disconnect, no further dwords are sent out

        void retryDisconnectAndReconnect();

        ///The interface to connect to the physical layer

        void setInterface(PhysicalLayerInterface * inter){this->inter = inter;};

private:

        ///If the TX side of the link is connected

        bool tx_connected;

        ///The current calculated TX periodic CRC

        int current_tx_crc;

        ///The value of the TX CRC for the last window of operation

        int last_tx_crc;

        ///If the current TX window is the first CRC window since init

        bool tx_firstCrcWindow;

        ///The count of where where are in the TX CRC window (in dwords)

        int tx_crc_count;

        ///If the RX side of the link is connected

        bool rx_connected;

        ///The current calculated RX periodic CRC

        int current_rx_crc;

        ///The value of the RX CRC for the last window of operation

        int last_rx_crc;

        ///If the current RX window is the first CRC window since init

        bool rx_firstCrcWindow;

        ///The count of where where are in the RX CRC window (in dwords)

        int rx_crc_count;

        ///Vector of only zeroes

        sc_bv<CAD_IN_DEPTH> v0;

        ///Vector of only ones

        sc_bv<CAD_IN_DEPTH> v1;

        ///If we are currently in a ldtstop sequence (ignore inputs and output discon nop until end of window)

        bool ldtstop_sequence;

        ///If done sending ldtstop packets

        bool ldtstop_sequence_complete;

        ///After sending the last CRC, the sequence will be complete

        bool ltdstop_last_crc_window;

        ///If a discon nop was received on the rx

        bool ltdstop_rx_received_disconnect;

        ///The number of cycles that the TX must stay disconnected for a retry sequence

        int retryDisconnectCountTX;

        ///The number of cycles that the RX must stay disconnected for a retry sequence

        int retryDisconnectCountRX;

        ///Process that handles receiving the data and generated events

        void receiveThread();

        ///Process that handles transmiting data

        void transmitThread();

        ///Keeps sending reset signaling until conditions have passed.

        void holdResetSignaling();

        ///Initiate the connect sequence for the TX

        void tx_connect();

        ///Calculate the periodic CRC for a send dword

        void calculateCrc(int &crc,int dword,bool lctl,bool hctl);

        ///Sends next dword, either data or the window CRC if at the correct time

        void sendNextDwordOrCrc();

        ///Sends the specified dword and CTL value on the outputs

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

        ///Initiate the connect sequence for the RX

        void rx_connect();

        ///If at the correct pos in the window, CRC is checked.  Otherwise, data is received

        void receiveDwordOrCrc();

        ///IExtracts the dword received from the input

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

};

#endif