C:/ESLX/projects/TLMWG/tlm2/include/tlm/tlm_utils/passthrough_target_socket.h

Go to the documentation of this file.
00001 /*****************************************************************************
00002 
00003   The following code is derived, directly or indirectly, from the SystemC
00004   source code Copyright (c) 1996-2008 by all Contributors.
00005   All Rights reserved.
00006 
00007   The contents of this file are subject to the restrictions and limitations
00008   set forth in the SystemC Open Source License Version 3.0 (the "License");
00009   You may not use this file except in compliance with such restrictions and
00010   limitations. You may obtain instructions on how to receive a copy of the
00011   License at http://www.systemc.org/. Software distributed by Contributors
00012   under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
00013   ANY KIND, either express or implied. See the License for the specific
00014   language governing rights and limitations under the License.
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   // REGISTER_XXX
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         // forward call
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 //        return tlm::TLM_COMPLETED;   ///< unreachable code
00160       }
00161     }
00162 
00163     void b_transport(transaction_type& trans, sc_core::sc_time& t)
00164     {
00165       if (m_b_transport_ptr) {
00166         // forward call
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 //        return tlm::TLM_COMPLETED;   ///< unreachable code
00174       }
00175     }
00176 
00177     unsigned int transport_dbg(transaction_type& trans)
00178     {
00179       if (m_transport_dbg_ptr) {
00180         // forward call
00181         assert(m_mod);
00182         return (m_mod->*m_transport_dbg_ptr)(trans);
00183 
00184       } else {
00185         // No debug support
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         // forward call
00195         assert(m_mod);
00196         return (m_mod->*m_get_direct_mem_ptr)(trans, dmi_data);
00197 
00198       } else {
00199         // No DMI support
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 //ID Tagged version
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   // REGISTER_XXX
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         // forward call
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 //        return tlm::TLM_COMPLETED;   ///< unreachable code
00381       }
00382     }
00383 
00384     void b_transport(transaction_type& trans, sc_core::sc_time& t)
00385     {
00386       if (m_b_transport_ptr) {
00387         // forward call
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 //        return tlm::TLM_COMPLETED;   ///< unreachable code
00395       }
00396     }
00397 
00398     unsigned int transport_dbg(transaction_type& trans)
00399     {
00400       if (m_transport_dbg_ptr) {
00401         // forward call
00402         assert(m_mod);
00403         return (m_mod->*m_transport_dbg_ptr)(m_transport_dbg_user_id, trans);
00404 
00405       } else {
00406         // No debug support
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         // forward call
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         // No DMI support
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

Generated on Thu Jun 5 17:43:03 2008 for TLM 2 by  doxygen 1.5.3