Subversion Repositories ht_tunnel

//synth_control_packet.cpp

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

#define SYNTH_CONTROL_PACKET_CPP

#include "synth_datatypes.h"

/**

        To parse a cmd vector

*/

PacketCommand getPacketCommand(const sc_bv<6> &cmd){

        //Check the command vector against all known

        //sequences

        sc_uint<6> command_value = cmd;

        PacketCommand return_val;

        switch(command_value){

        case 0:

                return_val = NOP;

                break;

        case 0x3F: //0b111111

                return_val = SYNC;

                break;

        case 0x30: //0b110000

                return_val = RD_RESPONSE;

                break;

        case 0x33: //0b110011

                return_val = TGTDONE;

                break;

        case 0x3A: //0b111010

                return_val = BROADCAST;

                break;

        case 0x3C: //0b111100

                return_val = FENCE;

                break;

        case 0x3D: //0b111101

                return_val = ATOMIC;

                break;

        case 0x37: //0b110111

                return_val = EXTENDED_FLOW;

                break;

        case 0x3E: //0b111110

                return_val = ADDR_EXT;

                break;

        case 0x02: //0b000010

                return_val = FLUSH;

                break;

        default:

                if(command_value.range(4 , 3) == 1){//          if(command_value.range(4 , 3) == "01"){

                        return_val = WRITE;

                }

                else if(command_value.range(5 , 4) == 1){//else if(command_value.range(5 , 4) == "01"){

                        return_val = READ;

                }

                else{

                        return_val = RESERVED_CMD;

                }

        }

        return return_val;

}

/**

        To know the type of packet from a command vector

*/

PacketType getPacketType(const sc_bv<6> &cmd){

        PacketType return_val;

        sc_bv<6> cmd_buf = cmd;//Workaround for a synthesis problem

        //Check the command vector against all known

        //sequences

        if(cmd_buf == "000000" || cmd_buf == "111111" || cmd_buf == "110111"){

                return_val = INFO;

        }

        else if(cmd_buf == "110000" || cmd_buf == "110011"){

                return_val = RESPONSE;

        }

        else if(cmd_buf.range(5 , 3) == "001" || cmd_buf.range(5 , 3) == "101"

                || cmd_buf.range(5 , 4) == "01" || cmd_buf == "111010"

                || cmd_buf == "111100" || cmd_buf == "111101" || cmd_buf == "000010")

        {

                return_val = REQUEST;

        }

        else if(cmd_buf == "111101"){

                return_val = ADDR_EXT_TYPE;

        }

        else{

                return_val = RESERVED_TYPE;

        }

        return return_val;

}

bool isDwordPacket(const sc_bv<64> &pkt, const PacketCommand &cmd){

        bool return_val;

        switch(cmd){

        case WRITE:

        case READ:

        case BROADCAST:

        case ATOMIC:

        case RESERVED_CMD:

                return_val = false;

                break;

        case EXTENDED_FLOW:

                return_val = !(bool)((sc_bit)pkt[6]);

                break;

        //case ADDR_EXT:

        //case FLUSH:

        //case NOP:

        //case SYNC:

        //case RD_RESPONSE:

        //case TGTDONE:

        //case FENCE:

        default:

                return_val = true;

        }

        return return_val;

}

VirtualChannel getVirtualChannel(const sc_bv<64> &pkt, const PacketCommand &cmd){

        VirtualChannel return_val;

        switch(cmd){

        case WRITE:

                if(pkt[5] == true){

                        return_val = VC_POSTED;

                }

                else{

                        return_val = VC_NON_POSTED;

                }

                break;

        case ATOMIC:

        case FLUSH:

        case READ:

                return_val = VC_NON_POSTED;

                break;

        case FENCE:

        case BROADCAST:

                return_val = VC_POSTED;

                break;

        case RD_RESPONSE:

        case TGTDONE:

                return_val = VC_RESPONSE;

                break;

        //case SYNC:

        //case RESERVED_CMD:

        //case ADDR_EXT:

        //case NOP:

        //case EXTENDED_FLOW:

        default:

                return_val = VC_NONE;

        }

        return return_val;

}

