summaryrefslogtreecommitdiff
path: root/src/systemc/tests/include/SimpleATInitiator2.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/systemc/tests/include/SimpleATInitiator2.h')
-rw-r--r--src/systemc/tests/include/SimpleATInitiator2.h306
1 files changed, 306 insertions, 0 deletions
diff --git a/src/systemc/tests/include/SimpleATInitiator2.h b/src/systemc/tests/include/SimpleATInitiator2.h
new file mode 100644
index 000000000..6decf11fa
--- /dev/null
+++ b/src/systemc/tests/include/SimpleATInitiator2.h
@@ -0,0 +1,306 @@
+/*****************************************************************************
+
+ 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.
+
+ *****************************************************************************/
+
+//====================================================================
+// Nov 06, 2008
+//
+// Updated by:
+// Xiaopeng Qiu, JEDA Technologies, Inc
+// Email: qiuxp@jedatechnologies.net
+//
+// To fix violations of TLM2.0 rules, which are detected by JEDA
+// TLM2.0 checker.
+//
+//====================================================================
+
+#ifndef __SIMPLE_AT_INITIATOR2_H__
+#define __SIMPLE_AT_INITIATOR2_H__
+
+#include "tlm.h"
+#include "tlm_utils/simple_initiator_socket.h"
+//#include <systemc>
+#include <cassert>
+#include <queue>
+//#include <iostream>
+
+class SimpleATInitiator2 : public sc_core::sc_module
+{
+public:
+ typedef tlm::tlm_generic_payload transaction_type;
+ typedef tlm::tlm_phase phase_type;
+ typedef tlm::tlm_sync_enum sync_enum_type;
+ typedef tlm_utils::simple_initiator_socket<SimpleATInitiator2> initiator_socket_type;
+
+public:
+ // extended transaction, holds tlm_generic_payload + data storage
+ template <typename DT>
+ class MyTransaction : public transaction_type
+ {
+ public:
+ MyTransaction()
+ {
+ this->set_data_ptr(reinterpret_cast<unsigned char*>(&mData));
+ }
+ MyTransaction(tlm::tlm_mm_interface* mm) : transaction_type(mm)
+ {
+ this->set_data_ptr(reinterpret_cast<unsigned char*>(&mData));
+ }
+
+ void setData(DT& data) { mData = data; }
+ DT getData() const { return mData; }
+
+ private:
+ DT mData;
+ };
+ typedef MyTransaction<unsigned int> mytransaction_type;
+
+ // Dummy Transaction Pool
+ class SimplePool : public tlm::tlm_mm_interface
+ {
+ public:
+ SimplePool() {}
+ mytransaction_type* claim()
+ {
+ mytransaction_type* t = new mytransaction_type(this);
+ t->acquire();
+ return t;
+ }
+ void release(mytransaction_type* t)
+ {
+ t->release();
+ }
+ void free(tlm::tlm_generic_payload* t)
+ {
+ t->reset();
+ delete t;
+ }
+ };
+
+public:
+ initiator_socket_type socket;
+
+public:
+ SC_HAS_PROCESS(SimpleATInitiator2);
+ SimpleATInitiator2(sc_core::sc_module_name name,
+ unsigned int nrOfTransactions = 0x5,
+ unsigned int baseAddress = 0) :
+ sc_core::sc_module(name),
+ socket("socket"),
+ ACCEPT_DELAY(10, sc_core::SC_NS),
+ mNrOfTransactions(nrOfTransactions),
+ mBaseAddress(baseAddress),
+ mTransactionCount(0),
+ mCurrentTransaction(0)
+ {
+ // register nb_transport method
+ socket.register_nb_transport_bw(this, &SimpleATInitiator2::myNBTransport);
+
+ // Initiator thread
+ SC_THREAD(run);
+ }
+
+ bool initTransaction(mytransaction_type*& trans)
+ {
+ if (mTransactionCount < mNrOfTransactions) {
+ trans = transPool.claim();
+ trans->set_address(mBaseAddress + 4*mTransactionCount);
+ trans->setData(mTransactionCount);
+ trans->set_command(tlm::TLM_WRITE_COMMAND);
+
+ } else if (mTransactionCount < 2 * mNrOfTransactions) {
+ trans = transPool.claim();
+ trans->set_address(mBaseAddress + 4*(mTransactionCount - mNrOfTransactions));
+ trans->set_command(tlm::TLM_READ_COMMAND);
+
+ } else {
+ return false;
+ }
+
+ trans->set_data_length(4);
+ trans->set_streaming_width(4);
+
+ ++mTransactionCount;
+ return true;
+ }
+
+ void logStartTransation(mytransaction_type& trans)
+ {
+ if (trans.get_command() == tlm::TLM_WRITE_COMMAND) {
+ std::cout << name() << ": Send write request: A = 0x"
+ << std::hex << (unsigned int)trans.get_address()
+ << ", D = 0x" << trans.getData() << std::dec
+ << " @ " << sc_core::sc_time_stamp() << std::endl;
+
+ } else {
+ std::cout << name() << ": Send read request: A = 0x"
+ << std::hex << (unsigned int)trans.get_address() << std::dec
+ << " @ " << sc_core::sc_time_stamp() << std::endl;
+ }
+ }
+
+ void logEndTransaction(mytransaction_type& trans)
+ {
+ if (trans.get_response_status() != tlm::TLM_OK_RESPONSE) {
+ std::cout << name() << ": Received error response @ "
+ << sc_core::sc_time_stamp() << std::endl;
+
+ } else {
+ std::cout << name() << ": Received ok response";
+ if (trans.get_command() == tlm::TLM_READ_COMMAND) {
+ std::cout << ": D = 0x" << std::hex << trans.getData() << std::dec;
+ }
+ std::cout << " @ " << sc_core::sc_time_stamp() << std::endl;
+ }
+ }
+
+ //
+ // Simple AT Initiator
+ // - Request must be accepted by the target before the next request can be
+ // send
+ // - Responses can come out of order
+ // - Responses will be accepted after fixed delay
+ //
+ void run()
+ {
+ phase_type phase;
+ sc_core::sc_time t;
+
+ mytransaction_type* ptrans;
+ while (initTransaction(ptrans)) {
+ // Create transaction and initialise phase and t
+ mytransaction_type& trans = *ptrans;
+ phase = tlm::BEGIN_REQ;
+ t = sc_core::SC_ZERO_TIME;
+
+ logStartTransation(trans);
+
+ switch (socket->nb_transport_fw(trans, phase, t)) {
+ case tlm::TLM_COMPLETED:
+ // Transaction Finished, wait for the returned delay
+ wait(t);
+ logEndTransaction(trans);
+ transPool.release(&trans);
+ break;
+
+ case tlm::TLM_ACCEPTED:
+ case tlm::TLM_UPDATED:
+ switch (phase) {
+ case tlm::BEGIN_REQ:
+ // Request phase not yet finished
+ // Wait until end of request phase before sending new request
+
+ // FIXME
+ mCurrentTransaction = &trans;
+ wait(mEndRequestPhase);
+ mCurrentTransaction = 0;
+ break;
+
+ case tlm::END_REQ:
+ // Request phase ended
+ if (t != sc_core::SC_ZERO_TIME) {
+ // Wait until end of request time before sending new request
+ wait(t);
+ }
+ break;
+
+ case tlm::BEGIN_RESP:
+ // Request phase ended and response phase already started
+ if (t != sc_core::SC_ZERO_TIME) {
+ // Wait until end of request time before sending new request
+ wait(t);
+ }
+ // Notify end of response phase after ACCEPT delay
+ t += ACCEPT_DELAY;
+ phase = tlm::END_RESP;
+ socket->nb_transport_fw(trans, phase, t);
+ logEndTransaction(trans);
+ transPool.release(&trans);
+ break;
+
+ case tlm::END_RESP: // fall-through
+ default:
+ // A target should never return with these phases
+ // If phase == END_RESP, nb_transport should have returned true
+ assert(0); exit(1);
+ break;
+ }
+ break;
+
+ default:
+ assert(0); exit(1);
+ };
+ }
+ wait();
+
+ }
+
+ sync_enum_type myNBTransport(transaction_type& trans, phase_type& phase, sc_core::sc_time& t)
+ {
+ switch (phase) {
+ case tlm::END_REQ:
+ assert(t == sc_core::SC_ZERO_TIME); // FIXME: can t != 0?
+ // Request phase ended
+ mEndRequestPhase.notify(sc_core::SC_ZERO_TIME);
+ return tlm::TLM_ACCEPTED;
+
+ case tlm::BEGIN_RESP:
+ {
+ assert(t == sc_core::SC_ZERO_TIME); // FIXME: can t != 0?
+
+ // Notify end of request phase if run thread is waiting for it
+ // FIXME
+ if (&trans == mCurrentTransaction) {
+ mEndRequestPhase.notify(sc_core::SC_ZERO_TIME);
+ }
+
+ assert(dynamic_cast<mytransaction_type*>(&trans));
+ mytransaction_type* myTrans = static_cast<mytransaction_type*>(&trans);
+ assert(myTrans);
+
+ // Notify end of response phase after ACCEPT delay
+ t += ACCEPT_DELAY;
+ phase = tlm::END_RESP;
+ logEndTransaction(*myTrans);
+ transPool.release(myTrans);
+
+ return tlm::TLM_COMPLETED;
+ }
+
+ case tlm::BEGIN_REQ: // fall-through
+ case tlm::END_RESP: // fall-through
+ default:
+ // A target should never call nb_transport with these phases
+ assert(0); exit(1);
+// return tlm::TLM_COMPLETED; //unreachable code
+ };
+ }
+
+private:
+ const sc_core::sc_time ACCEPT_DELAY;
+
+private:
+ unsigned int mNrOfTransactions;
+ unsigned int mBaseAddress;
+ SimplePool transPool;
+ unsigned int mTransactionCount;
+ sc_core::sc_event mEndRequestPhase;
+ transaction_type* mCurrentTransaction;
+};
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-20 20:12:20 +0000