1/*
2 * Copyright (c) 2011-2013, 2015 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Ali Saidi
41 * Steve Reinhardt
42 * Andreas Hansson
43 */
44
45/**
46 * @file
47 * Implementation of a memory-mapped bridge that connects a master
48 * and a slave through a request and response queue.
49 */
50
51#include "base/trace.hh"
52#include "debug/Bridge.hh"
53#include "mem/bridge.hh"
54#include "params/Bridge.hh"
55
56Bridge::BridgeSlavePort::BridgeSlavePort(const std::string& _name,
57 Bridge& _bridge,
58 BridgeMasterPort& _masterPort,
59 Cycles _delay, int _resp_limit,
60 std::vector<AddrRange> _ranges)
61 : SlavePort(_name, &_bridge), bridge(_bridge), masterPort(_masterPort),
62 delay(_delay), ranges(_ranges.begin(), _ranges.end()),
63 outstandingResponses(0), retryReq(false),
64 respQueueLimit(_resp_limit), sendEvent(*this)
65{
66}
67
68Bridge::BridgeMasterPort::BridgeMasterPort(const std::string& _name,
69 Bridge& _bridge,
70 BridgeSlavePort& _slavePort,
71 Cycles _delay, int _req_limit)
72 : MasterPort(_name, &_bridge), bridge(_bridge), slavePort(_slavePort),
73 delay(_delay), reqQueueLimit(_req_limit), sendEvent(*this)
74{
75}
76
77Bridge::Bridge(Params *p)
78 : MemObject(p),
79 slavePort(p->name + ".slave", *this, masterPort,
80 ticksToCycles(p->delay), p->resp_size, p->ranges),
81 masterPort(p->name + ".master", *this, slavePort,
82 ticksToCycles(p->delay), p->req_size)
83{
84}
85
86BaseMasterPort&
87Bridge::getMasterPort(const std::string &if_name, PortID idx)
88{
89 if (if_name == "master")
90 return masterPort;
91 else
92 // pass it along to our super class
93 return MemObject::getMasterPort(if_name, idx);
94}
95
96BaseSlavePort&
97Bridge::getSlavePort(const std::string &if_name, PortID idx)
98{
99 if (if_name == "slave")
100 return slavePort;
101 else
102 // pass it along to our super class
103 return MemObject::getSlavePort(if_name, idx);
104}
105
106void
107Bridge::init()
108{
109 // make sure both sides are connected and have the same block size
110 if (!slavePort.isConnected() || !masterPort.isConnected())
111 fatal("Both ports of a bridge must be connected.\n");
112
113 // notify the master side of our address ranges
114 slavePort.sendRangeChange();
115}
116
117bool
118Bridge::BridgeSlavePort::respQueueFull() const
119{
120 return outstandingResponses == respQueueLimit;
121}
122
123bool
124Bridge::BridgeMasterPort::reqQueueFull() const
125{
126 return transmitList.size() == reqQueueLimit;
127}
128
129bool
130Bridge::BridgeMasterPort::recvTimingResp(PacketPtr pkt)
131{
132 // all checks are done when the request is accepted on the slave
133 // side, so we are guaranteed to have space for the response
134 DPRINTF(Bridge, "recvTimingResp: %s addr 0x%x\n",
135 pkt->cmdString(), pkt->getAddr());
136
137 DPRINTF(Bridge, "Request queue size: %d\n", transmitList.size());
138
| 1/*
2 * Copyright (c) 2011-2013, 2015 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Ali Saidi
41 * Steve Reinhardt
42 * Andreas Hansson
43 */
44
45/**
46 * @file
47 * Implementation of a memory-mapped bridge that connects a master
48 * and a slave through a request and response queue.
49 */
50
51#include "base/trace.hh"
52#include "debug/Bridge.hh"
53#include "mem/bridge.hh"
54#include "params/Bridge.hh"
55
56Bridge::BridgeSlavePort::BridgeSlavePort(const std::string& _name,
57 Bridge& _bridge,
58 BridgeMasterPort& _masterPort,
59 Cycles _delay, int _resp_limit,
60 std::vector<AddrRange> _ranges)
61 : SlavePort(_name, &_bridge), bridge(_bridge), masterPort(_masterPort),
62 delay(_delay), ranges(_ranges.begin(), _ranges.end()),
63 outstandingResponses(0), retryReq(false),
64 respQueueLimit(_resp_limit), sendEvent(*this)
65{
66}
67
68Bridge::BridgeMasterPort::BridgeMasterPort(const std::string& _name,
69 Bridge& _bridge,
70 BridgeSlavePort& _slavePort,
71 Cycles _delay, int _req_limit)
72 : MasterPort(_name, &_bridge), bridge(_bridge), slavePort(_slavePort),
73 delay(_delay), reqQueueLimit(_req_limit), sendEvent(*this)
74{
75}
76
77Bridge::Bridge(Params *p)
78 : MemObject(p),
79 slavePort(p->name + ".slave", *this, masterPort,
80 ticksToCycles(p->delay), p->resp_size, p->ranges),
81 masterPort(p->name + ".master", *this, slavePort,
82 ticksToCycles(p->delay), p->req_size)
83{
84}
85
86BaseMasterPort&
87Bridge::getMasterPort(const std::string &if_name, PortID idx)
88{
89 if (if_name == "master")
90 return masterPort;
91 else
92 // pass it along to our super class
93 return MemObject::getMasterPort(if_name, idx);
94}
95
96BaseSlavePort&
97Bridge::getSlavePort(const std::string &if_name, PortID idx)
98{
99 if (if_name == "slave")
100 return slavePort;
101 else
102 // pass it along to our super class
103 return MemObject::getSlavePort(if_name, idx);
104}
105
106void
107Bridge::init()
108{
109 // make sure both sides are connected and have the same block size
110 if (!slavePort.isConnected() || !masterPort.isConnected())
111 fatal("Both ports of a bridge must be connected.\n");
112
113 // notify the master side of our address ranges
114 slavePort.sendRangeChange();
115}
116
117bool
118Bridge::BridgeSlavePort::respQueueFull() const
119{
120 return outstandingResponses == respQueueLimit;
121}
122
123bool
124Bridge::BridgeMasterPort::reqQueueFull() const
125{
126 return transmitList.size() == reqQueueLimit;
127}
128
129bool
130Bridge::BridgeMasterPort::recvTimingResp(PacketPtr pkt)
131{
132 // all checks are done when the request is accepted on the slave
133 // side, so we are guaranteed to have space for the response
134 DPRINTF(Bridge, "recvTimingResp: %s addr 0x%x\n",
135 pkt->cmdString(), pkt->getAddr());
136
137 DPRINTF(Bridge, "Request queue size: %d\n", transmitList.size());
138
|
139 // @todo: We need to pay for this and not just zero it out
| 139 // technically the packet only reaches us after the header delay,
140 // and typically we also need to deserialise any payload (unless
141 // the two sides of the bridge are synchronous)
142 Tick receive_delay = pkt->headerDelay + pkt->payloadDelay;
|
140 pkt->headerDelay = pkt->payloadDelay = 0;
141
| 143 pkt->headerDelay = pkt->payloadDelay = 0;
144
|
142 slavePort.schedTimingResp(pkt, bridge.clockEdge(delay));
| 145 slavePort.schedTimingResp(pkt, bridge.clockEdge(delay) +
146 receive_delay);
|
143
144 return true;
145}
146
147bool
148Bridge::BridgeSlavePort::recvTimingReq(PacketPtr pkt)
149{
150 DPRINTF(Bridge, "recvTimingReq: %s addr 0x%x\n",
151 pkt->cmdString(), pkt->getAddr());
152
153 // sink inhibited packets without further action, also discard any
154 // packet that is not a read or a write
155 if (pkt->memInhibitAsserted() ||
156 !(pkt->isWrite() || pkt->isRead())) {
157 assert(!pkt->needsResponse());
158 pendingDelete.reset(pkt);
159 return true;
160 }
161
162 // we should not get a new request after committing to retry the
163 // current one, but unfortunately the CPU violates this rule, so
164 // simply ignore it for now
165 if (retryReq)
166 return false;
167
168 DPRINTF(Bridge, "Response queue size: %d outresp: %d\n",
169 transmitList.size(), outstandingResponses);
170
171 // if the request queue is full then there is no hope
172 if (masterPort.reqQueueFull()) {
173 DPRINTF(Bridge, "Request queue full\n");
174 retryReq = true;
175 } else {
176 // look at the response queue if we expect to see a response
177 bool expects_response = pkt->needsResponse();
178 if (expects_response) {
179 if (respQueueFull()) {
180 DPRINTF(Bridge, "Response queue full\n");
181 retryReq = true;
182 } else {
183 // ok to send the request with space for the response
184 DPRINTF(Bridge, "Reserving space for response\n");
185 assert(outstandingResponses != respQueueLimit);
186 ++outstandingResponses;
187
188 // no need to set retryReq to false as this is already the
189 // case
190 }
191 }
192
193 if (!retryReq) {
| 147
148 return true;
149}
150
151bool
152Bridge::BridgeSlavePort::recvTimingReq(PacketPtr pkt)
153{
154 DPRINTF(Bridge, "recvTimingReq: %s addr 0x%x\n",
155 pkt->cmdString(), pkt->getAddr());
156
157 // sink inhibited packets without further action, also discard any
158 // packet that is not a read or a write
159 if (pkt->memInhibitAsserted() ||
160 !(pkt->isWrite() || pkt->isRead())) {
161 assert(!pkt->needsResponse());
162 pendingDelete.reset(pkt);
163 return true;
164 }
165
166 // we should not get a new request after committing to retry the
167 // current one, but unfortunately the CPU violates this rule, so
168 // simply ignore it for now
169 if (retryReq)
170 return false;
171
172 DPRINTF(Bridge, "Response queue size: %d outresp: %d\n",
173 transmitList.size(), outstandingResponses);
174
175 // if the request queue is full then there is no hope
176 if (masterPort.reqQueueFull()) {
177 DPRINTF(Bridge, "Request queue full\n");
178 retryReq = true;
179 } else {
180 // look at the response queue if we expect to see a response
181 bool expects_response = pkt->needsResponse();
182 if (expects_response) {
183 if (respQueueFull()) {
184 DPRINTF(Bridge, "Response queue full\n");
185 retryReq = true;
186 } else {
187 // ok to send the request with space for the response
188 DPRINTF(Bridge, "Reserving space for response\n");
189 assert(outstandingResponses != respQueueLimit);
190 ++outstandingResponses;
191
192 // no need to set retryReq to false as this is already the
193 // case
194 }
195 }
196
197 if (!retryReq) {
|
194 // @todo: We need to pay for this and not just zero it out
| 198 // technically the packet only reaches us after the header
199 // delay, and typically we also need to deserialise any
200 // payload (unless the two sides of the bridge are
201 // synchronous)
202 Tick receive_delay = pkt->headerDelay + pkt->payloadDelay;
|
195 pkt->headerDelay = pkt->payloadDelay = 0;
196
| 203 pkt->headerDelay = pkt->payloadDelay = 0;
204
|
197 masterPort.schedTimingReq(pkt, bridge.clockEdge(delay));
| 205 masterPort.schedTimingReq(pkt, bridge.clockEdge(delay) +
206 receive_delay);
|
198 }
199 }
200
201 // remember that we are now stalling a packet and that we have to
202 // tell the sending master to retry once space becomes available,
203 // we make no distinction whether the stalling is due to the
204 // request queue or response queue being full
205 return !retryReq;
206}
207
208void
209Bridge::BridgeSlavePort::retryStalledReq()
210{
211 if (retryReq) {
212 DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
213 retryReq = false;
214 sendRetryReq();
215 }
216}
217
218void
219Bridge::BridgeMasterPort::schedTimingReq(PacketPtr pkt, Tick when)
220{
221 // If we're about to put this packet at the head of the queue, we
222 // need to schedule an event to do the transmit. Otherwise there
223 // should already be an event scheduled for sending the head
224 // packet.
225 if (transmitList.empty()) {
226 bridge.schedule(sendEvent, when);
227 }
228
229 assert(transmitList.size() != reqQueueLimit);
230
231 transmitList.emplace_back(pkt, when);
232}
233
234
235void
236Bridge::BridgeSlavePort::schedTimingResp(PacketPtr pkt, Tick when)
237{
238 // If we're about to put this packet at the head of the queue, we
239 // need to schedule an event to do the transmit. Otherwise there
240 // should already be an event scheduled for sending the head
241 // packet.
242 if (transmitList.empty()) {
243 bridge.schedule(sendEvent, when);
244 }
245
246 transmitList.emplace_back(pkt, when);
247}
248
249void
250Bridge::BridgeMasterPort::trySendTiming()
251{
252 assert(!transmitList.empty());
253
254 DeferredPacket req = transmitList.front();
255
256 assert(req.tick <= curTick());
257
258 PacketPtr pkt = req.pkt;
259
260 DPRINTF(Bridge, "trySend request addr 0x%x, queue size %d\n",
261 pkt->getAddr(), transmitList.size());
262
263 if (sendTimingReq(pkt)) {
264 // send successful
265 transmitList.pop_front();
266 DPRINTF(Bridge, "trySend request successful\n");
267
268 // If there are more packets to send, schedule event to try again.
269 if (!transmitList.empty()) {
270 DeferredPacket next_req = transmitList.front();
271 DPRINTF(Bridge, "Scheduling next send\n");
272 bridge.schedule(sendEvent, std::max(next_req.tick,
273 bridge.clockEdge()));
274 }
275
276 // if we have stalled a request due to a full request queue,
277 // then send a retry at this point, also note that if the
278 // request we stalled was waiting for the response queue
279 // rather than the request queue we might stall it again
280 slavePort.retryStalledReq();
281 }
282
283 // if the send failed, then we try again once we receive a retry,
284 // and therefore there is no need to take any action
285}
286
287void
288Bridge::BridgeSlavePort::trySendTiming()
289{
290 assert(!transmitList.empty());
291
292 DeferredPacket resp = transmitList.front();
293
294 assert(resp.tick <= curTick());
295
296 PacketPtr pkt = resp.pkt;
297
298 DPRINTF(Bridge, "trySend response addr 0x%x, outstanding %d\n",
299 pkt->getAddr(), outstandingResponses);
300
301 if (sendTimingResp(pkt)) {
302 // send successful
303 transmitList.pop_front();
304 DPRINTF(Bridge, "trySend response successful\n");
305
306 assert(outstandingResponses != 0);
307 --outstandingResponses;
308
309 // If there are more packets to send, schedule event to try again.
310 if (!transmitList.empty()) {
311 DeferredPacket next_resp = transmitList.front();
312 DPRINTF(Bridge, "Scheduling next send\n");
313 bridge.schedule(sendEvent, std::max(next_resp.tick,
314 bridge.clockEdge()));
315 }
316
317 // if there is space in the request queue and we were stalling
318 // a request, it will definitely be possible to accept it now
319 // since there is guaranteed space in the response queue
320 if (!masterPort.reqQueueFull() && retryReq) {
321 DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
322 retryReq = false;
323 sendRetryReq();
324 }
325 }
326
327 // if the send failed, then we try again once we receive a retry,
328 // and therefore there is no need to take any action
329}
330
331void
332Bridge::BridgeMasterPort::recvReqRetry()
333{
334 trySendTiming();
335}
336
337void
338Bridge::BridgeSlavePort::recvRespRetry()
339{
340 trySendTiming();
341}
342
343Tick
344Bridge::BridgeSlavePort::recvAtomic(PacketPtr pkt)
345{
346 return delay * bridge.clockPeriod() + masterPort.sendAtomic(pkt);
347}
348
349void
350Bridge::BridgeSlavePort::recvFunctional(PacketPtr pkt)
351{
352 pkt->pushLabel(name());
353
354 // check the response queue
355 for (auto i = transmitList.begin(); i != transmitList.end(); ++i) {
356 if (pkt->checkFunctional((*i).pkt)) {
357 pkt->makeResponse();
358 return;
359 }
360 }
361
362 // also check the master port's request queue
363 if (masterPort.checkFunctional(pkt)) {
364 return;
365 }
366
367 pkt->popLabel();
368
369 // fall through if pkt still not satisfied
370 masterPort.sendFunctional(pkt);
371}
372
373bool
374Bridge::BridgeMasterPort::checkFunctional(PacketPtr pkt)
375{
376 bool found = false;
377 auto i = transmitList.begin();
378
379 while(i != transmitList.end() && !found) {
380 if (pkt->checkFunctional((*i).pkt)) {
381 pkt->makeResponse();
382 found = true;
383 }
384 ++i;
385 }
386
387 return found;
388}
389
390AddrRangeList
391Bridge::BridgeSlavePort::getAddrRanges() const
392{
393 return ranges;
394}
395
396Bridge *
397BridgeParams::create()
398{
399 return new Bridge(this);
400}
| 207 }
208 }
209
210 // remember that we are now stalling a packet and that we have to
211 // tell the sending master to retry once space becomes available,
212 // we make no distinction whether the stalling is due to the
213 // request queue or response queue being full
214 return !retryReq;
215}
216
217void
218Bridge::BridgeSlavePort::retryStalledReq()
219{
220 if (retryReq) {
221 DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
222 retryReq = false;
223 sendRetryReq();
224 }
225}
226
227void
228Bridge::BridgeMasterPort::schedTimingReq(PacketPtr pkt, Tick when)
229{
230 // If we're about to put this packet at the head of the queue, we
231 // need to schedule an event to do the transmit. Otherwise there
232 // should already be an event scheduled for sending the head
233 // packet.
234 if (transmitList.empty()) {
235 bridge.schedule(sendEvent, when);
236 }
237
238 assert(transmitList.size() != reqQueueLimit);
239
240 transmitList.emplace_back(pkt, when);
241}
242
243
244void
245Bridge::BridgeSlavePort::schedTimingResp(PacketPtr pkt, Tick when)
246{
247 // If we're about to put this packet at the head of the queue, we
248 // need to schedule an event to do the transmit. Otherwise there
249 // should already be an event scheduled for sending the head
250 // packet.
251 if (transmitList.empty()) {
252 bridge.schedule(sendEvent, when);
253 }
254
255 transmitList.emplace_back(pkt, when);
256}
257
258void
259Bridge::BridgeMasterPort::trySendTiming()
260{
261 assert(!transmitList.empty());
262
263 DeferredPacket req = transmitList.front();
264
265 assert(req.tick <= curTick());
266
267 PacketPtr pkt = req.pkt;
268
269 DPRINTF(Bridge, "trySend request addr 0x%x, queue size %d\n",
270 pkt->getAddr(), transmitList.size());
271
272 if (sendTimingReq(pkt)) {
273 // send successful
274 transmitList.pop_front();
275 DPRINTF(Bridge, "trySend request successful\n");
276
277 // If there are more packets to send, schedule event to try again.
278 if (!transmitList.empty()) {
279 DeferredPacket next_req = transmitList.front();
280 DPRINTF(Bridge, "Scheduling next send\n");
281 bridge.schedule(sendEvent, std::max(next_req.tick,
282 bridge.clockEdge()));
283 }
284
285 // if we have stalled a request due to a full request queue,
286 // then send a retry at this point, also note that if the
287 // request we stalled was waiting for the response queue
288 // rather than the request queue we might stall it again
289 slavePort.retryStalledReq();
290 }
291
292 // if the send failed, then we try again once we receive a retry,
293 // and therefore there is no need to take any action
294}
295
296void
297Bridge::BridgeSlavePort::trySendTiming()
298{
299 assert(!transmitList.empty());
300
301 DeferredPacket resp = transmitList.front();
302
303 assert(resp.tick <= curTick());
304
305 PacketPtr pkt = resp.pkt;
306
307 DPRINTF(Bridge, "trySend response addr 0x%x, outstanding %d\n",
308 pkt->getAddr(), outstandingResponses);
309
310 if (sendTimingResp(pkt)) {
311 // send successful
312 transmitList.pop_front();
313 DPRINTF(Bridge, "trySend response successful\n");
314
315 assert(outstandingResponses != 0);
316 --outstandingResponses;
317
318 // If there are more packets to send, schedule event to try again.
319 if (!transmitList.empty()) {
320 DeferredPacket next_resp = transmitList.front();
321 DPRINTF(Bridge, "Scheduling next send\n");
322 bridge.schedule(sendEvent, std::max(next_resp.tick,
323 bridge.clockEdge()));
324 }
325
326 // if there is space in the request queue and we were stalling
327 // a request, it will definitely be possible to accept it now
328 // since there is guaranteed space in the response queue
329 if (!masterPort.reqQueueFull() && retryReq) {
330 DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
331 retryReq = false;
332 sendRetryReq();
333 }
334 }
335
336 // if the send failed, then we try again once we receive a retry,
337 // and therefore there is no need to take any action
338}
339
340void
341Bridge::BridgeMasterPort::recvReqRetry()
342{
343 trySendTiming();
344}
345
346void
347Bridge::BridgeSlavePort::recvRespRetry()
348{
349 trySendTiming();
350}
351
352Tick
353Bridge::BridgeSlavePort::recvAtomic(PacketPtr pkt)
354{
355 return delay * bridge.clockPeriod() + masterPort.sendAtomic(pkt);
356}
357
358void
359Bridge::BridgeSlavePort::recvFunctional(PacketPtr pkt)
360{
361 pkt->pushLabel(name());
362
363 // check the response queue
364 for (auto i = transmitList.begin(); i != transmitList.end(); ++i) {
365 if (pkt->checkFunctional((*i).pkt)) {
366 pkt->makeResponse();
367 return;
368 }
369 }
370
371 // also check the master port's request queue
372 if (masterPort.checkFunctional(pkt)) {
373 return;
374 }
375
376 pkt->popLabel();
377
378 // fall through if pkt still not satisfied
379 masterPort.sendFunctional(pkt);
380}
381
382bool
383Bridge::BridgeMasterPort::checkFunctional(PacketPtr pkt)
384{
385 bool found = false;
386 auto i = transmitList.begin();
387
388 while(i != transmitList.end() && !found) {
389 if (pkt->checkFunctional((*i).pkt)) {
390 pkt->makeResponse();
391 found = true;
392 }
393 ++i;
394 }
395
396 return found;
397}
398
399AddrRangeList
400Bridge::BridgeSlavePort::getAddrRanges() const
401{
402 return ranges;
403}
404
405Bridge *
406BridgeParams::create()
407{
408 return new Bridge(this);
409}
|