| /***************************************************************************** |
| |
| Licensed to Accellera Systems Initiative Inc. (Accellera) under one or |
| more contributor license agreements. See the NOTICE file distributed |
| with this work for additional information regarding copyright ownership. |
| Accellera licenses this file to you under the Apache License, Version 2.0 |
| (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.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| implied. See the License for the specific language governing |
| permissions and limitations under the License. |
| |
| *****************************************************************************/ |
| |
| // ***************************************************************************** |
| // Modified by John Aynsley, Doulos, Feb 2009, |
| // Fix a bug in simple_target_socket and simple_target_socket_tagged |
| // with the addition of one new line of code in each: wait(*e); |
| // ***************************************************************************** |
| |
| // ***************************************************************************** |
| // Modified by John Aynsley on behalf of Robert Guenzel, May 2011, |
| // Fix a bug in simple_target_socket and simple_target_socket_tagged |
| // with the addition of one new line of code in each: wait(t); |
| // ***************************************************************************** |
| |
| |
| #ifndef __SIMPLE_TARGET_SOCKET_H__ |
| #define __SIMPLE_TARGET_SOCKET_H__ |
| |
| #ifndef SC_INCLUDE_DYNAMIC_PROCESSES // needed for sc_spawn |
| # define SC_INCLUDE_DYNAMIC_PROCESSES |
| #endif |
| |
| #include <systemc> |
| #include <tlm> |
| #include "tlm_utils/peq_with_get.h" |
| #include <sstream> |
| |
| namespace tlm_utils { |
| |
| template <typename MODULE, |
| unsigned int BUSWIDTH = 32, |
| typename TYPES = tlm::tlm_base_protocol_types> |
| class simple_target_socket : |
| public tlm::tlm_target_socket<BUSWIDTH, TYPES> |
| { |
| friend class fw_process; |
| friend class bw_process; |
| public: |
| typedef typename TYPES::tlm_payload_type transaction_type; |
| typedef typename TYPES::tlm_phase_type phase_type; |
| typedef tlm::tlm_sync_enum sync_enum_type; |
| typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; |
| typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; |
| typedef tlm::tlm_target_socket<BUSWIDTH, TYPES> base_type; |
| |
| public: |
| simple_target_socket() : |
| base_type(sc_core::sc_gen_unique_name("simple_target_socket")), |
| m_fw_process(this), |
| m_bw_process(this) |
| { |
| bind(m_fw_process); |
| } |
| |
| explicit simple_target_socket(const char* n) : |
| base_type(n), |
| m_fw_process(this), |
| m_bw_process(this) |
| { |
| bind(m_fw_process); |
| } |
| |
| using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind; |
| |
| // bw transport must come thru us. |
| tlm::tlm_bw_transport_if<TYPES> * operator ->() {return &m_bw_process;} |
| |
| // REGISTER_XXX |
| void register_nb_transport_fw(MODULE* mod, |
| sync_enum_type (MODULE::*cb)(transaction_type&, |
| phase_type&, |
| sc_core::sc_time&)) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_nb_transport_ptr(mod, cb); |
| } |
| |
| void register_b_transport(MODULE* mod, |
| void (MODULE::*cb)(transaction_type&, |
| sc_core::sc_time&)) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_b_transport_ptr(mod, cb); |
| } |
| |
| void register_transport_dbg(MODULE* mod, |
| unsigned int (MODULE::*cb)(transaction_type&)) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_transport_dbg_ptr(mod, cb); |
| } |
| |
| void register_get_direct_mem_ptr(MODULE* mod, |
| bool (MODULE::*cb)(transaction_type&, |
| tlm::tlm_dmi&)) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_get_direct_mem_ptr(mod, cb); |
| } |
| |
| private: |
| //make call on bw path. |
| sync_enum_type bw_nb_transport(transaction_type &trans, phase_type &phase, sc_core::sc_time &t) |
| { |
| return base_type::operator ->()->nb_transport_bw(trans, phase, t); |
| } |
| |
| void bw_invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e) |
| { |
| base_type::operator ->()->invalidate_direct_mem_ptr(s, e); |
| } |
| |
| //Helper class to handle bw path calls |
| // Needed to detect transaction end when called from b_transport. |
| class bw_process : public tlm::tlm_bw_transport_if<TYPES> |
| { |
| public: |
| bw_process(simple_target_socket *p_own) : m_owner(p_own) |
| { |
| } |
| |
| sync_enum_type nb_transport_bw(transaction_type &trans, phase_type &phase, sc_core::sc_time &t) |
| { |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it; |
| |
| it = m_owner->m_pending_trans.find(&trans); |
| if(it == m_owner->m_pending_trans.end()) { |
| // Not a blocking call, forward. |
| return m_owner->bw_nb_transport(trans, phase, t); |
| |
| } else { |
| if (phase == tlm::END_REQ) { |
| m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME); |
| return tlm::TLM_ACCEPTED; |
| |
| } else if (phase == tlm::BEGIN_RESP) { |
| if (m_owner->m_current_transaction == &trans) { |
| m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME); |
| } |
| //TODO: add response-accept delay? |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| return tlm::TLM_COMPLETED; |
| |
| } else { |
| assert(0); exit(1); |
| } |
| |
| // return tlm::TLM_COMPLETED; //Should not reach here |
| } |
| } |
| |
| void invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e) |
| { |
| return m_owner->bw_invalidate_direct_mem_ptr(s, e); |
| } |
| |
| private: |
| simple_target_socket *m_owner; |
| }; |
| |
| class fw_process : public tlm::tlm_fw_transport_if<TYPES>, |
| public tlm::tlm_mm_interface |
| { |
| public: |
| typedef sync_enum_type (MODULE::*NBTransportPtr)(transaction_type&, |
| phase_type&, |
| sc_core::sc_time&); |
| typedef void (MODULE::*BTransportPtr)(transaction_type&, |
| sc_core::sc_time&); |
| typedef unsigned int (MODULE::*TransportDbgPtr)(transaction_type&); |
| typedef bool (MODULE::*GetDirectMemPtr)(transaction_type&, |
| tlm::tlm_dmi&); |
| |
| fw_process(simple_target_socket *p_own) : |
| m_name(p_own->name()), |
| m_owner(p_own), |
| m_mod(0), |
| m_nb_transport_ptr(0), |
| m_b_transport_ptr(0), |
| m_transport_dbg_ptr(0), |
| m_get_direct_mem_ptr(0), |
| m_peq(sc_core::sc_gen_unique_name("m_peq")), |
| m_response_in_progress(false) |
| { |
| sc_core::sc_spawn_options opts; |
| opts.set_sensitivity(&m_peq.get_event()); |
| sc_core::sc_spawn(sc_bind(&fw_process::b2nb_thread, this), |
| sc_core::sc_gen_unique_name("b2nb_thread"), &opts); |
| } |
| |
| void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p) |
| { |
| if (m_nb_transport_ptr) { |
| std::stringstream s; |
| s << m_name << ": non-blocking callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_nb_transport_ptr = p; |
| } |
| } |
| |
| void set_b_transport_ptr(MODULE* mod, BTransportPtr p) |
| { |
| if (m_b_transport_ptr) { |
| std::stringstream s; |
| s << m_name << ": blocking callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_b_transport_ptr = p; |
| } |
| } |
| |
| void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p) |
| { |
| if (m_transport_dbg_ptr) { |
| std::stringstream s; |
| s << m_name << ": debug callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_transport_dbg_ptr = p; |
| } |
| } |
| |
| void set_get_direct_mem_ptr(MODULE* mod, GetDirectMemPtr p) |
| { |
| if (m_get_direct_mem_ptr) { |
| std::stringstream s; |
| s << m_name << ": get DMI pointer callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_get_direct_mem_ptr = p; |
| } |
| } |
| // Interface implementation |
| sync_enum_type nb_transport_fw(transaction_type& trans, |
| phase_type& phase, |
| sc_core::sc_time& t) |
| { |
| if (m_nb_transport_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_nb_transport_ptr)(trans, phase, t); |
| |
| } else if (m_b_transport_ptr) { |
| if (phase == tlm::BEGIN_REQ) { |
| // prepare thread to do blocking call |
| process_handle_class * ph = m_process_handle.get_handle(&trans); |
| |
| if (!ph) { // create new dynamic process |
| ph = new process_handle_class(&trans); |
| m_process_handle.put_handle(ph); |
| |
| sc_core::sc_spawn_options opts; |
| opts.dont_initialize(); |
| opts.set_sensitivity(&ph->m_e); |
| |
| sc_core::sc_spawn(sc_bind(&fw_process::nb2b_thread,this, ph), |
| sc_core::sc_gen_unique_name("nb2b_thread"), &opts); |
| } |
| |
| ph->m_e.notify(t); |
| return tlm::TLM_ACCEPTED; |
| |
| } else if (phase == tlm::END_RESP) { |
| m_response_in_progress = false; |
| m_end_response.notify(t); |
| return tlm::TLM_COMPLETED; |
| |
| } else { |
| assert(0); exit(1); |
| // return tlm::TLM_COMPLETED; ///< unreachable code |
| } |
| |
| } else { |
| std::stringstream s; |
| s << m_name << ": no non-blocking transport callback registered"; |
| SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } |
| return tlm::TLM_ACCEPTED; ///< unreachable code |
| } |
| |
| void b_transport(transaction_type& trans, sc_core::sc_time& t) |
| { |
| if (m_b_transport_ptr) { |
| // forward call |
| assert(m_mod); |
| (m_mod->*m_b_transport_ptr)(trans, t); |
| return; |
| |
| } else if (m_nb_transport_ptr) { |
| m_peq.notify(trans, t); |
| t = sc_core::SC_ZERO_TIME; |
| |
| mm_end_event_ext mm_ext; |
| const bool mm_added = !trans.has_mm(); |
| |
| if (mm_added) { |
| trans.set_mm(this); |
| trans.set_auto_extension(&mm_ext); |
| trans.acquire(); |
| } |
| |
| // wait until transaction is finished |
| sc_core::sc_event end_event; |
| m_owner->m_pending_trans[&trans] = &end_event; |
| sc_core::wait(end_event); |
| |
| if (mm_added) { |
| // release will not delete the transaction, it will notify mm_ext.done |
| trans.release(); |
| if (trans.get_ref_count()) { |
| sc_core::wait(mm_ext.done); |
| } |
| trans.set_mm(0); |
| } |
| |
| } else { |
| std::stringstream s; |
| s << m_name << ": no blocking transport callback registered"; |
| SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } |
| } |
| |
| unsigned int transport_dbg(transaction_type& trans) |
| { |
| if (m_transport_dbg_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_transport_dbg_ptr)(trans); |
| |
| } else { |
| // No debug support |
| return 0; |
| } |
| } |
| |
| bool get_direct_mem_ptr(transaction_type& trans, |
| tlm::tlm_dmi& dmi_data) |
| { |
| if (m_get_direct_mem_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_get_direct_mem_ptr)(trans, dmi_data); |
| |
| } else { |
| // No DMI support |
| dmi_data.allow_read_write(); |
| dmi_data.set_start_address(0x0); |
| dmi_data.set_end_address((sc_dt::uint64)-1); |
| return false; |
| } |
| } |
| |
| private: |
| |
| // dynamic process handler for nb2b conversion |
| |
| class process_handle_class { |
| public: |
| explicit process_handle_class(transaction_type * trans) |
| : m_trans(trans),m_suspend(false) {} |
| |
| transaction_type* m_trans; |
| sc_core::sc_event m_e; |
| bool m_suspend; |
| }; |
| |
| class process_handle_list { |
| public: |
| process_handle_list() {} |
| |
| ~process_handle_list() { |
| for( typename std::vector<process_handle_class*>::iterator |
| it=v.begin(), end = v.end(); it != end; ++it ) |
| delete *it; |
| } |
| |
| process_handle_class* get_handle(transaction_type *trans) |
| { |
| typename std::vector<process_handle_class*>::iterator it; |
| |
| for(it = v.begin(); it != v.end(); it++) { |
| if ((*it)->m_suspend) { // found suspended dynamic process, re-use it |
| (*it)->m_trans = trans; // replace to new one |
| (*it)->m_suspend = false; |
| return *it; |
| } |
| } |
| return NULL; // no suspended process |
| } |
| |
| void put_handle(process_handle_class* ph) |
| { |
| v.push_back(ph); |
| } |
| |
| private: |
| std::vector<process_handle_class*> v; |
| }; |
| |
| process_handle_list m_process_handle; |
| |
| |
| void nb2b_thread(process_handle_class* h) |
| { |
| |
| while(1) { |
| transaction_type *trans = h->m_trans; |
| sc_core::sc_time t = sc_core::SC_ZERO_TIME; |
| |
| // forward call |
| assert(m_mod); |
| (m_mod->*m_b_transport_ptr)(*trans, t); |
| |
| sc_core::wait(t); |
| |
| // return path |
| while (m_response_in_progress) { |
| sc_core::wait(m_end_response); |
| } |
| t = sc_core::SC_ZERO_TIME; |
| phase_type phase = tlm::BEGIN_RESP; |
| sync_enum_type sync = m_owner->bw_nb_transport(*trans, phase, t); |
| if ( !(sync == tlm::TLM_COMPLETED || |
| (sync == tlm::TLM_UPDATED && phase == tlm::END_RESP)) ) { |
| m_response_in_progress = true; |
| } |
| |
| // suspend until next transaction |
| h->m_suspend = true; |
| sc_core::wait(); |
| } |
| } |
| |
| void b2nb_thread() |
| { |
| while (true) { |
| sc_core::wait(m_peq.get_event()); |
| |
| transaction_type* trans; |
| while ((trans = m_peq.get_next_transaction())!=0) { |
| assert(m_mod); |
| assert(m_nb_transport_ptr); |
| phase_type phase = tlm::BEGIN_REQ; |
| sc_core::sc_time t = sc_core::SC_ZERO_TIME; |
| |
| switch ((m_mod->*m_nb_transport_ptr)(*trans, phase, t)) { |
| case tlm::TLM_COMPLETED: |
| { |
| // notify transaction is finished |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it = |
| m_owner->m_pending_trans.find(trans); |
| assert(it != m_owner->m_pending_trans.end()); |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| break; |
| } |
| |
| case tlm::TLM_ACCEPTED: |
| case tlm::TLM_UPDATED: |
| switch (phase) { |
| case tlm::BEGIN_REQ: |
| m_owner->m_current_transaction = trans; |
| sc_core::wait(m_owner->m_end_request); |
| m_owner->m_current_transaction = 0; |
| break; |
| |
| case tlm::END_REQ: |
| sc_core::wait(t); |
| break; |
| |
| case tlm::BEGIN_RESP: |
| { |
| phase = tlm::END_RESP; |
| sc_core::wait(t); // This line is a bug fix added in TLM-2.0.2 |
| t = sc_core::SC_ZERO_TIME; |
| (m_mod->*m_nb_transport_ptr)(*trans, phase, t); |
| |
| // notify transaction is finished |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it = |
| m_owner->m_pending_trans.find(trans); |
| assert(it != m_owner->m_pending_trans.end()); |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| break; |
| } |
| |
| default: |
| assert(0); exit(1); |
| }; |
| break; |
| |
| default: |
| assert(0); exit(1); |
| }; |
| } |
| } |
| } |
| |
| void free(tlm::tlm_generic_payload* trans) |
| { |
| mm_end_event_ext* ext = trans->template get_extension<mm_end_event_ext>(); |
| assert(ext); |
| // notif event first before freeing extensions (reset) |
| ext->done.notify(); |
| trans->reset(); |
| } |
| |
| private: |
| struct mm_end_event_ext : public tlm::tlm_extension<mm_end_event_ext> |
| { |
| tlm::tlm_extension_base* clone() const { return NULL; } |
| void free() {} |
| void copy_from(tlm::tlm_extension_base const &) {} |
| sc_core::sc_event done; |
| }; |
| |
| private: |
| const std::string m_name; |
| simple_target_socket *m_owner; |
| MODULE* m_mod; |
| NBTransportPtr m_nb_transport_ptr; |
| BTransportPtr m_b_transport_ptr; |
| TransportDbgPtr m_transport_dbg_ptr; |
| GetDirectMemPtr m_get_direct_mem_ptr; |
| peq_with_get<transaction_type> m_peq; |
| bool m_response_in_progress; |
| sc_core::sc_event m_end_response; |
| }; |
| |
| private: |
| fw_process m_fw_process; |
| bw_process m_bw_process; |
| std::map<transaction_type*, sc_core::sc_event *> m_pending_trans; |
| sc_core::sc_event m_end_request; |
| transaction_type* m_current_transaction; |
| }; |
| |
| //ID Tagged version |
| template <typename MODULE, |
| unsigned int BUSWIDTH = 32, |
| typename TYPES = tlm::tlm_base_protocol_types> |
| class simple_target_socket_tagged : |
| public tlm::tlm_target_socket<BUSWIDTH, TYPES> |
| { |
| friend class fw_process; |
| friend class bw_process; |
| public: |
| typedef typename TYPES::tlm_payload_type transaction_type; |
| typedef typename TYPES::tlm_phase_type phase_type; |
| typedef tlm::tlm_sync_enum sync_enum_type; |
| typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; |
| typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; |
| typedef tlm::tlm_target_socket<BUSWIDTH, TYPES> base_type; |
| |
| public: |
| simple_target_socket_tagged() : |
| base_type(sc_core::sc_gen_unique_name("simple_target_socket_tagged")), |
| m_fw_process(this), |
| m_bw_process(this) |
| { |
| bind(m_fw_process); |
| } |
| |
| explicit simple_target_socket_tagged(const char* n) : |
| base_type(n), |
| m_fw_process(this), |
| m_bw_process(this) |
| { |
| bind(m_fw_process); |
| } |
| |
| using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind; |
| |
| // bw transport must come thru us. |
| tlm::tlm_bw_transport_if<TYPES> * operator ->() {return &m_bw_process;} |
| |
| // REGISTER_XXX |
| void register_nb_transport_fw(MODULE* mod, |
| sync_enum_type (MODULE::*cb)(int id, |
| transaction_type&, |
| phase_type&, |
| sc_core::sc_time&), |
| int id) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_nb_transport_ptr(mod, cb); |
| m_fw_process.set_nb_transport_user_id(id); |
| } |
| |
| void register_b_transport(MODULE* mod, |
| void (MODULE::*cb)(int id, |
| transaction_type&, |
| sc_core::sc_time&), |
| int id) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_b_transport_ptr(mod, cb); |
| m_fw_process.set_b_transport_user_id(id); |
| } |
| |
| void register_transport_dbg(MODULE* mod, |
| unsigned int (MODULE::*cb)(int id, |
| transaction_type&), |
| int id) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_transport_dbg_ptr(mod, cb); |
| m_fw_process.set_transport_dbg_user_id(id); |
| } |
| |
| void register_get_direct_mem_ptr(MODULE* mod, |
| bool (MODULE::*cb)(int id, |
| transaction_type&, |
| tlm::tlm_dmi&), |
| int id) |
| { |
| assert(!sc_core::sc_get_curr_simcontext()->elaboration_done()); |
| m_fw_process.set_get_direct_mem_ptr(mod, cb); |
| m_fw_process.set_get_dmi_user_id(id); |
| } |
| |
| private: |
| //make call on bw path. |
| sync_enum_type bw_nb_transport(transaction_type &trans, phase_type &phase, sc_core::sc_time &t) |
| { |
| return base_type::operator ->()->nb_transport_bw(trans, phase, t); |
| } |
| |
| void bw_invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e) |
| { |
| base_type::operator ->()->invalidate_direct_mem_ptr(s, e); |
| } |
| |
| //Helper class to handle bw path calls |
| // Needed to detect transaction end when called from b_transport. |
| class bw_process : public tlm::tlm_bw_transport_if<TYPES> |
| { |
| public: |
| bw_process(simple_target_socket_tagged *p_own) : m_owner(p_own) |
| { |
| } |
| |
| sync_enum_type nb_transport_bw(transaction_type &trans, phase_type &phase, sc_core::sc_time &t) |
| { |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it; |
| |
| it = m_owner->m_pending_trans.find(&trans); |
| if(it == m_owner->m_pending_trans.end()) { |
| // Not a blocking call, forward. |
| return m_owner->bw_nb_transport(trans, phase, t); |
| |
| } else { |
| if (phase == tlm::END_REQ) { |
| m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME); |
| return tlm::TLM_ACCEPTED; |
| |
| } else if (phase == tlm::BEGIN_RESP) { |
| if (m_owner->m_current_transaction == &trans) { |
| m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME); |
| } |
| //TODO: add response-accept delay? |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| return tlm::TLM_COMPLETED; |
| |
| } else { |
| assert(0); exit(1); |
| } |
| |
| // return tlm::TLM_COMPLETED; //Should not reach here |
| } |
| } |
| |
| void invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e) |
| { |
| return m_owner->bw_invalidate_direct_mem_ptr(s, e); |
| } |
| |
| private: |
| simple_target_socket_tagged *m_owner; |
| }; |
| |
| class fw_process : public tlm::tlm_fw_transport_if<TYPES>, |
| public tlm::tlm_mm_interface |
| { |
| public: |
| typedef sync_enum_type (MODULE::*NBTransportPtr)(int id, |
| transaction_type&, |
| phase_type&, |
| sc_core::sc_time&); |
| typedef void (MODULE::*BTransportPtr)(int id, |
| transaction_type&, |
| sc_core::sc_time&); |
| typedef unsigned int (MODULE::*TransportDbgPtr)(int id, |
| transaction_type&); |
| typedef bool (MODULE::*GetDirectMemPtr)(int id, |
| transaction_type&, |
| tlm::tlm_dmi&); |
| |
| fw_process(simple_target_socket_tagged *p_own) : |
| m_name(p_own->name()), |
| m_owner(p_own), |
| m_mod(0), |
| m_nb_transport_ptr(0), |
| m_b_transport_ptr(0), |
| m_transport_dbg_ptr(0), |
| m_get_direct_mem_ptr(0), |
| m_nb_transport_user_id(0), |
| m_b_transport_user_id(0), |
| m_transport_dbg_user_id(0), |
| m_get_dmi_user_id(0), |
| m_peq(sc_core::sc_gen_unique_name("m_peq")), |
| m_response_in_progress(false) |
| { |
| sc_core::sc_spawn_options opts; |
| opts.set_sensitivity(&m_peq.get_event()); |
| sc_core::sc_spawn(sc_bind(&fw_process::b2nb_thread, this), |
| sc_core::sc_gen_unique_name("b2nb_thread"), &opts); |
| } |
| |
| void set_nb_transport_user_id(int id) { m_nb_transport_user_id = id; } |
| void set_b_transport_user_id(int id) { m_b_transport_user_id = id; } |
| void set_transport_dbg_user_id(int id) { m_transport_dbg_user_id = id; } |
| void set_get_dmi_user_id(int id) { m_get_dmi_user_id = id; } |
| |
| void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p) |
| { |
| if (m_nb_transport_ptr) { |
| std::stringstream s; |
| s << m_name << ": non-blocking callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_nb_transport_ptr = p; |
| } |
| } |
| |
| void set_b_transport_ptr(MODULE* mod, BTransportPtr p) |
| { |
| if (m_b_transport_ptr) { |
| std::stringstream s; |
| s << m_name << ": blocking callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_b_transport_ptr = p; |
| } |
| } |
| |
| void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p) |
| { |
| if (m_transport_dbg_ptr) { |
| std::stringstream s; |
| s << m_name << ": debug callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_transport_dbg_ptr = p; |
| } |
| } |
| |
| void set_get_direct_mem_ptr(MODULE* mod, GetDirectMemPtr p) |
| { |
| if (m_get_direct_mem_ptr) { |
| std::stringstream s; |
| s << m_name << ": get DMI pointer callback allready registered"; |
| SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } else { |
| assert(!m_mod || m_mod == mod); |
| m_mod = mod; |
| m_get_direct_mem_ptr = p; |
| } |
| } |
| // Interface implementation |
| sync_enum_type nb_transport_fw(transaction_type& trans, |
| phase_type& phase, |
| sc_core::sc_time& t) |
| { |
| if (m_nb_transport_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, trans, phase, t); |
| |
| } else if (m_b_transport_ptr) { |
| if (phase == tlm::BEGIN_REQ) { |
| |
| // prepare thread to do blocking call |
| process_handle_class * ph = m_process_handle.get_handle(&trans); |
| |
| if (!ph) { // create new dynamic process |
| ph = new process_handle_class(&trans); |
| m_process_handle.put_handle(ph); |
| |
| sc_core::sc_spawn_options opts; |
| opts.dont_initialize(); |
| opts.set_sensitivity(&ph->m_e); |
| |
| sc_core::sc_spawn(sc_bind(&fw_process::nb2b_thread, this, ph), |
| sc_core::sc_gen_unique_name("nb2b_thread"), &opts); |
| } |
| |
| ph->m_e.notify(t); |
| return tlm::TLM_ACCEPTED; |
| |
| } else if (phase == tlm::END_RESP) { |
| m_response_in_progress = false; |
| m_end_response.notify(t); |
| return tlm::TLM_COMPLETED; |
| |
| } else { |
| assert(0); exit(1); |
| // return tlm::TLM_COMPLETED; ///< unreachable code |
| } |
| |
| } else { |
| std::stringstream s; |
| s << m_name << ": no non-blocking transport callback registered"; |
| SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } |
| return tlm::TLM_ACCEPTED; ///< unreachable code |
| } |
| |
| void b_transport(transaction_type& trans, sc_core::sc_time& t) |
| { |
| if (m_b_transport_ptr) { |
| // forward call |
| assert(m_mod); |
| (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, trans, t); |
| return; |
| |
| } else if (m_nb_transport_ptr) { |
| m_peq.notify(trans, t); |
| t = sc_core::SC_ZERO_TIME; |
| |
| mm_end_event_ext mm_ext; |
| const bool mm_added = !trans.has_mm(); |
| |
| if (mm_added){ |
| trans.set_mm(this); |
| trans.set_auto_extension(&mm_ext); |
| trans.acquire(); |
| } |
| |
| // wait until transaction is finished |
| sc_core::sc_event end_event; |
| m_owner->m_pending_trans[&trans] = &end_event; |
| sc_core::wait(end_event); |
| |
| if (mm_added) { |
| // release will not delete the transaction, it will notify mm_ext.done |
| trans.release(); |
| if (trans.get_ref_count()) { |
| sc_core::wait(mm_ext.done); |
| } |
| trans.set_mm(0); |
| } |
| |
| } else { |
| std::stringstream s; |
| s << m_name << ": no transport callback registered"; |
| SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str()); |
| } |
| } |
| |
| unsigned int transport_dbg(transaction_type& trans) |
| { |
| if (m_transport_dbg_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_transport_dbg_ptr)(m_transport_dbg_user_id, trans); |
| |
| } else { |
| // No debug support |
| return 0; |
| } |
| } |
| |
| bool get_direct_mem_ptr(transaction_type& trans, |
| tlm::tlm_dmi& dmi_data) |
| { |
| if (m_get_direct_mem_ptr) { |
| // forward call |
| assert(m_mod); |
| return (m_mod->*m_get_direct_mem_ptr)(m_get_dmi_user_id, trans, dmi_data); |
| |
| } else { |
| // No DMI support |
| dmi_data.allow_read_write(); |
| dmi_data.set_start_address(0x0); |
| dmi_data.set_end_address((sc_dt::uint64)-1); |
| return false; |
| } |
| } |
| |
| private: |
| // dynamic process handler for nb2b conversion |
| |
| class process_handle_class { |
| public: |
| explicit process_handle_class(transaction_type * trans) |
| : m_trans(trans),m_suspend(false){} |
| |
| transaction_type* m_trans; |
| sc_core::sc_event m_e; |
| bool m_suspend; |
| }; |
| |
| class process_handle_list { |
| public: |
| process_handle_list() {} |
| |
| ~process_handle_list() { |
| for( typename std::vector<process_handle_class*>::iterator |
| it=v.begin(), end = v.end(); it != end; ++it ) |
| delete *it; |
| } |
| |
| process_handle_class* get_handle(transaction_type *trans) |
| { |
| typename std::vector<process_handle_class*>::iterator it; |
| |
| for(it = v.begin(); it != v.end(); it++) { |
| if ((*it)->m_suspend) { // found suspended dynamic process, re-use it |
| (*it)->m_trans = trans; // replace to new one |
| (*it)->m_suspend = false; |
| return *it; |
| } |
| } |
| return NULL; // no suspended process |
| } |
| |
| void put_handle(process_handle_class* ph) |
| { |
| v.push_back(ph); |
| } |
| |
| private: |
| std::vector<process_handle_class*> v; |
| }; |
| |
| process_handle_list m_process_handle; |
| |
| void nb2b_thread(process_handle_class* h) |
| { |
| |
| while(1) { |
| transaction_type * trans = h->m_trans; |
| sc_core::sc_time t = sc_core::SC_ZERO_TIME; |
| |
| // forward call |
| assert(m_mod); |
| (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, *trans, t); |
| |
| sc_core::wait(t); |
| |
| // return path |
| while (m_response_in_progress) { |
| sc_core::wait(m_end_response); |
| } |
| t = sc_core::SC_ZERO_TIME; |
| phase_type phase = tlm::BEGIN_RESP; |
| sync_enum_type sync = m_owner->bw_nb_transport(*trans, phase, t); |
| if ( !(sync == tlm::TLM_COMPLETED || |
| (sync == tlm::TLM_UPDATED && phase == tlm::END_RESP)) ) { |
| m_response_in_progress = true; |
| } |
| |
| // suspend until next transaction |
| h->m_suspend = true; |
| sc_core::wait(); |
| } |
| } |
| |
| void b2nb_thread() |
| { |
| while (true) { |
| sc_core::wait(m_peq.get_event()); |
| |
| transaction_type* trans; |
| while ((trans = m_peq.get_next_transaction())!=0) { |
| assert(m_mod); |
| assert(m_nb_transport_ptr); |
| phase_type phase = tlm::BEGIN_REQ; |
| sc_core::sc_time t = sc_core::SC_ZERO_TIME; |
| |
| switch ((m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, *trans, phase, t)) { |
| case tlm::TLM_COMPLETED: |
| { |
| // notify transaction is finished |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it = |
| m_owner->m_pending_trans.find(trans); |
| assert(it != m_owner->m_pending_trans.end()); |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| break; |
| } |
| |
| case tlm::TLM_ACCEPTED: |
| case tlm::TLM_UPDATED: |
| switch (phase) { |
| case tlm::BEGIN_REQ: |
| m_owner->m_current_transaction = trans; |
| sc_core::wait(m_owner->m_end_request); |
| m_owner->m_current_transaction = 0; |
| break; |
| |
| case tlm::END_REQ: |
| sc_core::wait(t); |
| break; |
| |
| case tlm::BEGIN_RESP: |
| { |
| phase = tlm::END_RESP; |
| sc_core::wait(t); // This line is a bug fix added in TLM-2.0.2 |
| t = sc_core::SC_ZERO_TIME; |
| (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, *trans, phase, t); |
| |
| // notify transaction is finished |
| typename std::map<transaction_type*, sc_core::sc_event *>::iterator it = |
| m_owner->m_pending_trans.find(trans); |
| assert(it != m_owner->m_pending_trans.end()); |
| it->second->notify(t); |
| m_owner->m_pending_trans.erase(it); |
| break; |
| } |
| |
| default: |
| assert(0); exit(1); |
| }; |
| break; |
| |
| default: |
| assert(0); exit(1); |
| }; |
| } |
| } |
| } |
| |
| void free(tlm::tlm_generic_payload* trans) |
| { |
| mm_end_event_ext* ext = trans->template get_extension<mm_end_event_ext>(); |
| assert(ext); |
| // notif event first before freeing extensions (reset) |
| ext->done.notify(); |
| trans->reset(); |
| } |
| |
| private: |
| struct mm_end_event_ext : public tlm::tlm_extension<mm_end_event_ext> |
| { |
| tlm::tlm_extension_base* clone() const { return NULL; } |
| void free() {} |
| void copy_from(tlm::tlm_extension_base const &) {} |
| sc_core::sc_event done; |
| }; |
| |
| private: |
| const std::string m_name; |
| simple_target_socket_tagged *m_owner; |
| MODULE* m_mod; |
| NBTransportPtr m_nb_transport_ptr; |
| BTransportPtr m_b_transport_ptr; |
| TransportDbgPtr m_transport_dbg_ptr; |
| GetDirectMemPtr m_get_direct_mem_ptr; |
| int m_nb_transport_user_id; |
| int m_b_transport_user_id; |
| int m_transport_dbg_user_id; |
| int m_get_dmi_user_id; |
| peq_with_get<transaction_type> m_peq; |
| bool m_response_in_progress; |
| sc_core::sc_event m_end_response; |
| }; |
| |
| private: |
| fw_process m_fw_process; |
| bw_process m_bw_process; |
| std::map<transaction_type*, sc_core::sc_event *> m_pending_trans; |
| sc_core::sc_event m_end_request; |
| transaction_type* m_current_transaction; |
| }; |
| |
| } |
| |
| #endif |
