src/dev/io_device.cc

   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;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Ali Saidi
  29  *          Nathan Binkert
  30  */
  31
  32 #include "base/chunk_generator.hh"
  33 #include "base/trace.hh"
  34 #include "dev/io_device.hh"
  35 #include "sim/system.hh"
  36
  37
  38 PioPort::PioPort(PioDevice *dev, System *s, std::string pname)
  39     : SimpleTimingPort(dev->name() + pname, dev), device(dev)
  40 { }
  41
  42
  43 Tick
  44 PioPort::recvAtomic(PacketPtr pkt)
  45 {
  46     return pkt->isRead() ? device->read(pkt) : device->write(pkt);
  47 }
  48
  49 void
  50 PioPort::getDeviceAddressRanges(AddrRangeList &resp, bool &snoop)
  51 {
  52     snoop = false;
  53     device->addressRanges(resp);
  54 }
  55
  56
  57 PioDevice::PioDevice(const Params *p)
  58     : MemObject(p), platform(p->platform), sys(p->system), pioPort(NULL)
  59 {}
  60
  61 PioDevice::~PioDevice()
  62 {
  63     if (pioPort)
  64         delete pioPort;
  65 }
  66
  67 void
  68 PioDevice::init()
  69 {
  70     if (!pioPort)
  71         panic("Pio port not connected to anything!");
  72     pioPort->sendStatusChange(Port::RangeChange);
  73 }
  74
  75
  76 unsigned int
  77 PioDevice::drain(Event *de)
  78 {
  79     unsigned int count;
  80     count = pioPort->drain(de);
  81     if (count)
  82         changeState(Draining);
  83     else
  84         changeState(Drained);
  85     return count;
  86 }
  87
  88 BasicPioDevice::BasicPioDevice(const Params *p)
  89     : PioDevice(p), pioAddr(p->pio_addr), pioSize(0),
  90       pioDelay(p->pio_latency)
  91 {}
  92
  93 void
  94 BasicPioDevice::addressRanges(AddrRangeList &range_list)
  95 {
  96     assert(pioSize != 0);
  97     range_list.clear();
  98     range_list.push_back(RangeSize(pioAddr, pioSize));
  99 }
 100
 101
 102 DmaPort::DmaPort(DmaDevice *dev, System *s)
 103     : Port(dev->name() + "-dmaport", dev), device(dev), sys(s),
 104       pendingCount(0), actionInProgress(0), drainEvent(NULL),
 105       backoffTime(0), inRetry(false), backoffEvent(this)
 106 { }
 107
 108 bool
 109 DmaPort::recvTiming(PacketPtr pkt)
 110 {
 111     if (pkt->wasNacked()) {
 112         DPRINTF(DMA, "Received nacked %s addr %#x\n",
 113                 pkt->cmdString(), pkt->getAddr());
 114
 115         if (backoffTime < device->minBackoffDelay)
 116             backoffTime = device->minBackoffDelay;
 117         else if (backoffTime < device->maxBackoffDelay)
 118             backoffTime <<= 1;
 119
 120         backoffEvent.reschedule(curTick + backoffTime, true);
 121
 122         DPRINTF(DMA, "Backoff time set to %d ticks\n", backoffTime);
 123
 124         pkt->reinitNacked();
 125         queueDma(pkt, true);
 126     } else if (pkt->senderState) {
 127         DmaReqState *state;
 128         backoffTime >>= 2;
 129
 130         DPRINTF(DMA, "Received response %s addr %#x size %#x\n",
 131                 pkt->cmdString(), pkt->getAddr(), pkt->req->getSize());
 132         state = dynamic_cast<DmaReqState*>(pkt->senderState);
 133         pendingCount--;
 134
 135         assert(pendingCount >= 0);
 136         assert(state);
 137
 138         state->numBytes += pkt->req->getSize();
 139         assert(state->totBytes >= state->numBytes);
 140         if (state->totBytes == state->numBytes) {
 141             if (state->delay)
 142                 state->completionEvent->schedule(state->delay + curTick);
 143             else
 144                 state->completionEvent->process();
 145             delete state;
 146         }
 147         delete pkt->req;
 148         delete pkt;
 149
 150         if (pendingCount == 0 && drainEvent) {
 151             drainEvent->process();
 152             drainEvent = NULL;
 153         }
 154     }  else {
 155         panic("Got packet without sender state... huh?\n");
 156     }
 157
 158     return true;
 159 }
 160
 161 DmaDevice::DmaDevice(const Params *p)
 162     : PioDevice(p), dmaPort(NULL), minBackoffDelay(p->min_backoff_delay),
 163       maxBackoffDelay(p->max_backoff_delay)
 164 { }
 165
 166
 167 unsigned int
 168 DmaDevice::drain(Event *de)
 169 {
 170     unsigned int count;
 171     count = pioPort->drain(de) + dmaPort->drain(de);
 172     if (count)
 173         changeState(Draining);
 174     else
 175         changeState(Drained);
 176     return count;
 177 }
 178
 179 unsigned int
 180 DmaPort::drain(Event *de)
 181 {
 182     if (pendingCount == 0)
 183         return 0;
 184     drainEvent = de;
 185     return 1;
 186 }
 187
 188
 189 void
 190 DmaPort::recvRetry()
 191 {
 192     assert(transmitList.size());
 193     bool result = true;
 194     do {
 195         PacketPtr pkt = transmitList.front();
 196         DPRINTF(DMA, "Retry on %s addr %#x\n",
 197                 pkt->cmdString(), pkt->getAddr());
 198         result = sendTiming(pkt);
 199         if (result) {
 200             DPRINTF(DMA, "-- Done\n");
 201             transmitList.pop_front();
 202             inRetry = false;
 203         } else {
 204             inRetry = true;
 205             DPRINTF(DMA, "-- Failed, queued\n");
 206         }
 207     } while (!backoffTime &&  result && transmitList.size());
 208
 209     if (transmitList.size() && backoffTime && !inRetry) {
 210         DPRINTF(DMA, "Scheduling backoff for %d\n", curTick+backoffTime);
 211         if (!backoffEvent.scheduled())
 212             backoffEvent.schedule(backoffTime+curTick);
 213     }
 214     DPRINTF(DMA, "TransmitList: %d, backoffTime: %d inRetry: %d es: %d\n",
 215             transmitList.size(), backoffTime, inRetry,
 216             backoffEvent.scheduled());
 217 }
 218
 219
 220 void
 221 DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
 222                    uint8_t *data, Tick delay)
 223 {
 224     assert(event);
 225
 226     assert(device->getState() == SimObject::Running);
 227
 228     DmaReqState *reqState = new DmaReqState(event, this, size, delay);
 229
 230
 231     DPRINTF(DMA, "Starting DMA for addr: %#x size: %d sched: %d\n", addr, size,
 232             event->scheduled());
 233     for (ChunkGenerator gen(addr, size, peerBlockSize());
 234          !gen.done(); gen.next()) {
 235             Request *req = new Request(gen.addr(), gen.size(), 0);
 236             PacketPtr pkt = new Packet(req, cmd, Packet::Broadcast);
 237
 238             // Increment the data pointer on a write
 239             if (data)
 240                 pkt->dataStatic(data + gen.complete());
 241
 242             pkt->senderState = reqState;
 243
 244             assert(pendingCount >= 0);
 245             pendingCount++;
 246             DPRINTF(DMA, "--Queuing DMA for addr: %#x size: %d\n", gen.addr(),
 247                     gen.size());
 248             queueDma(pkt);
 249     }
 250
 251 }
 252
 253 void
 254 DmaPort::queueDma(PacketPtr pkt, bool front)
 255 {
 256
 257     if (front)
 258         transmitList.push_front(pkt);
 259     else
 260         transmitList.push_back(pkt);
 261     sendDma();
 262 }
 263
 264
 265 void
 266 DmaPort::sendDma()
 267 {
 268     // some kind of selction between access methods
 269     // more work is going to have to be done to make
 270     // switching actually work
 271     assert(transmitList.size());
 272     PacketPtr pkt = transmitList.front();
 273
 274     Enums::MemoryMode state = sys->getMemoryMode();
 275     if (state == Enums::timing) {
 276         if (backoffEvent.scheduled() || inRetry) {
 277             DPRINTF(DMA, "Can't send immediately, waiting for retry or backoff timer\n");
 278             return;
 279         }
 280
 281         DPRINTF(DMA, "Attempting to send %s addr %#x\n",
 282                 pkt->cmdString(), pkt->getAddr());
 283
 284         bool result;
 285         do {
 286             result = sendTiming(pkt);
 287             if (result) {
 288                 transmitList.pop_front();
 289                 DPRINTF(DMA, "-- Done\n");
 290             } else {
 291                 inRetry = true;
 292                 DPRINTF(DMA, "-- Failed: queued\n");
 293             }
 294         } while (result && !backoffTime && transmitList.size());
 295
 296         if (transmitList.size() && backoffTime && !inRetry &&
 297                 !backoffEvent.scheduled()) {
 298             DPRINTF(DMA, "-- Scheduling backoff timer for %d\n",
 299                     backoffTime+curTick);
 300             backoffEvent.schedule(backoffTime+curTick);
 301         }
 302     } else if (state == Enums::atomic) {
 303         transmitList.pop_front();
 304
 305         Tick lat;
 306         DPRINTF(DMA, "--Sending  DMA for addr: %#x size: %d\n",
 307                 pkt->req->getPaddr(), pkt->req->getSize());
 308         lat = sendAtomic(pkt);
 309         assert(pkt->senderState);
 310         DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
 311         assert(state);
 312         state->numBytes += pkt->req->getSize();
 313
 314         DPRINTF(DMA, "--Received response for  DMA for addr: %#x size: %d nb: %d, tot: %d sched %d\n",
 315                 pkt->req->getPaddr(), pkt->req->getSize(), state->numBytes,
 316                 state->totBytes, state->completionEvent->scheduled());
 317
 318         if (state->totBytes == state->numBytes) {
 319             assert(!state->completionEvent->scheduled());
 320             state->completionEvent->schedule(curTick + lat + state->delay);
 321             delete state;
 322             delete pkt->req;
 323         }
 324         pendingCount--;
 325         assert(pendingCount >= 0);
 326         delete pkt;
 327
 328         if (pendingCount == 0 && drainEvent) {
 329             drainEvent->process();
 330             drainEvent = NULL;
 331         }
 332
 333    } else
 334        panic("Unknown memory command state.");
 335 }
 336
 337 DmaDevice::~DmaDevice()
 338 {
 339     if (dmaPort)
 340         delete dmaPort;
 341 }