00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef __PASSTHROUGH_TARGET_SOCKET_H__
00019 #define __PASSTHROUGH_TARGET_SOCKET_H__
00020
00021 #include "tlm.h"
00022
00023 namespace tlm_utils {
00024
00025 template <typename MODULE,
00026 unsigned int BUSWIDTH = 32,
00027 typename TYPES = tlm::tlm_base_protocol_types>
00028 class passthrough_target_socket :
00029 public tlm::tlm_target_socket<BUSWIDTH, TYPES>
00030 {
00031 public:
00032 typedef typename TYPES::tlm_payload_type transaction_type;
00033 typedef typename TYPES::tlm_phase_type phase_type;
00034 typedef tlm::tlm_sync_enum sync_enum_type;
00035 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
00036 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
00037 typedef tlm::tlm_target_socket<BUSWIDTH, TYPES> base_type;
00038
00039 public:
00040 explicit passthrough_target_socket(const char* n = "passthrough_target_socket") :
00041 base_type(sc_core::sc_gen_unique_name(n)),
00042 m_process(this->name())
00043 {
00044 bind(m_process);
00045 }
00046
00047
00048 void register_nb_transport_fw(MODULE* mod,
00049 sync_enum_type (MODULE::*cb)(transaction_type&,
00050 phase_type&,
00051 sc_core::sc_time&))
00052 {
00053 m_process.set_nb_transport_ptr(mod, cb);
00054 }
00055
00056 void register_b_transport(MODULE* mod,
00057 void (MODULE::*cb)(transaction_type&,
00058 sc_core::sc_time&))
00059 {
00060 m_process.set_b_transport_ptr(mod, cb);
00061 }
00062
00063 void register_transport_dbg(MODULE* mod,
00064 unsigned int (MODULE::*cb)(transaction_type&))
00065 {
00066 m_process.set_transport_dbg_ptr(mod, cb);
00067 }
00068
00069 void register_get_direct_mem_ptr(MODULE* mod,
00070 bool (MODULE::*cb)(transaction_type&,
00071 tlm::tlm_dmi&))
00072 {
00073 m_process.set_get_direct_mem_ptr(mod, cb);
00074 }
00075
00076 private:
00077 class process : public tlm::tlm_fw_transport_if<TYPES>
00078 {
00079 public:
00080 typedef sync_enum_type (MODULE::*NBTransportPtr)(transaction_type&,
00081 phase_type&,
00082 sc_core::sc_time&);
00083 typedef void (MODULE::*BTransportPtr)(transaction_type&,
00084 sc_core::sc_time&);
00085 typedef unsigned int (MODULE::*TransportDbgPtr)(transaction_type&);
00086 typedef bool (MODULE::*GetDirectMem_ptr)(transaction_type&,
00087 tlm::tlm_dmi&);
00088
00089 process(const std::string& name) :
00090 m_name(name),
00091 m_mod(0),
00092 m_nb_transport_ptr(0),
00093 m_b_transport_ptr(0),
00094 m_transport_dbg_ptr(0),
00095 m_get_direct_mem_ptr(0)
00096 {
00097 }
00098
00099 void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
00100 {
00101 if (m_nb_transport_ptr) {
00102 std::cerr << m_name << ": non-blocking callback allready registered" << std::endl;
00103
00104 } else {
00105 assert(!m_mod || m_mod == mod);
00106 m_mod = mod;
00107 m_nb_transport_ptr = p;
00108 }
00109 }
00110
00111 void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
00112 {
00113 if (m_b_transport_ptr) {
00114 std::cerr << m_name << ": non-blocking callback allready registered" << std::endl;
00115
00116 } else {
00117 assert(!m_mod || m_mod == mod);
00118 m_mod = mod;
00119 m_b_transport_ptr = p;
00120 }
00121 }
00122
00123 void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
00124 {
00125 if (m_transport_dbg_ptr) {
00126 std::cerr << m_name << ": debug callback allready registered" << std::endl;
00127
00128 } else {
00129 assert(!m_mod || m_mod == mod);
00130 m_mod = mod;
00131 m_transport_dbg_ptr = p;
00132 }
00133 }
00134
00135 void set_get_direct_mem_ptr(MODULE* mod, GetDirectMem_ptr p)
00136 {
00137 if (m_get_direct_mem_ptr) {
00138 std::cerr << m_name << ": get DMI pointer callback allready registered" << std::endl;
00139
00140 } else {
00141 assert(!m_mod || m_mod == mod);
00142 m_mod = mod;
00143 m_get_direct_mem_ptr = p;
00144 }
00145 }
00146
00147 sync_enum_type nb_transport_fw(transaction_type& trans,
00148 phase_type& phase,
00149 sc_core::sc_time& t)
00150 {
00151 if (m_nb_transport_ptr) {
00152
00153 assert(m_mod);
00154 return (m_mod->*m_nb_transport_ptr)(trans, phase, t);
00155
00156 } else {
00157 std::cerr << m_name << ": no non-blocking callback registered" << std::endl;
00158 assert(0); exit(1);
00159
00160 }
00161 }
00162
00163 void b_transport(transaction_type& trans, sc_core::sc_time& t)
00164 {
00165 if (m_b_transport_ptr) {
00166
00167 assert(m_mod);
00168 return (m_mod->*m_b_transport_ptr)(trans, t);
00169
00170 } else {
00171 std::cerr << m_name << ": no blocking callback registered" << std::endl;
00172 assert(0); exit(1);
00173
00174 }
00175 }
00176
00177 unsigned int transport_dbg(transaction_type& trans)
00178 {
00179 if (m_transport_dbg_ptr) {
00180
00181 assert(m_mod);
00182 return (m_mod->*m_transport_dbg_ptr)(trans);
00183
00184 } else {
00185
00186 return 0;
00187 }
00188 }
00189
00190 bool get_direct_mem_ptr(transaction_type& trans,
00191 tlm::tlm_dmi& dmi_data)
00192 {
00193 if (m_get_direct_mem_ptr) {
00194
00195 assert(m_mod);
00196 return (m_mod->*m_get_direct_mem_ptr)(trans, dmi_data);
00197
00198 } else {
00199
00200 dmi_data.allow_read_write();
00201 dmi_data.set_start_address(0x0);
00202 dmi_data.set_end_address((sc_dt::uint64)-1);
00203 return false;
00204 }
00205 }
00206
00207 private:
00208 const std::string m_name;
00209 MODULE* m_mod;
00210 NBTransportPtr m_nb_transport_ptr;
00211 BTransportPtr m_b_transport_ptr;
00212 TransportDbgPtr m_transport_dbg_ptr;
00213 GetDirectMem_ptr m_get_direct_mem_ptr;
00214 };
00215
00216 private:
00217 process m_process;
00218 };
00219
00220
00221 template <typename MODULE,
00222 unsigned int BUSWIDTH = 32,
00223 typename TYPES = tlm::tlm_base_protocol_types>
00224 class passthrough_target_socket_tagged :
00225 public tlm::tlm_target_socket<BUSWIDTH, TYPES>
00226 {
00227 public:
00228 typedef typename TYPES::tlm_payload_type transaction_type;
00229 typedef typename TYPES::tlm_phase_type phase_type;
00230 typedef tlm::tlm_sync_enum sync_enum_type;
00231 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
00232 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
00233 typedef tlm::tlm_target_socket<BUSWIDTH, TYPES> base_type;
00234
00235 public:
00236 explicit passthrough_target_socket_tagged(const char* n = "passthrough_target_socket_tagged") :
00237 base_type(sc_core::sc_gen_unique_name(n)),
00238 m_process(this->name())
00239 {
00240 bind(m_process);
00241 }
00242
00243
00244 void register_nb_transport_fw(MODULE* mod,
00245 sync_enum_type (MODULE::*cb)(int id,
00246 transaction_type&,
00247 phase_type&,
00248 sc_core::sc_time&),
00249 int id)
00250 {
00251 m_process.set_nb_transport_ptr(mod, cb);
00252 m_process.set_nb_transport_user_id(id);
00253 }
00254
00255 void register_b_transport(MODULE* mod,
00256 void (MODULE::*cb)(int id,
00257 transaction_type&,
00258 sc_core::sc_time&),
00259 int id)
00260 {
00261 m_process.set_b_transport_ptr(mod, cb);
00262 m_process.set_b_transport_user_id(id);
00263 }
00264
00265 void register_transport_dbg(MODULE* mod,
00266 unsigned int (MODULE::*cb)(int id,
00267 transaction_type&),
00268 int id)
00269 {
00270 m_process.set_transport_dbg_ptr(mod, cb);
00271 m_process.set_transport_dbg_user_id(id);
00272 }
00273
00274 void register_get_direct_mem_ptr(MODULE* mod,
00275 bool (MODULE::*cb)(int id,
00276 transaction_type&,
00277 tlm::tlm_dmi&),
00278 int id)
00279 {
00280 m_process.set_get_direct_mem_ptr(mod, cb);
00281 m_process.set_get_dmi_user_id(id);
00282 }
00283
00284 private:
00285 class process : public tlm::tlm_fw_transport_if<TYPES>
00286 {
00287 public:
00288 typedef sync_enum_type (MODULE::*NBTransportPtr)(int id,
00289 transaction_type&,
00290 phase_type&,
00291 sc_core::sc_time&);
00292 typedef void (MODULE::*BTransportPtr)(int id,
00293 transaction_type&,
00294 sc_core::sc_time&);
00295 typedef unsigned int (MODULE::*TransportDbgPtr)(int id,
00296 transaction_type&);
00297 typedef bool (MODULE::*GetDirectMem_ptr)(int id,
00298 transaction_type&,
00299 tlm::tlm_dmi&);
00300
00301 process(const std::string& name) :
00302 m_name(name),
00303 m_mod(0),
00304 m_nb_transport_ptr(0),
00305 m_b_transport_ptr(0),
00306 m_transport_dbg_ptr(0),
00307 m_get_direct_mem_ptr(0),
00308 m_nb_transport_user_id(0),
00309 m_b_transport_user_id(0),
00310 m_transport_dbg_user_id(0),
00311 m_get_dmi_user_id(0)
00312 {
00313 }
00314
00315 void set_nb_transport_user_id(int id) { m_nb_transport_user_id = id; }
00316 void set_b_transport_user_id(int id) { m_b_transport_user_id = id; }
00317 void set_transport_dbg_user_id(int id) { m_transport_dbg_user_id = id; }
00318 void set_get_dmi_user_id(int id) { m_get_dmi_user_id = id; }
00319
00320 void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
00321 {
00322 if (m_nb_transport_ptr) {
00323 std::cerr << m_name << ": non-blocking callback allready registered" << std::endl;
00324
00325 } else {
00326 assert(!m_mod || m_mod == mod);
00327 m_mod = mod;
00328 m_nb_transport_ptr = p;
00329 }
00330 }
00331
00332 void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
00333 {
00334 if (m_b_transport_ptr) {
00335 std::cerr << m_name << ": non-blocking callback allready registered" << std::endl;
00336
00337 } else {
00338 assert(!m_mod || m_mod == mod);
00339 m_mod = mod;
00340 m_b_transport_ptr = p;
00341 }
00342 }
00343
00344 void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
00345 {
00346 if (m_transport_dbg_ptr) {
00347 std::cerr << m_name << ": debug callback allready registered" << std::endl;
00348
00349 } else {
00350 assert(!m_mod || m_mod == mod);
00351 m_mod = mod;
00352 m_transport_dbg_ptr = p;
00353 }
00354 }
00355
00356 void set_get_direct_mem_ptr(MODULE* mod, GetDirectMem_ptr p)
00357 {
00358 if (m_get_direct_mem_ptr) {
00359 std::cerr << m_name << ": get DMI pointer callback allready registered" << std::endl;
00360
00361 } else {
00362 assert(!m_mod || m_mod == mod);
00363 m_mod = mod;
00364 m_get_direct_mem_ptr = p;
00365 }
00366 }
00367
00368 sync_enum_type nb_transport_fw(transaction_type& trans,
00369 phase_type& phase,
00370 sc_core::sc_time& t)
00371 {
00372 if (m_nb_transport_ptr) {
00373
00374 assert(m_mod);
00375 return (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, trans, phase, t);
00376
00377 } else {
00378 std::cerr << m_name << ": no non-blocking callback registered" << std::endl;
00379 assert(0); exit(1);
00380
00381 }
00382 }
00383
00384 void b_transport(transaction_type& trans, sc_core::sc_time& t)
00385 {
00386 if (m_b_transport_ptr) {
00387
00388 assert(m_mod);
00389 return (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, trans, t);
00390
00391 } else {
00392 std::cerr << m_name << ": no blocking callback registered" << std::endl;
00393 assert(0); exit(1);
00394
00395 }
00396 }
00397
00398 unsigned int transport_dbg(transaction_type& trans)
00399 {
00400 if (m_transport_dbg_ptr) {
00401
00402 assert(m_mod);
00403 return (m_mod->*m_transport_dbg_ptr)(m_transport_dbg_user_id, trans);
00404
00405 } else {
00406
00407 return 0;
00408 }
00409 }
00410
00411 bool get_direct_mem_ptr(transaction_type& trans,
00412 tlm::tlm_dmi& dmi_data)
00413 {
00414 if (m_get_direct_mem_ptr) {
00415
00416 assert(m_mod);
00417 return (m_mod->*m_get_direct_mem_ptr)(m_get_dmi_user_id, trans, dmi_data);
00418
00419 } else {
00420
00421 dmi_data.allow_read_write();
00422 dmi_data.set_start_address(0x0);
00423 dmi_data.set_end_address((sc_dt::uint64)-1);
00424 return false;
00425 }
00426 }
00427
00428 private:
00429 const std::string m_name;
00430 MODULE* m_mod;
00431 NBTransportPtr m_nb_transport_ptr;
00432 BTransportPtr m_b_transport_ptr;
00433 TransportDbgPtr m_transport_dbg_ptr;
00434 GetDirectMem_ptr m_get_direct_mem_ptr;
00435 int m_nb_transport_user_id;
00436 int m_b_transport_user_id;
00437 int m_transport_dbg_user_id;
00438 int m_get_dmi_user_id;
00439 };
00440
00441 private:
00442 process m_process;
00443 };
00444
00445 }
00446
00447 #endif