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;

--- 14 unchanged lines hidden (view full) ---

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 */
30
31/**
32 * @file
33 * Implement a port which adds simple support of a sendTiming() function that
34 * takes a delay. In this way the * device can immediatly call
35 * sendTiming(pkt, time) after processing a request and the request will be
36 * handled by the port even if the port bus the device connects to is blocked.
37 */
38
39/** recvTiming and drain should be implemented something like this when this
40 * class is used.
41
42bool
43PioPort::recvTiming(Packet *pkt)
44{
45 if (pkt->result == Packet::Nacked) {
46 resendNacked(pkt);
47 } else {
48 Tick latency = device->recvAtomic(pkt);
49 // turn packet around to go back to requester
50 pkt->makeTimingResponse();
51 sendTiming(pkt, latency);
52 }
53 return true;
54}
55
56PioDevice::drain(Event *de)
57{
58 unsigned int count;
59 count = SimpleTimingPort->drain(de);
60 if (count)
61 changeState(Draining);
62 else
63 changeState(Drained);
64 return count;
65}
66*/
67
68#ifndef __MEM_TPORT_HH__
69#define __MEM_TPORT_HH__
70
71#include "mem/port.hh"
72#include "sim/eventq.hh"
73#include <list>
74#include <string>
75
76class SimpleTimingPort : public Port
77{
78 protected:
79 /** A list of outgoing timing response packets that haven't been
80 * serviced yet. */
81 std::list<Packet*> transmitList;
82 /**
83 * This class is used to implemented sendTiming() with a delay. When
84 * a delay is requested a new event is created. When the event time
85 * expires it attempts to send the packet. If it cannot, the packet
86 * is pushed onto the transmit list to be sent when recvRetry() is
87 * called. */
88 class SendEvent : public Event
89 {

--- 17 unchanged lines hidden (view full) ---

107 */
108 int outTiming;
109
110 /** If we need to drain, keep the drain event around until we're done
111 * here.*/
112 Event *drainEvent;
113
114 /** Schedule a sendTiming() event to be called in the future. */
115 void sendTiming(Packet *pkt, Tick time)
116 { outTiming++; new SimpleTimingPort::SendEvent(this, pkt, time); }
117
118 /** This function is notification that the device should attempt to send a
119 * packet again. */
120 virtual void recvRetry();
121
122 void resendNacked(Packet *pkt);
123 public:
124
125 SimpleTimingPort(std::string pname)
126 : Port(pname), outTiming(0), drainEvent(NULL)
127 {}
128
129 unsigned int drain(Event *de);
130};
131
132#endif // __MEM_TPORT_HH__