io_device.cc (2846:89fbe74d8ea8) io_device.cc (2901:f9a45473ab55)
1/*
2 * Copyright (c) 2006 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 18 unchanged lines hidden (view full) ---

27 *
28 * Authors: Ali Saidi
29 * Nathan Binkert
30 */
31
32#include "base/trace.hh"
33#include "dev/io_device.hh"
34#include "sim/builder.hh"
1/*
2 * Copyright (c) 2006 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 18 unchanged lines hidden (view full) ---

27 *
28 * Authors: Ali Saidi
29 * Nathan Binkert
30 */
31
32#include "base/trace.hh"
33#include "dev/io_device.hh"
34#include "sim/builder.hh"
35#include "sim/system.hh"
35
36
36
37
37PioPort::PioPort(PioDevice *dev, Platform *p, std::string pname)
38 : Port(dev->name() + pname), device(dev), platform(p)
38PioPort::PioPort(PioDevice *dev, System *s, std::string pname)
39 : Port(dev->name() + pname), device(dev), sys(s),
40 outTiming(0), drainEvent(NULL)
39{ }
40
41
42Tick
43PioPort::recvAtomic(Packet *pkt)
44{
45 return device->recvAtomic(pkt);
46}

--- 16 unchanged lines hidden (view full) ---

