Subversion Repositories xge_mac

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

////                                                              ////

////  File name "sc_scoreboard.cpp"                               ////

////                                                              ////

////  This file is part of the "10GE MAC" project                 ////

////  http://www.opencores.org/cores/xge_mac/                     ////

////                                                              ////

////  Author(s):                                                  ////

////      - A. Tanguay (antanguay@opencores.org)                  ////

////                                                              ////

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

////                                                              ////

//// Copyright (C) 2008 AUTHORS. All rights reserved.             ////

////                                                              ////

//// This source file may be used and distributed without         ////

//// restriction provided that this copyright statement is not    ////

//// removed from the file and that any derivative work contains  ////

//// the original copyright notice and the associated disclaimer. ////

////                                                              ////

//// This source file is free software; you can redistribute it   ////

//// and/or modify it under the terms of the GNU Lesser General   ////

//// Public License as published by the Free Software Foundation; ////

//// either version 2.1 of the License, or (at your option) any   ////

//// later version.                                               ////

////                                                              ////

//// This source is distributed in the hope that it will be       ////

//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////

//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////

//// PURPOSE.  See the GNU Lesser General Public License for more ////

//// details.                                                     ////

////                                                              ////

//// You should have received a copy of the GNU Lesser General    ////

//// Public License along with this source; if not, download it   ////

//// from http://www.opencores.org/lgpl.shtml                     ////

////                                                              ////

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

#include <stdio.h>

#include <iostream>

#include <sys/times.h>

#include <sys/stat.h>

#include "systemc.h"

#include "sc_scoreboard.h"

void scoreboard::init(void) {

    disable_padding = false;

    disable_crc_check = false;

    disable_packet_check = false;

    disable_flags_check = false;

    disable_signal_check = false;

}

void scoreboard::notify_packet_tx(sbSourceId sid, packet_t* pkt) {

    //---

    // Save packet to a fifo

    if (sid == SB_PIF_ID) {

        cout << "SCOREBOARD PACKET INTERFACE TX ("

             << pkt->length << ")" << endl;

        //---

        // Store packet in scoreboard

        pif_fifo.write(pkt);

        pif_stats.tx_pkt_cnt++;

        pif_stats.tx_octets_cnt = pif_stats.tx_octets_cnt + pkt->length;

    }

    if (sid == SB_XGM_ID) {

        cout << "SCOREBOARD XGMII INTERFACE TX ("

             << pkt->length << ")" << endl;

        //---

        // Store packet in scoreboard

        if (sid == SB_XGM_ID && (pkt->dest_addr & 0xffff) == 0x000001 &&

            ((pkt->dest_addr >> 24) & 0xffffff) == 0x0180c2) {

            // Pause frames will be dropped

            cout << "SCOREBOARD PAUSE INJECTED" << endl;

            xgm_stats.inject_pause_frame_cnt++;

        }

        else {

            xgm_fifo.write(pkt);

            xgm_stats.tx_pkt_cnt++;

            xgm_stats.tx_octets_cnt = xgm_stats.tx_octets_cnt + pkt->length;

        }

    }

    //---

    // Update stats

    if (sid == SB_XGM_ID && pkt->err_flags & PKT_FLAG_ERR_CODING) {

        xgm_stats.crc_error_cnt++;

    }

    if (sid == SB_XGM_ID && pkt->err_flags & PKT_FLAG_LOCAL_FAULT) {

        // If less than 4 faults in 128 columns, it will not be detected

        if (pkt->err_info <= (128 - 4)) {

            xgm_stats.inject_local_fault_cnt++;

        }

    }

    if (sid == SB_XGM_ID && pkt->err_flags & PKT_FLAG_REMOTE_FAULT) {

        // If less than 4 faults in 128 columns, it will not be detected

        if (pkt->err_info <= (128 - 4)) {

            xgm_stats.inject_remote_fault_cnt++;

        }

    }

    //cout << *pkt << endl;

}

