ext: Include SystemC 2.3.1 into gem5

In the past it happened several times that some changes in gem5 broke the
SystemC coupling. Recently Accelera has changed the licence for SystemC
from their own licence to Apache2.0, which is compatible with gem5.
However, SystemC usually relies on the Boost library, but I was able to
exchange the boost calls by c++11 alternatives. The recent SystemC version
is placed into /ext and is integrated into gem5's build system. The goal is
to integrate some SystemC tests for the CI in some following patches.

Change-Id: I4b66ec806b5e3cffc1d7c85d3735ff4fa5b31fd0
Reviewed-on: https://gem5-review.googlesource.com/2240
Reviewed-by: Andreas Sandberg <andreas.sandberg@arm.com>
Maintainer: Andreas Sandberg <andreas.sandberg@arm.com>

39 files changed, 5321 insertions, 0 deletions

diff --git a/ext/systemc/src/tlm_core/tlm.pc.in b/ext/systemc/src/tlm_core/tlm.pc.in
new file mode 100644
index 000000000..2d3e55c7a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm.pc.in
@@ -0,0 +1,38 @@
+#  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.
+#
+# -------------------------------------------------------------------------
+#
+# tlm.pc.in --
+#    pkg-config definition file (template) for TLM-2.0
+#    (http://www.freedesktop.org/wiki/Software/pkg-config/)
+#
+# Author: Philipp A. Hartmann, OFFIS, 2013-05-07
+#
+# Note: The "real" definition (tlm.pc) is generated by "configure"
+#       during the build configuration.
+#
+# -------------------------------------------------------------------------
+#
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+
+Name: TLM-2.0
+Description: Accellera TLM-2.0 proof-of-concept library
+Version: @TLM_PACKAGE_VERSION@
+URL: @PACKAGE_URL@
+Requires: systemc >= 2.1.v1
+Cflags: -I${includedir}
diff --git a/ext/systemc/src/tlm_core/tlm_1/README.txt b/ext/systemc/src/tlm_core/tlm_1/README.txt
new file mode 100644
index 000000000..c7e1c5e1f
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/README.txt
@@ -0,0 +1,97 @@
+TLM-1.0 header files
+====================
+
+Dir: include/tlm_core/tlm_1/
+
+SubDirs: tlm_analysis/
+	 tlm_req_rsp/
+
+Files: README.txt
+
+
+Comments
+========
+
+User code should only #include the tlm or tlm.h header file in the include/
+directory and avoid including any of the include files in this directory
+directly.  All objects defined in this file hierarchy are in the tlm namespace.
+
+The header files are organizated, by subdirectory, as follows:
+
+
+tlm_analysis/ 
+--------------
+
+This contains the analysis interfaces, ports, and fifos. These files were not
+part of the original TLM-1.0 release, but have been grouped with TLM-1.0 in this
+release of TLM-2.0
+
+Files:
+  tlm_analysis.h        (includes the other header files in this directory )
+  tlm_analysis_fifo.h   (defines tlm_analysis_fifo )
+  tlm_analysis_if.h     (defines tlm_analysis_if and tlm_delayed_analysis_if )
+  tlm_analysis_port.h   (defines tlm_analysis_port )
+  tlm_analysis_triple.h (defines tlm_analysis_triple )
+  tlm_write_if.h        (defines tlm_write_if and tlm_delayed_write_if )
+
+
+tlm_req_rsp/
+------------
+
+This provides support for TLM modeling based on a request/response pair that 
+are passed by value. This is the original TLM 1.0 standard, with the addition 
+of an overloading of the blocking transport method with pass-by-reference arguments.
+
+Files:
+  tlm_req_rsp.h  (includes the key header files from the other directories)
+
+  tlm_1_interfaces/
+      tlm_core_ifs.h          (defines the TLM 1.0 core interfaces:
+					tlm_transport_if
+					tlm_blocking_get_if
+					tlm_blocking_put_if
+					tlm_nonblocking_get_if
+					tlm_nonblocking_put_if
+					tlm_get_if 
+					tlm_put_if 
+					tlm_blocking_peek_if
+					tlm_nonblocking_peek_if
+					tlm_peek_if 
+					tlm_blocking_get_peek_if 
+					tlm_nonblocking_get_peek_if 
+					tlm_get_peek_if              )     
+      tlm_fifo_ifs.h	     ( defines the TLM1.0 fifo interfaces:
+					tlm_fifo_debug_if			
+					tlm_fifo_put_if
+					tlm_fifo_get_if
+					tlm_fifo_config_size_if )
+      tlm_master_slave_ifs.h ( defines the TLM1.0 master slave interfaces:
+					tlm_blocking_master_if
+					tlm_blocking_slave_if
+					tlm_nonblocking_master_if
+					tlm_nonblocking_slave_if 
+					tlm_master_if 
+					tlm_slave_if )
+      tlm_tag.h	             ( defines tlm_tag )
+
+  tlm_ports/
+      tlm_nonblocking_port.h (defines tlm_nonblocking_put_port, 
+                                      tlm_nonblocking_get_port and
+				      tlm_nonblocking_peek_port )
+      tlm_event_finder.h     (defines tlm_event_finder_t )
+
+  tlm_channels/
+      tlm_fifo/
+          tlm_fifo.h         (defines tlm_fifo, includes the other files )
+          tlm_fifo_peek.h    (defines peek and poke interfaces for tlm_fifo )
+          tlm_fifo_put_get.h (defines put and get interfaces for tlm_fifo )
+          tlm_fifo_resize.h  (defines expand, reduce, bound and unbound
+	                      interfaces for tlm_fifo )
+          circular_buffer.h  (defines circular buffer used by tlm_fifo )
+      tlm_req_rsp_channels/
+          tlm_req_rsp_channels.h (defines tlm_req_rsp_channel and
+	  			          tlm_transport_channel )
+          tlm_put_get_imp.h      (contains implementatins used by the channels)
+
+  tlm_adapters/
+  	tlm_adapters.h  (defines transport_to_master and tlm_slave_to_transport)
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h
new file mode 100644
index 000000000..777f7141a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h
@@ -0,0 +1,33 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_H__
+#define __TLM_ANALYSIS_H__
+
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_write_if.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h"
+
+#endif 
+
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h
new file mode 100644
index 000000000..1f01b2a8e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h
@@ -0,0 +1,54 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_FIFO_H__
+#define __TLM_ANALYSIS_FIFO_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h"
+
+namespace tlm {
+
+template< typename T >
+class tlm_analysis_fifo :
+  public tlm_fifo< T > ,
+  public virtual tlm_analysis_if< T > ,
+  public virtual tlm_analysis_if< tlm_analysis_triple< T > > {
+
+ public:
+
+ // analysis fifo is an unbounded tlm_fifo
+
+  tlm_analysis_fifo( const char *nm ) : tlm_fifo<T>( nm , -16 ) {}
+  tlm_analysis_fifo() : tlm_fifo<T>( -16 ) {}
+
+  void write( const tlm_analysis_triple<T> &t ) {
+    nb_put( t );
+  }
+
+  void write( const T &t ) {
+    nb_put( t );
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h
new file mode 100644
index 000000000..bc24fee54
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h
@@ -0,0 +1,39 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_IF_H__
+#define __TLM_ANALYSIS_IF_H__
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_write_if.h"
+
+namespace tlm {
+
+template < typename T >
+class tlm_analysis_if : public virtual tlm_write_if<T>
+{
+};
+
+template < typename T >
+class tlm_delayed_analysis_if : public virtual tlm_delayed_write_if<T>
+{
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h
new file mode 100644
index 000000000..999092538
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h
@@ -0,0 +1,84 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_PORT_H__
+#define __TLM_ANALYSIS_PORT_H__
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+#include <deque>
+#include <algorithm>
+
+namespace tlm {
+
+
+template < typename T>
+class tlm_analysis_port :
+  public sc_core::sc_object ,
+  public virtual tlm_analysis_if< T >
+{
+ public:
+  tlm_analysis_port() : sc_core::sc_object() {}
+  tlm_analysis_port( const char *nm ) : sc_core::sc_object( nm ) {}
+
+  // bind and () work for both interfaces and analysis ports, since
+  // analysis ports implement the analysis interface
+
+  virtual void bind( tlm_analysis_if<T> &_if ) {
+    m_interfaces.push_back( &_if );
+  }
+
+  void operator() ( tlm_analysis_if<T> &_if ) { bind( _if ); }
+
+  virtual bool unbind( tlm_analysis_if<T> &_if ) {
+
+    typename std::deque< tlm_analysis_if<T> * >::iterator i
+      = std::remove( m_interfaces.begin(), m_interfaces.end(), &_if );
+
+    if( i != m_interfaces.end() ) {
+      m_interfaces.erase(i, m_interfaces.end() );
+      return 1;
+    }
+
+    return 0;
+
+  }
+
+  void write( const T &t ) {
+    typename std::deque< tlm_analysis_if<T> * >::iterator i;
+
+    for( i = m_interfaces.begin();
+   i != m_interfaces.end();
+   i++ ) {
+
+      (*i)->write( t );
+
+    }
+
+  }
+
+ private:
+  std::deque< tlm_analysis_if<T> * > m_interfaces;
+
+};
+
+} // namespace tlm
+
+#endif
+
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h
new file mode 100644
index 000000000..f65a25a2e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h
@@ -0,0 +1,53 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_TRIPLE_H__
+#define __TLM_ANALYSIS_TRIPLE_H__
+
+//#include <systemc>
+
+namespace tlm {
+
+template< typename T>
+struct tlm_analysis_triple {
+
+  sc_core::sc_time start_time;
+  T transaction;
+  sc_core::sc_time end_time;
+
+  tlm_analysis_triple() {}
+
+  tlm_analysis_triple( const tlm_analysis_triple &triple ) {
+    start_time = triple.start_time;
+    transaction = triple.transaction;
+    end_time = triple.end_time;
+  }
+
+  tlm_analysis_triple( const T &t ) {
+    transaction = t;
+  }
+
+  operator T() { return transaction; }
+  operator const T &() const { return transaction; }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h
new file mode 100644
index 000000000..b66a591bc
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h
@@ -0,0 +1,42 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_WRITE_IF_H__
+#define __TLM_WRITE_IF_H__
+
+#include <systemc>
+
+namespace tlm {
+
+template <typename T>
+class tlm_write_if : public virtual sc_core::sc_interface {
+public:
+  virtual void write(const T& t) = 0;
+};
+
+template <typename T>
+class tlm_delayed_write_if : public virtual sc_core::sc_interface {
+public:
+  virtual void write(const T& t, const sc_core::sc_time& time) = 0;
+};
+
+} // namespace tlm
+
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h
new file mode 100644
index 000000000..4c1340338
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h
@@ -0,0 +1,149 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : This is the core of the TLM standard
+//
+
+
+#ifndef __TLM_CORE_IFS_H__
+#define __TLM_CORE_IFS_H__
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h"
+
+namespace tlm {
+
+// bidirectional blocking interfaces
+
+template < typename REQ , typename RSP >
+class tlm_transport_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual RSP transport( const REQ & ) = 0;
+
+  virtual void transport( const REQ &req , RSP &rsp ) {
+    rsp = transport( req );
+  }
+
+};
+
+
+// uni-directional blocking interfaces
+
+template < typename T >
+class tlm_blocking_get_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual T get( tlm_tag<T> *t = 0 ) = 0;
+  virtual void get( T &t ) { t = get(); }
+
+};
+
+template < typename T >
+class tlm_blocking_put_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void put( const T &t ) = 0;
+};
+
+// uni-directional non blocking interfaces
+
+template < typename T >
+class tlm_nonblocking_get_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_get( T &t ) = 0;
+  virtual bool nb_can_get( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_get( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+template < typename T >
+class tlm_nonblocking_put_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_put( const T &t ) = 0;
+  virtual bool nb_can_put( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_put( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+
+// combined uni-directional blocking and non blocking
+
+template < typename T >
+class tlm_get_if :
+  public virtual tlm_blocking_get_if< T > ,
+  public virtual tlm_nonblocking_get_if< T > {};
+
+template < typename T >
+class tlm_put_if :
+  public virtual tlm_blocking_put_if< T > ,
+  public virtual tlm_nonblocking_put_if< T > {};
+
+
+// peek interfaces
+
+template < typename T >
+class tlm_blocking_peek_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual T peek( tlm_tag<T> *t = 0 ) const = 0;
+  virtual void peek( T &t ) const { t = peek(); }
+
+};
+
+template < typename T >
+class tlm_nonblocking_peek_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_peek( T &t ) const = 0;
+  virtual bool nb_can_peek( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_peek( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+template < typename T >
+class tlm_peek_if :
+  public virtual tlm_blocking_peek_if< T > ,
+  public virtual tlm_nonblocking_peek_if< T > {};
+
+// get_peek interfaces
+
+template < typename T >
+class tlm_blocking_get_peek_if :
+  public virtual tlm_blocking_get_if<T> ,
+  public virtual tlm_blocking_peek_if<T> {};
+
+template < typename T >
+class tlm_nonblocking_get_peek_if :
+  public virtual tlm_nonblocking_get_if<T> ,
+  public virtual tlm_nonblocking_peek_if<T> {};
+
+
+template < typename T >
+class tlm_get_peek_if :
+  public virtual tlm_get_if<T> ,
+  public virtual tlm_peek_if<T> ,
+  public virtual tlm_blocking_get_peek_if<T> ,
+  public virtual tlm_nonblocking_get_peek_if<T>
+  {};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h
new file mode 100644
index 000000000..d9b2b985b
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h
@@ -0,0 +1,85 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : These interfaces are channel specific interfaces
+// useful in the context of tlm_fifo.
+//
+
+#ifndef __TLM_FIFO_IFS_H__
+#define __TLM_FIFO_IFS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+
+namespace tlm {
+
+//
+// Fifo specific interfaces
+//
+
+// Fifo Debug Interface
+
+template< typename T >
+class tlm_fifo_debug_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual int used() const = 0;
+  virtual int size() const = 0;
+  virtual void debug() const = 0;
+
+  //
+  // non blocking peek and poke - no notification
+  //
+  // n is index of data :
+  // 0 <= n < size(), where 0 is most recently written, and size() - 1
+  // is oldest ie the one about to be read.
+  //
+
+  virtual bool nb_peek( T & , int n ) const = 0;
+  virtual bool nb_poke( const T & , int n = 0 ) = 0;
+
+};
+
+// fifo interfaces = extended + debug
+
+template < typename T >
+class tlm_fifo_put_if :
+  public virtual tlm_put_if<T> ,
+  public virtual tlm_fifo_debug_if<T> {};
+
+template < typename T >
+class tlm_fifo_get_if :
+  public virtual tlm_get_peek_if<T> ,
+  public virtual tlm_fifo_debug_if<T> {};
+
+class tlm_fifo_config_size_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void nb_expand( unsigned int n = 1 ) = 0;
+  virtual void nb_unbound( unsigned int n = 16 ) = 0;
+
+  virtual bool nb_reduce( unsigned int n = 1 ) = 0;
+  virtual bool nb_bound( unsigned int n ) = 0;
+
+};
+
+} // namespace tlm
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h
new file mode 100644
index 000000000..5bac3c877
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h
@@ -0,0 +1,73 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_MASTER_SLAVE_IFS_H__
+#define __TLM_MASTER_SLAVE_IFS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+
+namespace tlm {
+
+//
+// req/rsp combined interfaces
+//
+
+// blocking
+
+template < typename REQ , typename RSP>
+class tlm_blocking_master_if :
+  public virtual tlm_blocking_put_if< REQ > ,
+  public virtual tlm_blocking_get_peek_if< RSP > {};
+
+template < typename REQ , typename RSP>
+class tlm_blocking_slave_if :
+  public virtual tlm_blocking_put_if< RSP > ,
+  public virtual tlm_blocking_get_peek_if< REQ > {};
+
+// nonblocking
+
+template < typename REQ , typename RSP >
+class tlm_nonblocking_master_if :
+  public virtual tlm_nonblocking_put_if< REQ > ,
+  public virtual tlm_nonblocking_get_peek_if< RSP > {};
+
+template < typename REQ , typename RSP >
+class tlm_nonblocking_slave_if :
+  public virtual tlm_nonblocking_put_if< RSP > ,
+  public virtual tlm_nonblocking_get_peek_if< REQ > {};
+
+// combined
+
+template < typename REQ , typename RSP >
+class tlm_master_if :
+  public virtual tlm_put_if< REQ > ,
+  public virtual tlm_get_peek_if< RSP > ,
+  public virtual tlm_blocking_master_if< REQ , RSP > ,
+  public virtual tlm_nonblocking_master_if< REQ , RSP > {};
+
+template < typename REQ , typename RSP >
+class tlm_slave_if :
+  public virtual tlm_put_if< RSP > ,
+  public virtual tlm_get_peek_if< REQ > ,
+  public virtual tlm_blocking_slave_if< REQ , RSP > ,
+  public virtual tlm_nonblocking_slave_if< REQ , RSP > {};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h
new file mode 100644
index 000000000..230b77d17
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h
@@ -0,0 +1,31 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : This is part of the core TLM standard
+//
+
+#ifndef __TLM_TAG_H__
+#define __TLM_TAG_H__
+
+namespace tlm {
+template<class  T> class tlm_tag {};
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h
new file mode 100644
index 000000000..13207187a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h
@@ -0,0 +1,105 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ADAPTERS_H__
+#define __TLM_ADAPTERS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+namespace tlm {
+
+template< typename REQ , typename RSP >
+class tlm_transport_to_master :
+  public sc_core::sc_module ,
+  public virtual tlm_transport_if< REQ , RSP >
+{
+public:
+  sc_core::sc_export< tlm_transport_if< REQ , RSP > > target_export;
+  sc_core::sc_port< tlm_master_if< REQ , RSP > > master_port;
+
+  tlm_transport_to_master( sc_core::sc_module_name nm ) :
+    sc_core::sc_module( nm ) {
+
+    target_export( *this );
+
+  }
+
+  tlm_transport_to_master() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name( "transport_to_master" ) ) ){
+
+    target_export( *this );
+
+  }
+
+  RSP transport( const REQ &req ) {
+
+    mutex.lock();
+
+    master_port->put( req );
+    rsp = master_port->get();
+
+    mutex.unlock();
+    return rsp;
+
+  }
+
+private:
+  sc_core::sc_mutex mutex;
+  RSP rsp;
+
+};
+
+template< typename REQ , typename RSP >
+class tlm_slave_to_transport : public sc_core::sc_module
+{
+public:
+
+  SC_HAS_PROCESS( tlm_slave_to_transport );
+
+  sc_core::sc_port< tlm_slave_if< REQ , RSP > > slave_port;
+  sc_core::sc_port< tlm_transport_if< REQ , RSP > > initiator_port;
+
+  tlm_slave_to_transport( sc_core::sc_module_name nm ) : sc_core::sc_module( nm )
+  {}
+
+  tlm_slave_to_transport() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("slave_to_transport") ) )
+  {}
+
+private:
+  void run() {
+
+    REQ req;
+    RSP rsp;
+
+    while( true ) {
+
+     slave_port->get( req );
+     rsp = initiator_port->transport( req );
+     slave_port->put( rsp );
+
+    }
+
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h
new file mode 100644
index 000000000..68c3c2c1f
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h
@@ -0,0 +1,268 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+//
+// To the LRM writer : this class is purely an artifact of the implementation.
+//
+
+#ifndef __CIRCULAR_BUFFER_H__
+#define __CIRCULAR_BUFFER_H__
+
+#include <iostream>
+
+namespace tlm {
+
+template < typename T >
+class circular_buffer
+{
+public:
+
+  explicit
+  circular_buffer( int size = 0 );
+  ~circular_buffer();
+
+  void resize( int size );
+  void clear();
+
+  T read();
+  void write( const T & );
+
+  bool is_empty() const { return used() == 0; }
+  bool is_full() const { return free() == 0; }
+
+  int size() const { return m_size; }
+  int used() const { return m_used; }
+  int free() const { return m_free; }
+
+  const T& read_data() const
+    { return buf_read( m_buf, m_ri ); }
+
+  const T& peek_data( int i ) const
+    { return buf_read( m_buf, (m_ri + i) % size() ); }
+
+  T & poke_data( int i )
+    { return buf_read( m_buf , (m_wi + i) % size() ); }
+
+  void debug() const;
+
+private:
+  void increment_write_pos( int i = 1 );
+  void increment_read_pos( int i = 1 );
+
+  void init();
+
+  circular_buffer( const circular_buffer<T> &b );              // disabled
+  circular_buffer<T> &operator=( const circular_buffer<T> & ); // disabled
+
+  void* buf_alloc( int size );
+  void  buf_free( void*& buf );
+  void  buf_write( void* buf, int n, const T & t );
+  T&    buf_read( void* buf, int n ) const;
+  void  buf_clear( void* buf, int n );
+
+private:
+  int    m_size;                   // size of the buffer
+  void*  m_buf;                    // the buffer
+  int    m_free;                   // number of free spaces
+  int    m_used;                   // number of used spaces
+  int    m_ri;                     // index of next read
+  int    m_wi;                     // index of next write
+
+};
+
+template< typename T >
+void
+circular_buffer<T>::debug() const
+{
+
+  std::cout << "Buffer debug" << std::endl;
+  std::cout << "Size : " << size() << std::endl;
+  std::cout << "Free/Used " << free() << "/" << used() << std::endl;
+  std::cout << "Indices : r/w = " << m_ri << "/" << m_wi << std::endl;
+
+  if( is_empty() ) {
+
+    std::cout << "empty" << std::endl;
+
+  }
+
+  if( is_full() ) {
+
+    std::cout << "full" << std::endl;
+
+  }
+
+  std::cout << "Data : " << std::endl;
+  for( int i = 0; i < used(); i++ ) {
+
+    std::cout << peek_data( i ) << std::endl;
+
+  }
+
+
+}
+
+template < typename T >
+circular_buffer<T>::circular_buffer( int size )
+  : m_size(size)
+  , m_buf(0)
+{
+  init();
+
+}
+
+template < typename T >
+void
+circular_buffer<T>::clear()
+{
+  for( int i=0; i < used(); i++ ) {
+    buf_clear( m_buf, i );
+  }
+  m_free = m_size;
+  m_used = m_ri = m_wi = 0;
+}
+
+template < typename T >
+circular_buffer<T>::~circular_buffer()
+{
+  clear();
+  buf_free( m_buf );
+}
+
+template < typename T >
+void
+circular_buffer<T>::resize( int size )
+{
+
+  int i;
+  void * new_buf = buf_alloc(size);
+
+  for( i = 0; i < size && i < used(); i++ ) {
+
+    buf_write( new_buf, i, peek_data( i ) );
+    buf_clear( m_buf, (m_ri + i) % m_size );
+
+  }
+
+  buf_free( m_buf );
+
+  m_size = size;
+  m_ri   = 0;
+  m_wi   = i % m_size;
+  m_used = i;
+  m_free = m_size - m_used;
+
+  m_buf  = new_buf;
+}
+
+
+template < typename T >
+void
+circular_buffer<T>::init() {
+
+  if( m_size > 0 ) {
+    m_buf = buf_alloc( m_size );
+  }
+
+  m_free = m_size;
+  m_used = 0;
+  m_ri = 0;
+  m_wi = 0;
+
+}
+
+template < typename T >
+T
+circular_buffer<T>::read()
+{
+  T t = read_data();
+
+  buf_clear( m_buf, m_ri );
+  increment_read_pos();
+
+  return t;
+}
+
+template < typename T >
+void
+circular_buffer<T>::write( const T &t )
+{
+  buf_write( m_buf, m_wi, t );
+  increment_write_pos();
+}
+
+
+template < typename T >
+void
+circular_buffer<T>::increment_write_pos( int i ) {
+
+  m_wi = ( m_wi + i ) % m_size;
+  m_used += i;
+  m_free -= i;
+
+}
+
+template < typename T >
+void
+circular_buffer<T>::increment_read_pos( int i ) {
+
+  m_ri = ( m_ri + i ) % m_size;
+  m_used -= i;
+  m_free += i;
+
+}
+
+template < typename T >
+inline void*
+circular_buffer<T>::buf_alloc( int size )
+    { return new unsigned char[ size * sizeof(T) ]; }
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_free( void* & buf )
+    { delete [] static_cast<unsigned char*>(buf); buf = 0; }
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_write( void* buf, int n, const T & t )
+{
+  T* p = static_cast<T*>(buf) + n;
+  new (p) T(t);
+}
+
+template < typename T >
+inline T&
+circular_buffer<T>::buf_read( void* buf, int n ) const
+{
+  T* p = static_cast<T*>(buf) + n;
+  return *p;
+}
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_clear( void* buf, int n )
+{
+  T* p = static_cast<T*>(buf) + n;
+  p->~T();
+}
+
+} // namespace tlm
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h
new file mode 100644
index 000000000..7b44a32ee
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h
@@ -0,0 +1,263 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_H__
+#define __TLM_FIFO_H__
+
+//
+// This implements put, get and peek
+//
+// It also implements 0 and infinite size fifos - but the size
+// zero fifos aren't rendezvous like zero length fifos, they simply are both
+// full and empty at the same time.
+//
+// The size can be dynamically changed using the resize interface
+//
+// To get an infinite fifo use a -ve size in the constructor.
+// The absolute value of the size is taken as the starting size of the
+// actual physical buffer.
+//
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h"
+
+namespace tlm {
+
+template <typename T>
+class tlm_fifo :
+  public virtual tlm_fifo_get_if<T>,
+  public virtual tlm_fifo_put_if<T>,
+  public sc_core::sc_prim_channel
+{
+public:
+
+    // constructors
+
+    explicit tlm_fifo( int size_ = 1 )
+      : sc_core::sc_prim_channel( sc_core::sc_gen_unique_name( "fifo" ) ) {
+
+      init( size_ );
+
+    }
+
+    explicit tlm_fifo( const char* name_, int size_ = 1 )
+      : sc_core::sc_prim_channel( name_ ) {
+
+      init( size_ );
+
+    }
+
+    // destructor
+
+    virtual ~tlm_fifo() {}
+
+    // tlm get interface
+
+    T get( tlm_tag<T> * = 0 );
+
+    bool nb_get( T& );
+    bool nb_can_get( tlm_tag<T> * = 0 ) const;
+    const sc_core::sc_event &ok_to_get( tlm_tag<T> * = 0 ) const {
+      return m_data_written_event;
+    }
+
+    // tlm peek interface
+
+    T peek( tlm_tag<T> * = 0 ) const;
+
+    bool nb_peek( T& ) const;
+    bool nb_can_peek( tlm_tag<T> * = 0 ) const;
+    const sc_core::sc_event &ok_to_peek( tlm_tag<T> * = 0 ) const {
+      return m_data_written_event;
+    }
+
+    // tlm put interface
+
+    void put( const T& );
+
+    bool nb_put( const T& );
+    bool nb_can_put( tlm_tag<T> * = 0 ) const;
+
+    const sc_core::sc_event& ok_to_put( tlm_tag<T> * = 0 ) const {
+      return m_data_read_event;
+    }
+
+    // resize if
+
+    void nb_expand( unsigned int n = 1 );
+    void nb_unbound( unsigned int n = 16 );
+
+    bool nb_reduce( unsigned int n = 1 );
+    bool nb_bound( unsigned int n );
+
+    // debug interface
+
+    bool nb_peek( T & , int n ) const;
+    bool nb_poke( const T & , int n = 0 );
+
+    int used() const {
+      return m_num_readable - m_num_read;
+    }
+
+    int size() const {
+      return m_size;
+    }
+
+    void debug() const {
+
+      if( is_empty() ) std::cout << "empty" << std::endl;
+      if( is_full() ) std::cout << "full" << std::endl;
+
+      std::cout << "size " << size() << " - " << used() << " used "
+                << std::endl;
+      std::cout << "readable " << m_num_readable
+                << std::endl;
+      std::cout << "written/read " << m_num_written << "/" << m_num_read
+                << std::endl;
+
+    }
+
+    // support functions
+
+    static const char* const kind_string;
+
+    const char* kind() const
+        { return kind_string; }
+
+
+protected:
+    sc_core::sc_event &read_event( tlm_tag<T> * = 0 ) {
+      return m_data_read_event;
+    }
+
+protected:
+
+    void update();
+
+    // support methods
+
+    void init( int );
+
+protected:
+
+    circular_buffer<T> buffer;
+
+    int m_size;                  // logical size of fifo
+
+    int m_num_readable;          // #samples readable
+    int m_num_read;          // #samples read during this delta cycle
+    int m_num_written;           // #samples written during this delta cycle
+    bool m_expand;               // has an expand occurred during this delta cycle ?
+    int m_num_read_no_notify;    // #samples read without notify during this delta cycle
+
+    sc_core::sc_event m_data_read_event;
+    sc_core::sc_event m_data_written_event;
+
+private:
+
+    // disabled
+    tlm_fifo( const tlm_fifo<T>& );
+    tlm_fifo& operator = ( const tlm_fifo<T>& );
+
+    //
+    // use nb_can_get() and nb_can_put() rather than the following two
+    // private functions
+    //
+
+    bool is_empty() const {
+      return used() == 0;
+    }
+
+    bool is_full() const {
+      //return size() == m_num_readable + m_num_written; // Old buggy code
+      if( size() < 0 )
+        return false;
+      else
+        return size() <= m_num_readable + m_num_written;
+    }
+
+};
+
+template <typename T>
+const char* const tlm_fifo<T>::kind_string = "tlm_fifo";
+
+
+/******************************************************************
+//
+// init and update
+//
+******************************************************************/
+
+template< typename T >
+inline
+void
+tlm_fifo<T>::init( int size_ ) {
+
+  if( size_ > 0 ) {
+    buffer.resize( size_ );
+  }
+
+  else if( size_ < 0 ) {
+    buffer.resize( -size_ );
+  }
+
+  else {
+    buffer.resize( 16 );
+  }
+
+  m_size = size_;
+  m_num_readable = 0;
+  m_num_read = 0;
+  m_num_written = 0;
+  m_expand = false;
+  m_num_read_no_notify = false;
+
+}
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::update()
+{
+    if( m_num_read > m_num_read_no_notify || m_expand ) {
+  m_data_read_event.notify( sc_core::SC_ZERO_TIME );
+    }
+
+    if( m_num_written > 0 ) {
+  m_data_written_event.notify( sc_core::SC_ZERO_TIME );
+    }
+
+    m_expand = false;
+    m_num_read = 0;
+    m_num_written = 0;
+    m_num_readable = buffer.used();
+    m_num_read_no_notify = 0;
+
+}
+
+} // namespace tlm
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h
new file mode 100644
index 000000000..e856c5657
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h
@@ -0,0 +1,98 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_PEEK_H__
+#define __TLM_FIFO_PEEK_H__
+
+namespace tlm {
+
+template < typename T>
+inline
+T
+tlm_fifo<T>::peek( tlm_tag<T> * ) const {
+
+  while( is_empty() ) {
+
+    // call free-standing sc_core::wait(),
+    // since sc_prim_channel::wait(.) is not const
+
+    sc_core::wait( m_data_written_event );
+  }
+
+  return buffer.read_data();
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_peek( T &t ) const {
+
+  if( used() < 1 ) {
+    return false;
+  }
+
+  t = buffer.peek_data( 0 );
+  return true;
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_peek( T &t , int n ) const {
+
+  if( n >= used() || n < -1 ) {
+    return false;
+  }
+
+  if( n == -1 ) {
+    n = used() - 1;
+  }
+
+  t = buffer.peek_data( n );
+  return true;
+
+}
+
+template< typename T >
+inline
+bool
+tlm_fifo<T>::nb_can_peek( tlm_tag<T> * ) const
+{
+  return !is_empty();
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_poke( const T &t , int n ) {
+
+  if( n >= used() || n < 0 ) {
+    return false;
+  }
+
+  buffer.poke_data( n ) = t;
+  return true;
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h
new file mode 100644
index 000000000..2728e0394
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h
@@ -0,0 +1,140 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_PUT_GET_IF_H__
+#define __TLM_FIFO_PUT_GET_IF_H__
+
+namespace tlm {
+
+/******************************************************************
+//
+// get interface
+//
+******************************************************************/
+
+template <typename T>
+inline
+T
+tlm_fifo<T>::get( tlm_tag<T> * )
+{
+
+  while( is_empty() ) {
+    wait( m_data_written_event );
+  }
+
+  m_num_read ++;
+  request_update();
+
+  return buffer.read();
+
+}
+
+// non-blocking read
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_get( T& val_ )
+{
+
+  if( is_empty() ) {
+    return false;
+  }
+
+  m_num_read ++;
+  request_update();
+
+  val_ = buffer.read();
+
+  return true;
+
+}
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_can_get( tlm_tag<T> * ) const {
+
+  return !is_empty();
+
+}
+
+
+/******************************************************************
+//
+// put interface
+//
+******************************************************************/
+
+template <typename T>
+inline
+void
+tlm_fifo<T>::put( const T& val_ )
+{
+    while( is_full() ) {
+  wait( m_data_read_event );
+    }
+
+    if( buffer.is_full() ) {
+
+      buffer.resize( buffer.size() * 2 );
+
+    }
+
+    m_num_written ++;
+    buffer.write( val_ );
+
+    request_update();
+}
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_put( const T& val_ )
+{
+
+  if( is_full() ) {
+    return false;
+  }
+
+  if( buffer.is_full() ) {
+
+    buffer.resize( buffer.size() * 2 );
+
+  }
+
+  m_num_written ++;
+  buffer.write( val_ );
+  request_update();
+
+  return true;
+}
+
+template < typename T >
+inline
+bool
+tlm_fifo<T>::nb_can_put( tlm_tag<T> * ) const {
+
+  return !is_full();
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h
new file mode 100644
index 000000000..39932fea1
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h
@@ -0,0 +1,93 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_RESIZE_H__
+#define __TLM_FIFO_RESIZE_H__
+
+/******************************************************************
+//
+// resize interface
+//
+******************************************************************/
+
+namespace tlm {
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::nb_expand( unsigned int n ) {
+
+  if( m_size >= 0 ) {
+    m_expand = true;
+    m_size += n;
+    request_update();
+  }
+}
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::nb_unbound( unsigned int n ) {
+
+  m_expand = true;
+  m_size = -n;
+
+  if( buffer.size() < static_cast<int>( n ) ) {
+    buffer.resize( n );
+  }
+
+  request_update();
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_reduce( unsigned int n ) {
+
+  if( m_size < 0 ) {
+    return false;
+  }
+
+  return nb_bound( size() - n );
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_bound( unsigned int new_size ) {
+
+  bool ret = true;
+
+  if( static_cast<int>( new_size ) < used() ) {
+
+    new_size = used();
+    ret = false;
+
+  }
+
+  m_size = new_size;
+  return ret;
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h
new file mode 100644
index 000000000..36dbd21d6
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h
@@ -0,0 +1,114 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+//
+// To the LRM writer : these classes are purely artifacts of the implementation.
+//
+
+#ifndef __TLM_PUT_GET_IMP_H__
+#define __TLM_PUT_GET_IMP_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+namespace tlm {
+
+template < typename PUT_DATA , typename GET_DATA>
+class tlm_put_get_imp :
+  private virtual tlm_put_if< PUT_DATA > ,
+  private virtual tlm_get_peek_if< GET_DATA >
+{
+public:
+  tlm_put_get_imp( tlm_put_if<PUT_DATA> &p ,
+       tlm_get_peek_if<GET_DATA> &g ) :
+    put_fifo( p ) , get_fifo( g ) {}
+
+  // put interface
+
+  void put( const PUT_DATA &t ) { put_fifo.put( t ); }
+
+  bool nb_put( const PUT_DATA &t ) { return put_fifo.nb_put( t ); }
+  bool nb_can_put( tlm_tag<PUT_DATA> *t = 0 ) const {
+    return put_fifo.nb_can_put( t );
+  }
+  const sc_core::sc_event &ok_to_put( tlm_tag<PUT_DATA> *t = 0 ) const {
+    return put_fifo.ok_to_put( t );
+  }
+
+  // get interface
+
+  GET_DATA get( tlm_tag<GET_DATA> * = 0 ) { return get_fifo.get(); }
+
+  bool nb_get( GET_DATA &t ) { return get_fifo.nb_get( t ); }
+
+  bool nb_can_get( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.nb_can_get( t );
+  }
+
+  virtual const sc_core::sc_event &ok_to_get( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.ok_to_get( t );
+  }
+
+  // peek interface
+
+  GET_DATA peek( tlm_tag<GET_DATA> * = 0 ) const { return get_fifo.peek(); }
+
+  bool nb_peek( GET_DATA &t ) const { return get_fifo.nb_peek( t ); }
+
+  bool nb_can_peek( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.nb_can_peek( t );
+  }
+
+  virtual const sc_core::sc_event &ok_to_peek( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.ok_to_peek( t );
+  }
+
+private:
+  tlm_put_if<PUT_DATA> &put_fifo;
+  tlm_get_peek_if<GET_DATA> &get_fifo;
+};
+
+template < typename REQ , typename RSP >
+class tlm_master_imp :
+  private tlm_put_get_imp< REQ , RSP > ,
+  public virtual tlm_master_if< REQ , RSP >
+{
+public:
+
+  tlm_master_imp( tlm_put_if<REQ> &req ,
+                  tlm_get_peek_if<RSP> &rsp ) :
+    tlm_put_get_imp<REQ,RSP>( req , rsp ) {}
+
+};
+
+template < typename REQ , typename RSP >
+class tlm_slave_imp :
+  private tlm_put_get_imp< RSP , REQ > ,
+  public virtual tlm_slave_if< REQ , RSP >
+{
+public:
+
+  tlm_slave_imp( tlm_get_peek_if<REQ> &req ,
+                 tlm_put_if<RSP> &rsp ) :
+    tlm_put_get_imp<RSP,REQ>( rsp  , req ) {}
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h
new file mode 100644
index 000000000..7bd5652f7
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h
@@ -0,0 +1,155 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_REQ_RSP_CHANNELS_H__
+#define __TLM_REQ_RSP_CHANNELS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h"
+
+namespace tlm {
+
+template < typename REQ , typename RSP ,
+     typename REQ_CHANNEL = tlm_fifo<REQ> ,
+     typename RSP_CHANNEL = tlm_fifo<RSP> >
+
+class tlm_req_rsp_channel : public sc_core::sc_module
+{
+public:
+  // uni-directional slave interface
+
+  sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export;
+  sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export;
+
+  // uni-directional master interface
+
+  sc_core::sc_export< tlm_fifo_put_if< REQ > > put_request_export;
+  sc_core::sc_export< tlm_fifo_get_if< RSP > > get_response_export;
+
+  // master / slave interfaces
+
+  sc_core::sc_export< tlm_master_if< REQ , RSP > > master_export;
+  sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export;
+
+
+  tlm_req_rsp_channel( int req_size = 1 , int rsp_size = 1 ) :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("tlm_req_rsp_channel") ) ) ,
+    request_fifo( req_size ) ,
+    response_fifo( rsp_size ) ,
+    master( request_fifo , response_fifo ) ,
+    slave( request_fifo , response_fifo )
+  {
+
+    bind_exports();
+
+  }
+
+  tlm_req_rsp_channel( sc_core::sc_module_name module_name ,
+           int req_size = 1 , int rsp_size = 1 ) :
+    sc_core::sc_module( module_name  ) ,
+    request_fifo( req_size ) ,
+    response_fifo( rsp_size ) ,
+    master( request_fifo , response_fifo ) ,
+    slave( request_fifo , response_fifo )
+  {
+
+    bind_exports();
+
+  }
+
+private:
+  void bind_exports() {
+
+    put_request_export( request_fifo );
+    get_request_export( request_fifo );
+
+    put_response_export( response_fifo );
+    get_response_export( response_fifo );
+
+    master_export( master );
+    slave_export( slave );
+
+  }
+
+protected:
+  REQ_CHANNEL request_fifo;
+  RSP_CHANNEL response_fifo;
+
+  tlm_master_imp< REQ , RSP > master;
+  tlm_slave_imp< REQ , RSP > slave;
+};
+
+template < typename REQ , typename RSP ,
+     typename REQ_CHANNEL = tlm_fifo<REQ> ,
+     typename RSP_CHANNEL = tlm_fifo<RSP> >
+class tlm_transport_channel : public sc_core::sc_module
+{
+public:
+
+  // master transport interface
+
+  sc_core::sc_export< tlm_transport_if< REQ , RSP > > target_export;
+
+  // slave interfaces
+
+  sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export;
+  sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export;
+
+  sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export;
+
+  tlm_transport_channel() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("transport_channel" ) ) ) ,
+    target_export("target_export") ,
+    req_rsp( "req_rsp" , 1 , 1 ) ,
+    t2m("ts2m")
+  {
+    do_binding();
+  }
+
+  tlm_transport_channel( sc_core::sc_module_name nm ) :
+    sc_core::sc_module( nm ) ,
+    target_export("target_export") ,
+    req_rsp( "req_rsp" , 1 , 1 ) ,
+    t2m("tsm" )
+  {
+    do_binding();
+  }
+
+private:
+  void do_binding() {
+
+    target_export( t2m.target_export );
+
+    t2m.master_port( req_rsp.master_export );
+
+    get_request_export( req_rsp.get_request_export );
+    put_response_export( req_rsp.put_response_export );
+    slave_export( req_rsp.slave_export );
+
+  }
+
+  tlm_req_rsp_channel< REQ , RSP , REQ_CHANNEL , RSP_CHANNEL > req_rsp;
+  tlm_transport_to_master< REQ , RSP > t2m;
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h
new file mode 100644
index 000000000..60874ce91
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h
@@ -0,0 +1,94 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_EVENT_FINDER_H__
+#define __TLM_EVENT_FINDER_H__
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h"
+
+namespace tlm {
+
+template <class IF , class T>
+class tlm_event_finder_t
+: public sc_core::sc_event_finder
+{
+public:
+
+    // constructor
+
+    tlm_event_finder_t( const sc_core::sc_port_base& port_,
+                        const sc_core::sc_event& (IF::*event_method_) ( tlm_tag<T> * ) const )
+        : sc_core::sc_event_finder( port_ ), m_event_method( event_method_ )
+        {}
+
+    // destructor (does nothing)
+
+    virtual ~tlm_event_finder_t()
+        {}
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+    virtual const sc_core::sc_event& find_event( sc_core::sc_interface* if_p = 0 ) const;
+#else
+    virtual const sc_core::sc_event& find_event() const;
+#endif
+
+private:
+
+    const sc_core::sc_event& (IF::*m_event_method) ( tlm_tag<T> * ) const;
+
+private:
+
+    // disabled
+    tlm_event_finder_t();
+    tlm_event_finder_t( const tlm_event_finder_t<IF,T>& );
+    tlm_event_finder_t<IF,T>& operator = ( const tlm_event_finder_t<IF,T>& );
+};
+
+
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+template <class IF , class T>
+inline
+const sc_core::sc_event&
+tlm_event_finder_t<IF,T>::find_event( sc_core::sc_interface* if_p ) const
+{
+    const IF* iface = ( if_p ) ? dynamic_cast<const IF*>( if_p ) :
+                                 dynamic_cast<const IF*>( port().get_interface() );
+    if( iface == 0 ) {
+  report_error( sc_core::SC_ID_FIND_EVENT_, "port is not bound" );
+    }
+    return (const_cast<IF*>( iface )->*m_event_method) ( 0 );
+}
+#else
+template <class IF , class T>
+inline
+const sc_core::sc_event&
+tlm_event_finder_t<IF,T>::find_event() const
+{
+    const IF* iface = dynamic_cast<const IF*>( port().get_interface() );
+    if( iface == 0 ) {
+  report_error( sc_core::SC_ID_FIND_EVENT_, "port is not bound" );
+    }
+    return (const_cast<IF*>( iface )->*m_event_method) ( 0 );
+}
+#endif
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h
new file mode 100644
index 000000000..0af1e3487
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h
@@ -0,0 +1,91 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_NONBLOCKING_PORT_H__
+#define __TLM_NONBLOCKING_PORT_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h"
+
+namespace tlm {
+
+template < typename T >
+class tlm_nonblocking_get_port :
+public sc_core::sc_port< tlm_nonblocking_get_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_get_if<T> get_if_type;
+
+  tlm_nonblocking_get_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_get_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_get() const {
+
+    return *new tlm_event_finder_t< get_if_type , T >(
+       *this,
+       &get_if_type::ok_to_get );
+
+  }
+
+};
+
+template < typename T >
+class tlm_nonblocking_peek_port :
+public sc_core::sc_port< tlm_nonblocking_peek_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_peek_if<T> peek_if_type;
+
+  tlm_nonblocking_peek_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_peek_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_peek() const {
+
+    return *new tlm_event_finder_t< peek_if_type , T >(
+       *this,
+       &peek_if_type::ok_to_peek );
+
+  }
+
+};
+
+
+template < typename T >
+class tlm_nonblocking_put_port :
+public sc_core::sc_port< tlm_nonblocking_put_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_put_if<T> put_if_type;
+
+  tlm_nonblocking_put_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_put_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_put() const {
+
+    return *new tlm_event_finder_t< put_if_type , T >(
+             *this,
+       &put_if_type::ok_to_put );
+
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h
new file mode 100644
index 000000000..88f1d0e8c
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h
@@ -0,0 +1,37 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_REQ_RSP_H__
+#define __TLM_REQ_RSP_H__
+
+// The unannotated TLM interfaces
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+// The channels : tlm_fifo, tlm_transport_channel and tlm_req_rsp_channel
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h"
+
+// Some non blocking ports to provide static sensitivity
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h"
+
+
+#endif /* __TLM_REQ_RSP_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/README.txt b/ext/systemc/src/tlm_core/tlm_2/README.txt
new file mode 100644
index 000000000..cb02af2d8
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/README.txt
@@ -0,0 +1,111 @@
+TLM-2.0 interoperability layer header files
+===========================================
+
+Dir: include/tlm_core/tlm_2/
+
+SubDirs: tlm_2_interfaces/
+	 tlm_generic_payload/
+	 tlm_quantum/
+	 tlm_sockets
+
+Files: README.txt
+       tlm_version.h
+
+
+Comments
+========
+
+User code should only #include the tlm or tlm.h header file in the include/
+directory and avoid including any of the include files in this directory
+directly. All objects defined in this file hierarchy are in the tlm namespace.
+
+tlm_version.h contains the definitions for the version string and integer values
+
+The header files are organizated, by subdirectory, as follows:
+
+
+tlm_2_interfaces/
+-----------------
+
+Contains the TLM-2.0 core interfaces
+
+Files:
+      tlm_2_interfaces.h (includes the other header files in this directory )
+      tlm_fw_bw_ifs.h    (defines the TLM 2.0 interface API's:
+					tlm_fw_nonblocking_transport_if
+					tlm_bw_nonblocking_transport_if
+					tlm_blocking_transport_if
+					tlm_fw_direct_mem_if
+					tlm_bw_direct_mem_if
+					tlm_transport_dbg_if
+			  the enumeration type
+			   		tlm_sync_enum
+			  and the TLM 2.0 standard interfaces using the API's
+			   		tlm_fw_transport_if
+					tlm_bw_transport_if )
+      tlm_dmi.h          (defines tlm_dmi)
+
+
+tlm_generic_payload/
+--------------------
+
+Contains the TLM-2.0 generic payload and associated classes and helper functions
+
+Files:
+      tlm_generic_payload.h ( includes the other header files in this directory)
+      tlm_gp.h              (defines the TLM 2.0 generic payload classes:
+      					tlm_generic_payload
+					tlm_extension
+					tlm_extension_base
+					tlm_mm_interface
+			     and the enumeration types
+			    		tlm_command
+					tlm_response_status  ) 
+      tlm_array.h           (defines array class used by the extention 
+      			     mechanism )
+      tlm_endian_conv.h     (defines the implementation for the endianness 
+      			     helper functions:
+			    		tlm_to_hostendian_generic()
+					tlm_from_hostendian_generic()
+					tlm_to_hostendian_word()
+					tlm_from_hostendian_word()
+					tlm_to_hostendian_aligned()
+					tlm_from_hostendian_aligned()
+					tlm_to_hostendian_single()
+					tlm_from_hostendian_single()  )
+					  
+      tlm_helpers.h         (defines the helper functions to determine the
+      			     hostendianness:
+					get_host_endianness()
+					host_has_little_endianness()
+					has_host_endianness()
+			     and defines the enumeration type:
+			     		tlm_endianness	
+      tlm_phase.h           (defines tlm_phase as an extendable enum type)
+
+
+tlm_sockets/
+------------
+
+Contains the standard TLM-2.0 initiator and target sockets (which are used as
+the base classes for the convenience sockets in tlm_utils)
+
+Files:
+      tlm_sockets.h          (includes the other header files in this directory)
+      tlm_initiator_socket.h (defines the initiator sockets:
+					tlm_initiator_socket_base
+					tlm_initiator_socket_b
+					tlm_initiator_socket
+      tlm_target_socket.h    (defines the target sockets:
+					tlm_target_socket_base
+					tlm_target_socket_b
+					tlm_target_socket
+
+
+tlm_quantum/
+------------
+This contains the global quantum. (The quantum keeper is in tlm_utils)
+
+Files:
+  tlm_quantum.h        ( includes the other header file in this directory )
+  tlm_global_quantum.h ( defines tlm_global_quantum ) 
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h
new file mode 100644
index 000000000..8a0c543c8
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h
@@ -0,0 +1,27 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_2_INTERFACES_H__
+#define __TLM_2_INTERFACES_H__
+
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h"
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h
new file mode 100644
index 000000000..d7c3304eb
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h
@@ -0,0 +1,114 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_DMI_H__
+#define __TLM_DMI_H__
+
+#include <systemc>
+
+namespace tlm {
+
+class tlm_dmi
+{
+  public:
+
+  // Enum for indicating the access granted to the initiator. 
+  // The initiator uses gp.m_command to indicate it intention (read/write)
+  //  The target is allowed to promote DMI_ACCESS_READ or DMI_ACCESS_WRITE
+  //  requests to dmi_access_read_write.
+
+  enum dmi_access_e
+  { DMI_ACCESS_NONE       = 0x00                               // no access
+  , DMI_ACCESS_READ       = 0x01                               // read access
+  , DMI_ACCESS_WRITE      = 0x02                               // write access
+  , DMI_ACCESS_READ_WRITE = DMI_ACCESS_READ | DMI_ACCESS_WRITE // read/write access
+  };
+  
+  tlm_dmi (void)
+  {
+    init();
+  }
+  
+  void init (void)
+  {
+    m_dmi_ptr           = 0x0;
+    m_dmi_start_address = 0x0;
+    m_dmi_end_address   = (sc_dt::uint64)(-1);
+    m_dmi_access        = DMI_ACCESS_NONE;
+    m_dmi_read_latency  = sc_core::SC_ZERO_TIME;
+    m_dmi_write_latency = sc_core::SC_ZERO_TIME;
+  }
+  
+  unsigned char*    get_dmi_ptr           (void) const {return m_dmi_ptr;}
+  sc_dt::uint64     get_start_address     (void) const {return m_dmi_start_address;}
+  sc_dt::uint64     get_end_address       (void) const {return m_dmi_end_address;}
+  sc_core::sc_time  get_read_latency      (void) const {return m_dmi_read_latency;}
+  sc_core::sc_time  get_write_latency     (void) const {return m_dmi_write_latency;}
+  dmi_access_e      get_granted_access    (void) const {return m_dmi_access;}
+  bool              is_none_allowed       (void) const {return m_dmi_access == DMI_ACCESS_NONE;}
+  bool              is_read_allowed       (void) const {return (m_dmi_access & DMI_ACCESS_READ) == DMI_ACCESS_READ;}
+  bool              is_write_allowed      (void) const {return (m_dmi_access & DMI_ACCESS_WRITE) == DMI_ACCESS_WRITE;}
+  bool              is_read_write_allowed (void) const {return (m_dmi_access & DMI_ACCESS_READ_WRITE) == DMI_ACCESS_READ_WRITE;}
+
+  void              set_dmi_ptr           (unsigned char* p)   {m_dmi_ptr = p;}
+  void              set_start_address     (sc_dt::uint64 addr) {m_dmi_start_address = addr;}
+  void              set_end_address       (sc_dt::uint64 addr) {m_dmi_end_address = addr;}
+  void              set_read_latency      (sc_core::sc_time t) {m_dmi_read_latency = t;}
+  void              set_write_latency     (sc_core::sc_time t) {m_dmi_write_latency = t;}
+  void              set_granted_access    (dmi_access_e a)     {m_dmi_access = a;}
+  void              allow_none            (void)               {m_dmi_access = DMI_ACCESS_NONE;}
+  void              allow_read            (void)               {m_dmi_access = DMI_ACCESS_READ;}
+  void              allow_write           (void)               {m_dmi_access = DMI_ACCESS_WRITE;}
+  void              allow_read_write      (void)               {m_dmi_access = DMI_ACCESS_READ_WRITE;}
+
+  private:
+
+  // If the forward call is successful, the target returns the dmi_ptr,
+  // which must point to the data element corresponding to the
+  // dmi_start_address. The data is organized as a byte array with the
+  // endianness of the target (endianness member of the tlm_dmi struct).
+  
+  unsigned char*   m_dmi_ptr;
+  
+  // The absolute start and end addresses of the DMI region. If the decoder
+  // logic in the interconnect changes the address field e.g. by masking, the
+  // interconnect is responsible to transform the relative address back to an
+  // absolute address again.
+  
+  sc_dt::uint64    m_dmi_start_address;
+  sc_dt::uint64    m_dmi_end_address;
+
+  // Granted access
+  
+  dmi_access_e     m_dmi_access;
+
+  // These members define the latency of read/write transactions. The
+  // initiator must initialize these members to zero before requesting a
+  // dmi pointer, because both the interconnect as well as the target can
+  // add to the total transaction latency.
+  // Depending on the 'type' attribute only one, or both of these attributes
+  // will be valid.
+  
+  sc_core::sc_time m_dmi_read_latency;
+  sc_core::sc_time m_dmi_write_latency;
+};
+
+} // namespace tlm
+
+#endif /* TLM_DMI_HEADER */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h
new file mode 100644
index 000000000..59e81c658
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h
@@ -0,0 +1,223 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FW_BW_IFS_H__
+#define __TLM_FW_BW_IFS_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h"
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h"
+
+namespace tlm {
+
+enum tlm_sync_enum { TLM_ACCEPTED, TLM_UPDATED, TLM_COMPLETED };
+
+////////////////////////////////////////////////////////////////////////////
+// Basic interfaces
+////////////////////////////////////////////////////////////////////////////
+template <typename TRANS = tlm_generic_payload,
+          typename PHASE = tlm_phase>
+class tlm_fw_nonblocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual tlm_sync_enum nb_transport_fw(TRANS& trans,
+                                        PHASE& phase,
+                                        sc_core::sc_time& t) = 0;
+};
+
+template <typename TRANS = tlm_generic_payload,
+          typename PHASE = tlm_phase>
+class tlm_bw_nonblocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual tlm_sync_enum nb_transport_bw(TRANS& trans,
+                                        PHASE& phase,
+                                        sc_core::sc_time& t) = 0;
+};
+
+template <typename TRANS = tlm_generic_payload>
+class tlm_blocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual void b_transport(TRANS& trans,
+                           sc_core::sc_time& t) = 0;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// DMI interfaces for getting and invalidating DMI pointers:
+//////////////////////////////////////////////////////////////////////////
+
+// The semantics of the forward interface are as follows:
+//
+// - An initiator that wants to get direct access to a target's memory region
+//   can call the get_direct_mem_ptr method with the 'trans' parameter set to
+//   the address that it wants to gain access to. It sets the trans.m_command
+//   to specify if the initiator intended use (read or write)
+//   to the target's DMI region. The initiator is responsible for calling the
+//   method with a freshly initialized tlm_dmi object either by using a newly
+//   constructed object, or by calling an existing object's init() method.
+// - Although a reference to a complete 'TRANS' type is passed to the get_
+//   direct_mem_ptr call, only the address command, and extension fields are of
+//   interest in most cases.
+// - Read and write ranges are not necessarily identical. If they are, a target
+//   can specify that the range is valid for all accesses with the tlm_data
+//   m_type attribute in the.
+// - The interconnect, if any, needs to decode the address and forward the
+//   call to the corresponding target. It needs to handle the address exactly
+//   as the target would expect on a transaction call, e.g. mask the address
+//   according to the target's address width.
+// - If the target supports DMI access for the given address, it sets the
+//   data fields in the DMI struct and returns true.
+// - If a target does not support DMI access it needs to return false.
+//   The target can either set the correct address range in the DMI struct
+//   to indicate the memory region where DMI is disallowed, or it can specify
+//   the complete address range if it doesn't know it's memory range. In this
+//   case the interconnect is responsible for clipping the address range to
+//   the correct range that the target serves.
+// - The interconnect must always translate the addresses to the initiator's
+//   address space. This must be the inverse operation of what the
+//   interconnect needed to do when forwarding the call. In case the
+//   component wants to change any member of the tlm_dmi object, e.g. for
+//   its own latency to the target's latency, it must only do so *after* the
+//   target has been called. The target is always allowed to overwrite all
+//   values in the tlm_dmi object.
+// - In case the slave returned with an invalid region the bus/interconnect
+//   must fill in the complete address region for the particular slave in the
+//   DMI data structure.
+//
+// DMI hint optimization:
+//
+// Initiators may use the DMI hint in the tlm_generic_payload to avoid
+// unnecessary DMI attempts. The recommended sequence of interface
+// method calls would be:
+//
+// - The initiator first tries to check if it has a valid DMI region for the
+//   address that it wants to access next.
+// - If not, it performs a normal transaction.
+// - If the DMI hint in this transaction is true, the initiator can try and
+//   get the DMI region.
+//
+// Note that the DMI hint optimization is completely optional and every
+// initiator model is free to ignore the DMI hint. However, a target is
+// required to set the DMI hint to true if a DMI request on the given address
+// with the given transaction type (read or write) would have succeeded.
+
+template <typename TRANS = tlm_generic_payload>
+class tlm_fw_direct_mem_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool get_direct_mem_ptr(TRANS& trans,
+                                  tlm_dmi&  dmi_data) = 0;
+};
+
+// The semantics of the backwards call is as follows:
+//
+// - An interconnect component or a target is required to invalidate all
+//   affected DMI regions whenever any change in the regions take place.
+//   The exact rule is that a component must invalidate all those DMI regions
+//   that it already reported, if it would answer the same DMI request
+//   with any member of the tlm_dmi data structure set differently.
+// - An interconnect component must forward the invalidate_direct_mem_ptr call
+//   to all initiators that could potentially have a DMI pointer to the region
+//   specified in the method arguments. A safe implementation is to call
+//   every attached initiator.
+// - An interconnect component must transform the address region of an
+//   incoming invalidate_direct_mem_ptr to the corresponding address space
+//   for the initiators. Basically, this is the same address transformation
+//   that the interconnect does on the DMI ranges on the forward direction.
+// - Each initiator must check if it has a pointer to the given region and
+//   throw this away. It is recommended that the initiator throws away all DMI
+//   regions that have any overlap with the given regions, but this is not a
+//   hard requirement.
+//
+// - A full DMI pointer invalidation, e.g. for a bus remap can be signaled
+//   by setting the range: 0x0 - 0xffffffffffffffffull = (sc_dt::uint64)-1
+// - An initiator must throw away all DMI pointers in this case.
+//
+// - Under no circumstances a model is allowed to call the get_direct_mem_ptr
+//   from within the invalidate_direct_mem_ptr method, directly or indirectly.
+//
+class tlm_bw_direct_mem_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
+                                         sc_dt::uint64 end_range) = 0;
+};
+
+/////////////////////////////////////////////////////////////////////
+// debug interface for memory access
+/////////////////////////////////////////////////////////////////////
+//
+// This interface can be used to gain access to a targets memory or registers
+// in a non-intrusive manner. No side effects, waits or event notifications
+// must happen in the course of the method.
+//
+// Semantics:
+// - The initiator calls the transport_dbg method with transaction 'trans' as
+//   argument. The commonly used parts of trans for debug are:
+//   . address: The start address that it wants to peek or poke.
+//   . length:  The number of bytes that it requests to read or write.
+//   . command: Indicates a read or write access.
+//   . data:    A pointer to the initiator-allocated data buffer, which must
+//              be at least num_bytes large. The data is always organized in
+//              the endianness of the machine.
+//   . extensions: Any extension that could affect the transaction.
+// - The interconnect, if any, will decode the address and forward the call to
+//   the appropriate target.
+// - The target must return the number of successfully transmitted bytes, where
+//   this number must be <= num_bytes. Thus, a target can safely return 0 if it
+//   does not support debug transactions.
+//
+template <typename TRANS = tlm_generic_payload>
+class tlm_transport_dbg_if : public virtual sc_core::sc_interface
+{
+public:
+  // The return value of defines the number of bytes successfully
+  // transferred.
+  virtual unsigned int transport_dbg(TRANS& trans) = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Combined interfaces
+////////////////////////////////////////////////////////////////////////////
+
+struct tlm_base_protocol_types
+{
+  typedef tlm_generic_payload tlm_payload_type;
+  typedef tlm_phase tlm_phase_type;
+};
+
+// The forward interface:
+template <typename TYPES = tlm_base_protocol_types>
+class tlm_fw_transport_if
+  : public virtual tlm_fw_nonblocking_transport_if<typename TYPES::tlm_payload_type,
+                                                   typename TYPES::tlm_phase_type>
+  , public virtual tlm_blocking_transport_if<typename TYPES::tlm_payload_type>
+  , public virtual tlm_fw_direct_mem_if<typename TYPES::tlm_payload_type>
+  , public virtual tlm_transport_dbg_if<typename TYPES::tlm_payload_type>
+{};
+
+// The backward interface:
+template <typename TYPES = tlm_base_protocol_types>
+class tlm_bw_transport_if
+  : public virtual tlm_bw_nonblocking_transport_if<typename TYPES::tlm_payload_type,
+                                                   typename TYPES::tlm_phase_type>
+  , public virtual tlm_bw_direct_mem_if
+{};
+
+} // namespace tlm
+
+#endif /* __TLM_FW_BW_IFS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h
new file mode 100644
index 000000000..297dd3fe4
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h
@@ -0,0 +1,125 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ARRAY_H__
+#define __TLM_ARRAY_H__
+
+#include <systemc>
+#include <exception>
+// unused for the time being: #include <cassert>
+
+namespace tlm {
+
+//
+// To the LRM writer: the below class is an artifact of the tlm_generic_payload
+//                    implementation and not part of the core TLM standard
+//
+
+
+// This implements a lean and fast array class that supports array expansion on
+// request. The class is primarily used in the tlm_generic_payload class for
+// storing the pointers to the extensions.
+//
+// Individual array elements can be accessed through the [] operators, and the
+// array length is returned by the size() method.
+//
+// The size can be dynamically expanded using the expand(uint) method. There
+// is no shrinking mechanism implemented, because the extension mechanism
+// does not require this feature. Bear in mind that calling the expand method
+// may invalidate all direct pointers into the array.
+
+
+//the tlm_array shall always be used with T=tlm_extension_base*
+template <typename T>
+class tlm_array
+  : private std::vector<T>
+{
+    typedef std::vector<T>                base_type;
+    typedef typename base_type::size_type size_type;
+public:
+
+    // constructor:
+    tlm_array(size_type size = 0, T const & default_value = T() )
+        : base_type(size,default_value)
+        , m_entries()
+        , m_default(default_value)
+    {
+        //m_entries.reserve(size); // optional
+    }
+
+    // copy constructor:
+    // tlm_array(const tlm_array& orig) = default;
+
+    // destructor:
+    // ~tlm_array() = default;
+
+    // operators for dereferencing:
+    using base_type::operator[];
+
+    // array size:
+    using base_type::size;
+
+    // expand the array if needed:
+    void expand(size_type new_size)
+    {
+        if (new_size > size())
+        {
+            base_type::resize(new_size);
+            //m_entries.reserve(new_size); // optional
+        }
+    }
+
+    static const char* const kind_string;
+    const char* kind() const { return kind_string; }
+
+    //this function shall get a pointer to a array slot
+    // it stores this slot in a cache of active slots
+    void insert_in_cache(T* p)
+    {
+        //assert( (p-&(*this)[0]) < size() );
+        m_entries.push_back( p-&(*this)[0] );
+    }
+
+    //this functions clears all active slots of the array
+    void free_entire_cache()
+    {
+        while(m_entries.size())
+        {
+            if ((*this)[m_entries.back()])      //we make sure no one cleared the slot manually
+              (*this)[m_entries.back()]->free();//...and then we call free on the content of the slot
+            (*this)[m_entries.back()]=0;        //afterwards we set the slot to NULL
+            m_entries.pop_back();
+        }
+    }
+
+protected:
+    std::vector<size_type> m_entries;
+    T m_default;
+
+    // disabled:
+    tlm_array& operator=(const tlm_array<T>&);
+};
+
+
+template <typename T>
+const char* const tlm_array<T>::kind_string = "tlm_array";
+
+} // namespace tlm
+
+#endif /* __TLM_ARRAY_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h
new file mode 100644
index 000000000..648115554
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h
@@ -0,0 +1,792 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+
+#ifndef __TLM_ENDIAN_CONV_H__
+#define __TLM_ENDIAN_CONV_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h"
+
+
+namespace tlm {
+
+
+/*
+Tranaction-Level Modelling
+Endianness Helper Functions
+
+DESCRIPTION
+A set of functions for helping users to get the endianness
+right in their TLM models of system initiators.  These functions are
+for use within an initiator.  They can not be used as-is outside
+an initiator because the extension used to store context will not work
+if cascaded, and they do not respect the generic payload mutability
+rules.  However this code may be easily copied and adapted for use
+in bridges, etc..
+
+These functions are not compulsory.  There are other legitimate ways to
+achieve the same functionality.  If extra information is available at
+compile time about the nature of an initiator's transactions, this can
+be exploited to accelerate simulations by creating further functions
+similar to those in this file.  In general a functional transaction can be
+described in more than one way by a TLM-2 GP object.
+
+The functions convert the endianness of a GP object, either on request or
+response.  They should only be used when the initiator's endianness
+does not match the host's endianness.  They assume 'arithmetic mode'
+meaning that within a data word the byte order is always host-endian.
+For non-arithmetic mode initiators they can be used with a data word
+size of 1 byte.
+
+All the functions are templates, for example:
+
+template<class DATAWORD> inline void
+  to_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+
+The template parameter provides the data word width.  Having this as a class
+makes it easy to use it for copy and swap operations within the functions.
+If the assignment operator for this class is overloaded, the endianness
+conversion function may not have the desired effect.
+
+All the functions have the same signature except for different names.
+
+The principle is that a function to_hostendian_convtype() is called when the
+initiator-endian transaction is created, and the matching function
+from_hostendian_convtype() is called when the transaction is completed, for
+example before read data can be used.  In some cases the from_ function is
+redundant but an empty function is provided anyway.  It is strongly
+recommended that the from_ function is called, in case it ceases to be
+redundant in future versions of this code.
+
+No context needs to be managed outside the two functions, except that they
+must be called with the same template parameter and the same bus width.
+
+For initiator models that can not easily manage this context information,
+a single entry point for the from_ function is provided, which will be
+a little slower than calling the correct from_ function directly, as
+it can not be inlined.
+
+All functions assume power-of-2 bus and data word widths.
+
+Functions offered:
+
+0) A pair of functions that work for almost all TLM2 GP transactions.  The
+only limitations are that data and bus widths should be powers of 2, and that
+the data length should be an integer number of streaming widths and that the
+streaming width should be an integer number of data words.
+These functions always allocate new data and byte enable buffers and copy
+data one byte at a time.
+  tlm_to_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+
+1) A pair of functions that work for all transactions regardless of data and
+bus data sizes and address alignment except for the the following
+limitations:
+- byte-enables are supported only when byte-enable granularity is no finer
+than the data word (every data word is wholly enabled or wholly disabled)
+- byte-enable-length is not supported (if byte enables are present, the byte
+enable length must be equal to the data length).
+- streaming width is not supported
+- data word wider than bus word is not supported
+A new data buffer and a new byte enable buffer are always allocated.  Byte
+enables are assumed to be needed even if not required for the original
+(unconverted) transaction.  Data is copied to the new buffer on request
+(for writes) or on response (for reads).  Copies are done word-by-word
+where possible.
+  tlm_to_hostendian_word(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_word(tlm_generic_payload *txn, int sizeof_databus)
+
+2) If the original transaction is both word and bus-aligned then this pair of
+functions can be used.  It will complete faster than the generic function
+because the data reordering function is much simpler and no address
+conversion is required.
+The following limitations apply:
+- byte-enables are supported only when byte-enable granularity is no finer
+than the data word (every data word is wholly enabled or wholly disabled)
+- byte-enable-length is not supported (if byte enables are present, the byte
+enable length must be equal to the data length).
+- streaming width is not supported
+- data word wider than bus word is not supported
+- the transaction must be an integer number of bus words
+- the address must be aligned to the bus width
+  tlm_to_hostendian_aligned(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_aligned(tlm_generic_payload *txn, int sizeof_databus)
+
+3) For single word transactions that don't cross a bus word boundary it
+is always safe to work in-place and the conversion is very simple.  Again,
+streaming width and byte-enable length are not supported, and byte-enables
+may not changes within a data word.
+  tlm_to_hostendian_single(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_single(tlm_generic_payload *txn, int sizeof_databus)
+
+4) A single entry point for accessing the correct from_ function without
+needing to store context.
+  tlm_from_hostendian(tlm_generic_payload *txn)
+*/
+
+
+
+#ifndef uchar
+#define uchar unsigned char
+#else
+#define TLM_END_CONV_DONT_UNDEF_UCHAR
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Generic Utilities
+
+class tlm_endian_context;
+class tlm_endian_context_pool {
+  public:
+    tlm_endian_context *first;
+    inline tlm_endian_context_pool();
+    inline ~tlm_endian_context_pool();
+    inline tlm_endian_context *pop();
+    inline void push(tlm_endian_context *c);
+};
+static tlm_endian_context_pool global_tlm_endian_context_pool;
+
+// an extension to keep the information needed for reconversion of response
+class tlm_endian_context : public tlm_extension<tlm_endian_context> {
+  public:
+    tlm_endian_context() : dbuf_size(0), bebuf_size(0) {}
+    ~tlm_endian_context() {
+      if(dbuf_size > 0) delete [] new_dbuf;
+      if(bebuf_size > 0) delete [] new_bebuf;
+    }
+
+    sc_dt::uint64 address;     // used by generic, word
+    sc_dt::uint64 new_address;     // used by generic
+    uchar *data_ptr;     // used by generic, word, aligned
+    uchar *byte_enable;  // used by word
+    int length;         // used by generic, word
+    int stream_width;   // used by generic
+
+    // used by common entry point on response
+    void (*from_f)(tlm_generic_payload *txn, unsigned int sizeof_databus);
+    int sizeof_databus;
+
+    // reordering buffers for data and byte-enables
+    uchar *new_dbuf, *new_bebuf;
+    int dbuf_size, bebuf_size;
+    void establish_dbuf(int len) {
+      if(len <= dbuf_size) return;
+      if(dbuf_size > 0) delete [] new_dbuf;
+      new_dbuf = new uchar[len];
+      dbuf_size = len;
+    }
+    void establish_bebuf(int len) {
+      if(len <= bebuf_size) return;
+      if(bebuf_size > 0) delete [] new_bebuf;
+      new_bebuf = new uchar[len];
+      bebuf_size = len;
+    }
+
+    // required for extension management
+    void free() {
+      global_tlm_endian_context_pool.push(this);
+    }
+    tlm_extension_base* clone() const {return 0;}
+    void copy_from(tlm_extension_base const &) {return;}
+
+    // for pooling
+    tlm_endian_context *next;
+};
+// Assumptions about transaction contexts:
+// 1) only the address attribute of a transaction
+// is mutable.  all other attributes are unchanged from the request to
+// response side conversion.
+// 2) the conversion functions in this file do not respect the mutability
+// rules and do not put the transaction back into its original state after
+// completion.  so if the initiator has any cleaning up to do (eg of byte
+// enable buffers), it needs to store its own context.  the transaction
+// returned to the initiator may contain pointers to data and byte enable
+// that can/must not be deleted.
+// 3) the conversion functions in this file use an extension to store
+// context information.  they do not remove this extension.  the initiator
+// should not remove it unless it deletes the generic payload
+// object.
+
+inline tlm_endian_context *establish_context(tlm_generic_payload *txn) {
+  tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
+  if(tc == 0) {
+    tc = global_tlm_endian_context_pool.pop();
+    txn->set_extension(tc);
+  }
+  return tc;
+}
+
+inline tlm_endian_context_pool::tlm_endian_context_pool() : first(0) {}
+
+inline tlm_endian_context_pool::~tlm_endian_context_pool() {
+  while(first != 0) {
+    tlm_endian_context *next = first->next;
+    delete first;
+    first = next;
+  }
+}
+
+tlm_endian_context *tlm_endian_context_pool::pop() {
+  if(first == 0) return new tlm_endian_context;
+  tlm_endian_context *r = first;
+  first = first->next;
+  return r;
+}
+
+void tlm_endian_context_pool::push(tlm_endian_context *c) {
+  c->next = first;
+  first = c;
+}
+
+
+// a set of constants for efficient filling of byte enables
+template<class D> class tlm_bool {
+  public:
+    static D TLM_TRUE;
+    static D TLM_FALSE;
+    static D make_uchar_array(uchar c) {
+      D d;
+      uchar *tmp = (uchar *)(&d);
+      for(ptrdiff_t i=0; i!=sizeof(D); i++) tmp[i] = c;  // 64BITFIX negligable risk but easy fix //
+      return d;
+    }
+    // also provides an syntax-efficient tester, using a
+    // copy constuctor and an implicit cast to boolean
+    tlm_bool(D &d) : b(*((uchar*)&d) != TLM_BYTE_DISABLED) {}
+    operator bool() const {return b;}
+  private:
+    bool b;
+};
+
+template<class D> D tlm_bool<D>::TLM_TRUE
+  = tlm_bool<D>::make_uchar_array(TLM_BYTE_ENABLED);
+template<class D> D tlm_bool<D>::TLM_FALSE
+  = tlm_bool<D>::make_uchar_array(TLM_BYTE_DISABLED);
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Utilities
+inline void copy_db0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest1 = *src1;
+  *dest2 = *src2;
+}
+
+inline void copy_dbtrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest1 = *src1;
+  *dest2 = TLM_BYTE_ENABLED;
+}
+
+inline void copy_btrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest2 = TLM_BYTE_ENABLED;
+}
+
+inline void copy_b0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest2 = *src2;
+}
+
+inline void copy_dbyb0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  if(*dest2 == TLM_BYTE_ENABLED) *src1 = *dest1;
+}
+
+
+template<class D,
+  void COPY(uchar *he_d, uchar *he_b, uchar *ie_d, uchar *ie_b)>
+inline void loop_generic0(int new_len, int new_stream_width,
+  int orig_stream_width, int sizeof_databus,
+  sc_dt::uint64 orig_start_address, sc_dt::uint64 new_start_address, int be_length,
+  uchar *ie_data, uchar *ie_be, uchar *he_data, uchar *he_be) {
+
+  for(int orig_sword = 0, new_sword = 0; new_sword < new_len;
+      new_sword += new_stream_width, orig_sword += orig_stream_width) {
+
+    sc_dt::uint64 ie_addr = orig_start_address;
+    for(int orig_dword = orig_sword;
+      orig_dword < orig_sword + orig_stream_width; orig_dword += sizeof(D)) {
+
+      for(int curr_byte = orig_dword + sizeof(D) - 1;
+          curr_byte >= orig_dword; curr_byte--) {
+
+        ptrdiff_t he_index = ((ie_addr++) ^ (sizeof_databus - 1))
+          - new_start_address + new_sword;  // 64BITFIX //
+        COPY(ie_data+curr_byte,
+             ie_be+(curr_byte % be_length),  // 64BITRISK no risk of overflow, always positive //
+             he_data+he_index, he_be+he_index);
+      }
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  if(txn->is_read()) {
+    tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+    loop_generic0<DATAWORD, &copy_dbyb0>(txn->get_data_length(),
+      txn->get_streaming_width(), tc->stream_width, sizeof_databus, tc->address,
+      tc->new_address, txn->get_data_length(), tc->data_ptr, 0, txn->get_data_ptr(),
+      txn->get_byte_enable_ptr());
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_generic<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  // calculate new size:  nr stream words multiplied by big enough stream width
+  int s_width = txn->get_streaming_width();
+  int length = txn->get_data_length();
+  if(s_width >= length) s_width = length;
+  int nr_stream_words = length/s_width;
+
+  // find out in which bus word the stream word starts and ends
+  sc_dt::uint64 new_address = (txn->get_address() & ~(sizeof_databus - 1));
+  sc_dt::uint64 end_address = ((txn->get_address() + s_width - 1)
+    & ~(sizeof_databus - 1));
+
+  int new_stream_width = end_address - new_address + sizeof_databus;
+  int new_length = new_stream_width * nr_stream_words;
+
+  // store context
+  tc->data_ptr = txn->get_data_ptr();
+  tc->address = txn->get_address();
+  tc->new_address = new_address;
+  tc->stream_width = s_width;
+  uchar *orig_be = txn->get_byte_enable_ptr();
+  int orig_be_length = txn->get_byte_enable_length();
+
+  // create data and byte-enable buffers
+  txn->set_address(new_address);
+  tc->establish_dbuf(new_length);
+  txn->set_data_ptr(tc->new_dbuf);
+  tc->establish_bebuf(new_length);
+  txn->set_byte_enable_ptr(tc->new_bebuf);
+  memset(txn->get_byte_enable_ptr(), TLM_BYTE_DISABLED, new_length);
+  txn->set_streaming_width(new_stream_width);
+  txn->set_data_length(new_length);
+  txn->set_byte_enable_length(new_length);
+
+  // copy data and/or byte enables
+  if(txn->is_write()) {
+    if(orig_be == 0) {
+      loop_generic0<DATAWORD, &copy_dbtrue0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    } else {
+      loop_generic0<DATAWORD, &copy_db0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    }
+  } else { // read transaction
+    if(orig_be == 0) {
+      loop_generic0<DATAWORD, &copy_btrue0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    } else {
+      loop_generic0<DATAWORD, &copy_b0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    }
+  }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Utilities
+template<class D>
+inline void copy_d1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest1) = *((D *)src1);
+  *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
+}
+
+template<class D>
+inline void copy_db1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest1) = *((D *)src1);
+  *((D *)dest2) = *((D *)src2);
+}
+
+template<class D>
+inline void true_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
+}
+
+template<class D>
+inline void copy_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest2) = *((D *)src2);
+}
+
+template<class D>
+inline void copy_dbyb1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  if(*src2 != TLM_BYTE_DISABLED)  *((D *)src1) = *((D *)dest1);
+}
+
+template<class D>
+inline void copy_dbytrue1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)src1) = *((D *)dest1);
+}
+
+template<class D> inline void false_b1(uchar *dest1) {
+  *((D *)dest1) = tlm_bool<D>::TLM_FALSE;
+}
+
+template<class D> inline void no_b1(uchar *dest1) {
+}
+
+template<class D,
+         void COPY(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
+         void COPYuchar(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
+         void FILLFALSE(uchar *dest1), void FILLFALSEuchar(uchar *dest1)>
+inline int loop_word1(
+  int bytes_left, int len0, int lenN, int sizeof_databus,
+  uchar *start, uchar *end, uchar *src, uchar *bsrc, uchar *dest, uchar *bdest) {
+  ptrdiff_t d2b_src = bsrc - src;  // 64BITFIX was int //
+  ptrdiff_t d2b_dest = bdest - dest;  // 64BITFIX was int //
+  uchar *original_dest = dest;
+
+  while(true) {
+    // len0 bytes at start of a bus word
+    if((src >= start) && (src < end)) {
+      for(int i=0; i<len0; i++) {
+        COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
+        src++;
+        dest++;
+      }
+      bytes_left -= len0;
+      if(bytes_left <= 0) return int(dest - original_dest);
+    } else {
+      for(int i=0; i<len0; i++) {
+        FILLFALSEuchar(dest+d2b_dest);
+        src++;
+        dest++;
+      }
+    }
+    src -= 2 * sizeof(D);
+
+    // sequence of full data word fragments
+    for(unsigned int i=1; i<sizeof_databus/sizeof(D); i++) {
+      if((src >= start) && (src < end)) {
+        COPY(src, src+d2b_src, dest, dest+d2b_dest);
+        bytes_left -= sizeof(D);
+      } else {
+        FILLFALSE(dest+d2b_dest);
+      }
+      dest += sizeof(D);
+      if(bytes_left <= 0) return int(dest - original_dest);
+      src -= sizeof(D);
+    }
+
+    // lenN bytes at end of bus word
+    if((src >= start) && (src < end)) {
+      for(int i=0; i<lenN; i++) {
+        COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
+        src++;
+        dest++;
+      }
+      bytes_left -= lenN;
+      if(bytes_left <= 0) return int(dest - original_dest);
+    } else {
+      for(int i=0; i<lenN; i++) {
+        FILLFALSEuchar(dest+d2b_dest);
+        src++;
+        dest++;
+      }
+    }
+    src += 2 * sizeof_databus;
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  if(txn->is_read()) {
+    tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+    sc_dt::uint64 b_mask = sizeof_databus - 1;
+    int d_mask = sizeof(DATAWORD) - 1;
+    int a_offset = static_cast<int>(tc->address & b_mask);
+    int len0 = (sizeof_databus - a_offset) & d_mask;
+    int lenN = sizeof(DATAWORD) - len0;
+    uchar *d_start = tc->data_ptr;
+    uchar *d_end = ptrdiff_t(tc->length) + d_start;  // 64BITFIX probably redundant //
+    uchar *d = ptrdiff_t(((sizeof_databus - a_offset) & ~d_mask) + lenN) + d_start;  // 64BITFIX probably redundant //
+
+    // iterate over transaction copying data qualified by byte-enables
+    if(tc->byte_enable == 0) {
+      loop_word1<DATAWORD, &copy_dbytrue1<DATAWORD>,
+        &copy_dbytrue1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
+        tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
+        0, txn->get_data_ptr(), 0);
+    } else {
+      loop_word1<DATAWORD, &copy_dbyb1<DATAWORD>,
+        &copy_dbyb1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
+        tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
+        tc->byte_enable - d_start + d, txn->get_data_ptr(), 0);
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_word<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  sc_dt::uint64 b_mask = sizeof_databus - 1;
+  int d_mask = sizeof(DATAWORD) - 1;
+  sc_dt::uint64 a_aligned = txn->get_address() & ~b_mask;
+  int a_offset = static_cast<int>(txn->get_address() & b_mask);
+  int len0 = (sizeof_databus - a_offset) & d_mask;
+  int lenN = sizeof(DATAWORD) - len0;
+  uchar *d_start = txn->get_data_ptr();
+  uchar *d_end = ptrdiff_t(txn->get_data_length()) + d_start;  // 64BITFIX probably redundant //
+  uchar *d = ptrdiff_t(((sizeof_databus - a_offset) & ~d_mask) + lenN) + d_start;  // 64BITFIX probably redundant //
+
+  // create new data and byte enable buffers
+  int long_enough = txn->get_data_length() + 2 * sizeof_databus;
+  tc->establish_dbuf(long_enough);
+  uchar *new_data = tc->new_dbuf;
+  tc->establish_bebuf(long_enough);
+  uchar *new_be = tc->new_bebuf;
+
+  if(txn->is_read()) {
+    tc->data_ptr = d_start;
+    tc->address = txn->get_address();
+    tc->byte_enable = txn->get_byte_enable_ptr();
+    tc->length = txn->get_data_length();
+    if(txn->get_byte_enable_ptr() == 0) {
+      // iterate over transaction creating new byte enables from all-true
+      txn->set_data_length(loop_word1<DATAWORD, &true_b1<DATAWORD>,
+        &true_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus,
+        d_start, d_end, d, 0, new_data, new_be));
+    } else {
+      // iterate over transaction copying byte enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_b1<DATAWORD>,
+        &copy_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
+        d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
+    }
+  } else {
+    // WRITE
+    if(txn->get_byte_enable_ptr() == 0) {
+      // iterate over transaction copying data and creating new byte-enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_d1<DATAWORD>,
+        &copy_d1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus,
+        d_start, d_end, d, 0, new_data, new_be));
+    } else {
+      // iterate over transaction copying data and byte-enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_db1<DATAWORD>,
+        &copy_db1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
+        d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
+    }
+  }
+  txn->set_byte_enable_length(txn->get_data_length());
+  txn->set_streaming_width(txn->get_data_length());
+  txn->set_data_ptr(new_data);
+  txn->set_byte_enable_ptr(new_be);
+  txn->set_address(a_aligned);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Utilities
+template<class D> inline void copy_d2(D *src1, D *src2, D *dest1, D *dest2) {
+  *dest1 = *src1;
+}
+
+template<class D> inline void copy_db2(D *src1, D *src2, D *dest1, D *dest2) {
+  *dest1 = *src1;
+  *dest2 = *src2;
+}
+
+template<class D>
+inline void copy_dbyb2(D *src1, D *src2, D *dest1, D *dest2) {
+  if(tlm_bool<D>(*src2)) *dest1 = *src1;
+}
+
+template<class D, void COPY(D *src1, D *src2, D *dest1, D *dest2)>
+inline void loop_aligned2(D *src1, D *src2, D *dest1, D *dest2,
+    int words, int words_per_bus) {
+  ptrdiff_t src1to2 = (char *)src2 - (char *)src1;  // 64BITFIX was int and operands were cast to int //
+  ptrdiff_t dest1to2 = (char *)dest2 - (char *)dest1;  // 64BITFIX was int and operands were cast to int //
+
+  D *done = src1 + ptrdiff_t(words);  // 64BITFIX //
+  D *bus_start = src1;
+  src1 += ptrdiff_t(words_per_bus - 1);  // 64BITFIX //
+
+  while(true) {
+    COPY(src1, (D *)(src1to2+(char *)src1), dest1, (D *)(dest1to2+(char *)dest1));   // 64BITFIX //
+    dest1++;
+    if((--src1) < bus_start) {
+      bus_start += ptrdiff_t(words_per_bus);  // 64BITFIX //
+      if(bus_start == done) break;
+      src1 = bus_start + ptrdiff_t(words_per_bus - 1);  // 64BITFIX //
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  int words_per_bus = sizeof_databus/sizeof(DATAWORD);
+  if(words_per_bus == 1) return;
+  int words = (txn->get_data_length())/sizeof(DATAWORD);
+  tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+
+  if(txn->get_byte_enable_ptr() == 0) {
+    // no byte enables
+    if(txn->is_read()) {
+      // RD without byte enables.  Copy data to original buffer
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(
+        (DATAWORD *)(txn->get_data_ptr()),
+        0, (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
+    }
+  } else {
+    // byte enables present
+    if(txn->is_read()) {
+      // RD with byte enables.  Copy data qualified by byte-enables
+      loop_aligned2<DATAWORD, &copy_dbyb2<DATAWORD> >(
+        (DATAWORD *)(txn->get_data_ptr()),
+        (DATAWORD *)(txn->get_byte_enable_ptr()),
+        (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_aligned<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  int words_per_bus = sizeof_databus/sizeof(DATAWORD);
+  if(words_per_bus == 1) return;
+  int words = (txn->get_data_length())/sizeof(DATAWORD);
+
+  DATAWORD *original_be = (DATAWORD *)(txn->get_byte_enable_ptr());
+  DATAWORD *original_data = (DATAWORD *)(txn->get_data_ptr());
+
+  // always allocate a new data buffer
+  tc->establish_dbuf(txn->get_data_length());
+  txn->set_data_ptr(tc->new_dbuf);
+
+  if(original_be == 0) {
+    // no byte enables
+    if(txn->is_write()) {
+      // WR no byte enables.  Copy data
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(original_data, 0,
+        (DATAWORD *)(txn->get_data_ptr()), 0,
+        words, words_per_bus);
+    } else {
+      // RD no byte enables.  Save original data pointer
+      tc->data_ptr = (uchar *)original_data;
+    }
+  } else {
+    // byte enables present
+    // allocate a new buffer for them
+    tc->establish_bebuf(txn->get_data_length());
+    txn->set_byte_enable_ptr(tc->new_bebuf);
+    txn->set_byte_enable_length(txn->get_data_length());
+
+    if(txn->is_write()) {
+      // WR with byte enables.  Copy data and BEs
+      loop_aligned2<DATAWORD, &copy_db2<DATAWORD> >(original_data, original_be,
+        (DATAWORD *)(txn->get_data_ptr()),
+        (DATAWORD *)(txn->get_byte_enable_ptr()), words, words_per_bus);
+    } else {
+      // RD with byte enables.  Save original data pointer
+      tc->data_ptr = (uchar *)original_data;
+      // Copy byte enables to new buffer
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(original_be, 0,
+        (DATAWORD *)(txn->get_byte_enable_ptr()), 0,
+        words, words_per_bus);
+    }
+  }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (3): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  // nothing needs to be done here
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (3): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_single<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  // only need to change the address, always safe to work in-place
+  sc_dt::uint64 mask = sizeof_databus-1;
+  sc_dt::uint64 a = txn->get_address();
+  txn->set_address((a & ~mask) |
+    (sizeof_databus - (a & mask) - sizeof(DATAWORD)));
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// helper function which works for all responses
+inline void tlm_from_hostendian(tlm_generic_payload *txn) {
+  tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
+  (*(tc->from_f))(txn, tc->sizeof_databus);
+}
+
+
+#ifndef TLM_END_CONV_DONT_UNDEF_UCHAR
+#undef uchar
+#endif
+
+}  // namespace tlm
+
+
+#endif  // multiple-inclusion protection
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h
new file mode 100644
index 000000000..3e25e56f2
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h
@@ -0,0 +1,29 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_GENERIC_PAYLOAD_H__
+#define __TLM_GENERIC_PAYLOAD_H__
+
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h
new file mode 100644
index 000000000..965e059ab
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h
@@ -0,0 +1,642 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+// 12-Jan-2009  John Aynsley  Bug fix. has_mm() and get_ref_count() should both be const
+// 23-Mar-2009  John Aynsley  Add method update_original_from()
+// 20-Apr-2009  John Aynsley  Bug fix for 64-bit machines: unsigned long int -> unsigned int
+//  5-May-2011  JA and Philipp Hartmann  Add tlm_gp_option, set_gp_option, get_gp_option
+// 11-May-2011  John Aynsley  Add run-time check to release()
+
+
+#ifndef __TLM_GP_H__
+#define __TLM_GP_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_array.h"
+
+namespace tlm {
+
+class
+tlm_generic_payload;
+
+class tlm_mm_interface {
+public:
+  virtual void free(tlm_generic_payload*) = 0;
+  virtual ~tlm_mm_interface() {}
+};
+
+//---------------------------------------------------------------------------
+// Classes and helper functions for the extension mechanism
+//---------------------------------------------------------------------------
+// Helper function:
+inline unsigned int max_num_extensions(bool increment=false)
+{
+    static unsigned int max_num = 0;
+    if (increment) ++max_num;
+    return max_num;
+}
+
+// This class can be used for storing pointers to the extension classes, used
+// in tlm_generic_payload:
+class tlm_extension_base
+{
+public:
+    virtual tlm_extension_base* clone() const = 0;
+    virtual void free() { delete this; }
+    virtual void copy_from(tlm_extension_base const &) = 0;
+protected:
+    virtual ~tlm_extension_base() {}
+    static unsigned int register_extension()
+    {
+        return (max_num_extensions(true) - 1);
+    };
+};
+
+// Base class for all extension classes, derive your extension class in
+// the following way:
+// class my_extension : public tlm_extension<my_extension> { ...
+// This triggers proper extension registration during C++ static
+// contruction time. my_extension::ID will hold the unique index in the
+// tlm_generic_payload::m_extensions array.
+template <typename T>
+class tlm_extension : public tlm_extension_base
+{
+public:
+    virtual tlm_extension_base* clone() const = 0;
+    virtual void copy_from(tlm_extension_base const &ext) = 0; //{assert(typeid(this)==typeid(ext)); assert(ID === ext.ID); assert(0);}
+    virtual ~tlm_extension() {}
+    const static unsigned int ID;
+};
+
+template <typename T>
+const
+unsigned int tlm_extension<T>::ID = tlm_extension_base::register_extension();
+
+//---------------------------------------------------------------------------
+// enumeration types
+//---------------------------------------------------------------------------
+enum tlm_command {
+    TLM_READ_COMMAND,
+    TLM_WRITE_COMMAND,
+    TLM_IGNORE_COMMAND
+};
+
+enum tlm_response_status {
+    TLM_OK_RESPONSE = 1,
+    TLM_INCOMPLETE_RESPONSE = 0,
+    TLM_GENERIC_ERROR_RESPONSE = -1,
+    TLM_ADDRESS_ERROR_RESPONSE = -2,
+    TLM_COMMAND_ERROR_RESPONSE = -3,
+    TLM_BURST_ERROR_RESPONSE = -4,
+    TLM_BYTE_ENABLE_ERROR_RESPONSE = -5
+};
+
+enum tlm_gp_option {
+    TLM_MIN_PAYLOAD,
+    TLM_FULL_PAYLOAD,
+    TLM_FULL_PAYLOAD_ACCEPTED
+};
+
+#define TLM_BYTE_DISABLED 0x0
+#define TLM_BYTE_ENABLED 0xff
+
+//---------------------------------------------------------------------------
+// The generic payload class:
+//---------------------------------------------------------------------------
+class tlm_generic_payload {
+
+public:
+    //---------------
+    // Constructors
+    //---------------
+
+    // Default constructor
+    tlm_generic_payload()
+        : m_address(0)
+        , m_command(TLM_IGNORE_COMMAND)
+        , m_data(0)
+        , m_length(0)
+        , m_response_status(TLM_INCOMPLETE_RESPONSE)
+        , m_dmi(false)
+        , m_byte_enable(0)
+        , m_byte_enable_length(0)
+        , m_streaming_width(0)
+        , m_gp_option(TLM_MIN_PAYLOAD)
+        , m_extensions(max_num_extensions())
+        , m_mm(0)
+        , m_ref_count(0)
+    {
+    }
+
+    explicit tlm_generic_payload(tlm_mm_interface* mm)
+        : m_address(0)
+        , m_command(TLM_IGNORE_COMMAND)
+        , m_data(0)
+        , m_length(0)
+        , m_response_status(TLM_INCOMPLETE_RESPONSE)
+        , m_dmi(false)
+        , m_byte_enable(0)
+        , m_byte_enable_length(0)
+        , m_streaming_width(0)
+        , m_gp_option(TLM_MIN_PAYLOAD)
+        , m_extensions(max_num_extensions())
+        , m_mm(mm)
+        , m_ref_count(0)
+    {
+    }
+
+    void acquire(){assert(m_mm != 0); m_ref_count++;}
+    void release(){assert(m_mm != 0 && m_ref_count > 0); if (--m_ref_count==0) m_mm->free(this);}
+    int get_ref_count() const {return m_ref_count;}
+    void set_mm(tlm_mm_interface* mm) { m_mm = mm; }
+    bool has_mm() const { return m_mm != 0; }
+
+    void reset(){
+      //should the other members be reset too?
+      m_gp_option = TLM_MIN_PAYLOAD;
+      m_extensions.free_entire_cache();
+    };
+
+
+private:
+    //disabled copy ctor and assignment operator.
+    // Copy constructor
+    tlm_generic_payload(const tlm_generic_payload& x)
+        : m_address(x.get_address())
+        , m_command(x.get_command())
+        , m_data(x.get_data_ptr())
+        , m_length(x.get_data_length())
+        , m_response_status(x.get_response_status())
+        , m_dmi(x.is_dmi_allowed())
+        , m_byte_enable(x.get_byte_enable_ptr())
+        , m_byte_enable_length(x.get_byte_enable_length())
+        , m_streaming_width(x.get_streaming_width())
+        , m_gp_option(x.m_gp_option)
+        , m_extensions(max_num_extensions())
+    {
+        // copy all extensions
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            m_extensions[i] = x.get_extension(i);
+        }
+    }
+
+    // Assignment operator
+    tlm_generic_payload& operator= (const tlm_generic_payload& x)
+    {
+        m_command =            x.get_command();
+        m_address =            x.get_address();
+        m_data =               x.get_data_ptr();
+        m_length =             x.get_data_length();
+        m_response_status =    x.get_response_status();
+        m_byte_enable =        x.get_byte_enable_ptr();
+        m_byte_enable_length = x.get_byte_enable_length();
+        m_streaming_width =    x.get_streaming_width();
+        m_gp_option =          x.get_gp_option();
+        m_dmi =                x.is_dmi_allowed();
+
+        // extension copy: all extension arrays must be of equal size by
+        // construction (i.e. it must either be constructed after C++
+        // static construction time, or the resize_extensions() method must
+        // have been called prior to using the object)
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            m_extensions[i] = x.get_extension(i);
+        }
+        return (*this);
+    }
+public:
+    // non-virtual deep-copying of the object
+    void deep_copy_from(const tlm_generic_payload & other)
+    {
+        m_command =            other.get_command();
+        m_address =            other.get_address();
+        m_length =             other.get_data_length();
+        m_response_status =    other.get_response_status();
+        m_byte_enable_length = other.get_byte_enable_length();
+        m_streaming_width =    other.get_streaming_width();
+        m_gp_option =          other.get_gp_option();
+        m_dmi =                other.is_dmi_allowed();
+
+        // deep copy data
+        // there must be enough space in the target transaction!
+        if(m_data && other.m_data)
+        {
+            memcpy(m_data, other.m_data, m_length);
+        }
+        // deep copy byte enables
+        // there must be enough space in the target transaction!
+        if(m_byte_enable && other.m_byte_enable)
+        {
+            memcpy(m_byte_enable, other.m_byte_enable, m_byte_enable_length);
+        }
+        // deep copy extensions (sticky and non-sticky)
+        for(unsigned int i=0; i<other.m_extensions.size(); i++)
+        {
+            if(other.m_extensions[i])
+            {                       //original has extension i
+                if(!m_extensions[i])
+                {                   //We don't: clone.
+                    tlm_extension_base *ext = other.m_extensions[i]->clone();
+                    if(ext)     //extension may not be clonable.
+                    {
+                        if(has_mm())
+                        {           //mm can take care of removing cloned extensions
+                            set_auto_extension(i, ext);
+                        }
+                        else
+                        {           // no mm, user will call free_all_extensions().
+                            set_extension(i, ext);
+                        }
+                    }
+                }
+                else
+                {                   //We already have such extension. Copy original over it.
+                    m_extensions[i]->copy_from(*other.m_extensions[i]);
+                }
+            }
+        }
+    }
+
+    // To update the state of the original generic payload from a deep copy
+    // Assumes that "other" was created from the original by calling deep_copy_from
+    // Argument use_byte_enable_on_read determines whether to use or ignores byte enables
+    // when copying back the data array on a read command
+
+    void update_original_from(const tlm_generic_payload & other,
+                              bool use_byte_enable_on_read = true)
+    {
+        // Copy back extensions that are present on the original
+        update_extensions_from(other);
+
+        // Copy back the response status and DMI hint attributes
+        m_response_status = other.get_response_status();
+        m_dmi             = other.is_dmi_allowed();
+
+        // Copy back the data array for a read command only
+        // deep_copy_from allowed null pointers, and so will we
+        // We assume the arrays are the same size
+        // We test for equal pointers in case the original and the copy share the same array
+
+        if(is_read() && m_data && other.m_data && m_data != other.m_data)
+        {
+            if (m_byte_enable && use_byte_enable_on_read)
+            {
+                if (m_byte_enable_length == 8 && m_length % 8 == 0 )
+                {
+                    // Optimized implementation copies 64-bit words by masking
+                    for (unsigned int i = 0; i < m_length; i += 8)
+                    {
+                        typedef sc_dt::uint64* u;
+                        *reinterpret_cast<u>(&m_data[i]) &= ~*reinterpret_cast<u>(m_byte_enable);
+                        *reinterpret_cast<u>(&m_data[i]) |= *reinterpret_cast<u>(&other.m_data[i]) &
+                                                            *reinterpret_cast<u>(m_byte_enable);
+                    }
+                }
+                else if (m_byte_enable_length == 4 && m_length % 4 == 0 )
+                {
+                    // Optimized implementation copies 32-bit words by masking
+                    for (unsigned int i = 0; i < m_length; i += 4)
+                    {
+                        typedef unsigned int* u;
+                        *reinterpret_cast<u>(&m_data[i]) &= ~*reinterpret_cast<u>(m_byte_enable);
+                        *reinterpret_cast<u>(&m_data[i]) |= *reinterpret_cast<u>(&other.m_data[i]) &
+                                                            *reinterpret_cast<u>(m_byte_enable);
+                    }
+                }
+                else
+                    // Unoptimized implementation
+                    for (unsigned int i = 0; i < m_length; i++)
+                        if ( m_byte_enable[i % m_byte_enable_length] )
+                            m_data[i] = other.m_data[i];
+            }
+            else
+              memcpy(m_data, other.m_data, m_length);
+        }
+    }
+
+    void update_extensions_from(const tlm_generic_payload & other)
+    {
+        // deep copy extensions that are already present
+        for(unsigned int i=0; i<other.m_extensions.size(); i++)
+        {
+            if(other.m_extensions[i])
+            {                       //original has extension i
+                if(m_extensions[i])
+                {                   //We have it too. copy.
+                    m_extensions[i]->copy_from(*other.m_extensions[i]);
+                }
+            }
+        }
+    }
+
+    // Free all extensions. Useful when reusing a cloned transaction that doesn't have memory manager.
+    // normal and sticky extensions are freed and extension array cleared.
+    void free_all_extensions()
+    {
+        m_extensions.free_entire_cache();
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            if(m_extensions[i])
+            {
+                m_extensions[i]->free();
+                m_extensions[i] = 0;
+            }
+        }
+    }
+    //--------------
+    // Destructor
+    //--------------
+    virtual ~tlm_generic_payload() {
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+            if(m_extensions[i]) m_extensions[i]->free();
+    }
+
+    //----------------
+    // API (including setters & getters)
+    //---------------
+
+    // Command related method
+    bool                 is_read() const {return (m_command == TLM_READ_COMMAND);}
+    void                 set_read() {m_command = TLM_READ_COMMAND;}
+    bool                 is_write() const {return (m_command == TLM_WRITE_COMMAND);}
+    void                 set_write() {m_command = TLM_WRITE_COMMAND;}
+    tlm_command          get_command() const {return m_command;}
+    void                 set_command(const tlm_command command) {m_command = command;}
+
+    // Address related methods
+    sc_dt::uint64        get_address() const {return m_address;}
+    void                 set_address(const sc_dt::uint64 address) {m_address = address;}
+
+    // Data related methods
+    unsigned char*       get_data_ptr() const {return m_data;}
+    void                 set_data_ptr(unsigned char* data) {m_data = data;}
+
+    // Transaction length (in bytes) related methods
+    unsigned int         get_data_length() const {return m_length;}
+    void                 set_data_length(const unsigned int length) {m_length = length;}
+
+    // Response status related methods
+    bool                 is_response_ok() const {return (m_response_status > 0);}
+    bool                 is_response_error() const {return (m_response_status <= 0);}
+    tlm_response_status  get_response_status() const {return m_response_status;}
+    void                 set_response_status(const tlm_response_status response_status)
+        {m_response_status = response_status;}
+    std::string          get_response_string() const
+    {
+        switch(m_response_status)
+        {
+        case TLM_OK_RESPONSE:            return "TLM_OK_RESPONSE";
+        case TLM_INCOMPLETE_RESPONSE:    return "TLM_INCOMPLETE_RESPONSE";
+        case TLM_GENERIC_ERROR_RESPONSE: return "TLM_GENERIC_ERROR_RESPONSE";
+        case TLM_ADDRESS_ERROR_RESPONSE: return "TLM_ADDRESS_ERROR_RESPONSE";
+        case TLM_COMMAND_ERROR_RESPONSE: return "TLM_COMMAND_ERROR_RESPONSE";
+        case TLM_BURST_ERROR_RESPONSE:   return "TLM_BURST_ERROR_RESPONSE";
+        case TLM_BYTE_ENABLE_ERROR_RESPONSE: return "TLM_BYTE_ENABLE_ERROR_RESPONSE";
+        }
+        return "TLM_UNKNOWN_RESPONSE";
+    }
+
+    // Streaming related methods
+    unsigned int         get_streaming_width() const {return m_streaming_width;}
+    void                 set_streaming_width(const unsigned int streaming_width) {m_streaming_width = streaming_width; }
+
+    // Byte enable related methods
+    unsigned char*       get_byte_enable_ptr() const {return m_byte_enable;}
+    void                 set_byte_enable_ptr(unsigned char* byte_enable){m_byte_enable = byte_enable;}
+    unsigned int         get_byte_enable_length() const {return m_byte_enable_length;}
+    void                 set_byte_enable_length(const unsigned int byte_enable_length){m_byte_enable_length = byte_enable_length;}
+
+    // This is the "DMI-hint" a slave can set this to true if it
+    // wants to indicate that a DMI request would be supported:
+    void                 set_dmi_allowed(bool dmi_allowed) { m_dmi = dmi_allowed; }
+    bool                 is_dmi_allowed() const { return m_dmi; }
+
+    // Use full set of attributes in DMI/debug?
+    tlm_gp_option get_gp_option() const { return m_gp_option; }
+    void          set_gp_option( const tlm_gp_option gp_opt ) { m_gp_option = gp_opt; }
+
+private:
+
+    /* --------------------------------------------------------------------- */
+    /* Generic Payload attributes:                                           */
+    /* --------------------------------------------------------------------- */
+    /* - m_command         : Type of transaction. Three values supported:    */
+    /*                       - TLM_WRITE_COMMAND                             */
+    /*                       - TLM_READ_COMMAND                              */
+    /*                       - TLM_IGNORE_COMMAND                            */
+    /* - m_address         : Transaction base address (byte-addressing).     */
+    /* - m_data            : When m_command = TLM_WRITE_COMMAND contains a   */
+    /*                       pointer to the data to be written in the target.*/
+    /*                       When m_command = TLM_READ_COMMAND contains a    */
+    /*                       pointer where to copy the data read from the    */
+    /*                       target.                                         */
+    /* - m_length          : Total number of bytes of the transaction.       */
+    /* - m_response_status : This attribute indicates whether an error has   */
+    /*                       occurred during the transaction.                */
+    /*                       Values supported are:                           */
+    /*                       - TLM_OK_RESP                                   */
+    /*                       - TLM_INCOMPLETE_RESP                           */
+    /*                       - TLM_GENERIC_ERROR_RESP                        */
+    /*                       - TLM_ADDRESS_ERROR_RESP                        */
+    /*                       - TLM_COMMAND_ERROR_RESP                        */
+    /*                       - TLM_BURST_ERROR_RESP                          */
+    /*                       - TLM_BYTE_ENABLE_ERROR_RESP                    */
+    /*                                                                       */
+    /* - m_byte_enable     : It can be used to create burst transfers where  */
+    /*                    the address increment between each beat is greater */
+    /*                    than the word length of each beat, or to place     */
+    /*                    words in selected byte lanes of a bus.             */
+    /* - m_byte_enable_length : For a read or a write command, the target    */
+    /*                    interpret the byte enable length attribute as the  */
+    /*                    number of elements in the bytes enable array.      */
+    /* - m_streaming_width  :                                                */
+    /* --------------------------------------------------------------------- */
+
+    sc_dt::uint64        m_address;
+    tlm_command          m_command;
+    unsigned char*       m_data;
+    unsigned int         m_length;
+    tlm_response_status  m_response_status;
+    bool                 m_dmi;
+    unsigned char*       m_byte_enable;
+    unsigned int         m_byte_enable_length;
+    unsigned int         m_streaming_width;
+    tlm_gp_option        m_gp_option;
+
+public:
+
+    /* --------------------------------------------------------------------- */
+    /* Dynamic extension mechanism:                                          */
+    /* --------------------------------------------------------------------- */
+    /* The extension mechanism is intended to enable initiator modules to    */
+    /* optionally and transparently add data fields to the                   */
+    /* tlm_generic_payload. Target modules are free to check for extensions  */
+    /* and may or may not react to the data in the extension fields. The     */
+    /* definition of the extensions' semantics is solely in the              */
+    /* responsibility of the user.                                           */
+    /*                                                                       */
+    /* The following rules apply:                                            */
+    /*                                                                       */
+    /* - Every extension class must be derived from tlm_extension, e.g.:     */
+    /*     class my_extension : public tlm_extension<my_extension> { ... }   */
+    /*                                                                       */
+    /* - A tlm_generic_payload object should be constructed after C++        */
+    /*   static initialization time. This way it is guaranteed that the      */
+    /*   extension array is of sufficient size to hold all possible          */
+    /*   extensions. Alternatively, the initiator module can enforce a valid */
+    /*   extension array size by calling the resize_extensions() method      */
+    /*   once before the first transaction with the payload object is        */
+    /*   initiated.                                                          */
+    /*                                                                       */
+    /* - Initiators should use the the set_extension(e) or clear_extension(e)*/
+    /*   methods for manipulating the extension array. The type of the       */
+    /*   argument must be a pointer to the specific registered extension     */
+    /*   type (my_extension in the above example) and is used to             */
+    /*   automatically locate the appropriate index in the array.            */
+    /*                                                                       */
+    /* - Targets can check for a specific extension by calling               */
+    /*   get_extension(e). e will point to zero if the extension is not      */
+    /*   present.                                                            */
+    /*                                                                       */
+    /* --------------------------------------------------------------------- */
+
+    // Stick the pointer to an extension into the vector, return the
+    // previous value:
+    template <typename T> T* set_extension(T* ext)
+    {
+        return static_cast<T*>(set_extension(T::ID, ext));
+    }
+
+    // non-templatized version with manual index:
+    tlm_extension_base* set_extension(unsigned int index,
+                                      tlm_extension_base* ext)
+    {
+        tlm_extension_base* tmp = m_extensions[index];
+        m_extensions[index] = ext;
+        return tmp;
+    }
+
+    // Stick the pointer to an extension into the vector, return the
+    // previous value and schedule its release
+    template <typename T> T* set_auto_extension(T* ext)
+    {
+        return static_cast<T*>(set_auto_extension(T::ID, ext));
+    }
+
+    // non-templatized version with manual index:
+    tlm_extension_base* set_auto_extension(unsigned int index,
+                                           tlm_extension_base* ext)
+    {
+        tlm_extension_base* tmp = m_extensions[index];
+        m_extensions[index] = ext;
+        if (!tmp) m_extensions.insert_in_cache(&m_extensions[index]);
+        assert(m_mm != 0);
+        return tmp;
+    }
+
+    // Check for an extension, ext will point to 0 if not present
+    template <typename T> void get_extension(T*& ext) const
+    {
+        ext = get_extension<T>();
+    }
+    template <typename T> T* get_extension() const
+    {
+        return static_cast<T*>(get_extension(T::ID));
+    }
+    // Non-templatized version with manual index:
+    tlm_extension_base* get_extension(unsigned int index) const
+    {
+        return m_extensions[index];
+    }
+
+    //this call just removes the extension from the txn but does not
+    // call free() or tells the MM to do so
+    // it return false if there was active MM so you are now in an unsafe situation
+    // recommended use: when 100% sure there is no MM
+    template <typename T> void clear_extension(const T* ext)
+    {
+        clear_extension<T>();
+    }
+
+    //this call just removes the extension from the txn but does not
+    // call free() or tells the MM to do so
+    // it return false if there was active MM so you are now in an unsafe situation
+    // recommended use: when 100% sure there is no MM
+    template <typename T> void clear_extension()
+    {
+        clear_extension(T::ID);
+    }
+
+    //this call removes the extension from the txn and does
+    // call free() or tells the MM to do so when the txn is finally done
+    // recommended use: when not sure there is no MM
+    template <typename T> void release_extension(T* ext)
+    {
+        release_extension<T>();
+    }
+
+    //this call removes the extension from the txn and does
+    // call free() or tells the MM to do so when the txn is finally done
+    // recommended use: when not sure there is no MM
+    template <typename T> void release_extension()
+    {
+        release_extension(T::ID);
+    }
+
+private:
+    // Non-templatized version with manual index
+    void clear_extension(unsigned int index)
+    {
+        m_extensions[index] = static_cast<tlm_extension_base*>(0);
+    }
+    // Non-templatized version with manual index
+    void release_extension(unsigned int index)
+    {
+        if (m_mm)
+        {
+            m_extensions.insert_in_cache(&m_extensions[index]);
+        }
+        else
+        {
+            m_extensions[index]->free();
+            m_extensions[index] = static_cast<tlm_extension_base*>(0);
+        }
+    }
+
+public:
+    // Make sure the extension array is large enough. Can be called once by
+    // an initiator module (before issuing the first transaction) to make
+    // sure that the extension array is of correct size. This is only needed
+    // if the initiator cannot guarantee that the generic payload object is
+    // allocated after C++ static construction time.
+    void resize_extensions()
+    {
+        m_extensions.expand(max_num_extensions());
+    }
+
+private:
+    tlm_array<tlm_extension_base*> m_extensions;
+    tlm_mm_interface*              m_mm;
+    unsigned int                   m_ref_count;
+};
+
+} // namespace tlm
+
+#endif /* __TLM_GP_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h
new file mode 100644
index 000000000..da3abb4f9
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h
@@ -0,0 +1,80 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+/* ---------------------------------------------------------------------------------------
+ @file tlm_helpers.h
+ 
+ @brief
+ 
+  Original Authors:
+    Charles Wilson, ESLX
+    
+--------------------------------------------------------------------------------------- */
+
+#ifndef __TLM_HELPERS_H__
+#define __TLM_HELPERS_H__
+
+//#include <sys/param.h>
+//#include <cstring>
+
+namespace tlm {
+
+enum tlm_endianness { TLM_UNKNOWN_ENDIAN, TLM_LITTLE_ENDIAN, TLM_BIG_ENDIAN };
+
+inline tlm_endianness get_host_endianness(void)
+{
+  static tlm_endianness host_endianness = TLM_UNKNOWN_ENDIAN;
+  
+  if (host_endianness == TLM_UNKNOWN_ENDIAN) {
+    unsigned int number = 1;
+    unsigned char *p_msb_or_lsb = (unsigned char*)&number;
+
+    host_endianness = (p_msb_or_lsb[0] == 0) ? TLM_BIG_ENDIAN : TLM_LITTLE_ENDIAN;
+  }
+  return host_endianness;
+}
+
+inline bool host_has_little_endianness(void)
+{
+  static tlm_endianness host_endianness = TLM_UNKNOWN_ENDIAN;
+  static bool host_little_endian = false;
+  
+  if (host_endianness == TLM_UNKNOWN_ENDIAN) {
+    unsigned int number = 1;
+    unsigned char *p_msb_or_lsb = (unsigned char*)&number;
+
+    host_little_endian = (p_msb_or_lsb[0] == 0) ? false : true;
+  }
+
+  return host_little_endian;
+}
+
+inline bool has_host_endianness(tlm_endianness endianness)
+{
+  if (host_has_little_endianness()) {
+    return endianness == TLM_LITTLE_ENDIAN;
+
+  } else {
+    return endianness == TLM_BIG_ENDIAN;
+  }
+} 
+
+} // namespace tlm
+
+#endif /* __TLM_HELPERS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h
new file mode 100644
index 000000000..af0a278c9
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h
@@ -0,0 +1,87 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_PHASE_H__
+#define __TLM_PHASE_H__
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+namespace tlm {
+
+//enum tlm_phase { BEGIN_REQ, END_REQ, BEGIN_RESP, END_RESP };
+  
+enum tlm_phase_enum { UNINITIALIZED_PHASE=0, BEGIN_REQ=1, END_REQ, BEGIN_RESP, END_RESP };
+
+inline unsigned int create_phase_number(){
+  static unsigned int number=END_RESP+1;
+  return number++;
+}
+
+inline std::vector<const char*>& get_phase_name_vec(){
+  static std::vector<const char*> phase_name_vec(END_RESP+1, (const char*)NULL);
+  return phase_name_vec;
+}
+
+class tlm_phase{
+public:
+  tlm_phase(): m_id(0) {}
+  tlm_phase(unsigned int id): m_id(id){}
+  tlm_phase(const tlm_phase_enum& standard): m_id((unsigned int) standard){}
+  tlm_phase& operator=(const tlm_phase_enum& standard){m_id=(unsigned int)standard; return *this;}
+  operator unsigned int() const{return m_id;}
+  
+private:
+  unsigned int m_id;  
+};
+
+inline
+std::ostream& operator<<(std::ostream& s, const tlm_phase& p){
+  switch ((unsigned int)p){
+    case UNINITIALIZED_PHASE: s<<"UNINITIALIZED_PHASE"; break;
+    case BEGIN_REQ:  s<<"BEGIN_REQ"; break;
+    case END_REQ:    s<<"END_REQ"; break;
+    case BEGIN_RESP: s<<"BEGIN_RESP"; break;
+    case END_RESP:   s<<"END_RESP"; break;
+    default:
+      s<<get_phase_name_vec()[(unsigned int)p]; return s;      
+  }
+  return s;
+}
+  
+#define TLM_DECLARE_EXTENDED_PHASE(name_arg) \
+class tlm_phase_##name_arg:public tlm::tlm_phase{ \
+public:\
+static const tlm_phase_##name_arg& get_phase(){static tlm_phase_##name_arg tmp; return tmp;}\
+private:\
+tlm_phase_##name_arg():tlm::tlm_phase(tlm::create_phase_number()){tlm::get_phase_name_vec().push_back(get_char_##name_arg());};\
+tlm_phase_##name_arg(const tlm_phase_##name_arg&); \
+tlm_phase_##name_arg& operator=(const tlm_phase_##name_arg&); \
+static inline const char* get_char_##name_arg(){static const char* tmp=#name_arg; return tmp;} \
+}; \
+static const tlm_phase_##name_arg& name_arg=tlm_phase_##name_arg::get_phase()
+
+// for backwards-compatibility
+#define DECLARE_EXTENDED_PHASE(NameArg) \
+    TLM_DECLARE_EXTENDED_PHASE( NameArg )
+
+} // namespace tlm
+
+#endif /* TLM_PHASE_HEADER */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h
new file mode 100644
index 000000000..eb36a898e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h
@@ -0,0 +1,97 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_GLOBAL_QUANTUM_H__
+#define __TLM_GLOBAL_QUANTUM_H__
+
+#include <systemc>
+
+namespace tlm {
+
+//
+// tlm_global_quantum class
+//
+// The global quantum is the maximum time an initiator can run ahead of
+// systemC time. All initiators should synchronize on timingpoints that
+// are multiples of the global quantum value.
+//
+// sc_set_time_resolution can only be called before the first
+// sc_time object is created. This means that after setting the
+// global quantum it will not be possible to call sc_set_time_resolution.
+// If sc_set_time_resolution must be called this must be done before
+// the global quantum is set.
+//
+
+class tlm_global_quantum
+{
+public:
+  //
+  // Returns a reference to the tlm_global_quantum singleton
+  //
+  static tlm_global_quantum& instance()
+  {
+    static tlm_global_quantum instance_;
+    return instance_;
+  }
+
+public:
+
+  //
+  // Setter/getter for the global quantum
+  //
+  void set(const sc_core::sc_time& t)
+  {
+    m_global_quantum = t;
+  }
+
+  const sc_core::sc_time& get() const
+  {
+    return m_global_quantum;
+  }
+
+  //
+  // This function will calculate the maximum value for the next local
+  // quantum for an initiator. All initiators should synchronize on
+  // integer multiples of the global quantum value. The value for the
+  // local quantum of an initiator can be smaller, but should never be
+  // greater than the value returned by this method.
+  //
+  sc_core::sc_time compute_local_quantum()
+  {
+    if (m_global_quantum != sc_core::SC_ZERO_TIME) {
+      const sc_core::sc_time current = sc_core::sc_time_stamp();
+      const sc_core::sc_time g_quant = m_global_quantum;
+      return g_quant - (current % g_quant);
+    } else {
+      return sc_core::SC_ZERO_TIME;
+    }
+  }
+
+protected:
+  tlm_global_quantum() : m_global_quantum(sc_core::SC_ZERO_TIME)
+  {
+  }
+
+protected:
+  sc_core::sc_time m_global_quantum;
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h
new file mode 100644
index 000000000..c5138ab06
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h
@@ -0,0 +1,25 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_QUANTUM_H__
+#define __TLM_QUANTUM_H__
+
+#include "tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h"
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h
new file mode 100644
index 000000000..3dd42e806
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h
@@ -0,0 +1,252 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_INITIATOR_SOCKET_H__
+#define __TLM_INITIATOR_SOCKET_H__
+
+//#include <systemc>
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+namespace tlm {
+
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<> >
+class tlm_base_initiator_socket_b
+{
+public:
+  virtual ~tlm_base_initiator_socket_b() {}
+
+  virtual sc_core::sc_port_b<FW_IF> &       get_base_port() = 0;
+  virtual sc_core::sc_port_b<FW_IF> const & get_base_port() const = 0;
+  virtual                    BW_IF  &       get_base_interface() = 0;
+  virtual                    BW_IF  const & get_base_interface() const = 0;
+  virtual sc_core::sc_export<BW_IF> &       get_base_export() = 0;
+  virtual sc_core::sc_export<BW_IF> const & get_base_export() const = 0;
+};
+
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF> class tlm_base_target_socket_b;
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF,
+          int N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL
+#endif
+          > class tlm_base_target_socket;
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<>,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_base_initiator_socket : public tlm_base_initiator_socket_b<BUSWIDTH, FW_IF, BW_IF>,
+                                  public sc_core::sc_port<FW_IF, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                                        , POL
+#endif
+                                                    >
+
+{
+public:
+  typedef FW_IF                                 fw_interface_type;
+  typedef BW_IF                                 bw_interface_type;
+  typedef sc_core::sc_port<fw_interface_type, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                            , POL
+#endif
+                                            >   port_type;
+
+  typedef sc_core::sc_export<bw_interface_type> export_type;
+
+  typedef tlm_base_target_socket_b<BUSWIDTH,
+                                   fw_interface_type,
+                                   bw_interface_type> base_target_socket_type;
+  typedef tlm_base_initiator_socket_b<BUSWIDTH,
+                                      fw_interface_type,
+                                      bw_interface_type> base_type;
+
+  template <unsigned int, typename, typename, int
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+           ,sc_core::sc_port_policy
+#endif
+           >
+  friend class tlm_base_target_socket;
+
+public:
+  tlm_base_initiator_socket()
+  : port_type(sc_core::sc_gen_unique_name("tlm_base_initiator_socket"))
+  , m_export(sc_core::sc_gen_unique_name("tlm_base_initiator_socket_export"))
+  {
+  }
+
+  explicit tlm_base_initiator_socket(const char* name)
+  : port_type(name)
+  , m_export(sc_core::sc_gen_unique_name((std::string(name) + "_export").c_str()))
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_base_initiator_socket";
+  }
+
+  unsigned int get_bus_width() const
+  {
+    return BUSWIDTH;
+  }
+
+  //
+  // Bind initiator socket to target socket
+  // - Binds the port of the initiator socket to the export of the target
+  //   socket
+  // - Binds the port of the target socket to the export of the initiator
+  //   socket
+  //
+  virtual void bind(base_target_socket_type& s)
+  {
+    // initiator.port -> target.export
+    (get_base_port())(s.get_base_interface());
+    // target.port -> initiator.export
+    (s.get_base_port())(get_base_interface());
+  }
+
+  void operator() (base_target_socket_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind initiator socket to initiator socket (hierarchical bind)
+  // - Binds both the export and the port
+  //
+  virtual void bind(base_type& s)
+  {
+    // port
+    (get_base_port())(s.get_base_port());
+    // export
+    (s.get_base_export())(get_base_export());
+  }
+
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind interface to socket
+  // - Binds the interface to the export of this socket
+  //
+  virtual void bind(bw_interface_type& ifs)
+  {
+    (get_base_export())(ifs);
+  }
+
+  void operator() (bw_interface_type& s)
+  {
+    bind(s);
+  }
+
+  // Implementation of pure virtual functions of base class
+  virtual sc_core::sc_port_b<FW_IF> &       get_base_port()
+    { return *this; }
+  virtual sc_core::sc_port_b<FW_IF> const & get_base_port() const
+    { return *this; }
+
+  virtual                    BW_IF  &       get_base_interface()
+    { return m_export; }
+  virtual                    BW_IF  const & get_base_interface() const
+#if !( defined(IEEE_1666_SYSTEMC) && IEEE_1666_SYSTEMC >= 201101L )
+    { return const_cast<export_type &>(m_export); }
+#else
+    { return m_export; }
+#endif
+
+  virtual sc_core::sc_export<BW_IF> &       get_base_export()
+    { return m_export; }
+  virtual sc_core::sc_export<BW_IF> const & get_base_export() const
+    { return m_export; }
+
+protected:
+  export_type m_export;
+};
+
+//
+// Convenience socket classes
+//
+
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm_base_protocol_types,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_initiator_socket :
+  public tlm_base_initiator_socket <BUSWIDTH,
+                               tlm_fw_transport_if<TYPES>,
+                               tlm_bw_transport_if<TYPES>,
+                               N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                               ,POL
+#endif
+                              >
+{
+public:
+  tlm_initiator_socket() :
+    tlm_base_initiator_socket<BUSWIDTH,
+                         tlm_fw_transport_if<TYPES>,
+                         tlm_bw_transport_if<TYPES>,
+                         N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                         ,POL
+#endif
+                         >()
+  {
+  }
+
+  explicit tlm_initiator_socket(const char* name) :
+    tlm_base_initiator_socket<BUSWIDTH,
+                         tlm_fw_transport_if<TYPES>,
+                         tlm_bw_transport_if<TYPES>,
+                         N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                         ,POL
+#endif
+                         >(name)
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_initiator_socket";
+  }
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h
new file mode 100644
index 000000000..013e29286
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h
@@ -0,0 +1,26 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_SOCKETS_H__
+#define __TLM_SOCKETS_H__
+
+#include "tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h"
+#include "tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h"
+
+#endif /* __TLM_SOCKETS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h
new file mode 100644
index 000000000..4ed29f62a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h
@@ -0,0 +1,275 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#ifndef __TLM_TARGET_SOCKET_H__
+#define __TLM_TARGET_SOCKET_H__
+
+//#include <systemc>
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+
+namespace tlm {
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<> >
+class tlm_base_target_socket_b
+{
+public:
+  virtual ~tlm_base_target_socket_b() {}
+
+  virtual sc_core::sc_port_b<BW_IF> & get_base_port() = 0;
+  virtual sc_core::sc_export<FW_IF> & get_base_export() = 0;
+  virtual                    FW_IF  & get_base_interface() = 0;
+};
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF> class tlm_base_initiator_socket_b;
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF,
+          int N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL
+#endif
+          > class tlm_base_initiator_socket;
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<>,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_base_target_socket : public tlm_base_target_socket_b<BUSWIDTH, FW_IF, BW_IF>,
+                               public sc_core::sc_export<FW_IF>
+{
+public:
+  typedef FW_IF                                 fw_interface_type;
+  typedef BW_IF                                 bw_interface_type;
+  typedef sc_core::sc_port<bw_interface_type, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                            , POL
+#endif
+                                            >   port_type;
+
+  typedef sc_core::sc_export<fw_interface_type> export_type;
+  typedef tlm_base_initiator_socket_b<BUSWIDTH,
+                                      fw_interface_type,
+                                      bw_interface_type>  base_initiator_socket_type;
+
+  typedef tlm_base_target_socket_b<BUSWIDTH,
+                                   fw_interface_type,
+                                   bw_interface_type> base_type;
+
+  template <unsigned int, typename, typename, int
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                               ,sc_core::sc_port_policy
+#endif
+
+           >
+  friend class tlm_base_initiator_socket;
+
+public:
+  tlm_base_target_socket()
+  : export_type(sc_core::sc_gen_unique_name("tlm_base_target_socket"))
+  , m_port(sc_core::sc_gen_unique_name("tlm_base_target_socket_port"))
+  {
+  }
+
+  explicit tlm_base_target_socket(const char* name)
+  : export_type(name)
+  , m_port(sc_core::sc_gen_unique_name((std::string(name) + "_port").c_str()))
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_base_target_socket";
+  }
+
+  unsigned int get_bus_width() const
+  {
+    return BUSWIDTH;
+  }
+
+  //
+  // Bind target socket to initiator socket
+  // - Binds the port of the initiator socket to the export of the target
+  //   socket
+  // - Binds the port of the target socket to the export of the initiator
+  //   socket
+  //
+  virtual void bind(base_initiator_socket_type& s)
+  {
+    // initiator.port -> target.export
+    (s.get_base_port())(get_base_interface());
+    // target.port -> initiator.export
+    get_base_port()(s.get_base_interface());
+  }
+
+  void operator() (base_initiator_socket_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind target socket to target socket (hierarchical bind)
+  // - Binds both the export and the port
+  //
+  virtual void bind(base_type& s)
+  {
+    // export
+    (get_base_export())(s.get_base_export());
+    // port
+    (s.get_base_port())(get_base_port());
+  }
+
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind interface to socket
+  // - Binds the interface to the export
+  //
+  virtual void bind(fw_interface_type& ifs)
+  {
+    export_type* exp = &get_base_export();
+    if( this == exp ) {
+      export_type::bind( ifs ); // non-virtual function call
+    } else {
+      exp->bind( ifs );
+    }
+  }
+
+  void operator() (fw_interface_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Forward to 'size()' of port class
+  //
+  int size() const
+  {
+    return m_port.size();
+  }
+
+  //
+  // Forward to 'operator->()' of port class
+  //
+  bw_interface_type* operator->()
+  {
+    return m_port.operator->();
+  }
+
+  //
+  // Forward to 'operator[]()' of port class
+  //
+  bw_interface_type* operator[](int i)
+  {
+    return m_port.operator[](i);
+  }
+
+  // Implementation of pure virtual functions of base class
+
+  virtual sc_core::sc_port_b<BW_IF> &       get_base_port()
+    { return m_port; }
+  virtual sc_core::sc_port_b<BW_IF> const & get_base_port() const
+    { return m_port; }
+
+  virtual                    FW_IF  &       get_base_interface()
+    { return *this; }
+  virtual                    FW_IF  const & get_base_interface() const
+#if !( defined(IEEE_1666_SYSTEMC) && IEEE_1666_SYSTEMC >= 201101L )
+    { return *const_cast<export_type*>(static_cast<export_type const*>(this)); }
+#else
+    { return *this; }
+#endif
+
+  virtual sc_core::sc_export<FW_IF> &       get_base_export()
+    { return *this; }
+  virtual sc_core::sc_export<FW_IF> const & get_base_export() const
+    { return *this; }
+
+protected:
+  port_type m_port;
+};
+
+
+//
+// Convenience blocking and non-blocking socket classes
+//
+
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm_base_protocol_types,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_target_socket :
+  public tlm_base_target_socket <BUSWIDTH,
+                            tlm_fw_transport_if<TYPES>,
+                            tlm_bw_transport_if<TYPES>,
+                            N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                            ,POL
+#endif
+                            >
+{
+public:
+  tlm_target_socket() :
+    tlm_base_target_socket<BUSWIDTH,
+                      tlm_fw_transport_if<TYPES>,
+                      tlm_bw_transport_if<TYPES>,
+                      N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                      ,POL
+#endif
+                      >()
+  {
+  }
+
+  explicit tlm_target_socket(const char* name) :
+    tlm_base_target_socket<BUSWIDTH,
+                      tlm_fw_transport_if<TYPES>,
+                      tlm_bw_transport_if<TYPES>,
+                      N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                      ,POL
+#endif
+                      >(name)
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_target_socket";
+  }
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_version.h b/ext/systemc/src/tlm_core/tlm_2/tlm_version.h
new file mode 100644
index 000000000..e9b7a6569
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_version.h
@@ -0,0 +1,180 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+/* ---------------------------------------------------------------------------------------
+ @file tlm_version.h
+
+ @brief TLM version header
+
+  Original Author:
+    Charles Wilson, XtremeEDA Corporation
+
+ @description
+  This header contains preprocessor and compiler symbols to allow for the determination
+   of the TLM version information. This conforms to IEEE 1666-2005 section 8.5.5 - 8.5.7
+   .
+   The following are provided:
+   .
+   preprocessor: TLM_VERSION_MAJOR        numeric
+                 TLM_VERSION_MINOR        numeric
+                 TLM_VERSION_PATCH        numeric
+                 TLM_VERSION_ORIGINATOR   string       ([A-Z][a-z][0-9]_)
+                 TLM_VERSION_RELEASE_DATE ISO8601 date (YYYYMMDD)
+                 TLM_VERSION_PRERELEASE   string       ([A-Z][a-z][0-9]_)
+                 TLM_IS_PRERELEASE        bool         (1,0)
+                 TLM_VERSION              string       {2.0.0_DR3-TLMWG}
+                 TLM_COPYRIGHT            string
+   .
+   compiler:     tlm_version_major        const unsigned int
+                 tlm_version_minor        const unsigned int
+                 tlm_version_patch        const unsigned int
+                 tlm_version_originator   const std::string
+                 tlm_version_release_date const std::string
+                 tlm_version_prerelease   const std::string
+                 tlm_is_prerelease        const bool
+                 tlm_version              const string
+                 tlm_copyright            const string
+   .
+   accessors:    inline const char* tlm_release   (void)
+                 inline const char* tlm_version   (void)
+                 inline const char* tlm_copyright (void)
+
+--------------------------------------------------------------------------------------- */
+
+#ifndef __TLM_VERSION_H__
+#define __TLM_VERSION_H__
+
+namespace tlm
+{
+
+#define TLM_VERSION_MAJOR                   2           ///< version major level ( numeric )
+#define TLM_VERSION_MINOR                   0           ///< version minor level ( numeric )
+#define TLM_VERSION_PATCH                   3           ///< version patch level ( numeric )
+#define TLM_VERSION_ORIGINATOR              "Accellera" ///< TLM creator string
+#define TLM_VERSION_SEPARATOR               "."         ///< version string separator
+
+#define TLM_IS_PRERELEASE                   0           ///< pre-release flag ( 1 / 0 )
+
+#if TLM_IS_PRERELEASE
+#    define TLM_VERSION_PRERELEASE          "pub_rev"   ///< pre-release version string
+#else
+#    define TLM_VERSION_PRERELEASE          ""          ///< pre-release version string
+#endif
+
+#define TLM_VERSION_RELEASE_YEAR            "2013"      ///< release year  ( YYYY )
+#define TLM_VERSION_RELEASE_MONTH           "12"        ///< release month ( MM )
+#define TLM_VERSION_RELEASE_DAY             "15"        ///< release day   ( DD )
+
+#define TLM_COPYRIGHT \
+  "Copyright (c) 1996-" TLM_VERSION_RELEASE_YEAR " by all Contributors\n" \
+  "ALL RIGHTS RESERVED"
+
+/************************** do not modify below this line *******************************/
+
+/******************************* preprocessor symbols ***********************************/
+
+#define TLM_VERSION_RELEASE_DATE            TLM_VERSION_RELEASE_YEAR \
+                                            TLM_VERSION_RELEASE_MONTH \
+                                            TLM_VERSION_RELEASE_DAY
+
+#define TLM_VERSION_STR(x)                  TLM_VERSION_STR_HELPER(x)
+#define TLM_VERSION_STR_HELPER(x)           #x
+
+#define TLM_VERSION_STRING_MAJOR            TLM_VERSION_STR(TLM_VERSION_MAJOR)
+#define TLM_VERSION_STRING_MINOR            TLM_VERSION_STR(TLM_VERSION_MINOR)
+#define TLM_VERSION_STRING_PATCH            TLM_VERSION_STR(TLM_VERSION_PATCH)
+
+#define TLM_VERSION_STRING_MMP              TLM_VERSION_STRING_MAJOR TLM_VERSION_SEPARATOR \
+                                            TLM_VERSION_STRING_MINOR TLM_VERSION_SEPARATOR \
+                                            TLM_VERSION_STRING_PATCH
+
+#define TLM_VERSION_STRING_PRE_START        "_"
+#define TLM_VERSION_STRING_PRE_END          "-"
+
+#if ( TLM_IS_PRERELEASE == 1 )
+
+#define TLM_VERSION_STRING_PRERELEASE       TLM_VERSION_PRERELEASE
+#define TLM_VERSION_STRING_RELEASE_DATE     ""
+
+#else   /* TLM_IS_PRERELEASE == 1 */
+
+#define TLM_VERSION_STRING_PRERELEASE       ""
+#define TLM_VERSION_STRING_RELEASE_DATE     TLM_VERSION_RELEASE_DATE
+
+#endif  /* TLM_IS_PRERELEASE == 1 */
+
+#define TLM_VERSION_STRING                  TLM_VERSION_STRING_MMP \
+                                            TLM_VERSION_STRING_PRE_START \
+                                            TLM_VERSION_STRING_PRERELEASE \
+                                            TLM_VERSION_STRING_PRE_END \
+                                            TLM_VERSION_ORIGINATOR
+
+#define TLM_VERSION_STRING_2                "TLM " \
+                                            TLM_VERSION_STRING_MMP \
+                                            " --- " \
+                                            TLM_VERSION_RELEASE_YEAR \
+                                            "-" \
+                                            TLM_VERSION_RELEASE_MONTH \
+                                            "-" \
+                                            TLM_VERSION_RELEASE_DAY
+
+#define TLM_VERSION                         TLM_VERSION_STRING
+
+/********************************* compiler symbols **************************************/
+
+const unsigned int tlm_version_major        ( TLM_VERSION_MAJOR               );
+const unsigned int tlm_version_minor        ( TLM_VERSION_MINOR               );
+const unsigned int tlm_version_patch        ( TLM_VERSION_PATCH               );
+
+const bool         tlm_is_prerelease        ( TLM_IS_PRERELEASE               );
+
+const std::string  tlm_version_string       ( TLM_VERSION_STRING              );
+const std::string  tlm_version_originator   ( TLM_VERSION_ORIGINATOR          );
+const std::string  tlm_version_prerelease   ( TLM_VERSION_PRERELEASE          );
+const std::string  tlm_version_release_date ( TLM_VERSION_STRING_RELEASE_DATE );
+const std::string  tlm_copyright_string     ( TLM_COPYRIGHT                   );
+const std::string  tlm_version_string_2     ( TLM_VERSION_STRING_2            );
+
+inline const char*
+tlm_release
+( void
+)
+{
+  return tlm_version_string.c_str ();
+}
+
+inline const char*
+tlm_version
+( void
+)
+{
+  return tlm_version_string_2.c_str ();
+}
+
+inline const char*
+tlm_copyright
+( void
+)
+{
+  return tlm_copyright_string.c_str ();
+}
+
+} // namespace tlm
+
+#endif /* __TLM_VERSION_H__ */