Subversion Repositories ulpi_wrapper

#ifndef __SC_VPI_MODULE_H__
#define __SC_VPI_MODULE_H__
 
#include <systemc.h>
#include <assert.h>
#include <vpi_user.h>
 
static int sc_vpi_module_value_change(p_cb_data cb_data);
 
#define sc_vpi_module_read_output_int(obj, name)  \
{                                   \
    s_vpi_value  value_s;           \
    s_vpi_time   vpi_time_s;        \
                                    \
    value_s.format = vpiIntVal;     \
                                    \
    vpi_time_s.type = vpiSimTime;   \
    vpi_time_s.high = 0;            \
    vpi_time_s.low  = 0;            \
                                    \
    std::string path = m_hdl_name;  \
    path = path + "." + name;       \
    vpiHandle handle = vpi_handle_by_name(path.c_str(), NULL); \
    assert(handle != NULL);           \
                                      \
    vpi_get_value(handle, &value_s);  \
    obj.write(value_s.value.integer); \
}
 
#define sc_vpi_module_write_input_int(obj, name)  \
{                                   \
    s_vpi_value  value_s;           \
    s_vpi_time   vpi_time_s;        \
                                    \
    value_s.format = vpiIntVal;     \
                                    \
    vpi_time_s.type = vpiSimTime;   \
    vpi_time_s.high = 0;            \
    vpi_time_s.low  = 0;            \
                                    \
    std::string path = m_hdl_name;  \
    path = path + "." + name;       \
    vpiHandle handle = vpi_handle_by_name(path.c_str(), NULL); \
    assert(handle != NULL);           \
                                      \
    value_s.value.integer = obj.read();  \
    vpi_put_value(handle, &value_s, &vpi_time_s, vpiInertialDelay); \
}
 
class sc_vpi_module
{
public:   
    std::string      m_hdl_name;
    uint64_t         m_last_time;
    sc_signal<bool>  m_stop;
 
    sc_vpi_module(sc_module_name name) : m_hdl_name((std::string)name)
    {
        m_last_time = 0;
        m_stop.write(false);
    }
 
    // Simulation control    
    void stopSimulation()  { m_stop.write(true); }
    bool isStopped()       { return m_stop.read(); }
 
    virtual void read_outputs(void) { }
    virtual void write_inputs(void) { }
 
    bool register_signal(const char *name)
    {
        static s_vpi_value value_s;
        static s_vpi_time  vpi_time;
        s_cb_data          cb_data_s;
 
        vpi_time.high = 0;
        vpi_time.low  = 0;
        vpi_time.type = vpiSimTime;
 
        // For each I/O
        std::string path = m_hdl_name;
        path = path + "." + name;
        vpiHandle handle = vpi_handle_by_name(path.c_str(), NULL);
        if (!handle)
            return false;
 
        // Attach value change callbacks for outputs
        cb_data_s.user_data = (PLI_BYTE8*)this;
        cb_data_s.reason    = cbValueChange;
        cb_data_s.cb_rtn    = sc_vpi_module_value_change;
        cb_data_s.time      = &vpi_time;
        cb_data_s.value     = &value_s;
 
        value_s.format      = vpiIntVal;
 
        cb_data_s.obj  = handle;
        vpi_register_cb(&cb_data_s);
 
        return true;
    }
 
    int value_change(void)
    {
        s_vpi_time vpi_time_s;
 
        vpi_time_s.type = vpiSimTime;
        vpi_time_s.high = 0;
        vpi_time_s.low  = 0;
 
        // Outputs
        read_outputs();
 
        // Get current time
        uint64_t time_value = 0;
        s_vpi_time time_now;
        time_now.type = vpiSimTime;
        vpi_get_time (0, &time_now);
 
        time_value = time_now.high;
        time_value <<= 32;
        time_value |= time_now.low;
 
        // Update systemC TB
        if(sc_pending_activity())
            sc_start((int)(time_value-m_last_time),SC_NS);
 
        m_last_time = time_value;
 
        // Inputs
        write_inputs();
 
        if (isStopped())
            vpi_sim_control(vpiFinish, 0);
 
        return 0;
    }
};
 
static int sc_vpi_module_value_change(p_cb_data cb_data)
{
    sc_vpi_module *p = (sc_vpi_module*)cb_data->user_data;
    return p->value_change();
}
 
#endif