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             state->completionEvent->process();
 142             delete state;
 143         }
 144         delete pkt->req;
 145         delete pkt;
 146
 147         if (pendingCount == 0 && drainEvent) {
 148             drainEvent->process();
 149             drainEvent = NULL;
 150         }
 151     }  else {
 152         panic("Got packet without sender state... huh?\n");
 153     }
 154
 155     return true;
 156 }
 157
 158 DmaDevice::DmaDevice(const Params *p)
 159     : PioDevice(p), dmaPort(NULL), minBackoffDelay(p->min_backoff_delay),
 160       maxBackoffDelay(p->max_backoff_delay)
 161 { }
 162
 163
 164 unsigned int
 165 DmaDevice::drain(Event *de)
 166 {
 167     unsigned int count;
 168     count = pioPort->drain(de) + dmaPort->drain(de);
 169     if (count)
 170         changeState(Draining);
 171     else
 172         changeState(Drained);
 173     return count;
 174 }
 175
 176 unsigned int
 177 DmaPort::drain(Event *de)
 178 {
 179     if (pendingCount == 0)
 180         return 0;
 181     drainEvent = de;
 182     return 1;
 183 }
 184
 185
 186 void
 187 DmaPort::recvRetry()
 188 {
 189     assert(transmitList.size());
 190     PacketPtr pkt = transmitList.front();
 191     bool result = true;
 192     do {
 193         DPRINTF(DMA, "Retry on %s addr %#x\n",
 194                 pkt->cmdString(), pkt->getAddr());
 195         result = sendTiming(pkt);
 196         if (result) {
 197             DPRINTF(DMA, "-- Done\n");
 198             transmitList.pop_front();
 199             inRetry = false;
 200         } else {
 201             inRetry = true;
 202             DPRINTF(DMA, "-- Failed, queued\n");
 203         }
 204     } while (!backoffTime &&  result && transmitList.size());
 205
 206     if (transmitList.size() && backoffTime && !inRetry) {
 207         DPRINTF(DMA, "Scheduling backoff for %d\n", curTick+backoffTime);
 208         if (!backoffEvent.scheduled())
 209             backoffEvent.schedule(backoffTime+curTick);
 210     }
 211     DPRINTF(DMA, "TransmitList: %d, backoffTime: %d inRetry: %d es: %d\n",
 212             transmitList.size(), backoffTime, inRetry,
 213             backoffEvent.scheduled());
 214 }
 215
 216
 217 void
 218 DmaPort::dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
 219                    uint8_t *data)
 220 {
 221     assert(event);
 222
 223     assert(device->getState() == SimObject::Running);
 224
 225     DmaReqState *reqState = new DmaReqState(event, this, size);
 226
 227
 228     DPRINTF(DMA, "Starting DMA for addr: %#x size: %d sched: %d\n", addr, size,
 229             event->scheduled());
 230     for (ChunkGenerator gen(addr, size, peerBlockSize());
 231          !gen.done(); gen.next()) {
 232             Request *req = new Request(gen.addr(), gen.size(), 0);
 233             PacketPtr pkt = new Packet(req, cmd, Packet::Broadcast);
 234
 235             // Increment the data pointer on a write
 236             if (data)
 237                 pkt->dataStatic(data + gen.complete());
 238
 239             pkt->senderState = reqState;
 240
 241             assert(pendingCount >= 0);
 242             pendingCount++;
 243             DPRINTF(DMA, "--Queuing DMA for addr: %#x size: %d\n", gen.addr(),
 244                     gen.size());
 245             queueDma(pkt);
 246     }
 247
 248 }
 249
 250 void
 251 DmaPort::queueDma(PacketPtr pkt, bool front)
 252 {
 253
 254     if (front)
 255         transmitList.push_front(pkt);
 256     else
 257         transmitList.push_back(pkt);
 258     sendDma();
 259 }
 260
 261
 262 void
 263 DmaPort::sendDma()
 264 {
 265     // some kind of selction between access methods
 266     // more work is going to have to be done to make
 267     // switching actually work
 268     assert(transmitList.size());
 269     PacketPtr pkt = transmitList.front();
 270
 271     Enums::MemoryMode state = sys->getMemoryMode();
 272     if (state == Enums::timing) {
 273         if (backoffEvent.scheduled() || inRetry) {
 274             DPRINTF(DMA, "Can't send immediately, waiting for retry or backoff timer\n");
 275             return;
 276         }
 277
 278         DPRINTF(DMA, "Attempting to send %s addr %#x\n",
 279                 pkt->cmdString(), pkt->getAddr());
 280
 281         bool result;
 282         do {
 283             result = sendTiming(pkt);
 284             if (result) {
 285                 transmitList.pop_front();
 286                 DPRINTF(DMA, "-- Done\n");
 287             } else {
 288                 inRetry = true;
 289                 DPRINTF(DMA, "-- Failed: queued\n");
 290             }
 291         } while (result && !backoffTime && transmitList.size());
 292
 293         if (transmitList.size() && backoffTime && !inRetry &&
 294                 !backoffEvent.scheduled()) {
 295             DPRINTF(DMA, "-- Scheduling backoff timer for %d\n",
 296                     backoffTime+curTick);
 297             backoffEvent.schedule(backoffTime+curTick);
 298         }
 299     } else if (state == Enums::atomic) {
 300         transmitList.pop_front();
 301
 302         Tick lat;
 303         DPRINTF(DMA, "--Sending  DMA for addr: %#x size: %d\n",
 304                 pkt->req->getPaddr(), pkt->req->getSize());
 305         lat = sendAtomic(pkt);
 306         assert(pkt->senderState);
 307         DmaReqState *state = dynamic_cast<DmaReqState*>(pkt->senderState);
 308         assert(state);
 309         state->numBytes += pkt->req->getSize();
 310
 311         DPRINTF(DMA, "--Received response for  DMA for addr: %#x size: %d nb: %d, tot: %d sched %d\n",
 312                 pkt->req->getPaddr(), pkt->req->getSize(), state->numBytes,
 313                 state->totBytes, state->completionEvent->scheduled());
 314
 315         if (state->totBytes == state->numBytes) {
 316             assert(!state->completionEvent->scheduled());
 317             state->completionEvent->schedule(curTick + lat);
 318             delete state;
 319             delete pkt->req;
 320         }
 321         pendingCount--;
 322         assert(pendingCount >= 0);
 323         delete pkt;
 324
 325         if (pendingCount == 0 && drainEvent) {
 326             drainEvent->process();
 327             drainEvent = NULL;
 328         }
 329
 330    } else
 331        panic("Unknown memory command state.");
 332 }
 333
 334 DmaDevice::~DmaDevice()
 335 {
 336     if (dmaPort)
 337         delete dmaPort;
 338 }