void scoreboard::notify_packet_rx(sbSourceId sid, packet_t* pkt) {

    sbStats_t* stats;

    packet_t* pkt_tx;

    bool status;

    //---

    // Read matching packet from fifo

    if (sid == SB_PIF_ID) {

        status = xgm_fifo.nb_read(pkt_tx);

        if (status) {

            cout << "SCOREBOARD PACKET INTERFACE RX (TX SIZE="

                 << pkt_tx->length << "  RX SIZE="

                 << pkt->length << ")" << endl;

        }

    }

    if (sid == SB_XGM_ID) {

        status = pif_fifo.nb_read(pkt_tx);

        if (status) {

            cout << "SCOREBOARD XGMII INTERFACE RX (TX SIZE="

                 << pkt_tx->length << "  RX SIZE="

                 << pkt->length << ")" << endl;

        }

    }

    if (!status) {

        cout << "ERROR: FIFO EMPTY" << endl;

        sc_stop();

    }

    //---

    // Update stats

    if (sid == SB_PIF_ID) {

        stats = &pif_stats;

    }

    if (sid == SB_XGM_ID) {

        stats = &xgm_stats;

    }

    stats->rx_pkt_cnt++;

    if (stats->timestamp_first_pkt == 0) {

        stats->timestamp_first_pkt = sc_simulation_time();

    }

    stats->timestamp_last_pkt = sc_simulation_time();

    //---

    // Pad packet if it expected to be padded by MAC

    if (sid == SB_XGM_ID && !disable_padding) {

        pad(pkt_tx, 60);

    }

    //---

    // Calculate CRC

    calc_crc(pkt_tx);

    calc_crc(pkt);

    //---

    // Update byte count after padding

    stats->rx_octets_cnt = stats->rx_octets_cnt + pkt_tx->length + 4;

    //cout << *pkt_tx << *pkt << endl;

    //---

    // Compare TX and RX packets

    if (disable_packet_check) {

        cout << "INFO: Packet check disabled" << endl;

    }

    else if ((pkt_tx->err_flags & PKT_FLAG_ERR_FRG) &&

             (pkt->err_flags & PKT_FLAG_ERR_SIG)) {

        cout << "INFO: Fragment detected" << endl;

    }

    else if ((pkt_tx->err_flags & PKT_FLAG_ERR_LENGHT) &&

             (pkt->err_flags & PKT_FLAG_ERR_SIG)) {

        cout << "INFO: Lenght error detected" << endl;

    }

    else if ((pkt_tx->err_flags & PKT_FLAG_ERR_CODING) &&

             (pkt->err_flags & PKT_FLAG_ERR_SIG)) {

        cout << "INFO: Coding error detected:" << pkt_tx->err_info << endl;

    }

    else if ((sid == SB_PIF_ID || pkt->crc == pkt->crc_rx || disable_crc_check) &&

             compare(pkt_tx, pkt)) {

        //cout << "GOOD: Packets are matching" << endl;

    }

    else {

        cout << "ERROR: Packets don't match or bad CRC" << endl;

        cout << "<<<" << endl;

        cout << *pkt_tx << endl;

        cout << *pkt << endl;

        cout << ">>>" << endl;

        sc_stop();

    }

    //---

    // Check IFG against predicted IFG

    if (sid == SB_XGM_ID) {

        cout << "PKTMOD " << pkt->length % 4 \

             << " LANE " << pkt->start_lane \

             << " DIC " << stats->deficit_idle_count \

             << " IFGLEN " << stats->next_ifg_length  << endl;

        if (pkt->ifg < 1000 && stats->next_ifg_length != 1000) {

            if (pkt->ifg != stats->next_ifg_length) {

                cout << "ERROR: DIC IFG " << pkt->ifg                   \

                     << " Predicted: " << stats->next_ifg_length << endl;

                sc_stop();

            }

        }

    }

    //---

    // Update deficit idle count and predict IFG

    if (sid == SB_XGM_ID) {

        stats->next_ifg_length = 12 - (pkt->length % 4);

        stats->deficit_idle_count += (pkt->length % 4);

        if (stats->deficit_idle_count > 3) {

            stats->next_ifg_length += 4;

            stats->deficit_idle_count = stats->deficit_idle_count % 4;

        }

    }

    //---

    // Check error flags

    // CRC ERRORS

    if (sid == SB_PIF_ID && (pkt_tx->err_flags & PKT_FLAG_ERR_CRC)) {

        if (pkt->err_flags & PKT_FLAG_ERR_SIG) {

            cout << "SCOREBOARD CRC ERROR CHECKED" << endl;

            pif_stats.crc_error_cnt++;

            if (cpu_stats.crc_error_cnt+1 < pif_stats.crc_error_cnt) {

                cout << "ERROR: CRC error not reported to cpu" << endl;

                sc_stop();

            }

        }

        else {

            cout << "ERROR: CRC error not detected: " << hex << pkt->err_flags << dec << endl;

            sc_stop();

        }

        pkt->err_flags &= ~PKT_FLAG_ERR_SIG;

    }

    // FRAGMENT ERRORS

    if (sid == SB_PIF_ID && (pkt_tx->err_flags & PKT_FLAG_ERR_FRG)) {

        if (pkt->err_flags & PKT_FLAG_ERR_SIG) {

            cout << "SCOREBOARD FRAGMENT ERROR CHECKED" << endl;

            pif_stats.fragment_error_cnt++;

            if ((cpu_stats.fragment_error_cnt + cpu_stats.crc_error_cnt + 1)

                < pif_stats.fragment_error_cnt) {

                cout << "ERROR: FRAGMENT error not reported to cpu" << endl;

                sc_stop();

            }

        }

        else {

            cout << "ERROR: FRAGMENT error not detected: "

                 << hex << pkt->err_flags << dec << endl;

            sc_stop();

        }

        pkt->err_flags &= ~PKT_FLAG_ERR_SIG;

    }

    // LENGHT ERRORS

    if (sid == SB_PIF_ID && (pkt_tx->err_flags & PKT_FLAG_ERR_LENGHT)) {

        if (pkt->err_flags & PKT_FLAG_ERR_SIG) {

            cout << "SCOREBOARD LENGHT ERROR CHECKED" << endl;

            pif_stats.lenght_error_cnt++;

            if (cpu_stats.lenght_error_cnt + 1 < pif_stats.lenght_error_cnt) {

                cout << "ERROR: LENGHT error not reported to cpu" << endl;

                sc_stop();

            }

        }

        else {

            cout << "ERROR: LENGHT error not detected: "

                 << hex << pkt->err_flags << dec << endl;

            sc_stop();

        }

        pkt->err_flags &= ~PKT_FLAG_ERR_SIG;

    }

    // CODING ERRORS

    if (sid == SB_PIF_ID && (pkt_tx->err_flags & PKT_FLAG_ERR_CODING)) {

        if (pkt->err_flags & PKT_FLAG_ERR_SIG) {

            cout << "SCOREBOARD CODING ERROR CHECKED" << endl;

            if (cpu_stats.crc_error_cnt+1 < xgm_stats.crc_error_cnt) {

                cout << "CPU Count: " << cpu_stats.crc_error_cnt <<

                    " XGM Count: " << xgm_stats.crc_error_cnt << endl;

                cout << "ERROR: CODING error not reported to cpu" << endl;

                sc_stop();

            }

        }

        else {

            cout << "ERROR: CODING error not detected: "

                 << hex << pkt->err_flags << dec << endl;

            sc_stop();

        }

        pkt->err_flags &= ~PKT_FLAG_ERR_SIG;

    }

    if (pkt->err_flags != 0) {

        stats->flags_error_cnt++;

        if (!disable_flags_check) {

            cout << "ERROR: Error flags set: " << hex << pkt->err_flags << dec << endl;

            sc_stop();

        }

        else {

            cout << "INFO: Error flags set: " << hex << pkt->err_flags << dec << endl;

        }

    }

    //---

    // Delete packets

    delete(pkt_tx);

    delete(pkt);

}

