URL https://opencores.org/ocsvn/xge_mac/xge_mac/trunk

Subversion Repositories xge_mac

[/] [xge_mac/] [trunk/] [tbench/] [systemc/] [sc_testcases.cpp] - Blame information for rev 21

Go to most recent revision | Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "sc_testcases.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 "sc_testcases.h"
 
 
void testcases::connect_testbench(testbench* tbptr) {
    tb = tbptr;
}
 
void testcases::run_tests(void) {
 
    //---
    // Init
 
    tb->pkt_if0.init();
    tb->xgm_if0.init();
    tb->cpu_if0.init();
    tb->pif_gen0.init();
    tb->xgm_gen0.init();
    tb->sb.init();
 
    wait(300, SC_NS);
 
    tb->cpu_if0.enable_all_interrupts();
 
 
 
 
//    done = true;
//    return;
    //---
    // Testcases
 
    test_packet_size(50, 90, 50);
    test_packet_size(9000, 9020, 20);
    test_packet_size(9599, 9601, 10);
 
    test_deficit_idle_count();
 
    test_crc_errors(50, 90, 300, 2);
    test_crc_errors(9000, 9020, 20, 1);
 
    test_txdfifo_ovflow();
    test_rxdfifo_ovflow();
 
    test_rx_fragments(55, 90, 300, 2);
    test_rx_coding_err(400, 4);
 
    test_rx_local_fault(55, 90, 600, 15);
    test_rx_remote_fault(55, 90, 600, 15);
 
    test_rx_pause(64, 70, 600, 5);
 
    test_interrupt_mask();
 
    done = true;
 
}
 
 
void testcases::test_deficit_idle_count(void) {
 
    int range;
    int size;
 
    cout << "-----------------------" << endl;
    cout << "Deficit IDLE count" << endl;
    cout << "-----------------------" << endl;
 
    for (range = 0; range < 8; range++) {
        for (size = 60; size < 68; size++) {
            packet_dic(size, size + range);
        }
    }
 
}
 
 
void testcases::packet_dic(int minsize, int maxsize) {
 
    sbStats_t* pif_stats;
    sbStats_t* xgm_stats;
 
    int cnt = 6;
    float delta;
    float cycletime = 6.4;
    float rate;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->pif_gen0.set_pkt_size(minsize, maxsize);
    tb->xgm_gen0.set_pkt_size(minsize, maxsize);
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(cnt);
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->pif_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(1000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    xgm_stats = tb->sb.get_xgm_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt || xgm_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received." << endl;
        sc_stop();
    }
 
}
 
 
void testcases::test_packet_size(int min, int max, int cnt) {
 
    sbStats_t* pif_stats;
    sbStats_t* xgm_stats;
 
    cout << "-----------------------" << endl;
    cout << "Packet size" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->pif_gen0.set_pkt_size(min, max);
    tb->xgm_gen0.set_pkt_size(min, max);
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(cnt);
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->pif_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    xgm_stats = tb->sb.get_xgm_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
 
    if (xgm_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by XGM." << endl;
        cout << xgm_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
}
 
void testcases::test_crc_errors(int min, int max, int cnt, int interval) {
 
    sbStats_t* pif_stats;
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "CRC errors" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->xgm_gen0.set_pkt_size(min, max);
    tb->xgm_gen0.set_crc_errors(interval);
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    cpu_stats = tb->sb.get_cpu_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
 
    if (cpu_stats->crc_error_cnt != pif_stats->crc_error_cnt) {
        cout << "ERROR: Not all CRC errors reported to cpu" << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_crc_errors(0);
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_txdfifo_ovflow() {
 
    sbStats_t* xgm_stats;
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "TXD FIFO overflow" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->pif_gen0.set_pkt_size(1000, 1000);
 
    tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 0);
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(2);
 
    //---
    // Wait for packets to be sent
 
    while (tb->pif_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    wait(30000, SC_NS);
 
    //---
    // Check errors reported
 
    cpu_stats = tb->sb.get_cpu_stats();
    cout << "Count: " << cpu_stats->txd_fifo_ovflow_cnt << endl;
    sc_assert(cpu_stats->txd_fifo_ovflow_cnt == 1);
 
    //---
    // Flush out bad packets
 
    tb->xgm_if0.allow_idle_errors = true;
    tb->sb.disable_packet_check = true;
    tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 1);
 
    wait(30000, SC_NS);
    tb->xgm_if0.allow_idle_errors = false;
    tb->sb.disable_packet_check = false;
 
    //---
    // Check errors reported
 
    cpu_stats = tb->sb.get_cpu_stats();
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(2);
 
    //---
    // Wait for packets to be sent
 
    while (tb->pif_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    wait(30000, SC_NS);
 
    xgm_stats = tb->sb.get_xgm_stats();
    sc_assert(xgm_stats->rx_pkt_cnt == 4);
 
    //---
    // Return parameters to default state
 
    tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 1);
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_rxdfifo_ovflow() {
 
    sbStats_t* pif_stats;
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "RXD FIFO overflow" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->xgm_gen0.set_pkt_size(1000, 1000);
 
    tb->pkt_if0.disable_rx = true;
    tb->pkt_if0.allow_rx_sop_err = true;
    tb->sb.disable_flags_check = true;
    tb->sb.disable_packet_check = true;
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(3);
 
    //---
    // Wait for packets to be sent
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    wait(30000, SC_NS);
 
    //---
    // Check errors reported
 
    cpu_stats = tb->sb.get_cpu_stats();
    sc_assert(cpu_stats->rxd_fifo_ovflow_cnt == 2);
 
    //---
    // Flush out bad packets
 
    tb->pkt_if0.disable_rx = false;
 
    wait(30000, SC_NS);
 
    //---
    // Check errors reported
 
    cpu_stats = tb->sb.get_cpu_stats();
    tb->sb.clear_stats();
    tb->sb.disable_flags_check = false;
    tb->sb.disable_packet_check = false;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(2);
 
    //---
    // Wait for packets to be sent
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    sc_assert(pif_stats->rx_pkt_cnt == 2);
 
    //---
    // Return parameters to default state
 
    tb->pkt_if0.allow_rx_sop_err = false;
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_rx_fragments(int min, int max, int cnt, int interval) {
 
    sbStats_t* pif_stats;
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "Fragments errors" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->xgm_gen0.set_pkt_size(min, max);
    tb->xgm_gen0.set_fragment_errors(interval);
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    cpu_stats = tb->sb.get_cpu_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
 
    if ((cpu_stats->fragment_error_cnt + cpu_stats->crc_error_cnt)
                != pif_stats->fragment_error_cnt) {
        cout << "ERROR: Not all fragment errors reported to cpu" << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_fragment_errors(0);
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_rx_coding_err(int cnt, int interval) {
 
    sbStats_t* pif_stats;
    sbStats_t* xgm_stats;
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "Coding errors" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->xgm_gen0.set_pkt_size(64, 69);
    tb->xgm_gen0.set_coding_errors(interval);
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
    xgm_stats = tb->sb.get_xgm_stats();
    cpu_stats = tb->sb.get_cpu_stats();
 
    if (pif_stats->rx_pkt_cnt != xgm_stats->tx_pkt_cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << xgm_stats->tx_pkt_cnt << endl;
        sc_stop();
    }
 
    if (cpu_stats->crc_error_cnt != xgm_stats->crc_error_cnt) {
        cout << "ERROR: Not all coding errors reported to cpu" << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_coding_errors(0);
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_rx_local_fault(int min, int max, int cnt, int interval) {
 
    sbStats_t* pif_stats;
 
    cout << "-----------------------" << endl;
    cout << "Local fault" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->pif_gen0.set_pkt_size(min, max);
    tb->xgm_gen0.set_pkt_size(min, max);
 
    tb->xgm_gen0.set_local_fault(interval);
    tb->sb.disable_signal_check = true;
    tb->xgm_if0.allow_idle_errors = true;
    tb->xgm_if0.disable_receive = true;
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(cnt);
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_local_fault(0);
    tb->sb.disable_signal_check = false;
    tb->xgm_if0.allow_idle_errors = false;
    tb->xgm_if0.disable_receive = false;
}
 
void testcases::test_rx_remote_fault(int min, int max, int cnt, int interval) {
 
    sbStats_t* pif_stats;
 
    cout << "-----------------------" << endl;
    cout << "Remote fault" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->pif_gen0.set_pkt_size(min, max);
    tb->xgm_gen0.set_pkt_size(min, max);
 
    tb->xgm_gen0.set_remote_fault(interval);
    tb->sb.disable_signal_check = true;
    tb->xgm_if0.allow_idle_errors = true;
    tb->xgm_if0.disable_receive = true;
 
    //---
    // Enable traffic
 
    tb->pif_gen0.set_tx_bucket(cnt);
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    pif_stats = tb->sb.get_pif_stats();
 
    if (pif_stats->rx_pkt_cnt != cnt) {
        cout << "ERROR: Not all packets received by PIF." << endl;
        cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_remote_fault(0);
    tb->sb.disable_signal_check = false;
    tb->xgm_if0.allow_idle_errors = false;
    tb->xgm_if0.disable_receive = false;
}
 
void testcases::test_rx_pause(int min, int max, int cnt, int interval) {
 
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "Receive Pause" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
 
    tb->xgm_gen0.set_pkt_size(min, max);
 
    tb->xgm_gen0.set_inject_pause(interval);
    tb->sb.disable_signal_check = true;
 
    //---
    // Enable traffic
 
    tb->xgm_gen0.set_tx_bucket(cnt);
 
    //---
    // Wait for test to complete
 
    while (tb->xgm_gen0.get_tx_bucket() != 0) {
        wait(10, SC_NS);
    }
 
    //---
    // Check traffic
 
    wait(30000, SC_NS);
 
    cpu_stats = tb->sb.get_cpu_stats();
 
    if (cpu_stats->rx_pause_frame_cnt == 0) {
        cout << "ERROR: No pause frames received." << endl;
        sc_stop();
    }
 
    //---
    // Return parameters to default state
 
    tb->xgm_gen0.set_inject_pause(0);
    tb->sb.disable_signal_check = false;
}
 
void testcases::test_interrupt_mask() {
 
    sbCpuStats_t* cpu_stats;
 
    cout << "-----------------------" << endl;
    cout << "Interrupt Mask" << endl;
    cout << "-----------------------" << endl;
 
    //---
    // Setup parameters
 
    tb->sb.clear_stats();
    tb->sb.disable_signal_check = true;
 
 
    //---
    // Test unmasked
 
    tb->cpu_if0.set_interrupt(cpu_if::INT_CRC_ERROR);
 
    wait(300, SC_NS);
 
    cpu_stats = tb->sb.get_cpu_stats();
    sc_assert(cpu_stats->crc_error_cnt == 1);
 
 
    //---
    // Test masked
 
    tb->cpu_if0.set_interrupt_mask(cpu_if::INT_CRC_ERROR, 0);
    tb->cpu_if0.set_interrupt(cpu_if::INT_CRC_ERROR);
 
    wait(300, SC_NS);
 
    cpu_stats = tb->sb.get_cpu_stats();
    sc_assert(cpu_stats->crc_error_cnt == 1);
 
 
    //---
    // Return parameters to default state
 
    tb->sb.disable_signal_check = false;
    tb->cpu_if0.set_interrupt_mask(cpu_if::INT_CRC_ERROR, 1);
}

Browse

Tools

Subversion Repositories xge_mac

[/] [xge_mac/] [trunk/] [tbench/] [systemc/] [sc_testcases.cpp] - Blame information for rev 21

Line No.	Rev	Author	Line
1	2	antanguay	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// File name "sc_testcases.cpp" ////`
4			`//// ////`
5			`//// This file is part of the "10GE MAC" project ////`
6			`//// http://www.opencores.org/cores/xge_mac/ ////`
7			`//// ////`
8			`//// Author(s): ////`
9			`//// - A. Tanguay (antanguay@opencores.org) ////`
10			`//// ////`
11			`//////////////////////////////////////////////////////////////////////`
12			`//// ////`
13			`//// Copyright (C) 2008 AUTHORS. All rights reserved. ////`
14			`//// ////`
15			`//// This source file may be used and distributed without ////`
16			`//// restriction provided that this copyright statement is not ////`
17			`//// removed from the file and that any derivative work contains ////`
18			`//// the original copyright notice and the associated disclaimer. ////`
19			`//// ////`
20			`//// This source file is free software; you can redistribute it ////`
21			`//// and/or modify it under the terms of the GNU Lesser General ////`
22			`//// Public License as published by the Free Software Foundation; ////`
23			`//// either version 2.1 of the License, or (at your option) any ////`
24			`//// later version. ////`
25			`//// ////`
26			`//// This source is distributed in the hope that it will be ////`
27			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
28			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
29			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
30			`//// details. ////`
31			`//// ////`
32			`//// You should have received a copy of the GNU Lesser General ////`
33			`//// Public License along with this source; if not, download it ////`
34			`//// from http://www.opencores.org/lgpl.shtml ////`
35			`//// ////`
36			`//////////////////////////////////////////////////////////////////////`
37
38			`#include "sc_testcases.h"`
39
40
41			`void testcases::connect_testbench(testbench* tbptr) {`
42			`tb = tbptr;`
43			`}`
44
45			`void testcases::run_tests(void) {`
46
47			`//---`
48			`// Init`
49
50			`tb->pkt_if0.init();`
51			`tb->xgm_if0.init();`
52			`tb->cpu_if0.init();`
53			`tb->pif_gen0.init();`
54			`tb->xgm_gen0.init();`
55			`tb->sb.init();`
56
57			`wait(300, SC_NS);`
58
59			`tb->cpu_if0.enable_all_interrupts();`
60
61
62
63
64			`// done = true;`
65			`// return;`
66			`//---`
67			`// Testcases`
68
69			`test_packet_size(50, 90, 50);`
70			`test_packet_size(9000, 9020, 20);`
71	21	antanguay	`test_packet_size(9599, 9601, 10);`
72	2	antanguay
73			`test_deficit_idle_count();`
74
75			`test_crc_errors(50, 90, 300, 2);`
76			`test_crc_errors(9000, 9020, 20, 1);`
77
78			`test_txdfifo_ovflow();`
79			`test_rxdfifo_ovflow();`
80
81			`test_rx_fragments(55, 90, 300, 2);`
82			`test_rx_coding_err(400, 4);`
83
84			`test_rx_local_fault(55, 90, 600, 15);`
85			`test_rx_remote_fault(55, 90, 600, 15);`
86
87			`test_rx_pause(64, 70, 600, 5);`
88
89			`test_interrupt_mask();`
90
91			`done = true;`
92
93			`}`
94
95
96			`void testcases::test_deficit_idle_count(void) {`
97
98			`int range;`
99			`int size;`
100
101			`cout << "-----------------------" << endl;`
102			`cout << "Deficit IDLE count" << endl;`
103			`cout << "-----------------------" << endl;`
104
105			`for (range = 0; range < 8; range++) {`
106			`for (size = 60; size < 68; size++) {`
107			`packet_dic(size, size + range);`
108			`}`
109			`}`
110
111			`}`
112
113
114			`void testcases::packet_dic(int minsize, int maxsize) {`
115
116			`sbStats_t* pif_stats;`
117			`sbStats_t* xgm_stats;`
118
119			`int cnt = 6;`
120			`float delta;`
121			`float cycletime = 6.4;`
122			`float rate;`
123
124			`//---`
125			`// Setup parameters`
126
127			`tb->sb.clear_stats();`
128
129			`tb->pif_gen0.set_pkt_size(minsize, maxsize);`
130			`tb->xgm_gen0.set_pkt_size(minsize, maxsize);`
131
132			`//---`
133			`// Enable traffic`
134
135			`tb->pif_gen0.set_tx_bucket(cnt);`
136			`tb->xgm_gen0.set_tx_bucket(cnt);`
137
138			`//---`
139			`// Wait for test to complete`
140
141			`while (tb->pif_gen0.get_tx_bucket() != 0) {`
142			`wait(10, SC_NS);`
143			`}`
144
145			`//---`
146			`// Check traffic`
147
148			`wait(1000, SC_NS);`
149
150			`pif_stats = tb->sb.get_pif_stats();`
151			`xgm_stats = tb->sb.get_xgm_stats();`
152
153			`if (pif_stats->rx_pkt_cnt != cnt \|\| xgm_stats->rx_pkt_cnt != cnt) {`
154			`cout << "ERROR: Not all packets received." << endl;`
155			`sc_stop();`
156			`}`
157
158			`}`
159
160
161			`void testcases::test_packet_size(int min, int max, int cnt) {`
162
163			`sbStats_t* pif_stats;`
164			`sbStats_t* xgm_stats;`
165
166			`cout << "-----------------------" << endl;`
167			`cout << "Packet size" << endl;`
168			`cout << "-----------------------" << endl;`
169
170			`//---`
171			`// Setup parameters`
172
173			`tb->sb.clear_stats();`
174
175			`tb->pif_gen0.set_pkt_size(min, max);`
176			`tb->xgm_gen0.set_pkt_size(min, max);`
177
178			`//---`
179			`// Enable traffic`
180
181			`tb->pif_gen0.set_tx_bucket(cnt);`
182			`tb->xgm_gen0.set_tx_bucket(cnt);`
183
184			`//---`
185			`// Wait for test to complete`
186
187			`while (tb->pif_gen0.get_tx_bucket() != 0) {`
188			`wait(10, SC_NS);`
189			`}`
190
191			`//---`
192			`// Check traffic`
193
194			`wait(30000, SC_NS);`
195
196			`pif_stats = tb->sb.get_pif_stats();`
197			`xgm_stats = tb->sb.get_xgm_stats();`
198
199			`if (pif_stats->rx_pkt_cnt != cnt) {`
200			`cout << "ERROR: Not all packets received by PIF." << endl;`
201			`cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;`
202			`sc_stop();`
203			`}`
204
205			`if (xgm_stats->rx_pkt_cnt != cnt) {`
206			`cout << "ERROR: Not all packets received by XGM." << endl;`
207			`cout << xgm_stats->rx_pkt_cnt << " " << cnt << endl;`
208			`sc_stop();`
209			`}`
210			`}`
211
212			`void testcases::test_crc_errors(int min, int max, int cnt, int interval) {`
213
214			`sbStats_t* pif_stats;`
215			`sbCpuStats_t* cpu_stats;`
216
217			`cout << "-----------------------" << endl;`
218			`cout << "CRC errors" << endl;`
219			`cout << "-----------------------" << endl;`
220
221			`//---`
222			`// Setup parameters`
223
224			`tb->sb.clear_stats();`
225
226			`tb->xgm_gen0.set_pkt_size(min, max);`
227			`tb->xgm_gen0.set_crc_errors(interval);`
228			`tb->sb.disable_signal_check = true;`
229
230			`//---`
231			`// Enable traffic`
232
233			`tb->xgm_gen0.set_tx_bucket(cnt);`
234
235			`//---`
236			`// Wait for test to complete`
237
238			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
239			`wait(10, SC_NS);`
240			`}`
241
242			`//---`
243			`// Check traffic`
244
245			`wait(30000, SC_NS);`
246
247			`pif_stats = tb->sb.get_pif_stats();`
248			`cpu_stats = tb->sb.get_cpu_stats();`
249
250			`if (pif_stats->rx_pkt_cnt != cnt) {`
251			`cout << "ERROR: Not all packets received by PIF." << endl;`
252			`cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;`
253			`sc_stop();`
254			`}`
255
256			`if (cpu_stats->crc_error_cnt != pif_stats->crc_error_cnt) {`
257			`cout << "ERROR: Not all CRC errors reported to cpu" << endl;`
258			`sc_stop();`
259			`}`
260
261			`//---`
262			`// Return parameters to default state`
263
264			`tb->xgm_gen0.set_crc_errors(0);`
265			`tb->sb.disable_signal_check = false;`
266			`}`
267
268			`void testcases::test_txdfifo_ovflow() {`
269
270			`sbStats_t* xgm_stats;`
271			`sbCpuStats_t* cpu_stats;`
272
273			`cout << "-----------------------" << endl;`
274			`cout << "TXD FIFO overflow" << endl;`
275			`cout << "-----------------------" << endl;`
276
277			`//---`
278			`// Setup parameters`
279
280			`tb->sb.clear_stats();`
281
282			`tb->pif_gen0.set_pkt_size(1000, 1000);`
283	17	antanguay
284	2	antanguay	`tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 0);`
285			`tb->sb.disable_signal_check = true;`
286
287			`//---`
288			`// Enable traffic`
289
290			`tb->pif_gen0.set_tx_bucket(2);`
291
292			`//---`
293			`// Wait for packets to be sent`
294
295			`while (tb->pif_gen0.get_tx_bucket() != 0) {`
296			`wait(10, SC_NS);`
297			`}`
298
299			`wait(30000, SC_NS);`
300
301			`//---`
302			`// Check errors reported`
303
304			`cpu_stats = tb->sb.get_cpu_stats();`
305			`cout << "Count: " << cpu_stats->txd_fifo_ovflow_cnt << endl;`
306			`sc_assert(cpu_stats->txd_fifo_ovflow_cnt == 1);`
307
308			`//---`
309			`// Flush out bad packets`
310
311			`tb->xgm_if0.allow_idle_errors = true;`
312			`tb->sb.disable_packet_check = true;`
313			`tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 1);`
314
315			`wait(30000, SC_NS);`
316			`tb->xgm_if0.allow_idle_errors = false;`
317			`tb->sb.disable_packet_check = false;`
318
319			`//---`
320			`// Check errors reported`
321
322			`cpu_stats = tb->sb.get_cpu_stats();`
323	17	antanguay
324	2	antanguay	`//---`
325			`// Enable traffic`
326
327			`tb->pif_gen0.set_tx_bucket(2);`
328
329			`//---`
330			`// Wait for packets to be sent`
331
332			`while (tb->pif_gen0.get_tx_bucket() != 0) {`
333			`wait(10, SC_NS);`
334			`}`
335
336			`wait(30000, SC_NS);`
337
338			`xgm_stats = tb->sb.get_xgm_stats();`
339			`sc_assert(xgm_stats->rx_pkt_cnt == 4);`
340
341			`//---`
342			`// Return parameters to default state`
343
344			`tb->cpu_if0.set_param(cpu_if::TX_ENABLE, 1);`
345			`tb->sb.disable_signal_check = false;`
346			`}`
347
348			`void testcases::test_rxdfifo_ovflow() {`
349
350			`sbStats_t* pif_stats;`
351			`sbCpuStats_t* cpu_stats;`
352
353			`cout << "-----------------------" << endl;`
354			`cout << "RXD FIFO overflow" << endl;`
355			`cout << "-----------------------" << endl;`
356
357			`//---`
358			`// Setup parameters`
359
360			`tb->sb.clear_stats();`
361
362			`tb->xgm_gen0.set_pkt_size(1000, 1000);`
363	17	antanguay
364	2	antanguay	`tb->pkt_if0.disable_rx = true;`
365			`tb->pkt_if0.allow_rx_sop_err = true;`
366			`tb->sb.disable_flags_check = true;`
367			`tb->sb.disable_packet_check = true;`
368			`tb->sb.disable_signal_check = true;`
369
370			`//---`
371			`// Enable traffic`
372
373			`tb->xgm_gen0.set_tx_bucket(3);`
374
375			`//---`
376			`// Wait for packets to be sent`
377
378			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
379			`wait(10, SC_NS);`
380			`}`
381
382			`wait(30000, SC_NS);`
383
384			`//---`
385			`// Check errors reported`
386
387			`cpu_stats = tb->sb.get_cpu_stats();`
388			`sc_assert(cpu_stats->rxd_fifo_ovflow_cnt == 2);`
389
390			`//---`
391			`// Flush out bad packets`
392
393			`tb->pkt_if0.disable_rx = false;`
394
395			`wait(30000, SC_NS);`
396
397			`//---`
398			`// Check errors reported`
399
400			`cpu_stats = tb->sb.get_cpu_stats();`
401			`tb->sb.clear_stats();`
402			`tb->sb.disable_flags_check = false;`
403			`tb->sb.disable_packet_check = false;`
404
405			`//---`
406			`// Enable traffic`
407
408			`tb->xgm_gen0.set_tx_bucket(2);`
409
410			`//---`
411			`// Wait for packets to be sent`
412
413			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
414			`wait(10, SC_NS);`
415			`}`
416
417			`wait(30000, SC_NS);`
418
419			`pif_stats = tb->sb.get_pif_stats();`
420			`sc_assert(pif_stats->rx_pkt_cnt == 2);`
421
422			`//---`
423			`// Return parameters to default state`
424
425			`tb->pkt_if0.allow_rx_sop_err = false;`
426			`tb->sb.disable_signal_check = false;`
427			`}`
428
429			`void testcases::test_rx_fragments(int min, int max, int cnt, int interval) {`
430
431			`sbStats_t* pif_stats;`
432			`sbCpuStats_t* cpu_stats;`
433
434			`cout << "-----------------------" << endl;`
435			`cout << "Fragments errors" << endl;`
436			`cout << "-----------------------" << endl;`
437
438			`//---`
439			`// Setup parameters`
440
441			`tb->sb.clear_stats();`
442
443			`tb->xgm_gen0.set_pkt_size(min, max);`
444			`tb->xgm_gen0.set_fragment_errors(interval);`
445			`tb->sb.disable_signal_check = true;`
446
447			`//---`
448			`// Enable traffic`
449
450			`tb->xgm_gen0.set_tx_bucket(cnt);`
451
452			`//---`
453			`// Wait for test to complete`
454
455			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
456			`wait(10, SC_NS);`
457			`}`
458
459			`//---`
460			`// Check traffic`
461
462			`wait(30000, SC_NS);`
463
464			`pif_stats = tb->sb.get_pif_stats();`
465			`cpu_stats = tb->sb.get_cpu_stats();`
466
467			`if (pif_stats->rx_pkt_cnt != cnt) {`
468			`cout << "ERROR: Not all packets received by PIF." << endl;`
469			`cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;`
470			`sc_stop();`
471			`}`
472
473			`if ((cpu_stats->fragment_error_cnt + cpu_stats->crc_error_cnt)`
474			`!= pif_stats->fragment_error_cnt) {`
475			`cout << "ERROR: Not all fragment errors reported to cpu" << endl;`
476			`sc_stop();`
477			`}`
478
479			`//---`
480			`// Return parameters to default state`
481
482			`tb->xgm_gen0.set_fragment_errors(0);`
483			`tb->sb.disable_signal_check = false;`
484			`}`
485
486			`void testcases::test_rx_coding_err(int cnt, int interval) {`
487
488			`sbStats_t* pif_stats;`
489			`sbStats_t* xgm_stats;`
490			`sbCpuStats_t* cpu_stats;`
491
492			`cout << "-----------------------" << endl;`
493			`cout << "Coding errors" << endl;`
494			`cout << "-----------------------" << endl;`
495
496			`//---`
497			`// Setup parameters`
498
499			`tb->sb.clear_stats();`
500
501			`tb->xgm_gen0.set_pkt_size(64, 69);`
502			`tb->xgm_gen0.set_coding_errors(interval);`
503			`tb->sb.disable_signal_check = true;`
504
505			`//---`
506			`// Enable traffic`
507
508			`tb->xgm_gen0.set_tx_bucket(cnt);`
509
510			`//---`
511			`// Wait for test to complete`
512
513			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
514			`wait(10, SC_NS);`
515			`}`
516
517			`//---`
518			`// Check traffic`
519
520			`wait(30000, SC_NS);`
521
522			`pif_stats = tb->sb.get_pif_stats();`
523			`xgm_stats = tb->sb.get_xgm_stats();`
524			`cpu_stats = tb->sb.get_cpu_stats();`
525
526			`if (pif_stats->rx_pkt_cnt != xgm_stats->tx_pkt_cnt) {`
527			`cout << "ERROR: Not all packets received by PIF." << endl;`
528			`cout << pif_stats->rx_pkt_cnt << " " << xgm_stats->tx_pkt_cnt << endl;`
529			`sc_stop();`
530			`}`
531
532			`if (cpu_stats->crc_error_cnt != xgm_stats->crc_error_cnt) {`
533			`cout << "ERROR: Not all coding errors reported to cpu" << endl;`
534			`sc_stop();`
535			`}`
536
537			`//---`
538			`// Return parameters to default state`
539
540			`tb->xgm_gen0.set_coding_errors(0);`
541			`tb->sb.disable_signal_check = false;`
542			`}`
543
544			`void testcases::test_rx_local_fault(int min, int max, int cnt, int interval) {`
545
546			`sbStats_t* pif_stats;`
547
548			`cout << "-----------------------" << endl;`
549			`cout << "Local fault" << endl;`
550			`cout << "-----------------------" << endl;`
551
552			`//---`
553			`// Setup parameters`
554
555			`tb->sb.clear_stats();`
556
557			`tb->pif_gen0.set_pkt_size(min, max);`
558			`tb->xgm_gen0.set_pkt_size(min, max);`
559
560			`tb->xgm_gen0.set_local_fault(interval);`
561			`tb->sb.disable_signal_check = true;`
562			`tb->xgm_if0.allow_idle_errors = true;`
563			`tb->xgm_if0.disable_receive = true;`
564
565			`//---`
566			`// Enable traffic`
567
568			`tb->pif_gen0.set_tx_bucket(cnt);`
569			`tb->xgm_gen0.set_tx_bucket(cnt);`
570
571			`//---`
572			`// Wait for test to complete`
573
574			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
575			`wait(10, SC_NS);`
576			`}`
577
578			`//---`
579			`// Check traffic`
580
581			`wait(30000, SC_NS);`
582
583			`pif_stats = tb->sb.get_pif_stats();`
584
585			`if (pif_stats->rx_pkt_cnt != cnt) {`
586			`cout << "ERROR: Not all packets received by PIF." << endl;`
587			`cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;`
588			`sc_stop();`
589			`}`
590
591			`//---`
592			`// Return parameters to default state`
593
594			`tb->xgm_gen0.set_local_fault(0);`
595			`tb->sb.disable_signal_check = false;`
596			`tb->xgm_if0.allow_idle_errors = false;`
597			`tb->xgm_if0.disable_receive = false;`
598			`}`
599
600			`void testcases::test_rx_remote_fault(int min, int max, int cnt, int interval) {`
601
602			`sbStats_t* pif_stats;`
603
604			`cout << "-----------------------" << endl;`
605			`cout << "Remote fault" << endl;`
606			`cout << "-----------------------" << endl;`
607
608			`//---`
609			`// Setup parameters`
610
611			`tb->sb.clear_stats();`
612
613			`tb->pif_gen0.set_pkt_size(min, max);`
614			`tb->xgm_gen0.set_pkt_size(min, max);`
615
616			`tb->xgm_gen0.set_remote_fault(interval);`
617			`tb->sb.disable_signal_check = true;`
618			`tb->xgm_if0.allow_idle_errors = true;`
619			`tb->xgm_if0.disable_receive = true;`
620
621			`//---`
622			`// Enable traffic`
623
624			`tb->pif_gen0.set_tx_bucket(cnt);`
625			`tb->xgm_gen0.set_tx_bucket(cnt);`
626
627			`//---`
628			`// Wait for test to complete`
629
630			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
631			`wait(10, SC_NS);`
632			`}`
633
634			`//---`
635			`// Check traffic`
636
637			`wait(30000, SC_NS);`
638
639			`pif_stats = tb->sb.get_pif_stats();`
640
641			`if (pif_stats->rx_pkt_cnt != cnt) {`
642			`cout << "ERROR: Not all packets received by PIF." << endl;`
643			`cout << pif_stats->rx_pkt_cnt << " " << cnt << endl;`
644			`sc_stop();`
645			`}`
646
647			`//---`
648			`// Return parameters to default state`
649
650			`tb->xgm_gen0.set_remote_fault(0);`
651			`tb->sb.disable_signal_check = false;`
652			`tb->xgm_if0.allow_idle_errors = false;`
653			`tb->xgm_if0.disable_receive = false;`
654			`}`
655
656			`void testcases::test_rx_pause(int min, int max, int cnt, int interval) {`
657
658			`sbCpuStats_t* cpu_stats;`
659
660			`cout << "-----------------------" << endl;`
661			`cout << "Receive Pause" << endl;`
662			`cout << "-----------------------" << endl;`
663
664			`//---`
665			`// Setup parameters`
666
667			`tb->sb.clear_stats();`
668
669			`tb->xgm_gen0.set_pkt_size(min, max);`
670
671			`tb->xgm_gen0.set_inject_pause(interval);`
672			`tb->sb.disable_signal_check = true;`
673
674			`//---`
675			`// Enable traffic`
676
677			`tb->xgm_gen0.set_tx_bucket(cnt);`
678
679			`//---`
680			`// Wait for test to complete`
681
682			`while (tb->xgm_gen0.get_tx_bucket() != 0) {`
683			`wait(10, SC_NS);`
684			`}`
685
686			`//---`
687			`// Check traffic`
688
689			`wait(30000, SC_NS);`
690
691			`cpu_stats = tb->sb.get_cpu_stats();`
692
693			`if (cpu_stats->rx_pause_frame_cnt == 0) {`
694			`cout << "ERROR: No pause frames received." << endl;`
695			`sc_stop();`
696			`}`
697
698			`//---`
699			`// Return parameters to default state`
700
701			`tb->xgm_gen0.set_inject_pause(0);`
702			`tb->sb.disable_signal_check = false;`
703			`}`
704
705			`void testcases::test_interrupt_mask() {`
706
707			`sbCpuStats_t* cpu_stats;`
708
709			`cout << "-----------------------" << endl;`
710			`cout << "Interrupt Mask" << endl;`
711			`cout << "-----------------------" << endl;`
712
713			`//---`
714			`// Setup parameters`
715
716			`tb->sb.clear_stats();`
717			`tb->sb.disable_signal_check = true;`
718
719
720			`//---`
721			`// Test unmasked`
722
723			`tb->cpu_if0.set_interrupt(cpu_if::INT_CRC_ERROR);`
724
725			`wait(300, SC_NS);`
726
727			`cpu_stats = tb->sb.get_cpu_stats();`
728			`sc_assert(cpu_stats->crc_error_cnt == 1);`
729
730
731			`//---`
732			`// Test masked`
733
734			`tb->cpu_if0.set_interrupt_mask(cpu_if::INT_CRC_ERROR, 0);`
735			`tb->cpu_if0.set_interrupt(cpu_if::INT_CRC_ERROR);`
736
737			`wait(300, SC_NS);`
738
739			`cpu_stats = tb->sb.get_cpu_stats();`
740			`sc_assert(cpu_stats->crc_error_cnt == 1);`
741
742
743			`//---`
744			`// Return parameters to default state`
745	17	antanguay
746	2	antanguay	`tb->sb.disable_signal_check = false;`
747			`tb->cpu_if0.set_interrupt_mask(cpu_if::INT_CRC_ERROR, 1);`
748			`}`