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
--- 38 unchanged lines hidden (view full) ---
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>
57
58#include "base/types.hh"
59#include "mem/mem_object.hh"
60#include "mem/packet.hh"
61#include "mem/port.hh"
62#include "params/Bridge.hh"
63#include "sim/eventq.hh"
64
65/**
66 * A bridge is used to interface two different busses (or in general a
67 * memory-mapped master and slave), with buffering for requests and
68 * responses. The bridge has a fixed delay for packets passing through
69 * it and responds to a fixed set of address ranges.
70 *
71 * The bridge comprises a slave port and a master port, that buffer
72 * outgoing responses and requests respectively. Buffer space is
73 * 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.
77 */
78class Bridge : public MemObject
79{
80 protected:
81
82 /**
83 * A bridge request state stores packets along with their sender
84 * state and original source. It has enough information to also
--- 16 unchanged lines hidden (view full) ---
101 {
102 assert(pkt->senderState == this);
103 pkt->setDest(origSrc);
104 pkt->senderState = origSenderState;
105 }
106 };
107
108 /**
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.
112 */
113 class DeferredRequest
114 {
115
116 public:
117
118 Tick ready;
119 PacketPtr pkt;
120 bool expectResponse;
121
122 DeferredRequest(PacketPtr _pkt, Tick t)
123 : ready(t), pkt(_pkt), expectResponse(_pkt->needsResponse())
124 { }
125 };
126
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
146 // Forward declaration to allow the slave port to have a pointer
147 class BridgeMasterPort;
148
149 /**
150 * The port on the side that receives requests and sends
151 * responses. The slave port has a set of address ranges that it
152 * is responsible for. The slave port also has a buffer for the
153 * responses not yet sent.
154 */
155 class BridgeSlavePort : public SlavePort
156 {
157
158 private:
159
160 /** A pointer to the bridge to which this port belongs. */
161 Bridge *bridge;
162
163 /**
164 * Master port on the other side of the bridge
165 * (connected to the other bus).
166 */
167 BridgeMasterPort& masterPort;
168
169 /** Minimum request delay though this bridge. */
170 Tick delay;
171
172 /** Min delay to respond with a nack. */
173 Tick nackDelay;
174
175 /** Address ranges to pass through the bridge */
176 AddrRangeList ranges;
177
178 /**
179 * Response packet queue. Response packets are held in this
180 * queue for a specified delay to model the processing delay
181 * of the bridge.
182 */
183 std::list<DeferredResponse> responseQueue;
184
185 /** Counter to track the outstanding responses. */
186 unsigned int outstandingResponses;
187
188 /** If we're waiting for a retry to happen. */
189 bool inRetry;
190
191 /** Max queue size for reserved responses. */
192 unsigned int respQueueLimit;
193
194 /**
195 * Is this side blocked from accepting new response packets.
196 *
197 * @return true if the reserved space has reached the set limit
198 */
199 bool respQueueFull();
200
201 /**
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 /**
210 * Handle send event, scheduled when the packet at the head of
211 * the response queue is ready to transmit (for timing
212 * accesses only).
213 */
214 void trySend();
215
216 /** Send event for the response queue. */
217 EventWrapper<BridgeSlavePort, &BridgeSlavePort::trySend> sendEvent;
218
219 public:
220
221 /**
222 * Constructor for the BridgeSlavePort.
223 *
224 * @param _name the port name including the owner
225 * @param _bridge the structural owner
226 * @param _masterPort the master port on the other side of the bridge
227 * @param _delay the delay from seeing a response to sending it
228 * @param _nack_delay the delay from a NACK to sending the response
229 * @param _resp_limit the size of the response queue
230 * @param _ranges a number of address ranges to forward
231 */
232 BridgeSlavePort(const std::string &_name, Bridge *_bridge,
233 BridgeMasterPort& _masterPort, int _delay,
234 int _nack_delay, int _resp_limit,
235 std::vector<Range<Addr> > _ranges);
236
237 /**
238 * Queue a response packet to be sent out later and also schedule
239 * a send if necessary.
240 *
241 * @param pkt a response to send out after a delay
242 */
243 void queueForSendTiming(PacketPtr pkt);
244
245 protected:
246
247 /** When receiving a timing request from the peer port,
248 pass it to the bridge. */
249 virtual bool recvTimingReq(PacketPtr pkt);
250
251 /** When receiving a retry request from the peer port,
252 pass it to the bridge. */
253 virtual void recvRetry();
254
255 /** When receiving a Atomic requestfrom the peer port,
256 pass it to the bridge. */
257 virtual Tick recvAtomic(PacketPtr pkt);
258
259 /** When receiving a Functional request from the peer port,
260 pass it to the bridge. */
261 virtual void recvFunctional(PacketPtr pkt);
262
263 /** When receiving a address range request the peer port,
264 pass it to the bridge. */
265 virtual AddrRangeList getAddrRanges() const;
266 };
267
268
269 /**
270 * Port on the side that forwards requests and receives
271 * responses. The master port has a buffer for the requests not
272 * yet sent.
273 */
274 class BridgeMasterPort : public MasterPort
275 {
276
277 private:
278
279 /** A pointer to the bridge to which this port belongs. */
280 Bridge* bridge;
281
282 /**
283 * Pointer to the slave port on the other side of the bridge
284 * (connected to the other bus).
285 */
286 BridgeSlavePort& slavePort;
287
288 /** Minimum delay though this bridge. */
289 Tick delay;
290
291 /**
292 * Request packet queue. Request packets are held in this
293 * queue for a specified delay to model the processing delay
294 * of the bridge.
295 */
296 std::list<DeferredRequest> requestQueue;
297
298 /** If we're waiting for a retry to happen. */
299 bool inRetry;
300
301 /** Max queue size for request packets */
302 unsigned int reqQueueLimit;
303
304 /**
305 * Handle send event, scheduled when the packet at the head of
306 * the outbound queue is ready to transmit (for timing
307 * accesses only).
308 */
309 void trySend();
310
311 /** Send event for the request queue. */
312 EventWrapper<BridgeMasterPort, &BridgeMasterPort::trySend> sendEvent;
313
314 public:
315
316 /**
317 * Constructor for the BridgeMasterPort.
318 *
319 * @param _name the port name including the owner
320 * @param _bridge the structural owner
321 * @param _slavePort the slave port on the other side of the bridge
322 * @param _delay the delay from seeing a request to sending it
323 * @param _req_limit the size of the request queue
324 */
325 BridgeMasterPort(const std::string &_name, Bridge *_bridge,
326 BridgeSlavePort& _slavePort, int _delay,
327 int _req_limit);
328
329 /**
330 * Is this side blocked from accepting new request packets.
331 *
332 * @return true if the occupied space has reached the set limit
333 */
334 bool reqQueueFull();
335
336 /**
337 * Queue a request packet to be sent out later and also schedule
338 * a send if necessary.
339 *
340 * @param pkt a request to send out after a delay
341 */
342 void queueForSendTiming(PacketPtr pkt);
343
344 /**
345 * Check a functional request against the packets in our
346 * request queue.
347 *
348 * @param pkt packet to check against
349 *
350 * @return true if we find a match
351 */
352 bool checkFunctional(PacketPtr pkt);
353
354 protected:
355
356 /** When receiving a timing request from the peer port,
357 pass it to the bridge. */
358 virtual bool recvTimingResp(PacketPtr pkt);
359
360 /** When receiving a retry request from the peer port,
361 pass it to the bridge. */
362 virtual void recvRetry();
363 };
364
365 /** Slave port of the bridge. */
366 BridgeSlavePort slavePort;
367
368 /** Master port of the bridge. */
369 BridgeMasterPort masterPort;
370
371 /** If this bridge should acknowledge writes. */
372 bool ackWrites;
373
374 public:
375 typedef BridgeParams Params;
376
377 protected:
378 Params *_params;
379
380 public:
381 const Params *params() const { return _params; }
382
383 virtual MasterPort& getMasterPort(const std::string& if_name,
384 int idx = -1);
385 virtual SlavePort& getSlavePort(const std::string& if_name, int idx = -1);
386
387 virtual void init();
388
389 Bridge(Params *p);
390};
391
392#endif //__MEM_BUS_HH__
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
--- 38 unchanged lines hidden (view full) ---
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>
57
58#include "base/types.hh"
59#include "mem/mem_object.hh"
60#include "mem/packet.hh"
61#include "mem/port.hh"
62#include "params/Bridge.hh"
63#include "sim/eventq.hh"
64
65/**
66 * A bridge is used to interface two different busses (or in general a
67 * memory-mapped master and slave), with buffering for requests and
68 * responses. The bridge has a fixed delay for packets passing through
69 * it and responds to a fixed set of address ranges.
70 *
71 * The bridge comprises a slave port and a master port, that buffer
72 * outgoing responses and requests respectively. Buffer space is
73 * 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.
77 */
78class Bridge : public MemObject
79{
80 protected:
81
82 /**
83 * A bridge request state stores packets along with their sender
84 * state and original source. It has enough information to also
--- 16 unchanged lines hidden (view full) ---
101 {
102 assert(pkt->senderState == this);
103 pkt->setDest(origSrc);
104 pkt->senderState = origSenderState;
105 }
106 };
107
108 /**
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.
112 */
113 class DeferredRequest
114 {
115
116 public:
117
118 Tick ready;
119 PacketPtr pkt;
120 bool expectResponse;
121
122 DeferredRequest(PacketPtr _pkt, Tick t)
123 : ready(t), pkt(_pkt), expectResponse(_pkt->needsResponse())
124 { }
125 };
126
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
146 // Forward declaration to allow the slave port to have a pointer
147 class BridgeMasterPort;
148
149 /**
150 * The port on the side that receives requests and sends
151 * responses. The slave port has a set of address ranges that it
152 * is responsible for. The slave port also has a buffer for the
153 * responses not yet sent.
154 */
155 class BridgeSlavePort : public SlavePort
156 {
157
158 private:
159
160 /** A pointer to the bridge to which this port belongs. */
161 Bridge *bridge;
162
163 /**
164 * Master port on the other side of the bridge
165 * (connected to the other bus).
166 */
167 BridgeMasterPort& masterPort;
168
169 /** Minimum request delay though this bridge. */
170 Tick delay;
171
172 /** Min delay to respond with a nack. */
173 Tick nackDelay;
174
175 /** Address ranges to pass through the bridge */
176 AddrRangeList ranges;
177
178 /**
179 * Response packet queue. Response packets are held in this
180 * queue for a specified delay to model the processing delay
181 * of the bridge.
182 */
183 std::list<DeferredResponse> responseQueue;
184
185 /** Counter to track the outstanding responses. */
186 unsigned int outstandingResponses;
187
188 /** If we're waiting for a retry to happen. */
189 bool inRetry;
190
191 /** Max queue size for reserved responses. */
192 unsigned int respQueueLimit;
193
194 /**
195 * Is this side blocked from accepting new response packets.
196 *
197 * @return true if the reserved space has reached the set limit
198 */
199 bool respQueueFull();
200
201 /**
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 /**
210 * Handle send event, scheduled when the packet at the head of
211 * the response queue is ready to transmit (for timing
212 * accesses only).
213 */
214 void trySend();
215
216 /** Send event for the response queue. */
217 EventWrapper<BridgeSlavePort, &BridgeSlavePort::trySend> sendEvent;
218
219 public:
220
221 /**
222 * Constructor for the BridgeSlavePort.
223 *
224 * @param _name the port name including the owner
225 * @param _bridge the structural owner
226 * @param _masterPort the master port on the other side of the bridge
227 * @param _delay the delay from seeing a response to sending it
228 * @param _nack_delay the delay from a NACK to sending the response
229 * @param _resp_limit the size of the response queue
230 * @param _ranges a number of address ranges to forward
231 */
232 BridgeSlavePort(const std::string &_name, Bridge *_bridge,
233 BridgeMasterPort& _masterPort, int _delay,
234 int _nack_delay, int _resp_limit,
235 std::vector<Range<Addr> > _ranges);
236
237 /**
238 * Queue a response packet to be sent out later and also schedule
239 * a send if necessary.
240 *
241 * @param pkt a response to send out after a delay
242 */
243 void queueForSendTiming(PacketPtr pkt);
244
245 protected:
246
247 /** When receiving a timing request from the peer port,
248 pass it to the bridge. */
249 virtual bool recvTimingReq(PacketPtr pkt);
250
251 /** When receiving a retry request from the peer port,
252 pass it to the bridge. */
253 virtual void recvRetry();
254
255 /** When receiving a Atomic requestfrom the peer port,
256 pass it to the bridge. */
257 virtual Tick recvAtomic(PacketPtr pkt);
258
259 /** When receiving a Functional request from the peer port,
260 pass it to the bridge. */
261 virtual void recvFunctional(PacketPtr pkt);
262
263 /** When receiving a address range request the peer port,
264 pass it to the bridge. */
265 virtual AddrRangeList getAddrRanges() const;
266 };
267
268
269 /**
270 * Port on the side that forwards requests and receives
271 * responses. The master port has a buffer for the requests not
272 * yet sent.
273 */
274 class BridgeMasterPort : public MasterPort
275 {
276
277 private:
278
279 /** A pointer to the bridge to which this port belongs. */
280 Bridge* bridge;
281
282 /**
283 * Pointer to the slave port on the other side of the bridge
284 * (connected to the other bus).
285 */
286 BridgeSlavePort& slavePort;
287
288 /** Minimum delay though this bridge. */
289 Tick delay;
290
291 /**
292 * Request packet queue. Request packets are held in this
293 * queue for a specified delay to model the processing delay
294 * of the bridge.
295 */
296 std::list<DeferredRequest> requestQueue;
297
298 /** If we're waiting for a retry to happen. */
299 bool inRetry;
300
301 /** Max queue size for request packets */
302 unsigned int reqQueueLimit;
303
304 /**
305 * Handle send event, scheduled when the packet at the head of
306 * the outbound queue is ready to transmit (for timing
307 * accesses only).
308 */
309 void trySend();
310
311 /** Send event for the request queue. */
312 EventWrapper<BridgeMasterPort, &BridgeMasterPort::trySend> sendEvent;
313
314 public:
315
316 /**
317 * Constructor for the BridgeMasterPort.
318 *
319 * @param _name the port name including the owner
320 * @param _bridge the structural owner
321 * @param _slavePort the slave port on the other side of the bridge
322 * @param _delay the delay from seeing a request to sending it
323 * @param _req_limit the size of the request queue
324 */
325 BridgeMasterPort(const std::string &_name, Bridge *_bridge,
326 BridgeSlavePort& _slavePort, int _delay,
327 int _req_limit);
328
329 /**
330 * Is this side blocked from accepting new request packets.
331 *
332 * @return true if the occupied space has reached the set limit
333 */
334 bool reqQueueFull();
335
336 /**
337 * Queue a request packet to be sent out later and also schedule
338 * a send if necessary.
339 *
340 * @param pkt a request to send out after a delay
341 */
342 void queueForSendTiming(PacketPtr pkt);
343
344 /**
345 * Check a functional request against the packets in our
346 * request queue.
347 *
348 * @param pkt packet to check against
349 *
350 * @return true if we find a match
351 */
352 bool checkFunctional(PacketPtr pkt);
353
354 protected:
355
356 /** When receiving a timing request from the peer port,
357 pass it to the bridge. */
358 virtual bool recvTimingResp(PacketPtr pkt);
359
360 /** When receiving a retry request from the peer port,
361 pass it to the bridge. */
362 virtual void recvRetry();
363 };
364
365 /** Slave port of the bridge. */
366 BridgeSlavePort slavePort;
367
368 /** Master port of the bridge. */
369 BridgeMasterPort masterPort;
370
371 /** If this bridge should acknowledge writes. */
372 bool ackWrites;
373
374 public:
375 typedef BridgeParams Params;
376
377 protected:
378 Params *_params;
379
380 public:
381 const Params *params() const { return _params; }
382
383 virtual MasterPort& getMasterPort(const std::string& if_name,
384 int idx = -1);
385 virtual SlavePort& getSlavePort(const std::string& if_name, int idx = -1);
386
387 virtual void init();
388
389 Bridge(Params *p);
390};
391
392#endif //__MEM_BUS_HH__