void scoreboard::notify_status(sbSourceId sid, sbStatusId statusId) {

    //---

    // Detect errors

    if (sid == SB_CPU_ID && statusId == CRC_ERROR) {

        cout << "SCOREBOARD CRC_ERROR SIGNAL" << endl;

        cpu_stats.crc_error_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == FRAGMENT_ERROR) {

        cout << "SCOREBOARD FRAGMENT_ERROR SIGNAL" << endl;

        cpu_stats.fragment_error_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == LENGHT_ERROR) {

        cout << "SCOREBOARD LENGHT_ERROR SIGNAL" << endl;

        cpu_stats.lenght_error_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == LOCAL_FAULT) {

        cout << "SCOREBOARD LOCAL_FAULT SIGNAL" << endl;

        cpu_stats.local_fault_cnt++;

        if (cpu_stats.local_fault_cnt != xgm_stats.inject_local_fault_cnt) {

            cout << "ERROR: Local fault not reported to cpu "

                 << cpu_stats.local_fault_cnt << " "

                 << xgm_stats.inject_local_fault_cnt << endl;

            sc_stop();

        }

        if (cpu_stats.local_fault_cnt != xgm_stats.detect_remote_fault_cnt) {

            cout << "ERROR: Remote fault not detected "

                 << cpu_stats.local_fault_cnt << " "

                 << xgm_stats.detect_remote_fault_cnt << endl;

            sc_stop();

        }

    }

    if (sid == SB_CPU_ID && statusId == REMOTE_FAULT) {

        cout << "SCOREBOARD REMOTE_FAULT SIGNAL" << endl;

        cpu_stats.remote_fault_cnt++;

        if (cpu_stats.remote_fault_cnt != xgm_stats.inject_remote_fault_cnt) {

            cout << "ERROR: Remote fault not reported to cpu "

                 << cpu_stats.remote_fault_cnt << " "

                 << xgm_stats.inject_remote_fault_cnt << endl;

            sc_stop();

        }

    }

    if (sid == SB_CPU_ID && statusId == RXD_FIFO_OVFLOW) {

        cout << "SCOREBOARD RXD_FIFO_OVFLOW SIGNAL" << endl;

        cpu_stats.rxd_fifo_ovflow_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == RXD_FIFO_UDFLOW) {

        cout << "SCOREBOARD RXD_FIFO_UDFLOW SIGNAL" << endl;

        cpu_stats.rxd_fifo_udflow_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == TXD_FIFO_OVFLOW) {

        cout << "SCOREBOARD TXD_FIFO_OVFLOW SIGNAL" << endl;

        cpu_stats.txd_fifo_ovflow_cnt++;

    }

    if (sid == SB_CPU_ID && statusId == TXD_FIFO_UDFLOW) {

        cout << "SCOREBOARD TXD_FIFO_UDFLOW SIGNAL" << endl;

        cpu_stats.txd_fifo_udflow_cnt++;

    }

    //---

    // Detect XGMII local/remote faults

    if (sid == SB_XGM_ID && statusId == LOCAL_FAULT) {

        cout << "SCOREBOARD RX LOCAL FAULT" << endl;

        xgm_stats.detect_local_fault_cnt++;

        sc_stop();

    }

    if (sid == SB_XGM_ID && statusId == REMOTE_FAULT) {

        cout << "SCOREBOARD RX REMOTE FAULT" << endl;

        xgm_stats.detect_remote_fault_cnt++;

    }

    //---

    // Packet receive indication

    if (sid == SB_CPU_ID && statusId == RX_GOOD_PAUSE_FRAME) {

        cout << "SCOREBOARD RX GOOD PAUSE FRAME SIGNAL" << endl;

        cpu_stats.rx_pause_frame_cnt++;

        if (cpu_stats.rx_pause_frame_cnt != xgm_stats.inject_pause_frame_cnt) {

            cout << "ERROR: Pause frame not reported "

                 << cpu_stats.rx_pause_frame_cnt << " "

                 << xgm_stats.inject_pause_frame_cnt << endl;

            sc_stop();

        }

    }

    if (!disable_signal_check) {

        cout << "ERROR: Signal Active" << endl;

        sc_stop();

    }

}

