Only issue responses if we aren;t already blocked

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

diff --git a/src/dev/tsunami_io.cc b/src/dev/tsunami_io.cc
index dd9feae99e5a09a12ec65dd7130633ea7209aa38..e3da10eb50dbc9ca0e4022966c25029164462d05 100644 (file)
--- a/src/dev/tsunami_io.cc
+++ b/src/dev/tsunami_io.cc
@@ -24,6 +24,10 @@
  * 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
+ *          Andrew Schultz
+ *          Miguel Serrano
  */
 
 /** @file
@@ -118,25 +122,27 @@ TsunamiIO::RTC::writeData(const uint8_t data)
     }
 }
 
-void
-TsunamiIO::RTC::readData(uint8_t *data)
+uint8_t
+TsunamiIO::RTC::readData()
 {
     if (addr < RTC_STAT_REGA)
-        *data = clock_data[addr];
+        return clock_data[addr];
     else {
         switch (addr) {
           case RTC_STAT_REGA:
             // toggle UIP bit for linux
             stat_regA ^= RTCA_UIP;
-            *data = stat_regA;
+            return stat_regA;
             break;
           case RTC_STAT_REGB:
-            *data = stat_regB;
+            return stat_regB;
             break;
           case RTC_STAT_REGC:
           case RTC_STAT_REGD:
-            *data = 0x00;
+            return 0x00;
             break;
+          default:
+            panic("Shouldn't be here");
         }
     }
 }
@@ -263,31 +269,35 @@ TsunamiIO::PITimer::Counter::latchCount()
     }
 }
 
-void
-TsunamiIO::PITimer::Counter::read(uint8_t *data)
+uint8_t
+TsunamiIO::PITimer::Counter::read()
 {
     if (latch_on) {
         switch (read_byte) {
           case LSB:
             read_byte = MSB;
-            *data = (uint8_t)latched_count;
+            return (uint8_t)latched_count;
             break;
           case MSB:
             read_byte = LSB;
             latch_on = false;
-            *data = latched_count >> 8;
+            return latched_count >> 8;
             break;
+          default:
+            panic("Shouldn't be here");
         }
     } else {
         switch (read_byte) {
           case LSB:
             read_byte = MSB;
-            *data = (uint8_t)count;
+            return (uint8_t)count;
             break;
           case MSB:
             read_byte = LSB;
-            *data = count >> 8;
+            return count >> 8;
             break;
+          default:
+            panic("Shouldn't be here");
         }
     }
 }
@@ -438,18 +448,17 @@ TsunamiIO::frequency() const
 Tick
 TsunamiIO::read(Packet *pkt)
 {
-    assert(pkt->result == Unknown);
-    assert(pkt->addr >= pioAddr && pkt->addr < pioAddr + pioSize);
+    assert(pkt->result == Packet::Unknown);
+    assert(pkt->getAddr() >= pioAddr && pkt->getAddr() < pioAddr + pioSize);
 
-    pkt->time += pioDelay;
-    Addr daddr = pkt->addr - pioAddr;
+    Addr daddr = pkt->getAddr() - pioAddr;
 
-    DPRINTF(Tsunami, "io read  va=%#x size=%d IOPorrt=%#x\n", pkt->addr,
-            pkt->size, daddr);
+    DPRINTF(Tsunami, "io read  va=%#x size=%d IOPorrt=%#x\n", pkt->getAddr(),
+            pkt->getSize(), daddr);
 
     pkt->allocate();
 
-    if (pkt->size == sizeof(uint8_t)) {
+    if (pkt->getSize() == sizeof(uint8_t)) {
         switch(daddr) {
           // PIC1 mask read
           case TSDEV_PIC1_MASK:
@@ -469,16 +478,16 @@ TsunamiIO::read(Packet *pkt)
               pkt->set(0x00);
               break;
           case TSDEV_TMR0_DATA:
-            pitimer.counter0.read(pkt->getPtr<uint8_t>());
+            pkt->set(pitimer.counter0.read());
             break;
           case TSDEV_TMR1_DATA:
-            pitimer.counter1.read(pkt->getPtr<uint8_t>());
+            pkt->set(pitimer.counter1.read());
             break;
           case TSDEV_TMR2_DATA:
-            pitimer.counter2.read(pkt->getPtr<uint8_t>());
+            pkt->set(pitimer.counter2.read());
             break;
           case TSDEV_RTC_DATA:
-            rtc.readData(pkt->getPtr<uint8_t>());
+            pkt->set(rtc.readData());
             break;
           case TSDEV_CTRL_PORTB:
             if (pitimer.counter2.outputHigh())
@@ -487,34 +496,32 @@ TsunamiIO::read(Packet *pkt)
                 pkt->set(0x00);
             break;
           default:
-            panic("I/O Read - va%#x size %d\n", pkt->addr, pkt->size);
+            panic("I/O Read - va%#x size %d\n", pkt->getAddr(), pkt->getSize());
         }
-    } else if (pkt->size == sizeof(uint64_t)) {
+    } else if (pkt->getSize() == sizeof(uint64_t)) {
         if (daddr == TSDEV_PIC1_ISR)
             pkt->set<uint64_t>(picr);
         else
            panic("I/O Read - invalid addr - va %#x size %d\n",
-                   pkt->addr, pkt->size);
+                   pkt->getAddr(), pkt->getSize());
     } else {
-       panic("I/O Read - invalid size - va %#x size %d\n", pkt->addr, pkt->size);
+       panic("I/O Read - invalid size - va %#x size %d\n", pkt->getAddr(), pkt->getSize());
     }
-    pkt->result = Success;
+    pkt->result = Packet::Success;
     return pioDelay;
 }
 
 Tick
 TsunamiIO::write(Packet *pkt)
 {
-    pkt->time += pioDelay;
-
-    assert(pkt->result == Unknown);
-    assert(pkt->addr >= pioAddr && pkt->addr < pioAddr + pioSize);
-    Addr daddr = pkt->addr - pioAddr;
+    assert(pkt->result == Packet::Unknown);
+    assert(pkt->getAddr() >= pioAddr && pkt->getAddr() < pioAddr + pioSize);
+    Addr daddr = pkt->getAddr() - pioAddr;
 
     DPRINTF(Tsunami, "io write - va=%#x size=%d IOPort=%#x Data=%#x\n",
-            pkt->addr, pkt->size, pkt->addr & 0xfff, (uint32_t)pkt->get<uint8_t>());
+            pkt->getAddr(), pkt->getSize(), pkt->getAddr() & 0xfff, (uint32_t)pkt->get<uint8_t>());
 
-    assert(pkt->size == sizeof(uint8_t));
+    assert(pkt->getSize() == sizeof(uint8_t));
 
     switch(daddr) {
       case TSDEV_PIC1_MASK:
@@ -577,10 +584,10 @@ TsunamiIO::write(Packet *pkt)
       case TSDEV_CTRL_PORTB:
         break;
       default:
-        panic("I/O Write - va%#x size %d data %#x\n", pkt->addr, pkt->size, pkt->get<uint8_t>());
+        panic("I/O Write - va%#x size %d data %#x\n", pkt->getAddr(), pkt->getSize(), pkt->get<uint8_t>());
     }
 
-    pkt->result = Success;
+    pkt->result = Packet::Success;
     return pioDelay;
 }