2006-04-28 21:37:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright (c) 2006 The Regents of The University of Michigan
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* 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;
|
|
|
|
* neither the name of the copyright holders 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
|
|
|
|
* OWNER 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.
|
2006-06-01 01:26:56 +02:00
|
|
|
*
|
|
|
|
* Authors: Ali Saidi
|
|
|
|
* Steve Reinhardt
|
2006-04-28 21:37:48 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2006-08-15 01:25:07 +02:00
|
|
|
* @file
|
|
|
|
* Definition of a simple bus bridge without buffering.
|
2006-04-28 21:37:48 +02:00
|
|
|
*/
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
#include <algorithm>
|
2006-04-28 21:37:48 +02:00
|
|
|
|
|
|
|
#include "base/trace.hh"
|
|
|
|
#include "mem/bridge.hh"
|
|
|
|
#include "sim/builder.hh"
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
Bridge::BridgePort::BridgePort(const std::string &_name,
|
|
|
|
Bridge *_bridge, BridgePort *_otherPort,
|
|
|
|
int _delay, int _queueLimit)
|
|
|
|
: Port(_name), bridge(_bridge), otherPort(_otherPort),
|
|
|
|
delay(_delay), outstandingResponses(0),
|
|
|
|
queueLimit(_queueLimit), sendEvent(this)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Bridge::Bridge(const std::string &n, int qsa, int qsb,
|
|
|
|
Tick _delay, int write_ack)
|
|
|
|
: MemObject(n),
|
|
|
|
portA(n + "-portA", this, &portB, _delay, qsa),
|
|
|
|
portB(n + "-portB", this, &portA, _delay, qsa),
|
|
|
|
ackWrites(write_ack)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Port *
|
2006-06-14 05:19:28 +02:00
|
|
|
Bridge::getPort(const std::string &if_name, int idx)
|
2006-05-26 20:29:29 +02:00
|
|
|
{
|
|
|
|
BridgePort *port;
|
|
|
|
|
|
|
|
if (if_name == "side_a")
|
|
|
|
port = &portA;
|
|
|
|
else if (if_name == "side_b")
|
|
|
|
port = &portB;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (port->getPeer() != NULL)
|
|
|
|
panic("bridge side %s already connected to.", if_name);
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-04-28 21:37:48 +02:00
|
|
|
void
|
|
|
|
Bridge::init()
|
|
|
|
{
|
|
|
|
// Make sure that both sides are connected to.
|
2006-05-26 20:29:29 +02:00
|
|
|
if (portA.getPeer() == NULL || portB.getPeer() == NULL)
|
2006-04-28 21:37:48 +02:00
|
|
|
panic("Both ports of bus bridge are not connected to a bus.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
/** Function called by the port when the bus is receiving a Timing
|
2006-04-28 21:37:48 +02:00
|
|
|
* transaction.*/
|
|
|
|
bool
|
2006-10-20 09:10:12 +02:00
|
|
|
Bridge::BridgePort::recvTiming(PacketPtr pkt)
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-11-14 07:12:52 +01:00
|
|
|
if (pkt->flags & SNOOP_COMMIT) {
|
|
|
|
DPRINTF(BusBridge, "recvTiming: src %d dest %d addr 0x%x\n",
|
|
|
|
pkt->getSrc(), pkt->getDest(), pkt->getAddr());
|
|
|
|
|
|
|
|
return otherPort->queueForSendTiming(pkt);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Else it's just a snoop, properly return if we are blocking
|
|
|
|
return !queueFull();
|
|
|
|
}
|
2006-05-31 00:57:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
2006-10-20 09:10:12 +02:00
|
|
|
Bridge::BridgePort::queueForSendTiming(PacketPtr pkt)
|
2006-05-31 00:57:42 +02:00
|
|
|
{
|
|
|
|
if (queueFull())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (pkt->isResponse()) {
|
2006-05-26 20:29:29 +02:00
|
|
|
// This is a response for a request we forwarded earlier. The
|
|
|
|
// corresponding PacketBuffer should be stored in the packet's
|
|
|
|
// senderState field.
|
|
|
|
PacketBuffer *buf = dynamic_cast<PacketBuffer*>(pkt->senderState);
|
|
|
|
assert(buf != NULL);
|
|
|
|
// set up new packet dest & senderState based on values saved
|
|
|
|
// from original request
|
|
|
|
buf->fixResponse(pkt);
|
2006-05-31 00:57:42 +02:00
|
|
|
DPRINTF(BusBridge, "restoring sender state: %#X, from packet buffer: %#X\n",
|
|
|
|
pkt->senderState, buf);
|
2006-05-26 20:29:29 +02:00
|
|
|
DPRINTF(BusBridge, " is response, new dest %d\n", pkt->getDest());
|
|
|
|
delete buf;
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
Tick readyTime = curTick + delay;
|
|
|
|
PacketBuffer *buf = new PacketBuffer(pkt, readyTime);
|
2006-05-31 00:57:42 +02:00
|
|
|
DPRINTF(BusBridge, "old sender state: %#X, new sender state: %#X\n",
|
|
|
|
buf->origSenderState, buf);
|
2006-05-26 20:29:29 +02:00
|
|
|
|
|
|
|
// If we're about to put this packet at the head of the queue, we
|
|
|
|
// need to schedule an event to do the transmit. Otherwise there
|
|
|
|
// should already be an event scheduled for sending the head
|
|
|
|
// packet.
|
|
|
|
if (sendQueue.empty()) {
|
|
|
|
sendEvent.schedule(readyTime);
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
sendQueue.push_back(buf);
|
|
|
|
|
|
|
|
return true;
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2006-05-26 20:29:29 +02:00
|
|
|
Bridge::BridgePort::trySend()
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-05-26 20:29:29 +02:00
|
|
|
assert(!sendQueue.empty());
|
|
|
|
|
2006-05-31 00:57:42 +02:00
|
|
|
bool was_full = queueFull();
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
PacketBuffer *buf = sendQueue.front();
|
|
|
|
|
|
|
|
assert(buf->ready <= curTick);
|
|
|
|
|
2006-10-20 09:10:12 +02:00
|
|
|
PacketPtr pkt = buf->pkt;
|
2006-05-26 20:29:29 +02:00
|
|
|
|
|
|
|
DPRINTF(BusBridge, "trySend: origSrc %d dest %d addr 0x%x\n",
|
|
|
|
buf->origSrc, pkt->getDest(), pkt->getAddr());
|
|
|
|
|
2006-10-13 21:47:05 +02:00
|
|
|
pkt->flags &= ~SNOOP_COMMIT; //CLear it if it was set
|
2006-05-26 20:29:29 +02:00
|
|
|
if (sendTiming(pkt)) {
|
|
|
|
// send successful
|
|
|
|
sendQueue.pop_front();
|
|
|
|
buf->pkt = NULL; // we no longer own packet, so it's not safe to look at it
|
2006-05-31 00:57:42 +02:00
|
|
|
|
|
|
|
if (buf->expectResponse) {
|
|
|
|
// Must wait for response. We just need to count outstanding
|
|
|
|
// responses (in case we want to cap them); PacketBuffer
|
|
|
|
// pointer will be recovered on response.
|
|
|
|
++outstandingResponses;
|
|
|
|
DPRINTF(BusBridge, " successful: awaiting response (%d)\n",
|
|
|
|
outstandingResponses);
|
|
|
|
} else {
|
|
|
|
// no response expected... deallocate packet buffer now.
|
|
|
|
DPRINTF(BusBridge, " successful: no response expected\n");
|
|
|
|
delete buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there are more packets to send, schedule event to try again.
|
|
|
|
if (!sendQueue.empty()) {
|
|
|
|
buf = sendQueue.front();
|
|
|
|
sendEvent.schedule(std::max(buf->ready, curTick + 1));
|
|
|
|
}
|
|
|
|
// Let things start sending again
|
|
|
|
if (was_full) {
|
|
|
|
DPRINTF(BusBridge, "Queue was full, sending retry\n");
|
|
|
|
otherPort->sendRetry();
|
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
} else {
|
|
|
|
DPRINTF(BusBridge, " unsuccessful\n");
|
|
|
|
}
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-05-31 00:57:42 +02:00
|
|
|
void
|
2006-04-28 21:37:48 +02:00
|
|
|
Bridge::BridgePort::recvRetry()
|
|
|
|
{
|
2006-05-31 00:57:42 +02:00
|
|
|
trySend();
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
/** Function called by the port when the bus is receiving a Atomic
|
2006-04-28 21:37:48 +02:00
|
|
|
* transaction.*/
|
|
|
|
Tick
|
2006-10-20 09:10:12 +02:00
|
|
|
Bridge::BridgePort::recvAtomic(PacketPtr pkt)
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-05-26 20:29:29 +02:00
|
|
|
return otherPort->sendAtomic(pkt) + delay;
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
/** Function called by the port when the bus is receiving a Functional
|
2006-04-28 21:37:48 +02:00
|
|
|
* transaction.*/
|
|
|
|
void
|
2006-10-20 09:10:12 +02:00
|
|
|
Bridge::BridgePort::recvFunctional(PacketPtr pkt)
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-05-26 20:29:29 +02:00
|
|
|
std::list<PacketBuffer*>::iterator i;
|
2006-04-28 21:37:48 +02:00
|
|
|
bool pktContinue = true;
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
for (i = sendQueue.begin(); i != sendQueue.end(); ++i) {
|
|
|
|
if (pkt->intersect((*i)->pkt)) {
|
|
|
|
pktContinue &= fixPacket(pkt, (*i)->pkt);
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pktContinue) {
|
2006-05-26 20:29:29 +02:00
|
|
|
otherPort->sendFunctional(pkt);
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-26 20:29:29 +02:00
|
|
|
/** Function called by the port when the bus is receiving a status change.*/
|
2006-04-28 21:37:48 +02:00
|
|
|
void
|
2006-05-26 20:29:29 +02:00
|
|
|
Bridge::BridgePort::recvStatusChange(Port::Status status)
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-05-26 20:29:29 +02:00
|
|
|
otherPort->sendStatusChange(status);
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2006-05-26 20:29:29 +02:00
|
|
|
Bridge::BridgePort::getDeviceAddressRanges(AddrRangeList &resp,
|
|
|
|
AddrRangeList &snoop)
|
2006-04-28 21:37:48 +02:00
|
|
|
{
|
2006-05-26 20:29:29 +02:00
|
|
|
otherPort->getPeerAddressRanges(resp, snoop);
|
2006-04-28 21:37:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bridge)
|
|
|
|
|
|
|
|
Param<int> queue_size_a;
|
|
|
|
Param<int> queue_size_b;
|
|
|
|
Param<Tick> delay;
|
|
|
|
Param<bool> write_ack;
|
|
|
|
|
|
|
|
END_DECLARE_SIM_OBJECT_PARAMS(Bridge)
|
|
|
|
|
|
|
|
BEGIN_INIT_SIM_OBJECT_PARAMS(Bridge)
|
|
|
|
|
|
|
|
INIT_PARAM(queue_size_a, "The size of the queue for data coming into side a"),
|
|
|
|
INIT_PARAM(queue_size_b, "The size of the queue for data coming into side b"),
|
|
|
|
INIT_PARAM(delay, "The miminum delay to cross this bridge"),
|
|
|
|
INIT_PARAM(write_ack, "Acknowledge any writes that are received.")
|
|
|
|
|
|
|
|
END_INIT_SIM_OBJECT_PARAMS(Bridge)
|
|
|
|
|
|
|
|
CREATE_SIM_OBJECT(Bridge)
|
|
|
|
{
|
|
|
|
return new Bridge(getInstanceName(), queue_size_a, queue_size_b, delay,
|
|
|
|
write_ack);
|
|
|
|
}
|
|
|
|
|
|
|
|
REGISTER_SIM_OBJECT("Bridge", Bridge)
|