27namespace tlm_utils 28{ 29 30template <typename MODULE, unsigned int BUSWIDTH, typename TYPES, 31 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND> 32class simple_initiator_socket_b : 33 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>, 34 protected simple_socket_base 35{ 36 public: 37 typedef typename TYPES::tlm_payload_type transaction_type; 38 typedef typename TYPES::tlm_phase_type phase_type; 39 typedef tlm::tlm_sync_enum sync_enum_type; 40 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; 41 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; 42 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type; 43 44 public: 45 static const char * 46 default_name() 47 { 48 return sc_core::sc_gen_unique_name("simple_initiator_socket"); 49 } 50 51 explicit simple_initiator_socket_b(const char *n=default_name()) : 52 base_type(n), m_process(this) 53 { 54 this->m_export.bind(m_process); 55 } 56 57 void 58 register_nb_transport_bw(MODULE *mod, 59 sync_enum_type (MODULE::*cb)(transaction_type &, phase_type &, 60 sc_core::sc_time &)) 61 { 62 m_process.set_transport_ptr(mod, cb); 63 } 64 65 void 66 register_invalidate_direct_mem_ptr(MODULE *mod, 67 void (MODULE::*cb)(sc_dt::uint64, sc_dt::uint64)) 68 { 69 m_process.set_invalidate_direct_mem_ptr(mod, cb); 70 } 71 72 private: 73 class process : public tlm::tlm_bw_transport_if<TYPES>, 74 protected convenience_socket_cb_holder 75 { 76 public: 77 typedef sync_enum_type (MODULE::*TransportPtr)( 78 transaction_type &, phase_type &, sc_core::sc_time &); 79 typedef void (MODULE::*InvalidateDirectMemPtr)( 80 sc_dt::uint64, sc_dt::uint64); 81 82 explicit process(simple_socket_base *owner) : 83 convenience_socket_cb_holder(owner), m_mod(0), 84 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0) 85 {} 86 87 void 88 set_transport_ptr(MODULE *mod, TransportPtr p) 89 { 90 if (m_transport_ptr) { 91 display_warning("non-blocking callback already registered"); 92 return; 93 } 94 sc_assert(!m_mod || m_mod == mod); 95 m_mod = mod; 96 m_transport_ptr = p; 97 } 98 99 void 100 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p) 101 { 102 if (m_invalidate_direct_mem_ptr) { 103 display_warning("invalidate DMI callback already registered"); 104 return; 105 } 106 sc_assert(!m_mod || m_mod == mod); 107 m_mod = mod; 108 m_invalidate_direct_mem_ptr = p; 109 } 110 111 sync_enum_type 112 nb_transport_bw(transaction_type &trans, phase_type &phase, 113 sc_core::sc_time &t) 114 { 115 if (m_transport_ptr) { 116 // Forward call. 117 sc_assert(m_mod); 118 return (m_mod->*m_transport_ptr)(trans, phase, t); 119 } 120 display_error("no transport callback registered"); 121 return tlm::TLM_COMPLETED; 122 } 123 124 void 125 invalidate_direct_mem_ptr(sc_dt::uint64 start_range, 126 sc_dt::uint64 end_range) 127 { 128 if (m_invalidate_direct_mem_ptr) { 129 // Forward call. 130 sc_assert(m_mod); 131 (m_mod->*m_invalidate_direct_mem_ptr)( 132 start_range, end_range); 133 } 134 } 135 136 private: 137 MODULE *m_mod; 138 TransportPtr m_transport_ptr; 139 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr; 140 }; 141 142 private: 143 const sc_core::sc_object *get_socket() const { return this; } 144 145 private: 146 process m_process; 147}; 148 149template <typename MODULE, unsigned int BUSWIDTH=32, 150 typename TYPES=tlm::tlm_base_protocol_types> 151class simple_initiator_socket : 152 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> 153{ 154 typedef simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> socket_b; 155 public: 156 simple_initiator_socket() : socket_b() {} 157 explicit simple_initiator_socket(const char *name) : socket_b(name) {} 158}; 159 160template <typename MODULE, unsigned int BUSWIDTH=32, 161 typename TYPES=tlm::tlm_base_protocol_types> 162class simple_initiator_socket_optional : 163 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES, 164 sc_core::SC_ZERO_OR_MORE_BOUND> 165{ 166 typedef simple_initiator_socket_b< 167 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b; 168 public: 169 simple_initiator_socket_optional() : socket_b() {} 170 explicit simple_initiator_socket_optional(const char *name) : 171 socket_b(name) 172 {} 173}; 174 175 176// Tagged version 177 178template <typename MODULE, unsigned int BUSWIDTH, typename TYPES, 179 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND> 180class simple_initiator_socket_tagged_b : 181 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>, 182 protected simple_socket_base 183{ 184 public: 185 typedef typename TYPES::tlm_payload_type transaction_type; 186 typedef typename TYPES::tlm_phase_type phase_type; 187 typedef tlm::tlm_sync_enum sync_enum_type; 188 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; 189 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; 190 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type; 191 192 public: 193 static const char * 194 default_name() 195 { 196 return sc_core::sc_gen_unique_name("simple_initiator_socket_tagged"); 197 } 198 199 explicit simple_initiator_socket_tagged_b(const char *n=default_name()) : 200 base_type(n), m_process(this) 201 { 202 this->m_export.bind(m_process); 203 } 204 205 void 206 register_nb_transport_bw(MODULE *mod, 207 sync_enum_type (MODULE::*cb)( 208 int, transaction_type &, phase_type &, sc_core::sc_time &), 209 int id) 210 { 211 m_process.set_transport_ptr(mod, cb); 212 m_process.set_transport_user_id(id); 213 } 214 215 void 216 register_invalidate_direct_mem_ptr(MODULE *mod, 217 void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64), int id) 218 { 219 m_process.set_invalidate_direct_mem_ptr(mod, cb); 220 m_process.set_invalidate_dmi_user_id(id); 221 } 222 223 private: 224 class process : public tlm::tlm_bw_transport_if<TYPES>, 225 protected convenience_socket_cb_holder 226 { 227 public: 228 typedef sync_enum_type (MODULE::*TransportPtr)( 229 int, transaction_type &, phase_type &, sc_core::sc_time &); 230 typedef void (MODULE::*InvalidateDirectMemPtr)( 231 int, sc_dt::uint64, sc_dt::uint64); 232 233 explicit process(simple_socket_base *owner) : 234 convenience_socket_cb_holder(owner), m_mod(0), 235 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0), 236 m_transport_user_id(0), m_invalidate_direct_mem_user_id(0) 237 {} 238 239 void set_transport_user_id(int id) { m_transport_user_id = id; } 240 void 241 set_invalidate_dmi_user_id(int id) 242 { 243 m_invalidate_direct_mem_user_id = id; 244 } 245 246 void 247 set_transport_ptr(MODULE *mod, TransportPtr p) 248 { 249 if (m_transport_ptr) { 250 display_warning("non-blocking callback already registered"); 251 return; 252 } 253 sc_assert(!m_mod || m_mod == mod); 254 m_mod = mod; 255 m_transport_ptr = p; 256 } 257 258 void 259 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p) 260 { 261 if (m_invalidate_direct_mem_ptr) { 262 display_warning("invalidate DMI callback already registered"); 263 return; 264 } 265 sc_assert(!m_mod || m_mod == mod); 266 m_mod = mod; 267 m_invalidate_direct_mem_ptr = p; 268 } 269 270 sync_enum_type 271 nb_transport_bw(transaction_type &trans, phase_type &phase, 272 sc_core::sc_time &t) 273 { 274 if (m_transport_ptr) { 275 // Forward call. 276 sc_assert(m_mod); 277 return (m_mod->*m_transport_ptr)( 278 m_transport_user_id, trans, phase, t); 279 } 280 display_error("no transport callback registered"); 281 return tlm::TLM_COMPLETED; 282 } 283 284 void 285 invalidate_direct_mem_ptr( 286 sc_dt::uint64 start_range, sc_dt::uint64 end_range) 287 { 288 if (m_invalidate_direct_mem_ptr) { 289 // Forward call. 290 sc_assert(m_mod); 291 (m_mod->*m_invalidate_direct_mem_ptr)( 292 m_invalidate_direct_mem_user_id, 293 start_range, end_range); 294 } 295 } 296 297 private: 298 MODULE *m_mod; 299 TransportPtr m_transport_ptr; 300 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr; 301 int m_transport_user_id; 302 int m_invalidate_direct_mem_user_id; 303 }; 304 305 private: 306 const sc_core::sc_object *get_socket() const { return this; } 307 308 private: 309 process m_process; 310}; 311 312template <typename MODULE, unsigned int BUSWIDTH=32, 313 typename TYPES=tlm::tlm_base_protocol_types> 314class simple_initiator_socket_tagged : 315 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES> 316{ 317 typedef simple_initiator_socket_tagged_b< 318 MODULE, BUSWIDTH, TYPES> socket_b; 319 public: 320 simple_initiator_socket_tagged() : socket_b() {} 321 explicit simple_initiator_socket_tagged(const char *name) : 322 socket_b(name) 323 {} 324}; 325 326template <typename MODULE, unsigned int BUSWIDTH=32, 327 typename TYPES=tlm::tlm_base_protocol_types> 328class simple_initiator_socket_tagged_optional : 329 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES, 330 sc_core::SC_ZERO_OR_MORE_BOUND> 331{ 332 typedef simple_initiator_socket_tagged_b< 333 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b; 334 public: 335 simple_initiator_socket_tagged_optional() : socket_b() {} 336 explicit simple_initiator_socket_tagged_optional(const char *name) : 337 socket_b(name) 338 {} 339}; 340 341} // namespace tlm_utils 342 343#endif /* __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__ */
| 31namespace tlm_utils 32{ 33 34template <typename MODULE, unsigned int BUSWIDTH, typename TYPES, 35 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND> 36class simple_initiator_socket_b : 37 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>, 38 protected simple_socket_base 39{ 40 public: 41 typedef typename TYPES::tlm_payload_type transaction_type; 42 typedef typename TYPES::tlm_phase_type phase_type; 43 typedef tlm::tlm_sync_enum sync_enum_type; 44 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; 45 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; 46 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type; 47 48 public: 49 static const char * 50 default_name() 51 { 52 return sc_core::sc_gen_unique_name("simple_initiator_socket"); 53 } 54 55 explicit simple_initiator_socket_b(const char *n=default_name()) : 56 base_type(n), m_process(this) 57 { 58 this->m_export.bind(m_process); 59 } 60 61 void 62 register_nb_transport_bw(MODULE *mod, 63 sync_enum_type (MODULE::*cb)(transaction_type &, phase_type &, 64 sc_core::sc_time &)) 65 { 66 m_process.set_transport_ptr(mod, cb); 67 } 68 69 void 70 register_invalidate_direct_mem_ptr(MODULE *mod, 71 void (MODULE::*cb)(sc_dt::uint64, sc_dt::uint64)) 72 { 73 m_process.set_invalidate_direct_mem_ptr(mod, cb); 74 } 75 76 private: 77 class process : public tlm::tlm_bw_transport_if<TYPES>, 78 protected convenience_socket_cb_holder 79 { 80 public: 81 typedef sync_enum_type (MODULE::*TransportPtr)( 82 transaction_type &, phase_type &, sc_core::sc_time &); 83 typedef void (MODULE::*InvalidateDirectMemPtr)( 84 sc_dt::uint64, sc_dt::uint64); 85 86 explicit process(simple_socket_base *owner) : 87 convenience_socket_cb_holder(owner), m_mod(0), 88 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0) 89 {} 90 91 void 92 set_transport_ptr(MODULE *mod, TransportPtr p) 93 { 94 if (m_transport_ptr) { 95 display_warning("non-blocking callback already registered"); 96 return; 97 } 98 sc_assert(!m_mod || m_mod == mod); 99 m_mod = mod; 100 m_transport_ptr = p; 101 } 102 103 void 104 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p) 105 { 106 if (m_invalidate_direct_mem_ptr) { 107 display_warning("invalidate DMI callback already registered"); 108 return; 109 } 110 sc_assert(!m_mod || m_mod == mod); 111 m_mod = mod; 112 m_invalidate_direct_mem_ptr = p; 113 } 114 115 sync_enum_type 116 nb_transport_bw(transaction_type &trans, phase_type &phase, 117 sc_core::sc_time &t) 118 { 119 if (m_transport_ptr) { 120 // Forward call. 121 sc_assert(m_mod); 122 return (m_mod->*m_transport_ptr)(trans, phase, t); 123 } 124 display_error("no transport callback registered"); 125 return tlm::TLM_COMPLETED; 126 } 127 128 void 129 invalidate_direct_mem_ptr(sc_dt::uint64 start_range, 130 sc_dt::uint64 end_range) 131 { 132 if (m_invalidate_direct_mem_ptr) { 133 // Forward call. 134 sc_assert(m_mod); 135 (m_mod->*m_invalidate_direct_mem_ptr)( 136 start_range, end_range); 137 } 138 } 139 140 private: 141 MODULE *m_mod; 142 TransportPtr m_transport_ptr; 143 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr; 144 }; 145 146 private: 147 const sc_core::sc_object *get_socket() const { return this; } 148 149 private: 150 process m_process; 151}; 152 153template <typename MODULE, unsigned int BUSWIDTH=32, 154 typename TYPES=tlm::tlm_base_protocol_types> 155class simple_initiator_socket : 156 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> 157{ 158 typedef simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> socket_b; 159 public: 160 simple_initiator_socket() : socket_b() {} 161 explicit simple_initiator_socket(const char *name) : socket_b(name) {} 162}; 163 164template <typename MODULE, unsigned int BUSWIDTH=32, 165 typename TYPES=tlm::tlm_base_protocol_types> 166class simple_initiator_socket_optional : 167 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES, 168 sc_core::SC_ZERO_OR_MORE_BOUND> 169{ 170 typedef simple_initiator_socket_b< 171 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b; 172 public: 173 simple_initiator_socket_optional() : socket_b() {} 174 explicit simple_initiator_socket_optional(const char *name) : 175 socket_b(name) 176 {} 177}; 178 179 180// Tagged version 181 182template <typename MODULE, unsigned int BUSWIDTH, typename TYPES, 183 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND> 184class simple_initiator_socket_tagged_b : 185 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>, 186 protected simple_socket_base 187{ 188 public: 189 typedef typename TYPES::tlm_payload_type transaction_type; 190 typedef typename TYPES::tlm_phase_type phase_type; 191 typedef tlm::tlm_sync_enum sync_enum_type; 192 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type; 193 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type; 194 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type; 195 196 public: 197 static const char * 198 default_name() 199 { 200 return sc_core::sc_gen_unique_name("simple_initiator_socket_tagged"); 201 } 202 203 explicit simple_initiator_socket_tagged_b(const char *n=default_name()) : 204 base_type(n), m_process(this) 205 { 206 this->m_export.bind(m_process); 207 } 208 209 void 210 register_nb_transport_bw(MODULE *mod, 211 sync_enum_type (MODULE::*cb)( 212 int, transaction_type &, phase_type &, sc_core::sc_time &), 213 int id) 214 { 215 m_process.set_transport_ptr(mod, cb); 216 m_process.set_transport_user_id(id); 217 } 218 219 void 220 register_invalidate_direct_mem_ptr(MODULE *mod, 221 void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64), int id) 222 { 223 m_process.set_invalidate_direct_mem_ptr(mod, cb); 224 m_process.set_invalidate_dmi_user_id(id); 225 } 226 227 private: 228 class process : public tlm::tlm_bw_transport_if<TYPES>, 229 protected convenience_socket_cb_holder 230 { 231 public: 232 typedef sync_enum_type (MODULE::*TransportPtr)( 233 int, transaction_type &, phase_type &, sc_core::sc_time &); 234 typedef void (MODULE::*InvalidateDirectMemPtr)( 235 int, sc_dt::uint64, sc_dt::uint64); 236 237 explicit process(simple_socket_base *owner) : 238 convenience_socket_cb_holder(owner), m_mod(0), 239 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0), 240 m_transport_user_id(0), m_invalidate_direct_mem_user_id(0) 241 {} 242 243 void set_transport_user_id(int id) { m_transport_user_id = id; } 244 void 245 set_invalidate_dmi_user_id(int id) 246 { 247 m_invalidate_direct_mem_user_id = id; 248 } 249 250 void 251 set_transport_ptr(MODULE *mod, TransportPtr p) 252 { 253 if (m_transport_ptr) { 254 display_warning("non-blocking callback already registered"); 255 return; 256 } 257 sc_assert(!m_mod || m_mod == mod); 258 m_mod = mod; 259 m_transport_ptr = p; 260 } 261 262 void 263 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p) 264 { 265 if (m_invalidate_direct_mem_ptr) { 266 display_warning("invalidate DMI callback already registered"); 267 return; 268 } 269 sc_assert(!m_mod || m_mod == mod); 270 m_mod = mod; 271 m_invalidate_direct_mem_ptr = p; 272 } 273 274 sync_enum_type 275 nb_transport_bw(transaction_type &trans, phase_type &phase, 276 sc_core::sc_time &t) 277 { 278 if (m_transport_ptr) { 279 // Forward call. 280 sc_assert(m_mod); 281 return (m_mod->*m_transport_ptr)( 282 m_transport_user_id, trans, phase, t); 283 } 284 display_error("no transport callback registered"); 285 return tlm::TLM_COMPLETED; 286 } 287 288 void 289 invalidate_direct_mem_ptr( 290 sc_dt::uint64 start_range, sc_dt::uint64 end_range) 291 { 292 if (m_invalidate_direct_mem_ptr) { 293 // Forward call. 294 sc_assert(m_mod); 295 (m_mod->*m_invalidate_direct_mem_ptr)( 296 m_invalidate_direct_mem_user_id, 297 start_range, end_range); 298 } 299 } 300 301 private: 302 MODULE *m_mod; 303 TransportPtr m_transport_ptr; 304 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr; 305 int m_transport_user_id; 306 int m_invalidate_direct_mem_user_id; 307 }; 308 309 private: 310 const sc_core::sc_object *get_socket() const { return this; } 311 312 private: 313 process m_process; 314}; 315 316template <typename MODULE, unsigned int BUSWIDTH=32, 317 typename TYPES=tlm::tlm_base_protocol_types> 318class simple_initiator_socket_tagged : 319 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES> 320{ 321 typedef simple_initiator_socket_tagged_b< 322 MODULE, BUSWIDTH, TYPES> socket_b; 323 public: 324 simple_initiator_socket_tagged() : socket_b() {} 325 explicit simple_initiator_socket_tagged(const char *name) : 326 socket_b(name) 327 {} 328}; 329 330template <typename MODULE, unsigned int BUSWIDTH=32, 331 typename TYPES=tlm::tlm_base_protocol_types> 332class simple_initiator_socket_tagged_optional : 333 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES, 334 sc_core::SC_ZERO_OR_MORE_BOUND> 335{ 336 typedef simple_initiator_socket_tagged_b< 337 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b; 338 public: 339 simple_initiator_socket_tagged_optional() : socket_b() {} 340 explicit simple_initiator_socket_tagged_optional(const char *name) : 341 socket_b(name) 342 {} 343}; 344 345} // namespace tlm_utils 346 347#endif /* __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__ */
|