Subversion Repositories ht_tunnel

//fc_packet_crc_l3.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 ***** */

#include "fc_packet_crc_l3.h"

fc_packet_crc_l3::fc_packet_crc_l3(sc_module_name name) : sc_module(name)

{

        SC_METHOD(clocked_process);

        sensitive_neg << resetx;

        sensitive_pos << clk;

}

void fc_packet_crc_l3::clocked_process(){

        //At reset, CRC's are set to 0

        if(resetx.read() == false){

                crc_value = 0xFFFFFFFF;

                nop_crc_value = 0xFFFFFFFF;

                crc_output = 0;

                nop_crc_output = 0;

        }

        else{

                //Bu default, the crc values stay the same

                sc_uint<32> new_crc_value = crc_value.read();

                sc_uint<32> new_nop_crc_value = nop_crc_value.read();

                /**

                        Before synthesis, this was working with native C ints.  Since on most

                        platforms, an int is 32 bits and that we have to treat 34 bits of data

                        (the dword + LCTL + HCTL), the data calculation were seperated in two

                        passes of 17 bits.

                        Now that uint are being used, it might be possible to do it in a single

                        pass.  But the resulting logic and result is exactly the same.

                */

                sc_uint<32> inputDword = sc_uint<32>(data_in.read());

                //Generate first data set

                sc_uint<34> d;

                d.range(15,0) = inputDword.range(15,0);

                d[16] = fc_lctl_lk.read();

                //Generate second data set

                d.range(32,17) = inputDword.range(31,16);

                d[33] = fc_hctl_lk.read();

                //Choose which register to use for the treatment

                sc_uint<32> crc;

                sc_uint<32> crc_in;

                if(calculate_crc.read()) crc_in = crc_value.read();

                else crc_in = nop_crc_value.read();

                //Calculate the CRC

                /*for (int i=0; i<34; ++i) {

                        // xor highest bit w/ message:

                        //bool tmp = ((crc >> 31) & 1)^((data1 >> i) & 1);

                        bool tmp = crc[31]^data[i];

                        // subtract poly if greater:

                        //

                        //      This next code is equivalent to :

                        //              crc = (tmp) ? (crc << 1) ^ poly : ((crc << 1)|tmp);

                        //      but is nicer for the synthesis tool

                        crc[31] = crc[30];

                        crc[30] = crc[29];

                        crc[29] = crc[28];

                        crc[28] = crc[27];

                        crc[27] = crc[26];

                        crc[26] = crc[25]^tmp;

                        crc[25] = crc[24];

                        crc[24] = crc[23];

                        crc[23] = crc[22]^tmp;

                        crc[22] = crc[21]^tmp;

                        crc[21] = crc[20];

                        crc[20] = crc[19];

                        crc[19] = crc[18];

                        crc[18] = crc[17];

                        crc[17] = crc[16];

                        crc[16] = crc[15]^tmp;

                        crc[15] = crc[14];

                        crc[14] = crc[13];

                        crc[13] = crc[12];

                        crc[12] = crc[11]^tmp;

                        crc[11] = crc[10]^tmp;

                        crc[10] = crc[9]^tmp;

                        crc[9] = crc[8];

                        crc[8] = crc[7]^tmp;

                        crc[7] = crc[6]^tmp;

                        crc[6] = crc[5];

                        crc[5] = crc[4]^tmp;

                        crc[4] = crc[3]^tmp;

                        crc[3] = crc[2];

                        crc[2] = crc[1]^tmp;

                        crc[1] = crc[0]^tmp;

                        crc[0] = tmp;

                }*/

                //Created with Xilinx xapp209

                crc[0] = (sc_bit)( d[24] ^ d[33] ^ crc_in[22] ^ d[17] ^ crc_in[7] ^ d[2] ^ crc_in[24] ^ d[4] ^ crc_in[26] ^ crc_in[28] ^ d[8] ^ d[21] ^ crc_in[10] ^ d[23] ^ crc_in[4] ^ crc_in[30] ^ d[1] ^ crc_in[14] ^ crc_in[23] ^ d[27] ^ d[3] ^ crc_in[8] ^ d[5] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[9]);

                crc[1] = (sc_bit)( d[22] ^ crc_in[11] ^ d[24] ^ d[33] ^ crc_in[5] ^ d[0] ^ crc_in[22] ^ d[17] ^ crc_in[31] ^ d[26] ^ crc_in[7] ^ crc_in[15] ^ crc_in[9] ^ crc_in[26] ^ d[6] ^ d[21] ^ crc_in[10] ^ crc_in[4] ^ d[32] ^ d[16] ^ crc_in[14] ^ d[27] ^ crc_in[25] ^ d[5] ^ d[9] ^ d[20]);

                crc[2] = (sc_bit)( crc_in[11] ^ d[31] ^ d[15] ^ d[24] ^ d[33] ^ crc_in[5] ^ crc_in[22] ^ d[17] ^ d[26] ^ crc_in[7] ^ crc_in[15] ^ d[2] ^ crc_in[24] ^ d[19] ^ crc_in[28] ^ crc_in[0] ^ crc_in[4] ^ d[32] ^ crc_in[12] ^ d[16] ^ crc_in[30] ^ d[25] ^ crc_in[14] ^ crc_in[6] ^ d[1] ^ d[27] ^ crc_in[16] ^ d[3] ^ d[7] ^ crc_in[29] ^ d[9] ^ d[20]);

                crc[3] = (sc_bit)( d[31] ^ d[15] ^ d[24] ^ crc_in[5] ^ crc_in[13] ^ d[0] ^ crc_in[31] ^ d[26] ^ crc_in[15] ^ crc_in[7] ^ d[2] ^ d[19] ^ crc_in[17] ^ d[6] ^ d[8] ^ crc_in[0] ^ d[30] ^ d[14] ^ d[23] ^ d[32] ^ crc_in[12] ^ d[16] ^ crc_in[30] ^ d[25] ^ crc_in[6] ^ d[1] ^ crc_in[23] ^ d[18] ^ crc_in[8] ^ crc_in[16] ^ crc_in[25] ^ crc_in[29] ^ crc_in[1]);

                crc[4] = (sc_bit)( d[13] ^ d[22] ^ d[31] ^ d[15] ^ d[33] ^ crc_in[13] ^ d[0] ^ crc_in[22] ^ crc_in[31] ^ d[2] ^ crc_in[9] ^ crc_in[17] ^ d[4] ^ crc_in[28] ^ d[8] ^ crc_in[0] ^ d[21] ^ d[30] ^ crc_in[2] ^ crc_in[10] ^ d[14] ^ crc_in[4] ^ d[25] ^ crc_in[6] ^ crc_in[23] ^ d[18] ^ d[27] ^ crc_in[16] ^ d[3] ^ d[29] ^ crc_in[18] ^ crc_in[27] ^ crc_in[29] ^ d[9] ^ crc_in[1]);

                crc[5] = (sc_bit)( d[13] ^ crc_in[11] ^ crc_in[3] ^ d[33] ^ crc_in[5] ^ crc_in[22] ^ d[26] ^ d[28] ^ crc_in[17] ^ d[4] ^ crc_in[26] ^ crc_in[19] ^ d[12] ^ d[30] ^ crc_in[2] ^ d[14] ^ d[23] ^ crc_in[4] ^ d[32] ^ d[27] ^ crc_in[8] ^ d[29] ^ d[5] ^ crc_in[18] ^ crc_in[27] ^ d[9] ^ d[20] ^ crc_in[1]);

                crc[6] = (sc_bit)( d[13] ^ d[22] ^ d[31] ^ crc_in[3] ^ crc_in[20] ^ crc_in[5] ^ d[26] ^ d[19] ^ d[28] ^ crc_in[9] ^ d[4] ^ crc_in[19] ^ crc_in[28] ^ d[8] ^ crc_in[0] ^ d[12] ^ crc_in[2] ^ d[32] ^ crc_in[12] ^ crc_in[4] ^ d[25] ^ crc_in[6] ^ crc_in[23] ^ d[27] ^ d[3] ^ d[29] ^ crc_in[18] ^ crc_in[27] ^ d[11]);

                crc[7] = (sc_bit)( d[31] ^ crc_in[3] ^ crc_in[20] ^ d[33] ^ crc_in[13] ^ crc_in[5] ^ crc_in[22] ^ d[17] ^ d[26] ^ d[28] ^ d[4] ^ crc_in[26] ^ crc_in[19] ^ d[8] ^ d[10] ^ crc_in[0] ^ d[12] ^ d[30] ^ d[23] ^ crc_in[21] ^ crc_in[30] ^ d[25] ^ crc_in[6] ^ crc_in[14] ^ d[1] ^ crc_in[23] ^ d[18] ^ crc_in[8] ^ d[5] ^ crc_in[27] ^ d[9] ^ d[11] ^ crc_in[1]);

                crc[8] = (sc_bit)( d[22] ^ crc_in[20] ^ d[33] ^ d[0] ^ crc_in[31] ^ d[2] ^ crc_in[15] ^ crc_in[9] ^ crc_in[26] ^ d[10] ^ d[21] ^ d[30] ^ crc_in[2] ^ crc_in[10] ^ d[23] ^ d[32] ^ crc_in[21] ^ d[16] ^ crc_in[30] ^ d[25] ^ d[1] ^ crc_in[6] ^ crc_in[8] ^ d[29] ^ d[5] ^ crc_in[29] ^ d[11] ^ crc_in[1]);

                crc[9] = (sc_bit)( d[22] ^ d[31] ^ crc_in[3] ^ crc_in[11] ^ d[15] ^ d[24] ^ d[0] ^ crc_in[22] ^ crc_in[31] ^ crc_in[7] ^ d[28] ^ crc_in[9] ^ d[4] ^ d[10] ^ crc_in[0] ^ d[21] ^ crc_in[2] ^ crc_in[10] ^ d[32] ^ crc_in[21] ^ crc_in[30] ^ d[1] ^ crc_in[16] ^ d[29] ^ crc_in[27] ^ d[9] ^ d[20]);

                crc[10] = (sc_bit)( d[31] ^ crc_in[11] ^ crc_in[3] ^ d[24] ^ d[33] ^ d[0] ^ crc_in[31] ^ d[17] ^ crc_in[7] ^ d[2] ^ crc_in[24] ^ d[19] ^ d[28] ^ crc_in[17] ^ d[4] ^ crc_in[26] ^ crc_in[0] ^ d[30] ^ d[14] ^ crc_in[12] ^ crc_in[30] ^ crc_in[14] ^ d[1] ^ d[5] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[20] ^ crc_in[1]);

                crc[11] = (sc_bit)( d[13] ^ d[24] ^ d[33] ^ crc_in[13] ^ d[0] ^ crc_in[22] ^ d[17] ^ crc_in[31] ^ crc_in[7] ^ crc_in[15] ^ d[2] ^ crc_in[24] ^ d[19] ^ crc_in[26] ^ d[6] ^ d[8] ^ d[21] ^ d[30] ^ crc_in[2] ^ crc_in[10] ^ d[32] ^ crc_in[12] ^ d[16] ^ crc_in[14] ^ crc_in[23] ^ d[18] ^ crc_in[25] ^ d[29] ^ d[5] ^ crc_in[18] ^ d[7] ^ crc_in[29] ^ d[9] ^ crc_in[1]);

                crc[12] = (sc_bit)( d[31] ^ crc_in[3] ^ crc_in[11] ^ d[15] ^ d[24] ^ d[33] ^ crc_in[13] ^ crc_in[22] ^ crc_in[7] ^ crc_in[15] ^ d[2] ^ d[28] ^ d[6] ^ crc_in[19] ^ crc_in[28] ^ crc_in[0] ^ d[12] ^ d[21] ^ crc_in[2] ^ crc_in[10] ^ crc_in[4] ^ d[32] ^ d[16] ^ d[18] ^ d[27] ^ crc_in[16] ^ d[3] ^ crc_in[25] ^ d[29] ^ crc_in[29] ^ d[9] ^ d[20]);

                crc[13] = (sc_bit)( d[31] ^ crc_in[3] ^ crc_in[11] ^ crc_in[20] ^ d[15] ^ crc_in[5] ^ d[17] ^ d[26] ^ d[2] ^ d[19] ^ d[28] ^ crc_in[17] ^ crc_in[26] ^ d[8] ^ crc_in[0] ^ d[30] ^ d[14] ^ d[23] ^ d[32] ^ crc_in[4] ^ crc_in[12] ^ crc_in[30] ^ crc_in[14] ^ d[1] ^ crc_in[23] ^ d[27] ^ crc_in[8] ^ crc_in[16] ^ d[5] ^ crc_in[29] ^ d[11] ^ d[20] ^ crc_in[1]);

                crc[14] = (sc_bit)( d[13] ^ d[22] ^ d[31] ^ crc_in[5] ^ crc_in[13] ^ d[0] ^ crc_in[31] ^ d[26] ^ crc_in[15] ^ crc_in[24] ^ d[19] ^ crc_in[9] ^ crc_in[17] ^ d[4] ^ d[10] ^ crc_in[0] ^ d[30] ^ crc_in[2] ^ d[14] ^ crc_in[4] ^ crc_in[12] ^ crc_in[21] ^ d[16] ^ crc_in[30] ^ d[25] ^ crc_in[6] ^ d[1] ^ d[18] ^ d[27] ^ d[29] ^ crc_in[18] ^ crc_in[27] ^ d[7] ^ crc_in[1]);

                crc[15] = (sc_bit)( d[13] ^ crc_in[3] ^ d[15] ^ d[24] ^ crc_in[5] ^ d[0] ^ crc_in[13] ^ crc_in[22] ^ d[17] ^ crc_in[31] ^ d[26] ^ crc_in[7] ^ d[28] ^ d[6] ^ crc_in[19] ^ crc_in[28] ^ d[12] ^ d[21] ^ d[30] ^ crc_in[2] ^ crc_in[10] ^ d[25] ^ crc_in[6] ^ crc_in[14] ^ d[18] ^ crc_in[16] ^ d[3] ^ crc_in[25] ^ d[29] ^ crc_in[18] ^ d[9] ^ crc_in[1]);

                crc[16] = (sc_bit)( crc_in[11] ^ crc_in[3] ^ crc_in[20] ^ d[33] ^ crc_in[22] ^ crc_in[15] ^ crc_in[24] ^ d[28] ^ crc_in[17] ^ d[4] ^ crc_in[19] ^ crc_in[28] ^ d[12] ^ d[21] ^ crc_in[2] ^ crc_in[10] ^ d[14] ^ d[16] ^ crc_in[30] ^ d[25] ^ crc_in[6] ^ d[1] ^ d[3] ^ d[29] ^ crc_in[27] ^ d[7] ^ d[9] ^ d[11] ^ d[20]);

                crc[17] = (sc_bit)( d[13] ^ crc_in[3] ^ crc_in[11] ^ crc_in[20] ^ d[15] ^ d[24] ^ d[0] ^ crc_in[31] ^ crc_in[7] ^ d[2] ^ d[19] ^ d[28] ^ d[6] ^ crc_in[28] ^ d[8] ^ d[10] ^ d[32] ^ crc_in[12] ^ crc_in[4] ^ crc_in[21] ^ crc_in[23] ^ d[27] ^ crc_in[16] ^ d[3] ^ crc_in[25] ^ crc_in[18] ^ crc_in[29] ^ d[11] ^ d[20]);

                crc[18] = (sc_bit)( d[31] ^ crc_in[13] ^ crc_in[5] ^ crc_in[22] ^ d[26] ^ d[2] ^ crc_in[24] ^ d[19] ^ crc_in[17] ^ crc_in[26] ^ crc_in[19] ^ d[10] ^ crc_in[0] ^ d[12] ^ d[14] ^ d[23] ^ crc_in[4] ^ crc_in[12] ^ crc_in[21] ^ crc_in[30] ^ d[1] ^ d[18] ^ d[27] ^ crc_in[8] ^ d[5] ^ d[7] ^ crc_in[29] ^ d[9]);

                crc[19] = (sc_bit)( d[13] ^ d[22] ^ crc_in[20] ^ crc_in[5] ^ crc_in[13] ^ d[0] ^ crc_in[22] ^ d[17] ^ crc_in[31] ^ d[26] ^ crc_in[9] ^ d[4] ^ d[6] ^ d[8] ^ d[30] ^ crc_in[30] ^ d[25] ^ crc_in[14] ^ crc_in[6] ^ d[1] ^ crc_in[23] ^ d[18] ^ crc_in[25] ^ crc_in[18] ^ crc_in[27] ^ d[9] ^ d[11] ^ crc_in[1]);

                crc[20] = (sc_bit)( d[24] ^ d[0] ^ d[17] ^ crc_in[31] ^ crc_in[15] ^ crc_in[7] ^ crc_in[24] ^ crc_in[26] ^ crc_in[19] ^ crc_in[28] ^ d[8] ^ d[10] ^ d[12] ^ d[21] ^ crc_in[2] ^ crc_in[10] ^ crc_in[21] ^ d[16] ^ d[25] ^ crc_in[6] ^ crc_in[14] ^ crc_in[23] ^ d[3] ^ d[29] ^ d[5] ^ d[7]);

                crc[21] = (sc_bit)( crc_in[3] ^ crc_in[11] ^ crc_in[20] ^ d[15] ^ d[24] ^ crc_in[22] ^ crc_in[7] ^ crc_in[15] ^ d[2] ^ crc_in[24] ^ d[28] ^ d[4] ^ d[6] ^ d[23] ^ d[16] ^ crc_in[16] ^ crc_in[8] ^ crc_in[25] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[9] ^ d[11] ^ d[20]);

                crc[22] = (sc_bit)( d[22] ^ d[15] ^ d[24] ^ d[33] ^ crc_in[22] ^ d[17] ^ crc_in[7] ^ d[2] ^ crc_in[24] ^ d[19] ^ crc_in[17] ^ crc_in[9] ^ d[4] ^ d[6] ^ d[10] ^ d[21] ^ crc_in[10] ^ d[14] ^ crc_in[12] ^ crc_in[21] ^ crc_in[14] ^ crc_in[16] ^ crc_in[25] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[9]);

                crc[23] = (sc_bit)( d[13] ^ crc_in[11] ^ d[24] ^ d[33] ^ crc_in[13] ^ d[17] ^ crc_in[7] ^ crc_in[15] ^ d[2] ^ crc_in[24] ^ crc_in[17] ^ d[4] ^ d[6] ^ d[14] ^ crc_in[4] ^ d[32] ^ d[16] ^ crc_in[14] ^ d[18] ^ d[27] ^ crc_in[25] ^ crc_in[18] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[20]);

                crc[24] = (sc_bit)( d[13] ^ d[31] ^ d[15] ^ crc_in[5] ^ d[17] ^ d[26] ^ crc_in[15] ^ d[19] ^ crc_in[26] ^ crc_in[19] ^ d[6] ^ crc_in[28] ^ crc_in[0] ^ d[12] ^ d[23] ^ d[32] ^ crc_in[12] ^ d[16] ^ crc_in[30] ^ crc_in[14] ^ d[1] ^ crc_in[8] ^ crc_in[16] ^ d[3] ^ crc_in[25] ^ crc_in[18] ^ d[5]);

                crc[25] = (sc_bit)( d[22] ^ d[31] ^ crc_in[20] ^ d[15] ^ crc_in[13] ^ d[0] ^ crc_in[31] ^ crc_in[15] ^ d[2] ^ crc_in[9] ^ crc_in[17] ^ d[4] ^ crc_in[26] ^ crc_in[19] ^ crc_in[0] ^ d[12] ^ d[30] ^ d[14] ^ d[16] ^ d[25] ^ crc_in[6] ^ d[18] ^ crc_in[16] ^ d[5] ^ crc_in[27] ^ crc_in[29] ^ d[11] ^ crc_in[1]);

                crc[26] = (sc_bit)( d[13] ^ crc_in[20] ^ d[15] ^ d[33] ^ crc_in[22] ^ d[2] ^ crc_in[24] ^ crc_in[17] ^ crc_in[26] ^ d[8] ^ d[10] ^ d[30] ^ crc_in[2] ^ d[14] ^ d[23] ^ crc_in[4] ^ crc_in[21] ^ crc_in[23] ^ d[27] ^ crc_in[8] ^ crc_in[16] ^ d[29] ^ crc_in[18] ^ d[5] ^ d[7] ^ crc_in[29] ^ d[9] ^ d[11] ^ crc_in[1]);

                crc[27] = (sc_bit)( d[13] ^ d[22] ^ crc_in[3] ^ crc_in[5] ^ crc_in[22] ^ d[26] ^ crc_in[24] ^ d[28] ^ crc_in[9] ^ crc_in[17] ^ d[4] ^ crc_in[19] ^ d[6] ^ d[8] ^ d[10] ^ d[12] ^ crc_in[2] ^ d[14] ^ d[32] ^ crc_in[21] ^ crc_in[30] ^ d[1] ^ crc_in[23] ^ crc_in[25] ^ d[29] ^ crc_in[18] ^ crc_in[27] ^ d[7] ^ d[9]);

                crc[28] = (sc_bit)( d[13] ^ d[31] ^ crc_in[3] ^ crc_in[20] ^ d[0] ^ crc_in[22] ^ crc_in[31] ^ crc_in[24] ^ d[28] ^ crc_in[26] ^ crc_in[19] ^ d[6] ^ crc_in[28] ^ d[8] ^ crc_in[0] ^ d[12] ^ d[21] ^ crc_in[10] ^ crc_in[4] ^ d[25] ^ crc_in[6] ^ crc_in[23] ^ d[27] ^ d[3] ^ crc_in[25] ^ crc_in[18] ^ d[5] ^ d[7] ^ d[9] ^ d[11]);

                crc[29] = (sc_bit)( crc_in[11] ^ crc_in[20] ^ d[24] ^ crc_in[5] ^ d[26] ^ crc_in[7] ^ d[2] ^ crc_in[24] ^ d[4] ^ crc_in[26] ^ crc_in[19] ^ d[6] ^ d[8] ^ d[10] ^ d[12] ^ d[30] ^ crc_in[4] ^ crc_in[21] ^ crc_in[23] ^ d[27] ^ crc_in[25] ^ d[5] ^ crc_in[27] ^ d[7] ^ crc_in[29] ^ d[11] ^ d[20] ^ crc_in[1]);

                crc[30] = (sc_bit)( crc_in[20] ^ crc_in[5] ^ crc_in[22] ^ d[26] ^ crc_in[24] ^ d[19] ^ d[4] ^ crc_in[26] ^ d[6] ^ crc_in[28] ^ d[10] ^ crc_in[2] ^ d[23] ^ crc_in[12] ^ crc_in[21] ^ crc_in[30] ^ d[25] ^ crc_in[6] ^ d[1] ^ crc_in[8] ^ d[3] ^ crc_in[25] ^ d[29] ^ d[5] ^ crc_in[27] ^ d[7] ^ d[9] ^ d[11]);

                crc[31] = (sc_bit)( d[22] ^ crc_in[3] ^ d[24] ^ crc_in[13] ^ d[0] ^ crc_in[22] ^ crc_in[31] ^ crc_in[7] ^ d[2] ^ d[28] ^ crc_in[9] ^ d[4] ^ crc_in[26] ^ d[6] ^ crc_in[28] ^ d[8] ^ d[10] ^ crc_in[21] ^ d[25] ^ crc_in[6] ^ crc_in[23] ^ d[18] ^ d[3] ^ crc_in[25] ^ d[5] ^ crc_in[27] ^ crc_in[29] ^ d[9]);

                if(clear_crc.read()){

                        new_crc_value = 0xFFFFFFFF;

                }

                else if(calculate_crc.read()){

                        new_crc_value = crc;

                }

                if(clear_nop_crc.read()){

                        new_nop_crc_value = 0xFFFFFFFF;

                }

                else if(calculate_nop_crc.read()){

                        new_nop_crc_value = crc;

                }

                //Assign the new CRC value

                crc_value = new_crc_value;

                nop_crc_value = new_nop_crc_value;

                //Error mask for when forcing errors.  Bits that are '1' will be inversed

                sc_bv<32> error_mask_bv = "10101010101010101010101010101010";

                sc_uint<32> error_mask = error_mask_bv;

                //Output the result with the error mask if requested

                if(csr_force_single_error_fc.read()){

                        crc_output = new_crc_value ^ error_mask;

                        nop_crc_output = new_nop_crc_value ^ error_mask;

                }

                //Output the CRC value directly.  It is supposed to be inversed, so 

                //a non-inversed CRC represents a stomped packet

                else if(csr_force_single_stomp_fc.read()){

                        crc_output = new_crc_value;

                        nop_crc_output = ~new_nop_crc_value;

                }

                //Output the inverse of the calculated CRC value (normal behaviour)

                else{

                        crc_output = ~new_crc_value;

                        nop_crc_output = ~new_nop_crc_value;

                }

        }

}