sbStats_t* scoreboard::get_pif_stats(void) {

    return &pif_stats;

}

sbStats_t* scoreboard::get_xgm_stats(void) {

    return &xgm_stats;

}

sbCpuStats_t* scoreboard::get_cpu_stats(void) {

    return &cpu_stats;

}

void scoreboard::clear_stats(void) {

    //---

    // Clear FIFOs

    while (pif_fifo.num_available() != 0) {

        delete(pif_fifo.read());

    }

    while (xgm_fifo.num_available() != 0) {

        delete(xgm_fifo.read());

    }

    //---

    // Clear stats

    pif_stats.tx_pkt_cnt = 0;

    pif_stats.rx_pkt_cnt = 0;

    pif_stats.tx_octets_cnt = 0;

    pif_stats.rx_octets_cnt = 0;

    pif_stats.crc_error_cnt = 0;

    pif_stats.flags_error_cnt = 0;

    xgm_stats.tx_pkt_cnt = 0;

    xgm_stats.rx_pkt_cnt = 0;

    xgm_stats.tx_octets_cnt = 0;

    xgm_stats.rx_octets_cnt = 0;

    xgm_stats.crc_error_cnt = 0;

    xgm_stats.flags_error_cnt = 0;

    pif_stats.timestamp_first_pkt = 0;

    pif_stats.timestamp_last_pkt = 0;

    xgm_stats.timestamp_first_pkt = 0;

    xgm_stats.timestamp_last_pkt = 0;

    xgm_stats.next_ifg_length = 1000;

    xgm_stats.deficit_idle_count = 0;

    cpu_stats.crc_error_cnt = 0;

    cpu_stats.fragment_error_cnt = 0;

    cpu_stats.lenght_error_cnt = 0;

    cpu_stats.rxd_fifo_ovflow_cnt = 0;

    cpu_stats.rxd_fifo_udflow_cnt = 0;

    cpu_stats.txd_fifo_ovflow_cnt = 0;

    cpu_stats.txd_fifo_udflow_cnt = 0;

}