Subversion Repositories ht_tunnel

//history_buffer_l3.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):

 *   Jean-Francois Belanger

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

#define HISTORY_BUFFER_L3_H

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

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

///Keeps track of the history of sent packets

/**

        @class history_buffer_l3

        @author Ami Castonguay

        @description

        The retry mode allows to attach a CRC to every packet.  If

        a packet is corrupted, the packet can simply be resent.  To

        be able to be resent, sent packets must be stored in a buffer.

        This sub-module takes care of managing the content of such

        a buffer.  This buffer is made to be used with a dual-port

        memory (one read port, one write port).

        To keep track of the content of the buffer, a simple read pointer

        and a write pointer is kept.  When a new entry is created, a first

        dword is written in the memory which containes the tracking number

        and the size of the entry : this is the entry header.

        When a ack is received, the read pointer jumps from entry headers to

        the next entry header until either the ack number is reached or

        that the read pointer has reached the write pointer.

        The content of a header is :

                dword[7..0]  : ack value

                dword[12..8] : size of entry

        During retry playback, all that is stored in the history buffer will

        simply be resent.

*/

class history_buffer_l3 : public sc_module

{

        public:

        ///The possible internal state of the history buffer

        enum HISTORY_STATES {

                IDLE_STATE,     HISTORY_PLAYBACK};

        ///The write pointer in the buffer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > write_pointer;

        ///Next value of ::write_pointer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > next_write_pointer;

        ///The write stop pointer is the last position of the current entry.

        /**When the write pointer reaches the write_stop_pointer and the last

                dword is written, the NextPktToAck is incremented*/

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > write_stop_pointer;

        ///Next value of ::write_stop_pointer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > next_write_stop_pointer;

        ///The begginning of the current entry

        /** If a packet entry is cancelled, it will revert to this pos.*/

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > entry_write_start_pointer;

        ///Next value of ::entry_write_start_pointer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > next_entry_write_start_pointer;

        ///The pointer to keep track of where to start reading if a playback is started

        /** When acks are received, this read pointer will be updated to a correct position*/

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > idle_read_pointer;

        ///Next value of ::idle_read_pointer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > next_idle_read_pointer;

        ///Read pointer that will increment during history playback

        /** When history playback is started, it is set at idle_read_pointer value, then it is

                incremented until entry_write_start_pointer is reached */

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > playback_read_pointer;

        ///Next value of ::playback_read_pointer

        sc_signal<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > next_playback_read_pointer;

        ///The count value we are waiting to be acknoledged

        /**

                The best way to understand this is to read the HT doc on this.

                This is initialized at 0 at reset, so the first packet to be stored

                in the history is tagged with the value 1 and TxNextPktToAck takes

                on that same value.

                So in that example, #1 is the next packet that needs to be acked, hence the

                name TxNextPktToAck.  When we receive an ack value of 1, we can free

                that packet's entry.

        */

        sc_signal<sc_uint<8> >  TxNextPktToAck;

        ///Next value of ::TxNextPktToAck

        sc_signal<sc_uint<8> >  next_TxNextPktToAck;

        ///Registered value of what is received from nop

        /** This will not be identical to the value coming from the decoder

                since this variable is only updated when the nop is validated, while

                the value from the nop is updated as soon as */

        sc_signal<sc_uint<8> >  received_RxNextPktToAck;

        ///Next value of ::received_RxNextPktToAck

        sc_signal<sc_uint<8> >  next_received_RxNextPktToAck;

        ///Tracks how many reads are left to an entry during playback

        /** This is necessary to be able to recognize where are the headers and not

                send them as normal data*/

        sc_signal<sc_uint<5> > playback_count;

        ///Next value of ::playback_count

        sc_signal<sc_uint<5> > next_playback_count;

        ///The state of the state machine

        sc_signal<HISTORY_STATES>       state;

        ///Next value of ::state

        sc_signal<HISTORY_STATES>       next_state;

        ///Next value of ::history_playback_ready

        sc_signal<bool> next_history_playback_ready;

        ///Next value of ::history_playback_done

        sc_signal<bool> next_history_playback_done;

        /**If the data from memory corresponds to the content in memory.

          It has value false when something is written to memory at the read pointer.*/

        sc_signal<bool> valid_memory_data;

        sc_signal<bool> last_cycle_new_history_entry;

        sc_signal<sc_uint<5> >  last_cycle_new_history_entry_size_m1;

        ///The output dword when playing back history

        sc_out <sc_bv<32> > history_packet;

        ///When the complete history has finished playing back

        sc_out <bool > history_playback_done;

        ///To begin the playback of the history from the last acked packet

        sc_in <bool > begin_history_playback;

        ///To stop the playback of the history if the retry sequence is aborted

        sc_in <bool > stop_history_playback;

        ///If the playback of the history is ready, begin will be ignored when not asserted

        sc_out <bool > history_playback_ready;

        ///To consume the data produced by the history buffer

        /**A minimum pause of 1 cycle must be left between entries (to allow

                history entry header to be read) before starting to read a next entry.

                An entry is composed of the command and it's data.  Usually this should

                be natural since the CRC must be sent after an entry is sent.*/

        sc_in <bool > consume_history;

        ///If there is enough room left in the history for another maximum size packet

        /*to allow the flow control to know if a packet can be sent, maximum size is 18 dwords*/

        sc_out <bool > room_available_in_history;

        ///To add a dword to the history

        sc_in <bool > add_to_history;

#ifdef PERMIT_CANCEL_HISTORY

        ///To cancel a history_entry (like when there's an stomped packet sent)

        /** An entry MUST be canceled before a new one can be started.  Since this

                is only necessary in a cut-through implementation, which at the time of

                making this module was not an option for the HT design, it is only enable

                by using a preprocessor define

        */

        sc_in <bool > cancel_history_entry;

#endif

        ///To add a new entry to the history, to be done before starting to add to the history

        sc_in <bool > new_history_entry;

        ///The size (minus 1) of the new history entry

        sc_in <sc_uint<5> > new_history_entry_size_m1;

        ///dword being sent to the link, so it can be stored in the buffer

        sc_in<sc_bv<32> > fc_dword_lk;

        ///When a nop was received : read the new ack_value

        sc_in<bool>     nop_received;

        ///The value acked from the next HT node

        sc_in<sc_uint<8> >      ack_value;

        ///Reset

        sc_in<bool>     resetx;

        ///Clock

        sc_in<bool> clk;

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

        //      Memory interface - synchronous

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

        sc_out<bool> history_memory_write;///<Write to history memory

        sc_out<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_write_address;///<Address where to write in history memory

        sc_out<sc_bv<32> > history_memory_write_data;///<Data to write to history memory

        sc_out<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_read_address;///<Address where to read in history memory

        sc_in<sc_bv<32> > history_memory_output;///<Data read in history memory

        ///SystemC Macro

        SC_HAS_PROCESS(history_buffer_l3);

        //Constructor

        history_buffer_l3(sc_module_name name);

        ///Everything that is registered

        void clocked_process();

        ///Process that handle writing to the memory to store retry entries

        void write_in_memory();

        ///Process that handles reading the memory for playback and to delete acked entries

        void read_in_memory();

};

#endif