bool isChain(const sc_bv<64> &pkt){

        bool return_val;

        //if(posted && write && bit chain)

        if(pkt.range(5 , 3) == "101" &&

           pkt[19] == true) return_val = true;

        else return_val = false;

        return return_val;

}

///Packet has data associated

/**

                To know if there is a data packet associated with this control

                packet

                @return If the packet has data associated

*/

bool hasDataAssociated(const PacketCommand &cmd){

        bool return_val;

        switch(cmd){

        case WRITE:

        case RD_RESPONSE:

        case ATOMIC:

                return_val = true;

                break;

        //case TGTDONE:

        //case SYNC:

        //case RESERVED_CMD:

        //case ADDR_EXT:

        //case NOP:

        //case EXTENDED_FLOW:

        //case FLUSH:

        //case BROADCAST:

        //case FENCE:

        //case READ:

        default:

                return_val = false;

                break;

        }

        return return_val;

}

///Get the length-1 of the data associated

/**

                Gets the number of doublewords of data associated with this ctl packet

                minus 1.  So a returned number of 0 represents 1 doubleWord.

                If there is no data associated, the result is undefined.

                The number returned also includes the doubleword mask in a byte write

                @return Length-1 of data associated with the packet, or undefined

                if the packet has no data associated

*/

sc_uint<4> getDataLengthm1(const sc_bv<64> &pkt){

        sc_uint<4> return_val;

        //If a byte read (cmd starts by 01 for read, and pkt[2]=0 for byte

        if(pkt[5] == false && pkt[4] == true && pkt[2] == false){

                //DataLength is Doubleword

                return_val = 0;

        }

        else{

                sc_bv<4> temp = pkt.range(25,22);

                return_val = temp;

        }

        return return_val;

}

bool getPassPW(const sc_bv<64> &pkt){

        return (sc_bit)(pkt[15]);

}

bool getResponsePassPW(const sc_bv<32> &pkt){

        return (sc_bit)(pkt[15]);

}

sc_uint<40> getRequestAddr(const sc_bv<64> &request_pkt, const PacketCommand &cmd){

        sc_uint<40> addr = 0;

        //If the packet only has 32 bits, dont return an address

        //of only zeros, its the job of the caller to check before calling

        //

        //if(!isDwordPacket(request_pkt,cmd)) {

                //Copy the standard range of addresses

                addr.range(39,3) = sc_bv<37>(request_pkt.range(63,27));

                //Copy the last bit of the address.  An exception is made for

                //the ATOMIC packet, that has this bit always at 0

                if(cmd != ATOMIC) addr[2] = sc_bit(request_pkt[26]);

        //}

        //Return the address

        return addr;

}

sc_uint<5> getUnitID(const sc_bv<64> &pkt){

        return sc_bv<5>(pkt.range(12,8));

}

bool request_getCompatOrIsoc(const sc_bv<64> &pkt){

        return sc_bit(pkt[21]);

}

bool isInAddressRange(const sc_bv<64> &pkt,  const PacketCommand &cmd, const sc_uint<32> &low,

                                                                                 const sc_uint<32> &high) {

        bool isInAddressRange_val = false;

        if(!isDwordPacket(pkt,cmd)){

                sc_uint<32> addr = getRequestAddr(pkt,cmd).range(39,8);

                isInAddressRange_val = (addr >= low && addr < high);

        }

        return isInAddressRange_val;

}

#ifdef SYSTEMC_SIM

bool isInAddressRange(const sc_bv<64> &pkt,  const PacketCommand &cmd, const sc_uint<40> &low,

                                                                                 const sc_uint<40> &high) {

        bool isInAddressRange_val = false;

        if(!isDwordPacket(pkt,cmd)){

                sc_uint<40> addr = getRequestAddr(pkt,cmd);

                isInAddressRange_val = (addr >= low && addr < high);

        }

        return isInAddressRange_val;

}

                                                                                 bool isInAddressRange(const sc_bv<64> &pkt,  const PacketCommand &cmd, const sc_bv<40> &low, const sc_bv<40> &high) {

        //Start by converting the strings to uint

        sc_uint<40> low_uint(low);

        sc_uint<40> high_uint(high);

        //Call the function taking uints

        return isInAddressRange(pkt,cmd,low_uint,high_uint);

}

