/*
+ * Copyright (c) 2012 ARM Limited
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder. You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
* Copyright (c) 2002-2005 The Regents of The University of Michigan
* All rights reserved.
*
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Steve Reinhardt
+ * Andreas Hansson
+ * William Wang
*/
/**
* @file
* Port object definitions.
*/
-#include <cstring>
-
-#include "base/chunk_generator.hh"
#include "base/trace.hh"
#include "mem/mem_object.hh"
#include "mem/port.hh"
-/**
- * Special class for port objects that are used as peers for
- * unconnected ports. Assigning instances of this class to newly
- * allocated ports allows us to guarantee that every port has a peer
- * object (so there's no need to check for null peer pointers), while
- * catching uses of unconnected ports.
- */
-class DefaultPeerPort : public Port
+Port::Port(const std::string &_name, MemObject& _owner, PortID _id)
+ : portName(_name), id(_id), owner(_owner)
{
- protected:
- void blowUp()
- {
- Port *peer = getPeer();
- fatal("unconnected port: %s", peer ? peer->name() : "<unknown>");
- }
+}
- public:
- DefaultPeerPort(Port *_peer)
- : Port("default_port", NULL, _peer)
- { }
+Port::~Port()
+{
+}
- bool recvTiming(PacketPtr)
- {
- blowUp();
- return false;
- }
+BaseMasterPort::BaseMasterPort(const std::string& name, MemObject* owner,
+ PortID _id)
+ : Port(name, *owner, _id), _baseSlavePort(NULL)
+{
+}
- Tick recvAtomic(PacketPtr)
- {
- blowUp();
- return 0;
- }
+BaseMasterPort::~BaseMasterPort()
+{
+}
- void recvFunctional(PacketPtr)
- {
- blowUp();
- }
+BaseSlavePort&
+BaseMasterPort::getSlavePort() const
+{
+ if(_baseSlavePort == NULL)
+ panic("Cannot getSlavePort on master port %s that is not connected\n",
+ name());
- void recvStatusChange(Status)
- {
- blowUp();
- }
+ return *_baseSlavePort;
+}
- int deviceBlockSize()
- {
- blowUp();
- return 0;
- }
+bool
+BaseMasterPort::isConnected() const
+{
+ return _baseSlavePort != NULL;
+}
- void getDeviceAddressRanges(AddrRangeList &, bool &)
- {
- blowUp();
- }
+BaseSlavePort::BaseSlavePort(const std::string& name, MemObject* owner,
+ PortID _id)
+ : Port(name, *owner, _id), _baseMasterPort(NULL)
+{
+}
- bool isDefaultPort() const { return true; }
-};
+BaseSlavePort::~BaseSlavePort()
+{
+}
+BaseMasterPort&
+BaseSlavePort::getMasterPort() const
+{
+ if(_baseMasterPort == NULL)
+ panic("Cannot getMasterPort on slave port %s that is not connected\n",
+ name());
-Port::Port(const std::string &_name, MemObject *_owner, Port *_peer) :
- portName(_name),
- peer(_peer ? _peer : new DefaultPeerPort(this)),
- owner(_owner)
+ return *_baseMasterPort;
+}
+
+bool
+BaseSlavePort::isConnected() const
{
+ return _baseMasterPort != NULL;
}
-Port::~Port()
+/**
+ * Master port
+ */
+MasterPort::MasterPort(const std::string& name, MemObject* owner, PortID _id)
+ : BaseMasterPort(name, owner, _id), _slavePort(NULL)
+{
+}
+
+MasterPort::~MasterPort()
{
- disconnectFromPeer();
}
void
-Port::disconnectFromPeer()
+MasterPort::bind(BaseSlavePort& slave_port)
{
- if (peer) {
- assert(peer->getPeer() == this);
- peer->disconnect();
+ // bind on the level of the base ports
+ _baseSlavePort = &slave_port;
+
+ // also attempt to base the slave to the appropriate type
+ SlavePort* cast_slave_port = dynamic_cast<SlavePort*>(&slave_port);
+
+ // if this port is compatible, then proceed with the binding
+ if (cast_slave_port != NULL) {
+ // master port keeps track of the slave port
+ _slavePort = cast_slave_port;
+ // slave port also keeps track of master port
+ _slavePort->bind(*this);
+ } else {
+ fatal("Master port %s cannot bind to %s\n", name(),
+ slave_port.name());
}
}
void
-Port::disconnect()
-{
- // This notification should come only from our peer, so we must
- // have one,
- assert(peer != NULL);
- // We must clear 'peer' here, else if owner->deletePort() calls
- // delete on us then we'll recurse infinitely through the Port
- // destructor.
- peer = NULL;
- // If owner->deletePort() returns true, then we've been deleted,
- // so don't do anything but get out of here. If not, reset peer
- // pointer to a DefaultPeerPort.
- if (!(owner && owner->deletePort(this)))
- peer = new DefaultPeerPort(this);
+MasterPort::unbind()
+{
+ if (_slavePort == NULL)
+ panic("Attempting to unbind master port %s that is not connected\n",
+ name());
+ _slavePort->unbind();
+ _slavePort = NULL;
+ _baseSlavePort = NULL;
}
-void
-Port::setPeer(Port *port)
+unsigned
+MasterPort::peerBlockSize() const
+{
+ return _slavePort->deviceBlockSize();
+}
+
+AddrRangeList
+MasterPort::getAddrRanges() const
{
- DPRINTF(Config, "setting peer to %s, old peer %s\n",
- port->name(), peer ? peer->name() : "<null>");
-
- // You'd think we'd want to disconnect from the previous peer
- // here, but it turns out that with some functional ports the old
- // peer keeps using the connection, and it works because
- // functional ports are unidirectional.
- //
- // disconnectFromPeer();
+ return _slavePort->getAddrRanges();
+}
- peer = port;
+Tick
+MasterPort::sendAtomic(PacketPtr pkt)
+{
+ assert(pkt->isRequest());
+ return _slavePort->recvAtomic(pkt);
}
void
-Port::blobHelper(Addr addr, uint8_t *p, int size, MemCmd cmd)
+MasterPort::sendFunctional(PacketPtr pkt)
{
- Request req;
+ assert(pkt->isRequest());
+ return _slavePort->recvFunctional(pkt);
+}
- for (ChunkGenerator gen(addr, size, peerBlockSize());
- !gen.done(); gen.next()) {
- req.setPhys(gen.addr(), gen.size(), 0);
- Packet pkt(&req, cmd, Packet::Broadcast);
- pkt.dataStatic(p);
- sendFunctional(&pkt);
- p += gen.size();
- }
+bool
+MasterPort::sendTimingReq(PacketPtr pkt)
+{
+ assert(pkt->isRequest());
+ return _slavePort->recvTimingReq(pkt);
+}
+
+bool
+MasterPort::sendTimingSnoopResp(PacketPtr pkt)
+{
+ assert(pkt->isResponse());
+ return _slavePort->recvTimingSnoopResp(pkt);
}
void
-Port::writeBlob(Addr addr, uint8_t *p, int size)
+MasterPort::sendRetry()
+{
+ _slavePort->recvRetry();
+}
+
+void
+MasterPort::printAddr(Addr a)
+{
+ Request req(a, 1, 0, Request::funcMasterId);
+ Packet pkt(&req, MemCmd::PrintReq);
+ Packet::PrintReqState prs(std::cerr);
+ pkt.senderState = &prs;
+
+ sendFunctional(&pkt);
+}
+
+/**
+ * Slave port
+ */
+SlavePort::SlavePort(const std::string& name, MemObject* owner, PortID id)
+ : BaseSlavePort(name, owner, id), _masterPort(NULL)
+{
+}
+
+SlavePort::~SlavePort()
{
- blobHelper(addr, p, size, MemCmd::WriteReq);
}
void
-Port::readBlob(Addr addr, uint8_t *p, int size)
+SlavePort::unbind()
{
- blobHelper(addr, p, size, MemCmd::ReadReq);
+ _baseMasterPort = NULL;
+ _masterPort = NULL;
}
void
-Port::memsetBlob(Addr addr, uint8_t val, int size)
+SlavePort::bind(MasterPort& master_port)
{
- // quick and dirty...
- uint8_t *buf = new uint8_t[size];
+ _baseMasterPort = &master_port;
+ _masterPort = &master_port;
+}
- std::memset(buf, val, size);
- blobHelper(addr, buf, size, MemCmd::WriteReq);
+unsigned
+SlavePort::peerBlockSize() const
+{
+ return _masterPort->deviceBlockSize();
+}
- delete [] buf;
+Tick
+SlavePort::sendAtomicSnoop(PacketPtr pkt)
+{
+ assert(pkt->isRequest());
+ return _masterPort->recvAtomicSnoop(pkt);
}
+void
+SlavePort::sendFunctionalSnoop(PacketPtr pkt)
+{
+ assert(pkt->isRequest());
+ return _masterPort->recvFunctionalSnoop(pkt);
+}
+
+bool
+SlavePort::sendTimingResp(PacketPtr pkt)
+{
+ assert(pkt->isResponse());
+ return _masterPort->recvTimingResp(pkt);
+}
void
-Port::printAddr(Addr a)
+SlavePort::sendTimingSnoopReq(PacketPtr pkt)
{
- Request req(a, 1, 0);
- Packet pkt(&req, MemCmd::PrintReq, Packet::Broadcast);
- Packet::PrintReqState prs(std::cerr);
- pkt.senderState = &prs;
+ assert(pkt->isRequest());
+ _masterPort->recvTimingSnoopReq(pkt);
+}
- sendFunctional(&pkt);
+void
+SlavePort::sendRetry()
+{
+ _masterPort->recvRetry();
}