3 * Copyright (c) 2006 The Regents of The University of Michigan
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * Definition of a simple bus bridge without buffering.
40 #include "base/range_ops.hh"
41 #include "base/trace.hh"
42 #include "mem/bridge.hh"
43 #include "params/Bridge.hh"
45 Bridge::BridgePort::BridgePort(const std::string
&_name
,
46 Bridge
*_bridge
, BridgePort
*_otherPort
,
47 int _delay
, int _nack_delay
, int _req_limit
,
49 std::vector
<Range
<Addr
> > filter_ranges
)
50 : Port(_name
, _bridge
), bridge(_bridge
), otherPort(_otherPort
),
51 delay(_delay
), nackDelay(_nack_delay
), filterRanges(filter_ranges
),
52 outstandingResponses(0), queuedRequests(0), inRetry(false),
53 reqQueueLimit(_req_limit
), respQueueLimit(_resp_limit
), sendEvent(this)
57 Bridge::Bridge(Params
*p
)
59 portA(p
->name
+ "-portA", this, &portB
, p
->delay
, p
->nack_delay
,
60 p
->req_size_a
, p
->resp_size_a
, p
->filter_ranges_a
),
61 portB(p
->name
+ "-portB", this, &portA
, p
->delay
, p
->nack_delay
,
62 p
->req_size_b
, p
->resp_size_b
, p
->filter_ranges_b
),
63 ackWrites(p
->write_ack
), _params(p
)
66 panic("No support for acknowledging writes\n");
70 Bridge::getPort(const std::string
&if_name
, int idx
)
74 if (if_name
== "side_a")
76 else if (if_name
== "side_b")
81 if (port
->getPeer() != NULL
&& !port
->getPeer()->isDefaultPort())
82 panic("bridge side %s already connected to %s.",
83 if_name
, port
->getPeer()->name());
91 // Make sure that both sides are connected to.
92 if (!portA
.isConnected() || !portB
.isConnected())
93 fatal("Both ports of bus bridge are not connected to a bus.\n");
95 if (portA
.peerBlockSize() != portB
.peerBlockSize())
96 fatal("port A size %d, port B size %d \n " \
97 "Busses don't have the same block size... Not supported.\n",
98 portA
.peerBlockSize(), portB
.peerBlockSize());
102 Bridge::BridgePort::respQueueFull()
104 assert(outstandingResponses
>= 0 && outstandingResponses
<= respQueueLimit
);
105 return outstandingResponses
>= respQueueLimit
;
109 Bridge::BridgePort::reqQueueFull()
111 assert(queuedRequests
>= 0 && queuedRequests
<= reqQueueLimit
);
112 return queuedRequests
>= reqQueueLimit
;
115 /** Function called by the port when the bus is receiving a Timing
118 Bridge::BridgePort::recvTiming(PacketPtr pkt
)
120 DPRINTF(BusBridge
, "recvTiming: src %d dest %d addr 0x%x\n",
121 pkt
->getSrc(), pkt
->getDest(), pkt
->getAddr());
123 DPRINTF(BusBridge
, "Local queue size: %d outreq: %d outresp: %d\n",
124 sendQueue
.size(), queuedRequests
, outstandingResponses
);
125 DPRINTF(BusBridge
, "Remote queue size: %d outreq: %d outresp: %d\n",
126 otherPort
->sendQueue
.size(), otherPort
->queuedRequests
,
127 otherPort
->outstandingResponses
);
129 if (pkt
->isRequest() && otherPort
->reqQueueFull()) {
130 DPRINTF(BusBridge
, "Remote queue full, nacking\n");
135 if (pkt
->needsResponse()) {
136 if (respQueueFull()) {
137 DPRINTF(BusBridge
, "Local queue full, no space for response, nacking\n");
138 DPRINTF(BusBridge
, "queue size: %d outreq: %d outstanding resp: %d\n",
139 sendQueue
.size(), queuedRequests
, outstandingResponses
);
143 DPRINTF(BusBridge
, "Request Needs response, reserving space\n");
144 ++outstandingResponses
;
148 otherPort
->queueForSendTiming(pkt
);
154 Bridge::BridgePort::nackRequest(PacketPtr pkt
)
157 pkt
->makeTimingResponse();
160 //put it on the list to send
161 Tick readyTime
= curTick() + nackDelay
;
162 PacketBuffer
*buf
= new PacketBuffer(pkt
, readyTime
, true);
164 // nothing on the list, add it and we're done
165 if (sendQueue
.empty()) {
166 assert(!sendEvent
.scheduled());
167 schedule(sendEvent
, readyTime
);
168 sendQueue
.push_back(buf
);
172 assert(sendEvent
.scheduled() || inRetry
);
174 // does it go at the end?
175 if (readyTime
>= sendQueue
.back()->ready
) {
176 sendQueue
.push_back(buf
);
180 // ok, somewhere in the middle, fun
181 std::list
<PacketBuffer
*>::iterator i
= sendQueue
.begin();
182 std::list
<PacketBuffer
*>::iterator end
= sendQueue
.end();
183 std::list
<PacketBuffer
*>::iterator begin
= sendQueue
.begin();
186 while (i
!= end
&& !done
) {
187 if (readyTime
< (*i
)->ready
) {
189 reschedule(sendEvent
, readyTime
);
190 sendQueue
.insert(i
,buf
);
200 Bridge::BridgePort::queueForSendTiming(PacketPtr pkt
)
202 if (pkt
->isResponse()) {
203 // This is a response for a request we forwarded earlier. The
204 // corresponding PacketBuffer should be stored in the packet's
205 // senderState field.
207 PacketBuffer
*buf
= dynamic_cast<PacketBuffer
*>(pkt
->senderState
);
209 // set up new packet dest & senderState based on values saved
210 // from original request
211 buf
->fixResponse(pkt
);
213 DPRINTF(BusBridge
, "response, new dest %d\n", pkt
->getDest());
218 if (pkt
->isRequest()) {
224 Tick readyTime
= curTick() + delay
;
225 PacketBuffer
*buf
= new PacketBuffer(pkt
, readyTime
);
227 // If we're about to put this packet at the head of the queue, we
228 // need to schedule an event to do the transmit. Otherwise there
229 // should already be an event scheduled for sending the head
231 if (sendQueue
.empty()) {
232 schedule(sendEvent
, readyTime
);
234 sendQueue
.push_back(buf
);
238 Bridge::BridgePort::trySend()
240 assert(!sendQueue
.empty());
242 PacketBuffer
*buf
= sendQueue
.front();
244 assert(buf
->ready
<= curTick());
246 PacketPtr pkt
= buf
->pkt
;
248 DPRINTF(BusBridge
, "trySend: origSrc %d dest %d addr 0x%x\n",
249 buf
->origSrc
, pkt
->getDest(), pkt
->getAddr());
251 bool wasReq
= pkt
->isRequest();
252 bool was_nacked_here
= buf
->nackedHere
;
254 // If the send was successful, make sure sender state was set to NULL
255 // otherwise we could get a NACK back of a packet that didn't expect a
256 // response and we would try to use freed memory.
258 Packet::SenderState
*old_sender_state
= pkt
->senderState
;
259 if (pkt
->isRequest() && !buf
->expectResponse
)
260 pkt
->senderState
= NULL
;
262 if (sendTiming(pkt
)) {
264 sendQueue
.pop_front();
265 buf
->pkt
= NULL
; // we no longer own packet, so it's not safe to look at it
267 if (buf
->expectResponse
) {
268 // Must wait for response
269 DPRINTF(BusBridge
, " successful: awaiting response (%d)\n",
270 outstandingResponses
);
272 // no response expected... deallocate packet buffer now.
273 DPRINTF(BusBridge
, " successful: no response expected\n");
279 else if (!was_nacked_here
)
280 --outstandingResponses
;
282 // If there are more packets to send, schedule event to try again.
283 if (!sendQueue
.empty()) {
284 buf
= sendQueue
.front();
285 DPRINTF(BusBridge
, "Scheduling next send\n");
286 schedule(sendEvent
, std::max(buf
->ready
, curTick() + 1));
289 DPRINTF(BusBridge
, " unsuccessful\n");
290 pkt
->senderState
= old_sender_state
;
294 DPRINTF(BusBridge
, "trySend: queue size: %d outreq: %d outstanding resp: %d\n",
295 sendQueue
.size(), queuedRequests
, outstandingResponses
);
300 Bridge::BridgePort::recvRetry()
303 Tick nextReady
= sendQueue
.front()->ready
;
304 if (nextReady
<= curTick())
307 schedule(sendEvent
, nextReady
);
310 /** Function called by the port when the bus is receiving a Atomic
313 Bridge::BridgePort::recvAtomic(PacketPtr pkt
)
315 return delay
+ otherPort
->sendAtomic(pkt
);
318 /** Function called by the port when the bus is receiving a Functional
321 Bridge::BridgePort::recvFunctional(PacketPtr pkt
)
323 std::list
<PacketBuffer
*>::iterator i
;
325 pkt
->pushLabel(name());
327 for (i
= sendQueue
.begin(); i
!= sendQueue
.end(); ++i
) {
328 if (pkt
->checkFunctional((*i
)->pkt
)) {
336 // fall through if pkt still not satisfied
337 otherPort
->sendFunctional(pkt
);
340 /** Function called by the port when the bus is receiving a status change.*/
342 Bridge::BridgePort::recvStatusChange(Port::Status status
)
344 otherPort
->sendStatusChange(status
);
348 Bridge::BridgePort::getDeviceAddressRanges(AddrRangeList
&resp
,
351 otherPort
->getPeerAddressRanges(resp
, snoop
);
352 FilterRangeList(filterRanges
, resp
);
353 // we don't allow snooping across bridges
358 BridgeParams::create()
360 return new Bridge(this);