ipxact-ruby 0.11.1

data/spec/test_data/spiritconsortium.org/Leon2TLM/PV/pv_initiator_port.tpp

@@ -0,0 +1,247 @@
+/* -*- C++ -*- */
+/*****************************************************************************
+  
+  Revision:    $Revision: 1506 $
+  Date:        $Date: 2009-04-26 01:51:56 -0500 (Sun, 26 Apr 2009) $
+  
+  Copyright (c) 2008, 2009 The SPIRIT Consortium.
+  
+  This work forms part of a deliverable of The SPIRIT Consortium.
+  
+  Use of these materials are governed by the legal terms and conditions
+  outlined in the disclaimer available from www.spiritconsortium.org.
+  
+  This source file is provided on an AS IS basis.  The SPIRIT
+  Consortium disclaims any warranty express or implied including
+  any warranty of merchantability and fitness for use for a
+  particular purpose.
+  
+  The user of the source file shall indemnify and hold The SPIRIT
+  Consortium and its members harmless from any damages or liability.
+  Users are requested to provide feedback to The SPIRIT Consortium
+  using either mailto:feedback@lists.spiritconsortium.org or the forms at 
+  http://www.spiritconsortium.org/about/contact_us/
+  
+  This file may be copied, and distributed, with or without
+  modifications; but this notice must be included on any copy.
+
+  The following code is derived, directly or indirectly, from the SystemC
+  source code Copyright (c) 1996-2004 by all Contributors.
+  All Rights reserved.
+
+  The contents of this file are subject to the restrictions and limitations
+  set forth in the SystemC Open Source License Version 2.4 (the "License");
+  You may not use this file except in compliance with such restrictions and
+  limitations. You may obtain instructions on how to receive a copy of the
+  License at http://www.systemc.org/. Software distributed by Contributors
+  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+  ANY KIND, either express or implied. See the License for the specific
+  language governing rights and limitations under the License.
+
+*****************************************************************************/
+
+/*------------------------------------------------------------------------------
+ * Includes							       
+ *----------------------------------------------------------------------------*/
+#include "pv_initiator_port.h"
+#include <string>
+
+
+
+//--------------
+// Constructor
+//--------------
+template<typename ADDRESS,typename DATA,int N>
+pv_initiator_port<ADDRESS,DATA,N>::pv_initiator_port(const char * port_name) :
+  sc_initiator_port_type(port_name)
+{}
+
+//---------------------------------------
+//  Execute the transaction transfer
+//---------------------------------------
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::do_transport(request_type& request,
+						response_type& response,
+						unsigned int target_port_rank)
+{
+  // Send initiator request to the target, functionnal call method using  -> operator of sc_port
+  // response = (*this)[target_port_rank]->transport(request);
+
+	pv_target_port<ADDRESS,DATA>& target_port = *(static_cast<pv_target_port<ADDRESS,DATA>* >(this->get_target_port_list()[target_port_rank]));
+  response = target_port->transport(request);
+}
+
+//-------------------------------
+// pv_tlm_if methods implementation
+//-------------------------------
+
+//----------------------------
+// Read access 
+template<typename ADDRESS,typename DATA,int N>
+tlm::tlm_status
+pv_initiator_port<ADDRESS,DATA,N>::read(const ADDRESS& address,
+					DATA& data,
+					const unsigned int byte_enable,
+					const tlm::tlm_mode mode,
+					const unsigned int export_id
+					)
+{
+  response_type response;
+  request_type request;
+  request.set_command(PV_READ);
+  request.set_address(address);
+
+  do_transport(request,response);
+
+  data = response.get_data();
+
+  return response.get_status();
+}
+
+//----------------------------
+// Write access
+template<typename ADDRESS,typename DATA,int N>
+tlm::tlm_status 
+pv_initiator_port<ADDRESS,DATA,N>::write(const ADDRESS& address,
+					 const DATA& data,
+					 const unsigned int byte_enable,
+					 const tlm::tlm_mode mode,
+					 const unsigned int export_id
+					 )
+{
+  response_type response;
+  request_type request;
+  request.set_command(PV_WRITE);
+  request.set_address(address);
+  request.set_data(data);
+
+  do_transport(request,response);
+
+  return(response.get_status());
+}
+
+
+template<typename ADDRESS,typename DATA,int N>
+bool
+pv_initiator_port<ADDRESS,DATA,N>::is_interface_bound_twice(sc_export_base& target_port_)
+{
+  for(int i=0;i<this->size();i++) {
+    if ((*this)[i] == target_port_.get_interface()) {
+      sc_object * tmp = dynamic_cast<sc_object * >(target_port_.get_interface());
+      std::string if_name;
+      if (tmp) if_name = tmp->name();
+      else if_name = "unnamed interface/non sc_object";
+
+      std::string msg(sc_object::name());
+      msg += (std::string)(": tlm_initiator_port warning, while binding the interface \"");
+      msg += if_name + (std::string)("\" exported by target port ");
+      msg += (std::string)(target_port_.name()) + (std::string)(": the initiator port is already bound to this interface\n");
+      SC_REPORT_WARNING("binding warning",msg.c_str());
+	
+      return(true);
+    }
+  }
+  return(false);
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::before_end_of_elaboration()
+{
+
+  // Registered target port list propagation (complete sharing of target_port_list between all initiator ports)
+  // If current port's target port list exist, share the list with all other port of the chain using the 
+  // reversed initiator port list.
+  if (m_target_port_list.size()) {
+    for(typename std::vector<initiator_port_base_type *>::iterator port = get_reversed_initiator_port_list().begin();
+	port != get_reversed_initiator_port_list().end();
+	port++) {		 
+
+      // Copy the target port(s) to the target port list of the registered initiator (port info. propagation)
+      if ((*port) != this) {
+	for(typename std::vector<target_port_base_type *>::iterator target_port = m_target_port_list.begin();
+	    target_port != m_target_port_list.end();
+	    target_port++) {
+	  (*port)->register_target_port((*target_port));
+	}
+      }
+    }
+  }
+
+  // Recreate the complete list of registered initiator_port, from deeper port to higher port (hierarchically speaking)
+  // Objective: deeper port is able to "see" all others but intermediate port cannot "see" deeper ports.
+  std::vector<initiator_port_base_type *> tmp_initiator_port_list; 
+  tmp_initiator_port_list.push_back(this);
+  this->create_port_list(tmp_initiator_port_list);
+  // replace the regular initiator port list: this list is now complete
+  this->set_initiator_port_list(tmp_initiator_port_list);
+}
+
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::end_of_elaboration()
+{
+  // Checks the target port list
+  if ((!get_target_port_list().size()) && this->size()) {
+    std::string msg(sc_object::name());
+    msg += (std::string)(": tlm_initiator_port error, target port list is empty. Initiator port should be bound at least to one target port\n");
+    SC_REPORT_ERROR("port end of elaboration",msg.c_str());
+  }
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::bind(pv_target_port_type& target_port_) {
+  if (!is_interface_bound_twice(target_port_))
+    // Registers the target port
+    register_target_port(&target_port_);
+    
+  // Calls sc_port standard bind() method 
+  sc_port_b<interface_type>::bind(target_port_);
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::operator() (pv_target_port_type& target_port_) {
+  bind(target_port_);
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::bind(sc_port_b<interface_type>& port_) {
+  // Register the bound port in the regular list
+  this->register_initiator_port(static_cast<pv_initiator_port_type *>(&port_));
+
+  // Bound port registers the current port. Used to share the target port list between all port before the end of elaboration
+  for(typename std::vector<initiator_port_base_type *>::iterator initiator_port = get_reversed_initiator_port_list().begin();
+      initiator_port != get_reversed_initiator_port_list().end();
+      initiator_port++) {
+    static_cast<pv_initiator_port_type *>(&port_)->reversed_register_initiator_port(*initiator_port);
+  }
+
+  // Calls sc_port standard bind() method 
+  sc_port_b<interface_type>::bind(port_);
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::operator() (sc_port_b<interface_type>& port_) {
+  bind(port_);
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::bind(interface_type& interface_) {
+  // Calls sc_port standard bind method
+  sc_port_b<interface_type>::bind(interface_);    
+}
+
+template<typename ADDRESS,typename DATA,int N>
+void
+pv_initiator_port<ADDRESS,DATA,N>::operator() (interface_type& interface_) {
+  sc_port_b<interface_type>::bind(interface_); 
+}
+
+/* END of pv_initiator_port.tpp */

data/spec/test_data/spiritconsortium.org/Leon2TLM/PV/pv_initiator_port_base.h

@@ -0,0 +1,189 @@
+/*****************************************************************************
+   Description: pv_initiator_port_base.h
+   Author:      The SPIRIT Consortium
+   Revision:    $Revision: 1506 $
+   Date:        $Date: 2009-04-26 01:51:56 -0500 (Sun, 26 Apr 2009) $
+
+   Copyright (c) 2008, 2009 The SPIRIT Consortium.
+
+   This work forms part of a deliverable of The SPIRIT Consortium.
+
+   Use of these materials are governed by the legal terms and conditions
+   outlined in the disclaimer available from www.spiritconsortium.org.
+
+   This source file is provided on an AS IS basis.  The SPIRIT
+   Consortium disclaims any warranty express or implied including
+   any warranty of merchantability and fitness for use for a
+   particular purpose.
+
+   The user of the source file shall indemnify and hold The SPIRIT
+   Consortium and its members harmless from any damages or liability.
+   Users are requested to provide feedback to The SPIRIT Consortium
+   using either mailto:feedback@lists.spiritconsortium.org or the forms at
+   http://www.spiritconsortium.org/about/contact_us/
+
+   This file may be copied, and distributed, with or without
+   modifications; but this notice must be included on any copy.
+   -----------------------------------------------------------------------------
+
+  The following code is derived, directly or indirectly, from the SystemC
+  source code Copyright (c) 1996-2004 by all Contributors.
+  All Rights reserved.
+
+  The contents of this file are subject to the restrictions and limitations
+  set forth in the SystemC Open Source License Version 2.4 (the "License");
+  You may not use this file except in compliance with such restrictions and
+  limitations. You may obtain instructions on how to receive a copy of the
+  License at http://www.systemc.org/. Software distributed by Contributors
+  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+  ANY KIND, either express or implied. See the License for the specific
+  language governing rights and limitations under the License.
+
+ *****************************************************************************/
+
+
+#ifndef _PV_INITIATOR_PORT_BASE_H_
+#define _PV_INITIATOR_PORT_BASE_H_
+
+
+/*------------------------------------------------------------------------------
+ * Includes
+ *----------------------------------------------------------------------------*/
+#include <vector>
+
+#include "systemc.h"
+
+#include "pv_target_port_base.h"
+
+
+  //----------------------------------------------------------------------------
+  /// Class pv_initiator_port_base: This class is a base class for pv_initiator_port.
+  /**
+   * \n It provides a container to store registered target ports as pointer list (required for target port ID propagation and
+   *    transaction recording).
+   * \n It provides also two containers to store registered initiator ports as pointer list:
+   *  - The first container registers initiator port from "deeper" initiator port to the the initiator
+   *    port directly bound to the interface. 
+   *  - The second list, named reversed list, allows the port directly bound to the interface to propagate its target
+   *    port list to "deeper" initiator ports. 
+   *
+   * \n Accessors are provided for all the port lists.
+   **/
+  //----------------------------------------------------------------------------
+  class pv_initiator_port_base {
+
+    typedef pv_initiator_port_base this_type;
+    typedef pv_target_port_base target_port_type;
+    
+  public:
+    
+    //--------------
+    // Constructor
+    //--------------
+    pv_initiator_port_base() {
+      // Adds the port itself to the reversed initiator port list
+      m_reversed_initiator_port_list.push_back(this);
+    }
+
+
+    //------------------------------------------
+    /// @name  Data members access methods
+    //------------------------------------------
+    /// @{
+    
+    /// Register the target port
+    inline void register_target_port(target_port_type * target_port) {
+      m_target_port_list.push_back(target_port);
+    }
+
+    /// Returns the vector of registered target port(s) 
+    inline std::vector<target_port_type *>& get_target_port_list() {
+      return(m_target_port_list);
+    }
+    
+    /// Sets the vector of registered target port(s) (port propagation)
+    inline void set_target_port_list(std::vector<target_port_type *>& target_port_list) {
+      m_target_port_list = target_port_list;
+    }
+
+    //---------------------------------------------------------------------------
+
+    /// Register the initiator port in the regular list
+    inline void register_initiator_port(this_type * initiator_port) {
+      m_initiator_port_list.push_back(initiator_port);
+    }
+
+    /// Returns the vector of registered initiator port(s) 
+    inline std::vector<this_type *>& get_initiator_port_list() {
+      return(m_initiator_port_list);
+    }
+
+    /// Sets the vector of registered initiator port(s) (port propagation)
+    inline void set_initiator_port_list(std::vector<this_type *>& initiator_port_list) {
+      m_initiator_port_list = initiator_port_list;
+    }
+
+    //---------------------------------------------------------------------------
+
+    /// Register the initiator port in the reversed list
+    inline void reversed_register_initiator_port(this_type * initiator_port) {
+      m_reversed_initiator_port_list.push_back(initiator_port);
+    }
+
+    /// Returns the vector of registered initiator port(s), reversed list 
+    inline std::vector<this_type *>& get_reversed_initiator_port_list() {
+      return(m_reversed_initiator_port_list);
+    }
+
+    /// Sets the vector of registered initiator port(s) (port propagation) reversed list
+    inline void set_reversed_initiator_port_list(std::vector<this_type *>& initiator_port_list) {
+      m_reversed_initiator_port_list = initiator_port_list;
+    }
+
+    /// @}
+
+
+  protected:
+
+    /// sc_export objects registration 
+    /**
+     * Direct registration of the bound target port(s) into current initiator port 
+     **/
+    std::vector<target_port_type *> m_target_port_list;
+    
+    
+    /// sc_port objects registration 
+    /**
+     * Direct registration of the bound initiator port into current initiator port
+     **/
+    std::vector<this_type *> m_initiator_port_list;
+
+    /// sc_port objects registration 
+    /**
+     * Direct registration of the current initiator port into the bound initiator port for 
+     * port propagation: all bound initiator ports get back the same target_port_list
+     **/
+    std::vector<this_type *> m_reversed_initiator_port_list;
+
+    /// Creates the initiator port list from a non NULL initiator_port_type * list
+    /** Reentreant function to create the complete list of bound initiator_port 
+     **/
+    void create_port_list(std::vector<this_type *>& port_list) {
+      assert(port_list.size() > 0);      
+      this_type& current_port = *port_list[(port_list.size()-1)];    
+      // For all the registed initiator port of the port
+      for (int i=0;i<(int)current_port.get_initiator_port_list().size();i++) {
+	// register only other ports (the list contains the port itself)
+	if (static_cast<this_type *>(&current_port) != current_port.get_initiator_port_list()[i]) {
+	  port_list.push_back(current_port.get_initiator_port_list()[i]); // register port
+	  this->create_port_list(port_list); // find again in the updated port list
+	}
+      }
+    }
+
+
+  };
+
+#endif /* _PV_INITIATOR_PORT_BASE_H_ */
+
+

data/spec/test_data/spiritconsortium.org/Leon2TLM/PV/pv_router.h

@@ -0,0 +1,205 @@
+/*****************************************************************************
+
+  Description: pv_router.h
+  Author:      The SPIRIT Consortium
+  Revision:    $Revision: 1506 $
+  Date:        $Date: 2009-04-26 01:51:56 -0500 (Sun, 26 Apr 2009) $
+
+  Copyright (c) 2008, 2009 The SPIRIT Consortium.
+
+  This work forms part of a deliverable of The SPIRIT Consortium.
+
+  Use of these materials are governed by the legal terms and conditions
+  outlined in the disclaimer available from www.spiritconsortium.org.
+
+  This source file is provided on an AS IS basis.  The SPIRIT
+  Consortium disclaims any warranty express or implied including
+  any warranty of merchantability and fitness for use for a
+  particular purpose.
+
+  The user of the source file shall indemnify and hold The SPIRIT
+  Consortium and its members harmless from any damages or liability.
+  Users are requested to provide feedback to The SPIRIT Consortium
+  using either mailto:feedback@lists.spiritconsortium.org or the forms at
+  http://www.spiritconsortium.org/about/contact_us/
+
+  This file may be copied, and distributed, with or without
+  modifications; but this notice must be included on any copy.
+
+  The following code is derived, directly or indirectly, from the SystemC
+  source code Copyright (c) 1996-2004 by all Contributors.
+  All Rights reserved.
+
+  The contents of this file are subject to the restrictions and limitations
+  set forth in the SystemC Open Source License Version 2.4 (the "License");
+  You may not use this file except in compliance with such restrictions and
+  limitations. You may obtain instructions on how to receive a copy of the
+  License at http://www.systemc.org/. Software distributed by Contributors
+  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+  ANY KIND, either express or implied. See the License for the specific
+  language governing rights and limitations under the License.
+
+*****************************************************************************/
+
+#ifndef _PV_ROUTER_H_
+#define _PV_ROUTER_H_
+
+
+/*------------------------------------------------------------------------------
+ * Includes							       
+ *----------------------------------------------------------------------------*/
+#include <string>
+#include <iostream>
+#include <sstream>
+
+#include "systemc.h"
+
+#include "pv_initiator_port.h"
+#include "pv_target_port.h"
+
+
+//----------------------------------------------------------------------------
+template<typename ADDRESS>
+class address_map {
+  
+public:
+  
+  //----------------------
+  // Constructors
+  //----------------------
+  address_map() : 
+    m_target_port_rank(0),
+    m_start_address(0),
+    m_end_address(0)
+  {}
+  
+  address_map(std::string& name,ADDRESS start,ADDRESS end) :
+    m_target_port_rank(0),
+    m_entry_port_name(name),
+    m_start_address(start),
+    m_end_address(end)
+  {}
+  
+  //--------------------------------------------------
+  // Accessors
+  //--------------------------------------------------
+  inline void set_target_port_rank(unsigned int target_port_rank) {m_target_port_rank = target_port_rank;}
+  inline unsigned int get_target_port_rank() const {return(m_target_port_rank);}
+
+  inline std::string& get_entry_port_name() {return(m_entry_port_name);}
+  inline void set_entry_port_name(const char * name) {m_entry_port_name = name;}
+  inline void set_entry_port_name(const std::string& name) {m_entry_port_name = name;}
+
+  inline ADDRESS get_start_address() const {return(m_start_address);}
+  inline void set_start_address(ADDRESS address) {m_start_address = address;}
+
+  inline ADDRESS get_end_address() const {return(m_end_address);}
+  inline void set_end_address(ADDRESS address) {m_end_address = address;}
+
+
+  //--------------------------------------------------------------
+  // Decode method used to check port address range
+  //--------------------------------------------------------------
+  /// Returns true if input address matches the port address range
+  inline bool decode(const ADDRESS& address) const {
+    return((address>=m_start_address)&&(address<=m_end_address));
+  }
+  
+protected:
+  
+  unsigned int m_target_port_rank;        // Target port binding rank (initiator port<->target port binding order)
+  std::string m_entry_port_name;          // Name of the mapfile port name entry corresponding to the address range
+  ADDRESS m_start_address;                // Start address
+  ADDRESS m_end_address;                  // End address
+};
+
+//----------------------------------------------------------------------------
+template<typename ADDRESS,typename DATA>
+class pv_router :
+  public sc_module,
+  public virtual tlm::tlm_transport_if<pv_request<ADDRESS,DATA>, pv_response<DATA> >
+{
+  typedef pv_request<ADDRESS,DATA> request_type;
+  typedef pv_response<DATA> response_type;
+
+  typedef tlm::tlm_transport_if<request_type,response_type> interface_type;
+
+  typedef pv_initiator_port<ADDRESS,DATA,0> initiator_port_type; // 0 allows this port to be bound to several interfaces
+  typedef pv_target_port<ADDRESS,DATA> target_port_type;
+
+  typedef address_map<ADDRESS> address_map_type; 
+
+public:
+
+  //--------------
+  // Module ports
+  //--------------
+  initiator_port_type initiator_port;   
+  target_port_type target_port;
+  
+  
+  //--------------
+  // Constructors
+  //--------------
+  pv_router(sc_module_name module_name,
+	    const char * map_filename = NULL
+	    );
+  
+  //-------------
+  // Destructor
+  //-------------
+  ~pv_router();
+
+
+
+  //-------------------------------------------------  
+  // sc_module method override
+  //-------------------------------------------------  
+  // Called by elaboration_done. Used here to load the mapfile when the SC binding is finished     
+  void end_of_elaboration();
+
+  //-------------------------------------------------  
+  // tlm_transport_if method implementation   
+  //-------------------------------------------------      
+  virtual response_type transport(const request_type& request);
+//  virtual void transport(const request_type& request,response_type& response );
+  
+  //-------------------------------------------------
+  // Load mapfile. Called at the end of elaboration
+  // Can be called again dirung the simulation -> remap
+  //-------------------------------------------------
+  bool load_mapfile(const char * filename);
+
+protected :
+
+  std::string m_map_filename;       // Name of the file containing the mapping informations
+  std::stringstream m_map_stream;   // Stringsteam containing the mapping information
+  std::vector<address_map_type *> m_address_map_list; // List of address_map objects
+
+  //--------------------------------------------------------------
+  /* If the given address matches one address map, returns a reference on 
+     the address map. The address parameter is modified: remove address map start address 
+  */
+  inline address_map_type * decode(ADDRESS& address) {
+    // For each registered & mapped target port
+    for(typename std::vector<address_map_type *>::iterator map = m_address_map_list.begin();
+	map != m_address_map_list.end();
+	map ++) {
+      if ((*map)->decode(address)) { 
+	address = address - (*map)->get_start_address();
+	return(*map);
+      }
+    }
+    return(NULL);
+  }
+
+};
+
+
+// Class implementation
+#include "./pv_router.tpp"
+
+
+#endif /* _PV_ROUTER_H_ */
+
+