io_device.hh revision 4475:fb185cc1c845 
1/*
2 * Copyright (c) 2004-2005 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#ifndef __DEV_IO_DEVICE_HH__
33#define __DEV_IO_DEVICE_HH__
34
35#include "mem/mem_object.hh"
36#include "mem/packet.hh"
37#include "mem/tport.hh"
38#include "sim/sim_object.hh"
39
40class Event;
41class Platform;
42class PioDevice;
43class DmaDevice;
44class System;
45
46/**
47 * The PioPort class is a programmed i/o port that all devices that are
48 * sensitive to an address range use. The port takes all the memory
49 * access types and roles them into one read() and write() call that the device
50 * must respond to. The device must also provide the addressRanges() function
51 * with which it returns the address ranges it is interested in.
52 */
53class PioPort : public SimpleTimingPort
54{
55  protected:
56    /** The device that this port serves. */
57    PioDevice *device;
58
59    virtual Tick recvAtomic(PacketPtr pkt);
60
61    virtual void getDeviceAddressRanges(AddrRangeList &resp,
62                                        bool &snoop);
63
64  public:
65
66    PioPort(PioDevice *dev, System *s, std::string pname = "-pioport");
67};
68
69
70class DmaPort : public Port
71{
72  protected:
73    struct DmaReqState : public Packet::SenderState
74    {
75        /** Event to call on the device when this transaction (all packets)
76         * complete. */
77        Event *completionEvent;
78
79        /** Where we came from for some sanity checking. */
80        Port *outPort;
81
82        /** Total number of bytes that this transaction involves. */
83        Addr totBytes;
84
85        /** Number of bytes that have been acked for this transaction. */
86        Addr numBytes;
87
88        DmaReqState(Event *ce, Port *p, Addr tb)
89            : completionEvent(ce), outPort(p), totBytes(tb), numBytes(0)
90        {}
91    };
92
93    DmaDevice *device;
94    std::list<PacketPtr> transmitList;
95
96    /** The system that device/port are in. This is used to select which mode
97     * we are currently operating in. */
98    System *sys;
99
100    /** Number of outstanding packets the dma port has. */
101    int pendingCount;
102
103    /** If a dmaAction is in progress. */
104    int actionInProgress;
105
106    /** If we need to drain, keep the drain event around until we're done
107     * here.*/
108    Event *drainEvent;
109
110    /** time to wait between sending another packet, increases as NACKs are
111     * recived, decreases as responses are recived. */
112    Tick backoffTime;
113
114    /** If the port is currently waiting for a retry before it can send whatever
115     * it is that it's sending. */
116    bool inRetry;
117
118    virtual bool recvTiming(PacketPtr pkt);
119    virtual Tick recvAtomic(PacketPtr pkt)
120    { panic("dma port shouldn't be used for pio access."); M5_DUMMY_RETURN }
121    virtual void recvFunctional(PacketPtr pkt)
122    { panic("dma port shouldn't be used for pio access."); }
123
124    virtual void recvStatusChange(Status status)
125    { ; }
126
127    virtual void recvRetry() ;
128
129    virtual void getDeviceAddressRanges(AddrRangeList &resp,
130                                        bool &snoop)
131    { resp.clear(); snoop = false; }
132
133    void queueDma(PacketPtr pkt, bool front = false);
134    void sendDma();
135
136    /** event to give us a kick every time we backoff time is reached. */
137    EventWrapper<DmaPort, &DmaPort::sendDma> backoffEvent;
138
139  public:
140    DmaPort(DmaDevice *dev, System *s);
141
142    void dmaAction(Packet::Command cmd, Addr addr, int size, Event *event,
143                   uint8_t *data = NULL);
144
145    bool dmaPending() { return pendingCount > 0; }
146
147    int cacheBlockSize() { return peerBlockSize(); }
148    unsigned int drain(Event *de);
149};
150
151/**
152 * This device is the base class which all devices senstive to an address range
153 * inherit from. There are three pure virtual functions which all devices must
154 * implement addressRanges(), read(), and write(). The magic do choose which
155 * mode we are in, etc is handled by the PioPort so the device doesn't have to
156 * bother.
157 */
158class PioDevice : public MemObject
159{
160  protected:
161
162    /** The platform we are in. This is used to decide what type of memory
163     * transaction we should perform. */
164    Platform *platform;
165
166    System *sys;
167
168    /** The pioPort that handles the requests for us and provides us requests
169     * that it sees. */
170    PioPort *pioPort;
171
172    virtual void addressRanges(AddrRangeList &range_list) = 0;
173
174    /** Pure virtual function that the device must implement. Called
175     * when a read command is recieved by the port.
176     * @param pkt Packet describing this request
177     * @return number of ticks it took to complete
178     */
179    virtual Tick read(PacketPtr pkt) = 0;
180
181    /** Pure virtual function that the device must implement. Called when a
182     * write command is recieved by the port.
183     * @param pkt Packet describing this request
184     * @return number of ticks it took to complete
185     */
186    virtual Tick write(PacketPtr pkt) = 0;
187
188  public:
189    /** Params struct which is extended through each device based on
190     * the parameters it needs. Since we are re-writing everything, we
191     * might as well start from the bottom this time. */
192    struct Params
193    {
194        std::string name;
195        Platform *platform;
196        System *system;
197    };
198
199  protected:
200    Params *_params;
201
202  public:
203    const Params *params() const { return _params; }
204
205    PioDevice(Params *p)
206              : MemObject(p->name),  platform(p->platform), sys(p->system),
207              pioPort(NULL), _params(p)
208              {}
209
210    virtual ~PioDevice();
211
212    virtual void init();
213
214    virtual unsigned int drain(Event *de);
215
216    virtual Port *getPort(const std::string &if_name, int idx = -1)
217    {
218        if (if_name == "pio") {
219            if (pioPort != NULL)
220                panic("pio port already connected to.");
221            pioPort = new PioPort(this, sys);
222            return pioPort;
223        } else
224            return NULL;
225    }
226    friend class PioPort;
227
228};
229
230class BasicPioDevice : public PioDevice
231{
232  public:
233    struct Params :  public PioDevice::Params
234    {
235        Addr pio_addr;
236        Tick pio_delay;
237    };
238
239  protected:
240    /** Address that the device listens to. */
241    Addr pioAddr;
242
243    /** Size that the device's address range. */
244    Addr pioSize;
245
246    /** Delay that the device experinces on an access. */
247    Tick pioDelay;
248
249  public:
250    BasicPioDevice(Params *p)
251        : PioDevice(p), pioAddr(p->pio_addr), pioSize(0),
252          pioDelay(p->pio_delay)
253    {}
254
255    /** return the address ranges that this device responds to.
256     * @param range_list range list to populate with ranges
257     */
258    void addressRanges(AddrRangeList &range_list);
259
260};
261
262class DmaDevice : public PioDevice
263{
264  public:
265    struct Params :  public PioDevice::Params
266    {
267        Tick min_backoff_delay;
268        Tick max_backoff_delay;
269    };
270
271   protected:
272    DmaPort *dmaPort;
273    Tick minBackoffDelay;
274    Tick maxBackoffDelay;
275
276  public:
277    DmaDevice(Params *p);
278    virtual ~DmaDevice();
279
280    void dmaWrite(Addr addr, int size, Event *event, uint8_t *data)
281    {
282        dmaPort->dmaAction(MemCmd::WriteInvalidateReq,
283                           addr, size, event, data);
284    }
285
286    void dmaRead(Addr addr, int size, Event *event, uint8_t *data)
287    {
288        dmaPort->dmaAction(MemCmd::ReadReq, addr, size, event, data);
289    }
290
291    bool dmaPending() { return dmaPort->dmaPending(); }
292
293    virtual unsigned int drain(Event *de);
294
295    int cacheBlockSize() { return dmaPort->cacheBlockSize(); }
296
297    virtual Port *getPort(const std::string &if_name, int idx = -1)
298    {
299        if (if_name == "pio") {
300            if (pioPort != NULL)
301                panic("pio port already connected to.");
302            pioPort = new PioPort(this, sys);
303            return pioPort;
304        } else if (if_name == "dma") {
305            if (dmaPort != NULL)
306                panic("dma port already connected to.");
307            dmaPort = new DmaPort(this, sys);
308            return dmaPort;
309        } else
310            return NULL;
311    }
312
313    friend class DmaPort;
314};
315
316
317#endif // __DEV_IO_DEVICE_HH__
318