util/tlm/examples/slave_port/sc_target.cc - public/gem5 - Git at Google

 /*
  * Copyright (c) 2015, University of Kaiserslautern
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  * 1. Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * 3. Neither the name of the copyright holder nor the names of its
  *    contributors may be used to endorse or promote products derived from
  *    this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "sc_target.hh"

 using namespace sc_core;
 using namespace std;

 Target::Target(sc_core::sc_module_name name,
     bool debug,
     unsigned long long int size,
     unsigned int offset) :
     socket("socket"),
     transaction_in_progress(0),
     response_in_progress(false),
     next_response_pending(0),
     end_req_pending(0),
     m_peq(this, &Target::peq_cb),
     debug(debug),
     size(size),
     offset(offset)
 {
     /* Register tlm transport functions */
     socket.register_b_transport(this, &Target::b_transport);
     socket.register_transport_dbg(this, &Target::transport_dbg);
     socket.register_nb_transport_fw(this, &Target::nb_transport_fw);


     /* allocate storage memory */
     mem = new unsigned char[size];

     SC_METHOD(execute_transaction_process);
     sensitive << target_done_event;
     dont_initialize();
 }

 void
 Target::check_address(unsigned long long int addr)
 {
     if (addr < offset || addr >= offset + size)
         SC_REPORT_FATAL("Target", "Address out of range. Did you set an "
                                   "appropriate size and offset?");
 }

 void
 Target::b_transport(tlm::tlm_generic_payload& trans, sc_time& delay)
 {
     /* Execute the read or write commands */
     execute_transaction(trans);
 }

 unsigned int
 Target::transport_dbg(tlm::tlm_generic_payload& trans)
 {
     check_address(trans.get_address());

     tlm::tlm_command cmd = trans.get_command();
     sc_dt::uint64    adr = trans.get_address() - offset;
     unsigned char*   ptr = trans.get_data_ptr();
     unsigned int     len = trans.get_data_length();

     unsigned char *mem_array_ptr = mem + adr;

     /* Load / Store the access: */
     if ( cmd == tlm::TLM_READ_COMMAND ) {
         if (debug) {
             SC_REPORT_INFO("target", "tlm::TLM_READ_COMMAND");
         }
         std::memcpy(ptr, mem_array_ptr, len);
     } else if ( cmd == tlm::TLM_WRITE_COMMAND ) {
         if (debug) {
             SC_REPORT_INFO("target", "tlm::TLM_WRITE_COMMAND");
         }
         std::memcpy(mem_array_ptr, ptr, len);
     }

     return len;
 }


 /* TLM-2 non-blocking transport method */
 tlm::tlm_sync_enum Target::nb_transport_fw(tlm::tlm_generic_payload& trans,
                                            tlm::tlm_phase& phase,
                                            sc_time& delay)
 {
     /* Queue the transaction until the annotated time has elapsed */
     m_peq.notify(trans, phase, delay);
     return tlm::TLM_ACCEPTED;
 }

 void
 Target::peq_cb(tlm::tlm_generic_payload& trans,
                const tlm::tlm_phase& phase)
 {
     sc_time delay;

     if (phase == tlm::BEGIN_REQ) {
         if (debug) SC_REPORT_INFO("target", "tlm::BEGIN_REQ");

         /* Increment the transaction reference count */
         trans.acquire();

         if ( !transaction_in_progress ) {
             send_end_req(trans);
         } else {
             /* Put back-pressure on initiator by deferring END_REQ until
              * pipeline is clear */
             end_req_pending = &trans;
         }
     } else if (phase == tlm::END_RESP) {
         /* On receiving END_RESP, the target can release the transaction and
          * allow other pending transactions to proceed */
         if (!response_in_progress) {
             SC_REPORT_FATAL("TLM-2", "Illegal transaction phase END_RESP"
                             "received by target");
         }

         transaction_in_progress = 0;

         /* Target itself is now clear to issue the next BEGIN_RESP */
         response_in_progress = false;
         if (next_response_pending) {
             send_response( *next_response_pending );
             next_response_pending = 0;
         }

         /* ... and to unblock the initiator by issuing END_REQ */
         if (end_req_pending) {
             send_end_req( *end_req_pending );
             end_req_pending = 0;
         }

     } else /* tlm::END_REQ or tlm::BEGIN_RESP */ {
             SC_REPORT_FATAL("TLM-2", "Illegal transaction phase received by"
                             "target");
     }
 }

 void
 Target::send_end_req(tlm::tlm_generic_payload& trans)
 {
     tlm::tlm_phase bw_phase;
     sc_time delay;

     /* Queue the acceptance and the response with the appropriate latency */
     bw_phase = tlm::END_REQ;
     delay = sc_time(10.0, SC_NS); // Accept delay

     tlm::tlm_sync_enum status;
     status = socket->nb_transport_bw(trans, bw_phase, delay);

     /* Ignore return value;
      * initiator cannot terminate transaction at this point
      * Queue internal event to mark beginning of response: */
     delay = delay + sc_time(40.0, SC_NS); // Latency
     target_done_event.notify(delay);

     assert(transaction_in_progress == 0);
     transaction_in_progress = &trans;
 }

 void
 Target::execute_transaction_process()
 {
     /* Execute the read or write commands */
     execute_transaction( *transaction_in_progress );

     /* Target must honor BEGIN_RESP/END_RESP exclusion rule; i.e. must not
      * send BEGIN_RESP until receiving previous END_RESP or BEGIN_REQ */
     if (response_in_progress) {
         /* Target allows only two transactions in-flight */
         if (next_response_pending) {
             SC_REPORT_FATAL("TLM-2", "Attempt to have two pending responses"
                             "in target");
         }
         next_response_pending = transaction_in_progress;
     } else {
         send_response( *transaction_in_progress );
     }
 }

 void
 Target::execute_transaction(tlm::tlm_generic_payload& trans)
 {
     check_address(trans.get_address());

     tlm::tlm_command cmd = trans.get_command();
     sc_dt::uint64    adr = trans.get_address() - offset;
     unsigned char*   ptr = trans.get_data_ptr();
     unsigned int     len = trans.get_data_length();
     unsigned char*   byt = trans.get_byte_enable_ptr();
     unsigned int     wid = trans.get_streaming_width();

     if ( byt != 0 ) {
         cout << "Byte Error" << endl;
         trans.set_response_status( tlm::TLM_BYTE_ENABLE_ERROR_RESPONSE );
         return;
     }

     //if ( len > 4 || wid < len ) {
     //    cout << "Burst Error len=" << len << " wid=" << wid << endl;
     //    trans.set_response_status( tlm::TLM_BURST_ERROR_RESPONSE );
     //    return;
     //}

     unsigned char *mem_array_ptr = mem + adr;

     /* Load / Store the access: */
     if ( cmd == tlm::TLM_READ_COMMAND ) {
         if (debug) {
             SC_REPORT_INFO("target", "tlm::TLM_READ_COMMAND");
         }
         std::memcpy(ptr, mem_array_ptr, len);
     } else if ( cmd == tlm::TLM_WRITE_COMMAND ) {
         if (debug) {
             SC_REPORT_INFO("target", "tlm::TLM_WRITE_COMMAND");
         }
         std::memcpy(mem_array_ptr, ptr, len);
     }

     trans.set_response_status( tlm::TLM_OK_RESPONSE );
 }

 void
 Target::send_response(tlm::tlm_generic_payload& trans)
 {
     tlm::tlm_sync_enum status;
     tlm::tlm_phase bw_phase;
     sc_time delay;

     response_in_progress = true;
     bw_phase = tlm::BEGIN_RESP;
     delay = sc_time(10.0, SC_NS);
     status = socket->nb_transport_bw( trans, bw_phase, delay );

     if (status == tlm::TLM_UPDATED) {
         /* The timing annotation must be honored */
         m_peq.notify(trans, bw_phase, delay);
     } else if (status == tlm::TLM_COMPLETED) {
         /* The initiator has terminated the transaction */
         transaction_in_progress = 0;
         response_in_progress = false;
     }
     trans.release();
 }
	/*
	* Copyright (c) 2015, University of Kaiserslautern
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* 3. Neither the name of the copyright holder nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
	* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "sc_target.hh"

	using namespace sc_core;
	using namespace std;

	Target::Target(sc_core::sc_module_name name,
	bool debug,
	unsigned long long int size,
	unsigned int offset) :
	socket("socket"),
	transaction_in_progress(0),
	response_in_progress(false),
	next_response_pending(0),
	end_req_pending(0),
	m_peq(this, &Target::peq_cb),
	debug(debug),
	size(size),
	offset(offset)
	{
	/* Register tlm transport functions */
	socket.register_b_transport(this, &Target::b_transport);
	socket.register_transport_dbg(this, &Target::transport_dbg);
	socket.register_nb_transport_fw(this, &Target::nb_transport_fw);


	/* allocate storage memory */
	mem = new unsigned char[size];

	SC_METHOD(execute_transaction_process);
	sensitive << target_done_event;
	dont_initialize();
	}

	void
	Target::check_address(unsigned long long int addr)
	{
	if (addr < offset \|\| addr >= offset + size)
	SC_REPORT_FATAL("Target", "Address out of range. Did you set an "
	"appropriate size and offset?");
	}

	void
	Target::b_transport(tlm::tlm_generic_payload& trans, sc_time& delay)
	{
	/* Execute the read or write commands */
	execute_transaction(trans);
	}

	unsigned int
	Target::transport_dbg(tlm::tlm_generic_payload& trans)
	{
	check_address(trans.get_address());

	tlm::tlm_command cmd = trans.get_command();
	sc_dt::uint64 adr = trans.get_address() - offset;
	unsigned char* ptr = trans.get_data_ptr();
	unsigned int len = trans.get_data_length();

	unsigned char *mem_array_ptr = mem + adr;

	/* Load / Store the access: */
	if ( cmd == tlm::TLM_READ_COMMAND ) {
	if (debug) {
	SC_REPORT_INFO("target", "tlm::TLM_READ_COMMAND");
	}
	std::memcpy(ptr, mem_array_ptr, len);
	} else if ( cmd == tlm::TLM_WRITE_COMMAND ) {
	if (debug) {
	SC_REPORT_INFO("target", "tlm::TLM_WRITE_COMMAND");
	}
	std::memcpy(mem_array_ptr, ptr, len);
	}

	return len;
	}


	/* TLM-2 non-blocking transport method */
	tlm::tlm_sync_enum Target::nb_transport_fw(tlm::tlm_generic_payload& trans,
	tlm::tlm_phase& phase,
	sc_time& delay)
	{
	/* Queue the transaction until the annotated time has elapsed */
	m_peq.notify(trans, phase, delay);
	return tlm::TLM_ACCEPTED;
	}

	void
	Target::peq_cb(tlm::tlm_generic_payload& trans,
	const tlm::tlm_phase& phase)
	{
	sc_time delay;

	if (phase == tlm::BEGIN_REQ) {
	if (debug) SC_REPORT_INFO("target", "tlm::BEGIN_REQ");

	/* Increment the transaction reference count */
	trans.acquire();

	if ( !transaction_in_progress ) {
	send_end_req(trans);
	} else {
	/* Put back-pressure on initiator by deferring END_REQ until
	* pipeline is clear */
	end_req_pending = &trans;
	}
	} else if (phase == tlm::END_RESP) {
	/* On receiving END_RESP, the target can release the transaction and
	* allow other pending transactions to proceed */
	if (!response_in_progress) {
	SC_REPORT_FATAL("TLM-2", "Illegal transaction phase END_RESP"
	"received by target");
	}

	transaction_in_progress = 0;

	/* Target itself is now clear to issue the next BEGIN_RESP */
	response_in_progress = false;
	if (next_response_pending) {
	send_response( *next_response_pending );
	next_response_pending = 0;
	}

	/* ... and to unblock the initiator by issuing END_REQ */
	if (end_req_pending) {
	send_end_req( *end_req_pending );
	end_req_pending = 0;
	}

	} else /* tlm::END_REQ or tlm::BEGIN_RESP */ {
	SC_REPORT_FATAL("TLM-2", "Illegal transaction phase received by"
	"target");
	}
	}

	void
	Target::send_end_req(tlm::tlm_generic_payload& trans)
	{
	tlm::tlm_phase bw_phase;
	sc_time delay;

	/* Queue the acceptance and the response with the appropriate latency */
	bw_phase = tlm::END_REQ;
	delay = sc_time(10.0, SC_NS); // Accept delay

	tlm::tlm_sync_enum status;
	status = socket->nb_transport_bw(trans, bw_phase, delay);

	/* Ignore return value;
	* initiator cannot terminate transaction at this point
	* Queue internal event to mark beginning of response: */
	delay = delay + sc_time(40.0, SC_NS); // Latency
	target_done_event.notify(delay);

	assert(transaction_in_progress == 0);
	transaction_in_progress = &trans;
	}

	void
	Target::execute_transaction_process()
	{
	/* Execute the read or write commands */
	execute_transaction( *transaction_in_progress );

	/* Target must honor BEGIN_RESP/END_RESP exclusion rule; i.e. must not
	* send BEGIN_RESP until receiving previous END_RESP or BEGIN_REQ */
	if (response_in_progress) {
	/* Target allows only two transactions in-flight */
	if (next_response_pending) {
	SC_REPORT_FATAL("TLM-2", "Attempt to have two pending responses"
	"in target");
	}
	next_response_pending = transaction_in_progress;
	} else {
	send_response( *transaction_in_progress );
	}
	}

	void
	Target::execute_transaction(tlm::tlm_generic_payload& trans)
	{
	check_address(trans.get_address());

	tlm::tlm_command cmd = trans.get_command();
	sc_dt::uint64 adr = trans.get_address() - offset;
	unsigned char* ptr = trans.get_data_ptr();
	unsigned int len = trans.get_data_length();
	unsigned char* byt = trans.get_byte_enable_ptr();
	unsigned int wid = trans.get_streaming_width();

	if ( byt != 0 ) {
	cout << "Byte Error" << endl;
	trans.set_response_status( tlm::TLM_BYTE_ENABLE_ERROR_RESPONSE );
	return;
	}

	//if ( len > 4 \|\| wid < len ) {
	// cout << "Burst Error len=" << len << " wid=" << wid << endl;
	// trans.set_response_status( tlm::TLM_BURST_ERROR_RESPONSE );
	// return;
	//}

	unsigned char *mem_array_ptr = mem + adr;

	/* Load / Store the access: */
	if ( cmd == tlm::TLM_READ_COMMAND ) {
	if (debug) {
	SC_REPORT_INFO("target", "tlm::TLM_READ_COMMAND");
	}
	std::memcpy(ptr, mem_array_ptr, len);
	} else if ( cmd == tlm::TLM_WRITE_COMMAND ) {
	if (debug) {
	SC_REPORT_INFO("target", "tlm::TLM_WRITE_COMMAND");
	}
	std::memcpy(mem_array_ptr, ptr, len);
	}

	trans.set_response_status( tlm::TLM_OK_RESPONSE );
	}

	void
	Target::send_response(tlm::tlm_generic_payload& trans)
	{
	tlm::tlm_sync_enum status;
	tlm::tlm_phase bw_phase;
	sc_time delay;

	response_in_progress = true;
	bw_phase = tlm::BEGIN_RESP;
	delay = sc_time(10.0, SC_NS);
	status = socket->nb_transport_bw( trans, bw_phase, delay );

	if (status == tlm::TLM_UPDATED) {
	/* The timing annotation must be honored */
	m_peq.notify(trans, bw_phase, delay);
	} else if (status == tlm::TLM_COMPLETED) {
	/* The initiator has terminated the transaction */
	transaction_in_progress = 0;
	response_in_progress = false;
	}
	trans.release();
	}