X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fdev%2Fio_device.cc;h=cdba171a6017d21b9f9a255e9f511f4a65c47c1d;hb=eac5eac67ae8076e934d78063a24eeef08f25413;hp=9384c4b9241f20b41ee55d093a18b435833875ea;hpb=376cff64bd3ac5bafd8fa566674964fd4836790c;p=gem5.git

diff --git a/src/dev/io_device.cc b/src/dev/io_device.cc
index 9384c4b92..cdba171a6 100644
--- a/src/dev/io_device.cc
+++ b/src/dev/io_device.cc
@@ -32,7 +32,6 @@
 #include "base/chunk_generator.hh"
 #include "base/trace.hh"
 #include "dev/io_device.hh"
-#include "sim/builder.hh"
 #include "sim/system.hh"
 
 
@@ -48,13 +47,17 @@ PioPort::recvAtomic(PacketPtr pkt)
 }
 
 void
-PioPort::getDeviceAddressRanges(AddrRangeList &resp, AddrRangeList &snoop)
+PioPort::getDeviceAddressRanges(AddrRangeList &resp, bool &snoop)
 {
-    snoop.clear();
+    snoop = false;
     device->addressRanges(resp);
 }
 
 
+PioDevice::PioDevice(const Params *p)
+    : MemObject(p), platform(p->platform), sys(p->system), pioPort(NULL)
+{}
+
 PioDevice::~PioDevice()
 {
     if (pioPort)
@@ -82,6 +85,11 @@ PioDevice::drain(Event *de)
     return count;
 }
 
