1/* 2 * Copyright (c) 2011-2012 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 * Declaration of a memory-mapped bus bridge that connects a master 48 * and a slave through a request and response queue. 49 */ 50 51#ifndef __MEM_BRIDGE_HH__ 52#define __MEM_BRIDGE_HH__ 53 54#include <list>
|
55#include <queue>
56#include <string>
|
55 56#include "base/types.hh" 57#include "mem/mem_object.hh"
|
60#include "mem/packet.hh"
61#include "mem/port.hh"
|
58#include "params/Bridge.hh"
|
63#include "sim/eventq.hh"
|
59 60/** 61 * A bridge is used to interface two different busses (or in general a 62 * memory-mapped master and slave), with buffering for requests and 63 * responses. The bridge has a fixed delay for packets passing through 64 * it and responds to a fixed set of address ranges. 65 * 66 * The bridge comprises a slave port and a master port, that buffer 67 * outgoing responses and requests respectively. Buffer space is 68 * reserved when a request arrives, also reserving response space
|
74 * before forwarding the request. An incoming request is always
75 * accepted (recvTiming returns true), but is potentially NACKed if
76 * there is no request space or response space.
|
69 * before forwarding the request. If there is no space present, then 70 * the bridge will delay accepting the packet until space becomes 71 * available. |
72 */ 73class Bridge : public MemObject 74{ 75 protected: 76 77 /** 78 * A bridge request state stores packets along with their sender 79 * state and original source. It has enough information to also 80 * restore the response once it comes back to the bridge. 81 */ 82 class RequestState : public Packet::SenderState 83 { 84 85 public: 86 87 Packet::SenderState *origSenderState; 88 PortID origSrc; 89 90 RequestState(PacketPtr _pkt) 91 : origSenderState(_pkt->senderState), 92 origSrc(_pkt->getSrc()) 93 { } 94 95 void fixResponse(PacketPtr pkt) 96 { 97 assert(pkt->senderState == this); 98 pkt->setDest(origSrc); 99 pkt->senderState = origSenderState; 100 } 101 }; 102 103 /**
|
109 * A deferred request stores a packet along with its scheduled
110 * transmission time, and whether we can expect to see a response
111 * or not.
|
104 * A deferred packet stores a packet along with its scheduled 105 * transmission time |
106 */
|
113 class DeferredRequest
|
107 class DeferredPacket |
108 { 109 110 public: 111
|
118 Tick ready;
|
112 Tick tick; |
113 PacketPtr pkt;
|
120 bool expectResponse;
|
114
|
122 DeferredRequest(PacketPtr _pkt, Tick t)
123 : ready(t), pkt(_pkt), expectResponse(_pkt->needsResponse())
|
115 DeferredPacket(PacketPtr _pkt, Tick _tick) : tick(_tick), pkt(_pkt) |
116 { } 117 }; 118
|
127 /**
128 * A deferred response stores a packet along with its scheduled
129 * transmission time. It also contains information of whether the
130 * bridge NACKed the packet to be able to correctly maintain
131 * counters of outstanding responses.
132 */
133 class DeferredResponse {
134
135 public:
136
137 Tick ready;
138 PacketPtr pkt;
139 bool nackedHere;
140
141 DeferredResponse(PacketPtr _pkt, Tick t, bool nack = false)
142 : ready(t), pkt(_pkt), nackedHere(nack)
143 { }
144 };
145
|
119 // Forward declaration to allow the slave port to have a pointer 120 class BridgeMasterPort; 121 122 /** 123 * The port on the side that receives requests and sends 124 * responses. The slave port has a set of address ranges that it 125 * is responsible for. The slave port also has a buffer for the 126 * responses not yet sent. 127 */ 128 class BridgeSlavePort : public SlavePort 129 { 130 131 private: 132
|
160 /** A pointer to the bridge to which this port belongs. */
161 Bridge *bridge;
|
133 /** The bridge to which this port belongs. */ 134 Bridge& bridge; |
135 136 /**
|
164 * Master port on the other side of the bridge
165 * (connected to the other bus).
|
137 * Master port on the other side of the bridge (connected to 138 * the other bus). |
139 */ 140 BridgeMasterPort& masterPort; 141 142 /** Minimum request delay though this bridge. */ 143 Tick delay; 144
|
172 /** Min delay to respond with a nack. */
173 Tick nackDelay;
174
|
145 /** Address ranges to pass through the bridge */ 146 AddrRangeList ranges; 147 148 /** 149 * Response packet queue. Response packets are held in this 150 * queue for a specified delay to model the processing delay 151 * of the bridge. 152 */
|
183 std::list<DeferredResponse> responseQueue;
|
153 std::list<DeferredPacket> transmitList; |
154 155 /** Counter to track the outstanding responses. */ 156 unsigned int outstandingResponses; 157
|
188 /** If we're waiting for a retry to happen. */
189 bool inRetry;
|
158 /** If we should send a retry when space becomes available. */ 159 bool retryReq; |
160 161 /** Max queue size for reserved responses. */ 162 unsigned int respQueueLimit; 163 164 /** 165 * Is this side blocked from accepting new response packets. 166 * 167 * @return true if the reserved space has reached the set limit 168 */ 169 bool respQueueFull(); 170 171 /**
|
202 * Turn the request packet into a NACK response and put it in
203 * the response queue and schedule its transmission.
204 *
205 * @param pkt the request packet to NACK
206 */
207 void nackRequest(PacketPtr pkt);
208
209 /**
|
172 * Handle send event, scheduled when the packet at the head of 173 * the response queue is ready to transmit (for timing 174 * accesses only). 175 */
|
214 void trySend();
|
176 void trySendTiming(); |
177 178 /** Send event for the response queue. */
|
217 EventWrapper<BridgeSlavePort, &BridgeSlavePort::trySend> sendEvent;
|
179 EventWrapper180 &BridgeSlavePort::trySendTiming> sendEvent; |
181 182 public: 183 184 /** 185 * Constructor for the BridgeSlavePort. 186 * 187 * @param _name the port name including the owner 188 * @param _bridge the structural owner 189 * @param _masterPort the master port on the other side of the bridge 190 * @param _delay the delay from seeing a response to sending it
|
228 * @param _nack_delay the delay from a NACK to sending the response
|
191 * @param _resp_limit the size of the response queue 192 * @param _ranges a number of address ranges to forward 193 */
|
232 BridgeSlavePort(const std::string &_name, Bridge *_bridge,
|
194 BridgeSlavePort(const std::string& _name, Bridge& _bridge, |
195 BridgeMasterPort& _masterPort, int _delay,
|
234 int _nack_delay, int _resp_limit,
235 std::vector<Range<Addr> > _ranges);
|
196 int _resp_limit, std::vector<Range<Addr> > _ranges); |
197 198 /** 199 * Queue a response packet to be sent out later and also schedule 200 * a send if necessary. 201 * 202 * @param pkt a response to send out after a delay
|
203 * @param when tick when response packet should be sent |
204 */
|
243 void queueForSendTiming(PacketPtr pkt);
|
205 void schedTimingResp(PacketPtr pkt, Tick when); |
206
|
207 /** 208 * Retry any stalled request that we have failed to accept at 209 * an earlier point in time. This call will do nothing if no 210 * request is waiting. 211 */ 212 void retryStalledReq(); 213 |
214 protected: 215 216 /** When receiving a timing request from the peer port, 217 pass it to the bridge. */
|
249 virtual bool recvTimingReq(PacketPtr pkt);
|
218 bool recvTimingReq(PacketPtr pkt); |
219 220 /** When receiving a retry request from the peer port, 221 pass it to the bridge. */
|
253 virtual void recvRetry();
|
222 void recvRetry(); |
223 224 /** When receiving a Atomic requestfrom the peer port, 225 pass it to the bridge. */
|
257 virtual Tick recvAtomic(PacketPtr pkt);
|
226 Tick recvAtomic(PacketPtr pkt); |
227 228 /** When receiving a Functional request from the peer port, 229 pass it to the bridge. */
|
261 virtual void recvFunctional(PacketPtr pkt);
|
230 void recvFunctional(PacketPtr pkt); |
231 232 /** When receiving a address range request the peer port, 233 pass it to the bridge. */
|
265 virtual AddrRangeList getAddrRanges() const;
|
234 AddrRangeList getAddrRanges() const; |
235 }; 236 237 238 /** 239 * Port on the side that forwards requests and receives 240 * responses. The master port has a buffer for the requests not 241 * yet sent. 242 */ 243 class BridgeMasterPort : public MasterPort 244 { 245 246 private: 247
|
279 /** A pointer to the bridge to which this port belongs. */
280 Bridge* bridge;
|
248 /** The bridge to which this port belongs. */ 249 Bridge& bridge; |
250 251 /**
|
283 * Pointer to the slave port on the other side of the bridge
284 * (connected to the other bus).
|
252 * The slave port on the other side of the bridge (connected 253 * to the other bus). |
254 */ 255 BridgeSlavePort& slavePort; 256 257 /** Minimum delay though this bridge. */ 258 Tick delay; 259 260 /** 261 * Request packet queue. Request packets are held in this 262 * queue for a specified delay to model the processing delay 263 * of the bridge. 264 */
|
296 std::list<DeferredRequest> requestQueue;
|
265 std::list<DeferredPacket> transmitList; |
266
|
298 /** If we're waiting for a retry to happen. */
299 bool inRetry;
300
|
267 /** Max queue size for request packets */ 268 unsigned int reqQueueLimit; 269 270 /** 271 * Handle send event, scheduled when the packet at the head of 272 * the outbound queue is ready to transmit (for timing 273 * accesses only). 274 */
|
309 void trySend();
|
275 void trySendTiming(); |
276 277 /** Send event for the request queue. */
|
312 EventWrapper<BridgeMasterPort, &BridgeMasterPort::trySend> sendEvent;
|
278 EventWrapper279 &BridgeMasterPort::trySendTiming> sendEvent; |
280 281 public: 282 283 /** 284 * Constructor for the BridgeMasterPort. 285 * 286 * @param _name the port name including the owner 287 * @param _bridge the structural owner 288 * @param _slavePort the slave port on the other side of the bridge 289 * @param _delay the delay from seeing a request to sending it 290 * @param _req_limit the size of the request queue 291 */
|
325 BridgeMasterPort(const std::string &_name, Bridge *_bridge,
|
292 BridgeMasterPort(const std::string& _name, Bridge& _bridge, |
293 BridgeSlavePort& _slavePort, int _delay, 294 int _req_limit); 295 296 /** 297 * Is this side blocked from accepting new request packets. 298 * 299 * @return true if the occupied space has reached the set limit 300 */ 301 bool reqQueueFull(); 302 303 /** 304 * Queue a request packet to be sent out later and also schedule 305 * a send if necessary. 306 * 307 * @param pkt a request to send out after a delay
|
308 * @param when tick when response packet should be sent |
309 */
|
342 void queueForSendTiming(PacketPtr pkt);
|
310 void schedTimingReq(PacketPtr pkt, Tick when); |
311 312 /** 313 * Check a functional request against the packets in our 314 * request queue. 315 * 316 * @param pkt packet to check against 317 * 318 * @return true if we find a match 319 */ 320 bool checkFunctional(PacketPtr pkt); 321 322 protected: 323 324 /** When receiving a timing request from the peer port, 325 pass it to the bridge. */
|
358 virtual bool recvTimingResp(PacketPtr pkt);
|
326 bool recvTimingResp(PacketPtr pkt); |
327 328 /** When receiving a retry request from the peer port, 329 pass it to the bridge. */
|
362 virtual void recvRetry();
|
330 void recvRetry(); |
331 }; 332 333 /** Slave port of the bridge. */ 334 BridgeSlavePort slavePort; 335 336 /** Master port of the bridge. */ 337 BridgeMasterPort masterPort; 338
|
371 /** If this bridge should acknowledge writes. */
372 bool ackWrites;
373
|
339 public:
|
375 typedef BridgeParams Params;
|
340
|
377 protected:
378 Params *_params;
379
380 public:
381 const Params *params() const { return _params; }
382
|
341 virtual MasterPort& getMasterPort(const std::string& if_name, 342 int idx = -1); 343 virtual SlavePort& getSlavePort(const std::string& if_name, int idx = -1); 344 345 virtual void init(); 346
|
347 typedef BridgeParams Params; 348 |
349 Bridge(Params *p); 350}; 351 352#endif //__MEM_BUS_HH__
|