1/*
2 * Copyright (c) 2002-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: Steve Reinhardt
29 */
30
31/**
32 * @file
33 * Port object definitions.
34 */
35#include <cstring>
36
37#include "base/chunk_generator.hh"
38#include "base/trace.hh"
39#include "mem/mem_object.hh"
40#include "mem/port.hh"
41
42/**
43 * Special class for port objects that are used as peers for
44 * unconnected ports. Assigning instances of this class to newly
45 * allocated ports allows us to guarantee that every port has a peer
46 * object (so there's no need to check for null peer pointers), while
47 * catching uses of unconnected ports.
48 */
49class DefaultPeerPort : public Port
50{
51 protected:
52 void blowUp()
53 {
54 Port *peer = getPeer();
55 fatal("unconnected port: %s", peer ? peer->name() : "<unknown>");
56 }
57
58 public:
59 DefaultPeerPort(Port *_peer)
60 : Port("default_port", NULL, _peer)
61 { }
62
63 bool recvTiming(PacketPtr)
64 {
65 blowUp();
66 return false;
67 }
68
69 Tick recvAtomic(PacketPtr)
70 {
71 blowUp();
72 return 0;
73 }
74
75 void recvFunctional(PacketPtr)
76 {
77 blowUp();
78 }
79
80 void recvStatusChange(Status)
81 {
82 blowUp();
83 }
84
85 int deviceBlockSize()
86 {
87 blowUp();
88 return 0;
89 }
90
91 void getDeviceAddressRanges(AddrRangeList &, bool &)
92 {
93 blowUp();
94 }
95
96 bool isDefaultPort() const { return true; }
97};
98
99
100Port::Port(const std::string &_name, MemObject *_owner, Port *_peer) :
101 portName(_name),
102 peer(_peer ? _peer : new DefaultPeerPort(this)),
103 owner(_owner)
104{
105}
106
107Port::~Port()
108{
109 disconnectFromPeer();
110}
111
112void
113Port::disconnectFromPeer()
114{
115 if (peer) {
116 assert(peer->getPeer() == this);
117 peer->disconnect();
118 }
119}
120
121void
122Port::disconnect()
123{
124 // This notification should come only from our peer, so we must
125 // have one,
126 assert(peer != NULL);
127 // We must clear 'peer' here, else if owner->deletePort() calls
128 // delete on us then we'll recurse infinitely through the Port
129 // destructor.
130 peer = NULL;
131 // If owner->deletePort() returns true, then we've been deleted,
132 // so don't do anything but get out of here. If not, reset peer
133 // pointer to a DefaultPeerPort.
134 if (!(owner && owner->deletePort(this)))
135 peer = new DefaultPeerPort(this);
136}
137
138void
139Port::setPeer(Port *port)
140{
141 DPRINTF(Config, "setting peer to %s, old peer %s\n",
142 port->name(), peer ? peer->name() : "<null>");
143
144 // You'd think we'd want to disconnect from the previous peer
145 // here, but it turns out that with some functional ports the old
146 // peer keeps using the connection, and it works because
147 // functional ports are unidirectional.
148 //
149 // disconnectFromPeer();
150
151 peer = port;
152}
153
154void
155Port::blobHelper(Addr addr, uint8_t *p, int size, MemCmd cmd)
156{
157 Request req;
158
159 for (ChunkGenerator gen(addr, size, peerBlockSize());
160 !gen.done(); gen.next()) {
161 req.setPhys(gen.addr(), gen.size(), 0);
162 Packet pkt(&req, cmd, Packet::Broadcast);
163 pkt.dataStatic(p);
164 sendFunctional(&pkt);
165 p += gen.size();
166 }
167}
168
169void
170Port::writeBlob(Addr addr, uint8_t *p, int size)
171{
172 blobHelper(addr, p, size, MemCmd::WriteReq);
173}
174
175void
176Port::readBlob(Addr addr, uint8_t *p, int size)
177{
178 blobHelper(addr, p, size, MemCmd::ReadReq);
179}
180
181void
182Port::memsetBlob(Addr addr, uint8_t val, int size)
183{
184 // quick and dirty...
185 uint8_t *buf = new uint8_t[size];
186
187 std::memset(buf, val, size);
188 blobHelper(addr, buf, size, MemCmd::WriteReq);
189
190 delete [] buf;
191}
192
193
194void
195Port::printAddr(Addr a)
196{
197 Request req(a, 1, 0);
198 Packet pkt(&req, MemCmd::PrintReq, Packet::Broadcast);
199 Packet::PrintReqState prs(std::cerr);
200 pkt.senderState = &prs;
201
202 sendFunctional(&pkt);
203}