63PioPort::recvRetry()
64{
65 bool result = true;
66 while (result && transmitList.size()) {
67 result = Port::sendTiming(transmitList.front());
68 if (result)
69 transmitList.pop_front();
70 }
41{ }
42
43
44Tick
45PioPort::recvAtomic(Packet *pkt)
46{
47 return device->recvAtomic(pkt);
48}

--- 16 unchanged lines hidden (view full) ---

65PioPort::recvRetry()
66{
67 bool result = true;
68 while (result && transmitList.size()) {
69 result = Port::sendTiming(transmitList.front());
70 if (result)
71 transmitList.pop_front();
72 }
73 if (transmitList.size() == 0 && drainEvent) {
74 drainEvent->process();
75 drainEvent = NULL;
76 }
71}
72
73void
74PioPort::SendEvent::process()
75{
77}
78
79void
80PioPort::SendEvent::process()
81{
82 port->outTiming--;
83 assert(port->outTiming >= 0);
76 if (port->Port::sendTiming(packet))
84 if (port->Port::sendTiming(packet))
77 return;
85 if (port->transmitList.size() == 0 && port->drainEvent) {
86 port->drainEvent->process();
87 port->drainEvent = NULL;
88 }
89 return;
78
79 port->transmitList.push_back(packet);
80}
81
82void
83PioPort::resendNacked(Packet *pkt) {
84 pkt->reinitNacked();
85 if (transmitList.size()) {

--- 14 unchanged lines hidden (view full) ---

100 Tick latency = device->recvAtomic(pkt);
101 // turn packet around to go back to requester
102 pkt->makeTimingResponse();
103 sendTiming(pkt, latency);
104 }
105 return true;
106}
107
90
91 port->transmitList.push_back(packet);
92}
93
94void
95PioPort::resendNacked(Packet *pkt) {
96 pkt->reinitNacked();
97 if (transmitList.size()) {

--- 14 unchanged lines hidden (view full) ---

112 Tick latency = device->recvAtomic(pkt);
113 // turn packet around to go back to requester
114 pkt->makeTimingResponse();
115 sendTiming(pkt, latency);
116 }
117 return true;
118}
119
120unsigned int
121PioPort::drain(Event *de)
122{
123 if (outTiming == 0 && transmitList.size() == 0)
124 return 0;
125 drainEvent = de;
126 return 1;
127}
128
108PioDevice::~PioDevice()
109{
110 if (pioPort)
111 delete pioPort;
112}
113
114void
115PioDevice::init()
116{
117 if (!pioPort)
118 panic("Pio port not connected to anything!");
119 pioPort->sendStatusChange(Port::RangeChange);
120}
121
129PioDevice::~PioDevice()
130{
131 if (pioPort)
132 delete pioPort;
133}
134
135void
136PioDevice::init()
137{
138 if (!pioPort)
139 panic("Pio port not connected to anything!");
140 pioPort->sendStatusChange(Port::RangeChange);
141}
142
143
144unsigned int
145PioDevice::drain(Event *de)
146{
147 unsigned int count;
148 count = pioPort->drain(de);
149 if (count)
150 changeState(Draining);
151 else
152 changeState(Drained);
153 return count;
154}
155
122void
123BasicPioDevice::addressRanges(AddrRangeList &range_list)
124{
125 assert(pioSize != 0);
126 range_list.clear();
127 range_list.push_back(RangeSize(pioAddr, pioSize));
128}
129
130
156void
157BasicPioDevice::addressRanges(AddrRangeList &range_list)
158{
159 assert(pioSize != 0);
160 range_list.clear();
161 range_list.push_back(RangeSize(pioAddr, pioSize));
162}
163
164
131DmaPort::DmaPort(DmaDevice *dev, Platform *p)
132 : Port(dev->name() + "-dmaport"), device(dev), platform(p), pendingCount(0)
165DmaPort::DmaPort(DmaDevice *dev, System *s)
166 : Port(dev->name() + "-dmaport"), device(dev), sys(s), pendingCount(0),
167 actionInProgress(0), drainEvent(NULL)
133{ }
134
135bool
136DmaPort::recvTiming(Packet *pkt)
137{
138
139
140 if (pkt->result == Packet::Nacked) {

--- 13 unchanged lines hidden (view full) ---

154
155 state->numBytes += pkt->req->getSize();
156 if (state->totBytes == state->numBytes) {
157 state->completionEvent->process();
158 delete state;
159 }
160 delete pkt->req;
161 delete pkt;
168{ }
169
170bool
171DmaPort::recvTiming(Packet *pkt)
172{
173
174
175 if (pkt->result == Packet::Nacked) {

--- 13 unchanged lines hidden (view full) ---

189
190 state->numBytes += pkt->req->getSize();
191 if (state->totBytes == state->numBytes) {
192 state->completionEvent->process();
193 delete state;
194 }
195 delete pkt->req;
196 delete pkt;
197
198 if (pendingCount == 0 && drainEvent) {
199 drainEvent->process();
200 drainEvent = NULL;
201 }
162 } else {
163 panic("Got packet without sender state... huh?\n");
164 }
165
166 return true;
167}
168
169DmaDevice::DmaDevice(Params *p)
170 : PioDevice(p), dmaPort(NULL)
171{ }
172
202 } else {
203 panic("Got packet without sender state... huh?\n");
204 }
205
206 return true;
207}
208
209DmaDevice::DmaDevice(Params *p)
210 : PioDevice(p), dmaPort(NULL)
211{ }
212
213
214unsigned int
215DmaDevice::drain(Event *de)
216{
217 unsigned int count;
218 count = pioPort->drain(de) + dmaPort->drain(de);
219 if (count)
220 changeState(Draining);
221 else
222 changeState(Drained);
223 return count;
224}
225
226unsigned int
227DmaPort::drain(Event *de)
228{
229 if (pendingCount == 0)
230 return 0;
231 drainEvent = de;
232 return 1;
233}
234
235
173void
174DmaPort::recvRetry()
175{
176 Packet* pkt = transmitList.front();
177 bool result = true;
178 while (result && transmitList.size()) {
179 DPRINTF(DMA, "Retry on Packet %#x with senderState: %#x\n",
180 pkt, pkt->senderState);

--- 9 unchanged lines hidden (view full) ---

190
191
192void
193DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
194 uint8_t *data)
195{
196 assert(event);
197
236void
237DmaPort::recvRetry()
238{
239 Packet* pkt = transmitList.front();
240 bool result = true;
241 while (result && transmitList.size()) {
242 DPRINTF(DMA, "Retry on Packet %#x with senderState: %#x\n",
243 pkt, pkt->senderState);

--- 9 unchanged lines hidden (view full) ---

253
254
255void
256DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
257 uint8_t *data)
258{
259 assert(event);
260
261 assert(device->getState() == SimObject::Running);
262
198 DmaReqState *reqState = new DmaReqState(event, this, size);
199
200 for (ChunkGenerator gen(addr, size, peerBlockSize());
201 !gen.done(); gen.next()) {
202 Request *req = new Request(gen.addr(), gen.size(), 0);
203 Packet *pkt = new Packet(req, cmd, Packet::Broadcast);
204
205 // Increment the data pointer on a write
206 if (data)
207 pkt->dataStatic(data + gen.complete());
208
209 pkt->senderState = reqState;
210
211 assert(pendingCount >= 0);
212 pendingCount++;
213 sendDma(pkt);
214 }
263 DmaReqState *reqState = new DmaReqState(event, this, size);
264
265 for (ChunkGenerator gen(addr, size, peerBlockSize());
266 !gen.done(); gen.next()) {
267 Request *req = new Request(gen.addr(), gen.size(), 0);
268 Packet *pkt = new Packet(req, cmd, Packet::Broadcast);
269
270 // Increment the data pointer on a write
271 if (data)
272 pkt->dataStatic(data + gen.complete());
273
274 pkt->senderState = reqState;
275
276 assert(pendingCount >= 0);
277 pendingCount++;
278 sendDma(pkt);
279 }
280
215}
216
217
218void
219DmaPort::sendDma(Packet *pkt, bool front)
220{
281}
282
283
284void
285DmaPort::sendDma(Packet *pkt, bool front)
286{
221 // some kind of selction between access methods
222 // more work is going to have to be done to make
223 // switching actually work
224 /* MemState state = device->platform->system->memState;
287 // some kind of selction between access methods
288 // more work is going to have to be done to make
289 // switching actually work
290 System::MemoryMode state = sys->getMemoryMode();
291 if (state == System::Timing) {
292 DPRINTF(DMA, "Attempting to send Packet %#x with addr: %#x\n",
293 pkt, pkt->getAddr());
294 if (transmitList.size() || !sendTiming(pkt)) {
295 if (front)
296 transmitList.push_front(pkt);
297 else
298 transmitList.push_back(pkt);
299 DPRINTF(DMA, "-- Failed: queued\n");
300 } else {
301 DPRINTF(DMA, "-- Done\n");
302 }
303 } else if (state == System::Atomic) {
304 sendAtomic(pkt);
305 assert(pkt->senderState);
306 DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
307 assert(state);
225
308
226 if (state == Timing) { */
227 DPRINTF(DMA, "Attempting to send Packet %#x with addr: %#x\n",
228 pkt, pkt->getAddr());
229 if (transmitList.size() || !sendTiming(pkt)) {
230 if (front)
231 transmitList.push_front(pkt);
232 else
233 transmitList.push_back(pkt);
234 DPRINTF(DMA, "-- Failed: queued\n");
235 } else {
236 DPRINTF(DMA, "-- Done\n");
237 }
238 /* } else if (state == Atomic) {
239 sendAtomic(pkt);
240 if (pkt->senderState) {
241 DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
242 assert(state);
243 state->completionEvent->schedule(curTick + (pkt->time -
244 pkt->req->getTime()) +1);
245 delete state;
246 }
247 pendingCount--;
248 assert(pendingCount >= 0);
249 delete pkt->req;
250 delete pkt;
309 state->numBytes += pkt->req->getSize();
310 if (state->totBytes == state->numBytes) {
311 state->completionEvent->schedule(curTick +
312 (pkt->time - pkt->req->getTime()) +1);
313 delete state;
314 delete pkt->req;
315 }
316 pendingCount--;
317 assert(pendingCount >= 0);
318 delete pkt;
251
319
252 } else if (state == Functional) {
253 sendFunctional(pkt);
254 // Is this correct???
255 completionEvent->schedule(pkt->req->responseTime - pkt->req->requestTime);
256 completionEvent == NULL;
320 if (pendingCount == 0 && drainEvent) {
321 drainEvent->process();
322 drainEvent = NULL;
323 }
324
257 } else
258 panic("Unknown memory command state.");
325 } else
326 panic("Unknown memory command state.");
259 */
260}
261
262DmaDevice::~DmaDevice()
263{
264 if (dmaPort)
265 delete dmaPort;
266}
267
268
327}
328
329DmaDevice::~DmaDevice()
330{
331 if (dmaPort)
332 delete dmaPort;
333}
334
335