Subversion Repositories ulpi_wrapper

#include "ulpi_wrapper_tb.h"

//-----------------------------------------------------------------

// sc_main_tb

//-----------------------------------------------------------------

static int attach_system_c(p_cb_data user_data)

{

    ulpi_wrapper_tb * u_tb  = new ulpi_wrapper_tb("ulpi_wrapper_tb");

    // Initialize SystemC

    sc_start(0, SC_NS);

    // Start clock

    u_tb->m_vpi_clk.start();

}

//-----------------------------------------------------------------

// _register

//-----------------------------------------------------------------

static void _register(void)

{

    s_cb_data          cb_data_s;

    cb_data_s.user_data = NULL;

    cb_data_s.reason    = cbStartOfSimulation;

    cb_data_s.cb_rtn    = attach_system_c;

    cb_data_s.time      = NULL;

    cb_data_s.value     = NULL;

    vpi_register_cb(&cb_data_s);

}

void (*vlog_startup_routines[])() =

{

    _register,

};

//-----------------------------------------------------------------

// testbench

//-----------------------------------------------------------------

void ulpi_wrapper_tb::testbench(void)

{

    sc_uint <8> last_wr = 0xFF;

    ulpi_rst_i.write(true);

    wait(5);

    ulpi_rst_i.write(false);

    wait(1);

    m_reg.write(ULPI_REG_SCRATCH, last_wr);

    int cycles = 0;

    while (true)

    {

        // Random delay

        int wait_len = rand() % 10;

        if (wait_len)

            wait(wait_len);

        // Random register write

        if (rand() & 1)

        {

            last_wr = rand();

            m_reg.write(ULPI_REG_SCRATCH, last_wr);

        }

        // Random register read

        else

        {

            sc_assert(m_reg.read(ULPI_REG_SCRATCH) == last_wr);

        }

        if (!(rand() % 32))

        {

            if (rand() & 1)

                utmi_opmode_i.write(rand());

            else

                utmi_dppulldown_i.write(rand() & 1);

        }

        if (cycles++ == 1000)

            m_dut.stopSimulation();

    }

}

//-----------------------------------------------------------------

// phy_rx: PHY Rx Thread

//-----------------------------------------------------------------

void ulpi_wrapper_tb::phy_rx(void)

{

    sc_uint <8> data;

    sc_uint <1> last;

    sc_uint <8> ulpi_data;

    sc_uint <1> ulpi_last;

    while (ulpi_rst_i.read())

        wait();

    while (1)

    {

        // Wait for data from ULPI interface

        ulpi_last = m_ulpi.read(ulpi_data);

        // Read actual data FIFO

        (last, data) = m_link_phy_queue.read();

        cout << hex << "EXPECT: DATA " << data << " LAST " << last << endl;

        cout << hex << "GOT:    DATA " << ulpi_data << " LAST " << ulpi_last << endl;

        sc_assert(ulpi_data == data);

        sc_assert(ulpi_last == last);

    }

}

//-----------------------------------------------------------------

// link_rx: Link Rx Thread

//-----------------------------------------------------------------

void ulpi_wrapper_tb::link_rx(void)

{

    sc_uint <8> data;

    sc_uint <1> last;

    sc_uint <8> ulpi_data;

    sc_uint <1> ulpi_last;

    while (ulpi_rst_i.read())

        wait();

    while (1)

    {

        // Wait for data from UTMI interface

        ulpi_last = m_utmi.read(ulpi_data);

        // Read actual data FIFO

        (last, data) = m_phy_link_queue.read();

        cout << hex << "EXPECT: DATA " << data << " LAST " << last << endl;

        cout << hex << "GOT:    DATA " << ulpi_data << " LAST " << ulpi_last << endl;

        sc_assert(ulpi_data == data);

        sc_assert(ulpi_last == last);

    }

}

//-----------------------------------------------------------------

// phy_tx: PHY Tx Thread

//-----------------------------------------------------------------

void ulpi_wrapper_tb::phy_tx(void)

{

    while (ulpi_rst_i.read())

        wait();

    while (1)

    {

        wait(10 + (rand() % 16));

        m_mutex.lock();

        int len = 1 + (rand() % 8);

        while (len--)

        {

            sc_uint <8> data = rand();

            sc_uint <1> last = (len == 0);

            cout << hex << "QUEUE (RX): DATA " << data << " LAST " << last << endl;

            m_phy_link_queue.write((last, data));

            m_ulpi.write(data, last);

        }

        do

        {

            wait(1);

        }

        while (m_phy_link_queue.num_available());

        m_mutex.unlock();

    }

}

//-----------------------------------------------------------------

// link_tx: Link Tx Thread

//-----------------------------------------------------------------

void ulpi_wrapper_tb::link_tx(void)

{

    while (ulpi_rst_i.read())

        wait();

    while (1)

    {

        wait(10 + (rand() % 16));

        m_mutex.lock();

        int len = 1 + (rand() % 8);

        bool first = true;

        while (len--)

        {

            sc_uint <8> data = rand();

            sc_uint <1> last = (len == 0);

            // First byte is PID

            if (first)

                data.range(7,4) = ~data.range(3,0);

            first = false;

            cout << hex << "QUEUE (TX): DATA " << data << " LAST " << last << endl;

            m_link_phy_queue.write((last, data));

            m_utmi.write(data, last);

        }

        // Wait until transfer completed

        do

        {

            wait();

        }

        while (m_link_phy_queue.num_available());

        m_mutex.unlock();

    }

}