* Authors: Andrew Bardsley
*/
+#include "mem/external_slave.hh"
+
#include <cctype>
#include <iomanip>
+#include "base/trace.hh"
#include "debug/ExternalPort.hh"
-#include "mem/external_slave.hh"
/** Implement a `stub' port which just responds to requests by printing
* a message. The stub port can be used to configure and test a system
* where the external port is used for a peripheral before connecting
* the external port */
-class StubSlavePort : public ExternalSlave::Port
+class StubSlavePort : public ExternalSlave::ExternalPort
{
public:
- class ResponseEvent : public Event
- {
- public:
- StubSlavePort &owner;
-
- ResponseEvent(StubSlavePort &owner_) : owner(owner_) { }
-
- void process();
- };
+ void processResponseEvent();
- ResponseEvent responseEvent;
+ EventFunctionWrapper responseEvent;
/** Stub can handle a single request at a time. This will be
* NULL when no packet is in flight */
StubSlavePort(const std::string &name_,
ExternalSlave &owner_) :
- ExternalSlave::Port(name_, owner_),
- responseEvent(*this), responsePacket(NULL), mustRetry(false)
+ ExternalSlave::ExternalPort(name_, owner_),
+ responseEvent([this]{ processResponseEvent(); }, name()),
+ responsePacket(NULL), mustRetry(false)
{ }
Tick recvAtomic(PacketPtr packet);
void recvFunctional(PacketPtr packet);
bool recvTimingReq(PacketPtr packet);
bool recvTimingSnoopResp(PacketPtr packet);
- void recvRetry();
+ void recvRespRetry();
void recvFunctionalSnoop(PacketPtr packet);
};
ExternalSlave::Handler
{
public:
- ExternalSlave::Port *getExternalPort(
+ ExternalSlave::ExternalPort *getExternalPort(
const std::string &name_,
ExternalSlave &owner,
const std::string &port_data)
}
void
-StubSlavePort::ResponseEvent::process()
+StubSlavePort::processResponseEvent()
{
- owner.responsePacket->makeResponse();
- owner.responsePacket->headerDelay = 0;
- owner.responsePacket->payloadDelay = 0;
+ responsePacket->makeResponse();
+ responsePacket->headerDelay = 0;
+ responsePacket->payloadDelay = 0;
- if (owner.sendTimingResp(owner.responsePacket)) {
- owner.responsePacket = NULL;
+ if (sendTimingResp(responsePacket)) {
+ responsePacket = NULL;
- if (owner.mustRetry)
- owner.sendRetry();
- owner.mustRetry = false;
+ if (mustRetry)
+ sendRetryReq();
+ mustRetry = false;
}
}
}
void
-StubSlavePort::recvRetry()
+StubSlavePort::recvRespRetry()
{
assert(responsePacket);
/* Stub handles only one response at a time so responseEvent should never
ExternalSlave::portHandlers;
AddrRangeList
-ExternalSlave::Port::getAddrRanges() const
+ExternalSlave::ExternalPort::getAddrRanges() const
{
return owner.addrRanges;
}
registerHandler("stub", new StubSlavePortHandler);
}
-BaseSlavePort &
-ExternalSlave::getSlavePort(const std::string &if_name,
- PortID idx)
+Port &
+ExternalSlave::getPort(const std::string &if_name, PortID idx)
{
if (if_name == "port") {
DPRINTF(ExternalPort, "Trying to bind external port: %s %s\n",
}
return *externalPort;
} else {
- return MemObject::getSlavePort(if_name, idx);
+ return MemObject::getPort(if_name, idx);
}
}