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