From 8654cfa427d7346d7164946b91ea768e1fd64310 Mon Sep 17 00:00:00 2001 From: Ali Saidi Date: Tue, 21 Mar 2006 15:45:31 -0500 Subject: Make PioPort/DmaPort,DmaDevice/PioDevice compile. Add another type to the PacketResult enum of Unknown Seperate time into requsetTime and responseTime. dev/io_device.cc: dev/io_device.hh: Make PioPort/DmaPort,DmaDevice/PioDevice compile. mem/packet.hh: Add another type to the PacketResult enum of Unknown (e.g. no state set yet) mem/request.hh: Seperate time into requsetTime and responseTime. --HG-- extra : convert_revision : c6394cb838013296caea6492275252b8cae2882f --- dev/io_device.cc | 104 ++++++++++++++++++++++++++++++++++----------- dev/io_device.hh | 125 ++++++++++++++++++++++++++++++++++++++----------------- 2 files changed, 165 insertions(+), 64 deletions(-) (limited to 'dev') diff --git a/dev/io_device.cc b/dev/io_device.cc index b580c2805..268484e57 100644 --- a/dev/io_device.cc +++ b/dev/io_device.cc @@ -29,10 +29,44 @@ #include "dev/io_device.hh" #include "sim/builder.hh" + +PioPort::PioPort(PioDevice *dev) + : device(dev) +{ } + + +Tick +PioPort::recvAtomic(Packet &pkt) +{ + return device->recvAtomic(pkt); +} + +void +PioPort::recvFunctional(Packet &pkt) +{ + device->recvAtomic(pkt); +} + +void +PioPort::getDeviceAddressRanges(AddrRangeList &range_list, bool &owner) +{ + device->addressRanges(range_list, owner); +} + + +Packet * +PioPort::recvRetry() +{ + Packet* pkt = transmitList.front(); + transmitList.pop_front(); + return pkt; +} + + void PioPort::SendEvent::process() { - if (port->sendTiming(packet) == Success) + if (port->Port::sendTiming(packet) == Success) return; port->transmitList.push_back(&packet); @@ -46,37 +80,57 @@ PioDevice::PioDevice(const std::string &name, Platform *p) bool -PioDevice::recvTiming(Packet &pkt) +PioPort::recvTiming(Packet &pkt) { device->recvAtomic(pkt); - sendTiming(pkt, pkt.responseTime-pkt.requestTime); + sendTiming(pkt, pkt.req->responseTime-pkt.req->requestTime); return Success; } PioDevice::~PioDevice() { if (pioPort) - delete pioInterface; + delete pioPort; } -void -DmaPort::sendDma(Packet &pkt) + +DmaPort::DmaPort(DmaDevice *dev) + : device(dev) +{ } + +bool +DmaPort::recvTiming(Packet &pkt) { - device->platform->system->memoryMode() - { - case MemAtomic: - } + completionEvent->schedule(curTick+1); + completionEvent = NULL; + return Success; } DmaDevice::DmaDevice(const std::string &name, Platform *p) : PioDevice(name, p) { - dmaPort = new dmaPort(this); + dmaPort = new DmaPort(this); } void -DmaPort::dmaAction(Memory::Command cmd, DmaPort port, Addr addr, int size, - Event *event, uint8_t *data = NULL) +DmaPort::SendEvent::process() +{ + if (port->Port::sendTiming(packet) == Success) + return; + + port->transmitList.push_back(&packet); +} + +Packet * +DmaPort::recvRetry() +{ + Packet* pkt = transmitList.front(); + transmitList.pop_front(); + return pkt; +} +void +DmaPort::dmaAction(Command cmd, DmaPort port, Addr addr, int size, + Event *event, uint8_t *data) { assert(event); @@ -92,9 +146,9 @@ DmaPort::dmaAction(Memory::Command cmd, DmaPort port, Addr addr, int size, basePkt.dest = 0; basePkt.cmd = cmd; basePkt.result = Unknown; - basePkt.request = NULL; + basePkt.req = NULL; baseReq.nicReq = true; - baseReq.time = curTick; + baseReq.requestTime = curTick; completionEvent = event; @@ -109,7 +163,7 @@ DmaPort::dmaAction(Memory::Command cmd, DmaPort port, Addr addr, int size, pkt->req->size = pkt->size; // Increment the data pointer on a write pkt->data = data ? data + prevSize : NULL ; - prevSize = pkt->size; + prevSize += pkt->size; sendDma(*pkt); } @@ -122,29 +176,29 @@ DmaPort::sendDma(Packet &pkt) // some kind of selction between access methods // more work is going to have to be done to make // switching actually work - MemState state = device->platform->system->memState; + /* MemState state = device->platform->system->memState; if (state == Timing) { if (sendTiming(pkt) == Failure) transmitList.push_back(&packet); - } else if (state == Atomic) { + } else if (state == Atomic) {*/ sendAtomic(pkt); - completionEvent->schedule(pkt.responseTime - pkt.requestTime); - completionEvent == NULL; - } else if (state == Functional) { + completionEvent->schedule(pkt.req->responseTime - pkt.req->requestTime); + completionEvent = NULL; +/* } else if (state == Functional) { sendFunctional(pkt); // Is this correct??? - completionEvent->schedule(pkt.responseTime - pkt.requestTime); + completionEvent->schedule(pkt.req->responseTime - pkt.req->requestTime); completionEvent == NULL; } else panic("Unknown memory command state."); - + */ } DmaDevice::~DmaDevice() { - if (dmaInterface) - delete dmaInterface; + if (dmaPort) + delete dmaPort; } diff --git a/dev/io_device.hh b/dev/io_device.hh index a79c3f20a..8e44a1c00 100644 --- a/dev/io_device.hh +++ b/dev/io_device.hh @@ -32,30 +32,56 @@ #include "base/chunk_generator.hh" #include "mem/port.hh" #include "sim/eventq.hh" +#include "sim/sim_object.hh" -class Bus; class Platform; class PioDevice; - +class DmaDevice; + +/** + * The PioPort class is a programmed i/o port that all devices that are + * sensitive to an address range use. The port takes all the memory + * access types and roles them into one read() and write() call that the device + * must respond to. The device must also provide the addressRanges() function + * with which it returns the address ranges it is interested in. An extra + * sendTiming() function is implemented which takes an delay. In this way the + * device can immediatly call sendTiming(pkt, time) after processing a request + * and the request will be handled by the port even if the port bus the device + * connects to is blocked. + */ class PioPort : public Port { protected: + /** The device that this port serves. */ PioDevice *device; + /** The platform that device/port are in. This is used to select which mode + * we are currently operating in. */ + Platfrom *platform; + + /** A list of outgoing timing response packets that haven't been serviced + * yet. */ + std::list transmitList; + + /** The current status of the peer(bus) that we are connected to. */ + Status peerStatus; + virtual bool recvTiming(Packet &pkt); - virtual Tick recvAtomic(Packet &pkt) - { return device->recvAtomic(pkt) }; + virtual Tick recvAtomic(Packet &pkt); - virtual void recvFunctional(Packet &pkt) - { device->recvAtomic(pkt) }; + virtual void recvFunctional(Packet &pkt) ; - virtual void getDeviceAddressRanges(AddrRangeList &range_list, bool &owner) - { device->addressRanges(range_list, owner); } + virtual void recvStatusChange(Status status) + { peerStatus = status; } - void sendTiming(Packet &pkt, Tick time) - { new SendEvent(this, pkt, time); } + virtual void getDeviceAddressRanges(AddrRangeList &range_list, bool &owner); + /** + * This class is used to implemented sendTiming() with a delay. When a delay + * is requested a new event is created. When the event time expires it + * attempts to send the packet. If it cannot, the packet is pushed onto the + * transmit list to be sent when recvRetry() is called. */ class SendEvent : public Event { PioPort *port; @@ -71,13 +97,19 @@ class PioPort : public Port { return "Future scheduled sendTiming event"; } friend class PioPort; - } + }; + + /** Schedule a sendTiming() event to be called in the future. */ + void sendTiming(Packet &pkt, Tick time) + { new PioPort::SendEvent(this, pkt, time); } + + /** This function pops the last element off the transmit list and sends it.*/ + virtual Packet *recvRetry(); public: - PioPort(PioDevice *dev) - : device(dev) - { } + PioPort(PioDevice *dev, Platform *p); + friend class PioPort::SendEvent; }; class DmaPort : public Port @@ -85,10 +117,10 @@ class DmaPort : public Port protected: PioDevice *device; std::list transmitList; + Event *completionEvent; - virtual bool recvTiming(Packet &pkt) - { completionEvent->schedule(curTick+1); completionEvent = NULL; } + virtual bool recvTiming(Packet &pkt); virtual Tick recvAtomic(Packet &pkt) { panic("dma port shouldn't be used for pio access."); } virtual void recvFunctional(Packet &pkt) @@ -97,23 +129,14 @@ class DmaPort : public Port virtual void recvStatusChange(Status status) { ; } - virtual Packet *recvRetry() - { return transmitList.pop_front(); } + virtual Packet *recvRetry() ; virtual void getDeviceAddressRanges(AddrRangeList &range_list, bool &owner) { range_list.clear(); owner = true; } - void dmaAction(Memory::Command cmd, DmaPort port, Addr addr, int size, - Event *event, uint8_t *data = NULL); - - void sendDma(Packet &pkt); - - virtual Packet *recvRetry() - { return transmitList.pop_front(); } - class SendEvent : public Event { - PioPort *port; + DmaPort *port; Packet packet; SendEvent(PioPort *p, Packet &pkt, Tick t) @@ -125,33 +148,55 @@ class DmaPort : public Port virtual const char *description() { return "Future scheduled sendTiming event"; } - friend class PioPort; - } + friend class DmaPort; + }; + + void dmaAction(Command cmd, DmaPort port, Addr addr, int size, + Event *event, uint8_t *data = NULL); + + void sendDma(Packet &pkt); + public: - DmaPort(DmaDevice *dev) - : device(dev) - { } + DmaPort(DmaDevice *dev); + friend class DmaPort::SendEvent; }; +/** + * This device is the base class which all devices senstive to an address range + * inherit from. There are three pure virtual functions which all devices must + * implement addressRanges(), read(), and write(). The magic do choose which + * mode we are in, etc is handled by the PioPort so the device doesn't have to + * bother. + */ class PioDevice : public SimObject { protected: + /** The platform we are in. This is used to decide what type of memory + * transaction we should perform. */ Platform *platform; + /** The pioPort that handles the requests for us and provides us requests + * that it sees. */ PioPort *pioPort; virtual void addressRanges(AddrRangeList &range_list, bool &owner) = 0; - virtual read(Packet &pkt) = 0; + /** As far as the devices are concerned they only accept atomic transactions + * which are converted to either a write or a read. */ + Tick recvAtomic(Packet &pkt) + { return pkt.cmd == Read ? this->read(pkt) : this->write(pkt); } - virtual write(Packet &pkt) = 0; + /** Pure virtual function that the device must implement. Called when a read + * command is recieved by the port. */ + virtual bool read(Packet &pkt) = 0; - Tick recvAtomic(Packet &pkt) - { return pkt->cmd == Read ? this->read(pkt) : this->write(pkt); } + /** Pure virtual function that the device must implement. Called when a + * write command is recieved by the port. */ + virtual bool write(Packet &pkt) = 0; public: PioDevice(const std::string &name, Platform *p); @@ -165,6 +210,8 @@ class PioDevice : public SimObject else return NULL; } + friend class PioPort; + }; class DmaDevice : public PioDevice @@ -180,14 +227,14 @@ class DmaDevice : public PioDevice { if (if_name == "pio") return pioPort; - else if (if_name = "dma") + else if (if_name == "dma") return dmaPort; else return NULL; } -}; - + friend class DmaPort; +}; #endif // __DEV_IO_DEVICE_HH__ -- cgit v1.2.3