+BasicPioDevice::BasicPioDevice(const Params *p)
+    : PioDevice(p), pioAddr(p->pio_addr), pioSize(0),
+      pioDelay(p->pio_latency)
+{}
+
 void
 BasicPioDevice::addressRanges(AddrRangeList &range_list)
 {
@@ -100,21 +108,16 @@ DmaPort::DmaPort(DmaDevice *dev, System *s)
 bool
 DmaPort::recvTiming(PacketPtr pkt)
 {
-
-
-    if (pkt->result == Packet::Nacked) {
-        DPRINTF(DMA, "Received nacked Pkt %#x with State: %#x Addr: %#x\n",
-               pkt, pkt->senderState, pkt->getAddr());
+    if (pkt->wasNacked()) {
+        DPRINTF(DMA, "Received nacked %s addr %#x\n",
+                pkt->cmdString(), pkt->getAddr());
 
         if (backoffTime < device->minBackoffDelay)
             backoffTime = device->minBackoffDelay;
         else if (backoffTime < device->maxBackoffDelay)
             backoffTime <<= 1;
 
-        if (backoffEvent.scheduled())
-            backoffEvent.reschedule(curTick + backoffTime);
-        else
-            backoffEvent.schedule(curTick + backoffTime);
+        reschedule(backoffEvent, curTick + backoffTime, true);
 
         DPRINTF(DMA, "Backoff time set to %d ticks\n", backoffTime);
 
@@ -124,8 +127,8 @@ DmaPort::recvTiming(PacketPtr pkt)
         DmaReqState *state;
         backoffTime >>= 2;
 
-        DPRINTF(DMA, "Received response Pkt %#x with State: %#x Addr: %#x size: %#x\n",
-               pkt, pkt->senderState, pkt->getAddr(), pkt->req->getSize());
+        DPRINTF(DMA, "Received response %s addr %#x size %#x\n",
+                pkt->cmdString(), pkt->getAddr(), pkt->req->getSize());
         state = dynamic_cast<DmaReqState*>(pkt->senderState);
         pendingCount--;
 
@@ -135,7 +138,10 @@ DmaPort::recvTiming(PacketPtr pkt)
         state->numBytes += pkt->req->getSize();
         assert(state->totBytes >= state->numBytes);
         if (state->totBytes == state->numBytes) {
-            state->completionEvent->process();
+            if (state->delay)
+                schedule(state->completionEvent, curTick + state->delay);
+            else
+                state->completionEvent->process();
             delete state;
         }
         delete pkt->req;
@@ -152,7 +158,7 @@ DmaPort::recvTiming(PacketPtr pkt)
     return true;
 }
 
-DmaDevice::DmaDevice(Params *p)
+DmaDevice::DmaDevice(const Params *p)
     : PioDevice(p), dmaPort(NULL), minBackoffDelay(p->min_backoff_delay),
       maxBackoffDelay(p->max_backoff_delay)
 { }
@@ -184,11 +190,11 @@ void
 DmaPort::recvRetry()
 {
     assert(transmitList.size());
-    PacketPtr pkt = transmitList.front();
     bool result = true;
     do {
-        DPRINTF(DMA, "Retry on  Packet %#x with senderState: %#x\n",
-                   pkt, pkt->senderState);
+        PacketPtr pkt = transmitList.front();
+        DPRINTF(DMA, "Retry on %s addr %#x\n",
+                pkt->cmdString(), pkt->getAddr());
         result = sendTiming(pkt);
         if (result) {
             DPRINTF(DMA, "-- Done\n");
@@ -203,7 +209,7 @@ DmaPort::recvRetry()
     if (transmitList.size() && backoffTime && !inRetry) {
         DPRINTF(DMA, "Scheduling backoff for %d\n", curTick+backoffTime);
         if (!backoffEvent.scheduled())
-            backoffEvent.schedule(backoffTime+curTick);
+            schedule(backoffEvent, backoffTime + curTick);
     }
     DPRINTF(DMA, "TransmitList: %d, backoffTime: %d inRetry: %d es: %d\n",
             transmitList.size(), backoffTime, inRetry,
@@ -213,14 +219,17 @@ DmaPort::recvRetry()
 
 void
 DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
-                   uint8_t *data)
+                   uint8_t *data, Tick delay)
 {
     assert(event);
 
     assert(device->getState() == SimObject::Running);
 
-    DmaReqState *reqState = new DmaReqState(event, this, size);
+    DmaReqState *reqState = new DmaReqState(event, this, size, delay);
+
 
+    DPRINTF(DMA, "Starting DMA for addr: %#x size: %d sched: %d\n", addr, size,
+            event->scheduled());
     for (ChunkGenerator gen(addr, size, peerBlockSize());
          !gen.done(); gen.next()) {
             Request *req = new Request(gen.addr(), gen.size(), 0);
@@ -234,6 +243,8 @@ DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
 
             assert(pendingCount >= 0);
             pendingCount++;
+            DPRINTF(DMA, "--Queuing DMA for addr: %#x size: %d\n", gen.addr(),
+                    gen.size());
             queueDma(pkt);
     }
 
@@ -260,15 +271,15 @@ DmaPort::sendDma()
     assert(transmitList.size());
     PacketPtr pkt = transmitList.front();
 
-    System::MemoryMode state = sys->getMemoryMode();
-    if (state == System::Timing) {
+    Enums::MemoryMode state = sys->getMemoryMode();
+    if (state == Enums::timing) {
         if (backoffEvent.scheduled() || inRetry) {
             DPRINTF(DMA, "Can't send immediately, waiting for retry or backoff timer\n");
             return;
         }
 
-        DPRINTF(DMA, "Attempting to send Packet %#x with addr: %#x\n",
-                pkt, pkt->getAddr());
+        DPRINTF(DMA, "Attempting to send %s addr %#x\n",
+                pkt->cmdString(), pkt->getAddr());
 
         bool result;
         do {
@@ -284,20 +295,29 @@ DmaPort::sendDma()
 
         if (transmitList.size() && backoffTime && !inRetry &&
                 !backoffEvent.scheduled()) {
-            backoffEvent.schedule(backoffTime+curTick);
+            DPRINTF(DMA, "-- Scheduling backoff timer for %d\n",
+                    backoffTime+curTick);
+            schedule(backoffEvent, backoffTime + curTick);
         }
-    } else if (state == System::Atomic) {
+    } else if (state == Enums::atomic) {
         transmitList.pop_front();
 
         Tick lat;
+        DPRINTF(DMA, "--Sending  DMA for addr: %#x size: %d\n",
+                pkt->req->getPaddr(), pkt->req->getSize());
         lat = sendAtomic(pkt);
         assert(pkt->senderState);
         DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
         assert(state);
-
         state->numBytes += pkt->req->getSize();
+
+        DPRINTF(DMA, "--Received response for  DMA for addr: %#x size: %d nb: %d, tot: %d sched %d\n",
+                pkt->req->getPaddr(), pkt->req->getSize(), state->numBytes,
+                state->totBytes, state->completionEvent->scheduled());
+
         if (state->totBytes == state->numBytes) {
-            state->completionEvent->schedule(curTick + lat);
+            assert(!state->completionEvent->scheduled());
+            schedule(state->completionEvent, curTick + lat + state->delay);
             delete state;
             delete pkt->req;
         }
@@ -319,5 +339,3 @@ DmaDevice::~DmaDevice()
     if (dmaPort)
         delete dmaPort;
 }
-
-