* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Ali Saidi
+ * Nathan Binkert
*/
+#include "base/chunk_generator.hh"
+#include "base/trace.hh"
#include "dev/io_device.hh"
#include "sim/builder.hh"
+#include "sim/system.hh"
-PioPort::PioPort(PioDevice *dev, Platform *p)
- : Port(dev->name() + "-pioport"), device(dev), platform(p)
+PioPort::PioPort(PioDevice *dev, System *s, std::string pname)
+ : SimpleTimingPort(dev->name() + pname), device(dev)
{ }
Tick
PioPort::recvAtomic(Packet *pkt)
{
- return device->recvAtomic(pkt);
-}
-
-void
-PioPort::recvFunctional(Packet *pkt)
-{
- device->recvAtomic(pkt);
+ return pkt->isRead() ? device->read(pkt) : device->write(pkt);
}
void
}
-Packet *
-PioPort::recvRetry()
-{
- Packet* pkt = transmitList.front();
- transmitList.pop_front();
- return pkt;
-}
-
-
-void
-PioPort::SendEvent::process()
-{
- if (port->Port::sendTiming(packet) == Success)
- return;
-
- port->transmitList.push_back(packet);
-}
-
-
-bool
-PioPort::recvTiming(Packet *pkt)
-{
- device->recvAtomic(pkt);
- // turn packet around to go back to requester
- pkt->dest = pkt->src;
- sendTiming(pkt, pkt->time - pkt->req->getTime());
- return Success;
-}
-
PioDevice::~PioDevice()
{
if (pioPort)
pioPort->sendStatusChange(Port::RangeChange);
}
+
+unsigned int
+PioDevice::drain(Event *de)
+{
+ unsigned int count;
+ count = pioPort->drain(de);
+ if (count)
+ changeState(Draining);
+ else
+ changeState(Drained);
+ return count;
+}
+
void
BasicPioDevice::addressRanges(AddrRangeList &range_list)
{
}
-DmaPort::DmaPort(DmaDevice *dev, Platform *p)
- : Port(dev->name() + "-dmaport"), device(dev), platform(p), pendingCount(0)
+DmaPort::DmaPort(DmaDevice *dev, System *s)
+ : Port(dev->name() + "-dmaport"), device(dev), sys(s), pendingCount(0),
+ actionInProgress(0), drainEvent(NULL)
{ }
bool
DmaPort::recvTiming(Packet *pkt)
{
- if (pkt->senderState) {
+
+
+ if (pkt->result == Packet::Nacked) {
+ DPRINTF(DMA, "Received nacked Pkt %#x with State: %#x Addr: %#x\n",
+ pkt, pkt->senderState, pkt->getAddr());
+ pkt->reinitNacked();
+ sendDma(pkt, true);
+ } else if (pkt->senderState) {
DmaReqState *state;
- state = (DmaReqState*)pkt->senderState;
- state->completionEvent->schedule(pkt->time - pkt->req->getTime());
+ DPRINTF(DMA, "Received response Pkt %#x with State: %#x Addr: %#x\n",
+ pkt, pkt->senderState, pkt->getAddr());
+ state = dynamic_cast<DmaReqState*>(pkt->senderState);
+ pendingCount--;
+
+ assert(pendingCount >= 0);
+ assert(state);
+
+ state->numBytes += pkt->req->getSize();
+ if (state->totBytes == state->numBytes) {
+ state->completionEvent->process();
+ delete state;
+ }
delete pkt->req;
delete pkt;
+
+ if (pendingCount == 0 && drainEvent) {
+ drainEvent->process();
+ drainEvent = NULL;
+ }
} else {
- delete pkt->req;
- delete pkt;
+ panic("Got packet without sender state... huh?\n");
}
- return Success;
+ return true;
}
DmaDevice::DmaDevice(Params *p)
: PioDevice(p), dmaPort(NULL)
{ }
-void
-DmaPort::SendEvent::process()
+
+unsigned int
+DmaDevice::drain(Event *de)
{
- if (port->Port::sendTiming(packet) == Success)
- return;
+ unsigned int count;
+ count = pioPort->drain(de) + dmaPort->drain(de);
+ if (count)
+ changeState(Draining);
+ else
+ changeState(Drained);
+ return count;
+}
- port->transmitList.push_back(packet);
+unsigned int
+DmaPort::drain(Event *de)
+{
+ if (pendingCount == 0)
+ return 0;
+ drainEvent = de;
+ return 1;
}
-Packet *
+
+void
DmaPort::recvRetry()
{
Packet* pkt = transmitList.front();
- transmitList.pop_front();
- return pkt;
+ bool result = true;
+ while (result && transmitList.size()) {
+ DPRINTF(DMA, "Retry on Packet %#x with senderState: %#x\n",
+ pkt, pkt->senderState);
+ result = sendTiming(pkt);
+ if (result) {
+ DPRINTF(DMA, "-- Done\n");
+ transmitList.pop_front();
+ } else {
+ DPRINTF(DMA, "-- Failed, queued\n");
+ }
+ }
}
+
+
void
-DmaPort::dmaAction(Command cmd, Addr addr, int size, Event *event,
- uint8_t *data)
+DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
+ uint8_t *data)
{
-
assert(event);
- int prevSize = 0;
- Packet basePkt;
- Request baseReq(false);
+ assert(device->getState() == SimObject::Running);
- basePkt.flags = 0;
- basePkt.coherence = NULL;
- basePkt.senderState = NULL;
- basePkt.dest = Packet::Broadcast;
- basePkt.cmd = cmd;
- basePkt.result = Unknown;
- basePkt.req = NULL;
-// baseReq.nicReq = true;
- baseReq.setTime(curTick);
+ DmaReqState *reqState = new DmaReqState(event, this, size);
for (ChunkGenerator gen(addr, size, peerBlockSize());
!gen.done(); gen.next()) {
- Packet *pkt = new Packet(basePkt);
- Request *req = new Request(baseReq);
- pkt->addr = gen.addr();
- pkt->size = gen.size();
- pkt->req = req;
- pkt->req->setPaddr(pkt->addr);
- pkt->req->setSize(pkt->size);
+ Request *req = new Request(gen.addr(), gen.size(), 0);
+ Packet *pkt = new Packet(req, cmd, Packet::Broadcast);
+
// Increment the data pointer on a write
if (data)
- pkt->dataStatic(data + prevSize) ;
- prevSize += pkt->size;
- // Set the last bit of the dma as the final packet for this dma
- // and set it's completion event.
- if (prevSize == size) {
- DmaReqState *state = new DmaReqState(event, true);
-
- pkt->senderState = (void*)state;
- }
+ pkt->dataStatic(data + gen.complete());
+
+ pkt->senderState = reqState;
+
assert(pendingCount >= 0);
pendingCount++;
sendDma(pkt);
}
- // since this isn't getting used and we want a check to make sure that all
- // packets had data in them at some point.
- basePkt.dataStatic((uint8_t*)NULL);
+
}
void
-DmaPort::sendDma(Packet *pkt)
+DmaPort::sendDma(Packet *pkt, bool front)
{
- // some kind of selction between access methods
- // more work is going to have to be done to make
- // switching actually work
- /* MemState state = device->platform->system->memState;
-
- if (state == Timing) {
- if (sendTiming(pkt) == Failure)
- transmitList.push_back(&packet);
- } else if (state == Atomic) {*/
- sendAtomic(pkt);
- if (pkt->senderState) {
- DmaReqState *state = (DmaReqState*)pkt->senderState;
- state->completionEvent->schedule(curTick + (pkt->time - pkt->req->getTime()) +1);
- }
- pendingCount--;
- assert(pendingCount >= 0);
- delete pkt->req;
- delete pkt;
-
-/* } else if (state == Functional) {
- sendFunctional(pkt);
- // Is this correct???
- completionEvent->schedule(pkt->req->responseTime - pkt->req->requestTime);
- completionEvent == NULL;
+ // some kind of selction between access methods
+ // more work is going to have to be done to make
+ // switching actually work
+
+ System::MemoryMode state = sys->getMemoryMode();
+ if (state == System::Timing) {
+ DPRINTF(DMA, "Attempting to send Packet %#x with addr: %#x\n",
+ pkt, pkt->getAddr());
+ if (transmitList.size() || !sendTiming(pkt)) {
+ if (front)
+ transmitList.push_front(pkt);
+ else
+ transmitList.push_back(pkt);
+ DPRINTF(DMA, "-- Failed: queued\n");
+ } else {
+ DPRINTF(DMA, "-- Done\n");
+ }
+ } else if (state == System::Atomic) {
+ Tick lat;
+ lat = sendAtomic(pkt);
+ assert(pkt->senderState);
+ DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
+ assert(state);
+
+ state->numBytes += pkt->req->getSize();
+ if (state->totBytes == state->numBytes) {
+ state->completionEvent->schedule(curTick + lat);
+ delete state;
+ delete pkt->req;
+ }
+ pendingCount--;
+ assert(pendingCount >= 0);
+ delete pkt;
+
+ if (pendingCount == 0 && drainEvent) {
+ drainEvent->process();
+ drainEvent = NULL;
+ }
+
} else
panic("Unknown memory command state.");
- */
}
DmaDevice::~DmaDevice()
projects / gem5.git / blobdiff