#endif

sc_bv<4> request_getSeqID(const sc_bv<64> &pkt){

        sc_bv<4> temp;

        temp.range(3,2) = pkt.range(7,6);

        temp.range(1,0) = pkt.range(14,13);

        return temp;

}

bool write_getDataError(const sc_bv<64> &pkt) {

        bool dataError;

        if(pkt[5] == true) dataError = sc_bit(pkt[20]);

        else dataError = false;

        return dataError;

}

ResponseError response_getResponseError(const sc_bv<64> &pkt) {

        ResponseError error;

        if(pkt[20] == false){

                if(pkt[28] == false) error = RE_NORMAL;

                error = RE_DATA_ERROR;

        }

        else{

                if(pkt[28] == false) error = RE_TARGET_ABORT;

                error = RE_MASTER_ABORT;

        }

        return error;

}

sc_bv<5> request_getSrcTag(const sc_bv<64> &pkt) {

        return pkt.range(20,16);

}

sc_bv<32> generateReadResponse(const sc_bv<5> &unitID,

                                                 const sc_bv<5> &srcTag,

                                                 const sc_bv<2> &rqUID,

                                                 const sc_bv<4> &count,

                                                 bool bridge,

                                                 ResponseError error,

                                                 bool passPW,

                                                 bool isoc)

{

        sc_bv<32> packet = 0;

        packet.range(25,22) = count;

        sc_bv<6> packet_command = "110000";

        packet.range(5,0) = packet_command;

        packet.range(12,8) = unitID;

        packet.range(20,16) = srcTag;

        packet.range(31,30) = rqUID;

        //Error 0 => bv[20]

        //Error 1 => bv[28]

        if(error == RE_NORMAL || error == RE_DATA_ERROR)

                packet[20] = false;

        else

                packet[20] = true;

        if(error == RE_NORMAL || error == RE_TARGET_ABORT)

                packet[28] = false;

        else

                packet[28] = true;

        packet[14] = bridge;

        packet[15] = passPW;

        packet[7] = isoc;

        return packet;

}

sc_bv<32> generateTargetDone(const sc_bv<5> &unitID,

                                                 const sc_bv<5> &srcTag,

                                                 const sc_bv<2> &rqUID,

                                                 bool bridge,

                                                 ResponseError error,

                                                 bool passPW,

                                                 bool isoc){

        sc_bv<32> packet = 0;

        sc_bv<6> packet_command = "110011";

        packet.range(5,0) = packet_command;

        packet.range(12,8) = unitID;

        packet.range(20,16) = srcTag;

        packet.range(31,30) = rqUID;

        //Error 0 => bv[20]

        //Error 1 => bv[28]

        if(error == RE_NORMAL || error == RE_DATA_ERROR)

                packet[20] = false;

        else

                packet[20] = true;

        if(error == RE_NORMAL || error == RE_TARGET_ABORT)

                packet[28] = false;

        else

                packet[28] = true;

        packet[14] = bridge;

        packet[15] = passPW;

        packet[7] = isoc;

        return packet;

}

sc_uint<5> getPacketSizeWithDatam1(const sc_bv<64> &pkt, const PacketCommand &cmd){

        sc_uint<5> pkt_size;

        sc_uint<2> packet_size_selector;

        packet_size_selector[1] = isDwordPacket(pkt,cmd);

        packet_size_selector[0] = hasDataAssociated(cmd);

        sc_uint<4> datalength_m1 = getDataLengthm1(pkt);

        switch(packet_size_selector){

                case 3:

                        pkt_size = datalength_m1 + 1;

                        break;

                case 2:

                        pkt_size = 0;

                        break;

                case 1:

                        pkt_size = datalength_m1 + 2;

                        break;

                default:

                        pkt_size = 1;

        }

        return pkt_size;

}

sc_uint<5> getDwordPacketSizeWithDatam1(const sc_bv<64> &pkt, const PacketCommand &cmd){

        sc_uint<5> pkt_size;

        if(hasDataAssociated(cmd)){

                pkt_size = getDataLengthm1(pkt) + 1;

        }

        else{

                pkt_size = 0;

        }

        return pkt_size;

}

#endif