arch-arm: Do not check MustBeOne flag for TLB requests from the prefetcher

[gem5.git] / src / dev / isa_fake.cc

diff --git a/src/dev/isa_fake.cc b/src/dev/isa_fake.cc
index 103fdd8ce154ab739cf6c3bda0fed389790e2d83..407d08ca458bedf720f2e64aba3fa5b7f21c7110 100644 (file)
--- a/src/dev/isa_fake.cc
+++ b/src/dev/isa_fake.cc
@@ -32,63 +32,60 @@
  * Isa Fake Device implementation
  */
 
-#include "base/trace.hh"
 #include "dev/isa_fake.hh"
+
+#include "base/trace.hh"
+#include "debug/IsaFake.hh"
 #include "mem/packet.hh"
 #include "mem/packet_access.hh"
-#include "sim/builder.hh"
 #include "sim/system.hh"
 
 using namespace std;
 
 IsaFake::IsaFake(Params *p)
-    : BasicPioDevice(p)
-{
-    if (!params()->retBadAddr)
-        pioSize = p->pio_size;
-
-    memset(&retData, p->retData, sizeof(retData));
-}
-
-void
-IsaFake::init()
+    : BasicPioDevice(p, p->ret_bad_addr ? 0 : p->pio_size)
 {
-    // Only init this device if it's connected to anything.
-    if (pioPort)
-        PioDevice::init();
+    retData8 = p->ret_data8;
+    retData16 = p->ret_data16;
+    retData32 = p->ret_data32;
+    retData64 = p->ret_data64;
 }
 
-
 Tick
 IsaFake::read(PacketPtr pkt)
 {
-    assert(pkt->result == Packet::Unknown);
+    pkt->makeAtomicResponse();
 
-    if (params()->retBadAddr) {
-        DPRINTF(Tsunami, "read to bad address va=%#x size=%d\n",
+    if (params()->warn_access != "")
+        warn("Device %s accessed by read to address %#x size=%d\n",
+                name(), pkt->getAddr(), pkt->getSize());
+    if (params()->ret_bad_addr) {
+        DPRINTF(IsaFake, "read to bad address va=%#x size=%d\n",
                 pkt->getAddr(), pkt->getSize());
-        pkt->result = Packet::BadAddress;
+        pkt->setBadAddress();
     } else {
         assert(pkt->getAddr() >= pioAddr && pkt->getAddr() < pioAddr + pioSize);
-        DPRINTF(Tsunami, "read  va=%#x size=%d\n",
+        DPRINTF(IsaFake, "read  va=%#x size=%d\n",
                 pkt->getAddr(), pkt->getSize());
         switch (pkt->getSize()) {
           case sizeof(uint64_t):
-             pkt->set(retData);
+             pkt->setLE(retData64);
              break;
           case sizeof(uint32_t):
-             pkt->set((uint32_t)retData);
+             pkt->setLE(retData32);
              break;
           case sizeof(uint16_t):
-             pkt->set((uint16_t)retData);
+             pkt->setLE(retData16);
              break;
           case sizeof(uint8_t):
-             pkt->set((uint8_t)retData);
+             pkt->setLE(retData8);
              break;
           default:
-            panic("invalid access size!\n");
+             if (params()->fake_mem)
+                 std::memset(pkt->getPtr<uint8_t>(), 0, pkt->getSize());
+             else
+                 panic("invalid access size! Device being accessed by cache?\n");
         }
-        pkt->result = Packet::Success;
     }
     return pioDelay;
 }
@@ -96,54 +93,60 @@ IsaFake::read(PacketPtr pkt)
 Tick
 IsaFake::write(PacketPtr pkt)
 {
-    if (params()->retBadAddr) {
-        DPRINTF(Tsunami, "write to bad address va=%#x size=%d \n",
+    pkt->makeAtomicResponse();
+    if (params()->warn_access != "") {
+        uint64_t data;
+        switch (pkt->getSize()) {
+          case sizeof(uint64_t):
+            data = pkt->getLE<uint64_t>();
+            break;
+          case sizeof(uint32_t):
+            data = pkt->getLE<uint32_t>();
+            break;
+          case sizeof(uint16_t):
+            data = pkt->getLE<uint16_t>();
+            break;
+          case sizeof(uint8_t):
+            data = pkt->getLE<uint8_t>();
+            break;
+          default:
+            panic("invalid access size: %u\n", pkt->getSize());
+        }
+        warn("Device %s accessed by write to address %#x size=%d data=%#x\n",
+                name(), pkt->getAddr(), pkt->getSize(), data);
+    }
+    if (params()->ret_bad_addr) {
+        DPRINTF(IsaFake, "write to bad address va=%#x size=%d \n",
                 pkt->getAddr(), pkt->getSize());
-        pkt->result = Packet::BadAddress;
+        pkt->setBadAddress();
     } else {
-        DPRINTF(Tsunami, "write - va=%#x size=%d \n",
+        DPRINTF(IsaFake, "write - va=%#x size=%d \n",
                 pkt->getAddr(), pkt->getSize());
-        pkt->result = Packet::Success;
+
+        if (params()->update_data) {
+            switch (pkt->getSize()) {
+              case sizeof(uint64_t):
+                retData64 = pkt->getLE<uint64_t>();
+                break;
+              case sizeof(uint32_t):
+                retData32 = pkt->getLE<uint32_t>();
+                break;
+              case sizeof(uint16_t):
+                retData16 = pkt->getLE<uint16_t>();
+                break;
+              case sizeof(uint8_t):
+                retData8 = pkt->getLE<uint8_t>();
+                break;
+              default:
+                panic("invalid access size!\n");
+            }
+        }
     }
     return pioDelay;
 }
 
-BEGIN_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
-
-    Param<Addr> pio_addr;
-    Param<Tick> pio_latency;
-    Param<Addr> pio_size;
-    Param<bool> ret_bad_addr;
-    Param<uint8_t> ret_data;
-    SimObjectParam<Platform *> platform;
-    SimObjectParam<System *> system;
-
-END_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
-
-BEGIN_INIT_SIM_OBJECT_PARAMS(IsaFake)
-
-    INIT_PARAM(pio_addr, "Device Address"),
-    INIT_PARAM(pio_latency, "Programmed IO latency"),
-    INIT_PARAM(pio_size, "Size of address range"),
-    INIT_PARAM(ret_bad_addr, "Return pkt status BadAddr"),
-    INIT_PARAM(ret_data, "Data to return if not bad addr"),
-    INIT_PARAM(platform, "platform"),
-    INIT_PARAM(system, "system object")
-
-END_INIT_SIM_OBJECT_PARAMS(IsaFake)
-
-CREATE_SIM_OBJECT(IsaFake)
+IsaFake *
+IsaFakeParams::create()
 {
-    IsaFake::Params *p = new IsaFake::Params;
-    p->name = getInstanceName();
-    p->pio_addr = pio_addr;
-    p->pio_delay = pio_latency;
-    p->pio_size = pio_size;
-    p->retBadAddr = ret_bad_addr;
-    p->retData = ret_data;
-    p->platform = platform;
-    p->system = system;
-    return new IsaFake(p);
+    return new IsaFake(this);
 }
-
-REGISTER_SIM_OBJECT("IsaFake", IsaFake)