rogue
Loading...
Searching...
No Matches
SrpV3.cpp
Go to the documentation of this file.
1
17#include "rogue/Directives.h"
18
20
21#include <inttypes.h>
22#include <stdint.h>
23
24#include <cstring>
25#include <memory>
26#include <thread>
27
28#include "rogue/GilRelease.h"
29#include "rogue/Logging.h"
39
40namespace rps = rogue::protocols::srp;
43
44#ifndef NO_PYTHON
45 #include <boost/python.hpp>
46namespace bp = boost::python;
47#endif
48
50rps::SrpV3Ptr rps::SrpV3::create() {
51 rps::SrpV3Ptr p = std::make_shared<rps::SrpV3>();
52 return (p);
53}
54
56void rps::SrpV3::setup_python() {
57#ifndef NO_PYTHON
58 bp::class_<rps::SrpV3, rps::SrpV3Ptr, bp::bases<ris::Master, ris::Slave, rim::Slave>, boost::noncopyable>(
59 "SrpV3",
60 bp::init<>())
61 .def("_setHardwareTimeout", &rps::SrpV3::setHardwareTimeout);
62 bp::implicitly_convertible<rps::SrpV3Ptr, ris::MasterPtr>();
63 bp::implicitly_convertible<rps::SrpV3Ptr, ris::SlavePtr>();
64 bp::implicitly_convertible<rps::SrpV3Ptr, rim::SlavePtr>();
65#endif
66}
67
69rps::SrpV3::SrpV3() : ris::Master(), ris::Slave(), rim::Slave(4, 4096) {
70 log_ = rogue::Logging::create("SrpV3");
71}
72
74rps::SrpV3::~SrpV3() {}
75
77void rps::SrpV3::setHardwareTimeout(uint8_t val) {
78 timeout_ = val;
79}
80
82bool rps::SrpV3::setupHeader(rim::TransactionPtr tran, uint32_t* header, uint32_t& frameLen, bool tx) {
83 bool doWrite = true;
84
85 // Bits 7:0 of first 32-bit word are version
86 header[0] = 0x03;
87
88 // Bits 9:8: 0x0 = read, 0x1 = write, 0x2 = posted write
89 switch (tran->type()) {
90 case rim::Write:
91 header[0] |= 0x100;
92 break;
93 case rim::Post:
94 header[0] |= 0x200;
95 break;
96 default:
97 doWrite = false;
98 break; // Read or verify
99 }
100
101 // Bits 13:10 not used in gen frame
102 // Bit 14 = ignore mem resp
103 // Bit 23:15 = Unused
104 // Bit 31:24 = timeout count
105 header[0] |= (timeout_ << 24 | 0x00000000);
106
107 // Header word 1, transaction ID
108 header[1] = tran->id();
109
110 // Header word 2, lower address
111 header[2] = tran->address() & 0xFFFFFFFF;
112
113 // Header word 3, upper address
114 header[3] = (tran->address() >> 32) & 0xFFFFFFFF;
115
116 // Header word 4, request size
117 header[4] = tran->size() - 1;
118
119 // Determine frame length
120 frameLen = HeadLen;
121
122 // Transmit with write data
123 if (tx && doWrite) frameLen += tran->size();
124
125 // Receive frames
126 else if (!tx)
127 frameLen += tran->size() + TailLen;
128
129 return doWrite;
130}
131
133void rps::SrpV3::doTransaction(rim::TransactionPtr tran) {
134 ris::FrameIterator fIter;
135 rim::Transaction::iterator tIter;
136 ris::FramePtr frame;
137 uint32_t frameSize;
138 uint32_t header[HeadLen / 4];
139 bool doWrite;
140
141 // Size error
142 if ((tran->address() % min()) != 0) {
143 tran->error("Transaction address 0x%" PRIx64 " is not aligned to min size %" PRIu32, tran->address(), min());
144 return;
145 }
146
147 // Size error
148 if ((tran->size() % min()) != 0 || tran->size() < min()) {
149 tran->error("Transaction size 0x%" PRIx32 " is not aligned to min size %" PRIu32, tran->size(), min());
150 return;
151 }
152
153 if (tran->size() > max()) {
154 tran->error("Transaction size %" PRIu32 " exceeds max size %" PRIu32, tran->size(), max());
155 return;
156 }
157
158 // Compute header and frame size
159 doWrite = setupHeader(tran, header, frameSize, true);
160
161 // Request frame
162 frame = reqFrame(frameSize, true);
163 frame->setPayload(frameSize);
164
165 // Setup iterators
166 rogue::GilRelease noGil;
167 rim::TransactionLockPtr lock = tran->lock();
168 fIter = frame->begin();
169 tIter = tran->begin();
170
171 // Write header
172 ris::toFrame(fIter, HeadLen, header);
173
174 // Write data
175 if (doWrite) ris::toFrame(fIter, tran->size(), tIter);
176
177 if (tran->type() == rim::Post)
178 tran->done();
179 else
180 addTransaction(tran);
181
182 log_->debug("Send frame for id=%" PRIu32 ", addr 0x%0.8" PRIx64 ". Size=%" PRIu32 ", type=%" PRIu32,
183 tran->id(),
184 tran->address(),
185 tran->size(),
186 tran->type());
187 log_->debug("Send frame for id=%" PRIu32 ", header: 0x%0.8" PRIx32 " 0x%0.8" PRIx32 " 0x%0.8" PRIx32
188 " 0x%0.8" PRIx32 " 0x%0.8" PRIx32,
189 tran->id(),
190 header[0],
191 header[1],
192 header[2],
193 header[3],
194 header[4]);
195
196 // Serialization and response registration (or posted completion) are done.
197 // Downstream backpressure must not hold the transaction lock: receiving an
198 // earlier response can need this lock while refreshing pending timers.
199 lock.reset();
200 sendFrame(frame);
201}
202
204void rps::SrpV3::acceptFrame(ris::FramePtr frame) {
205 ris::FrameIterator fIter;
206 rim::Transaction::iterator tIter;
208 uint32_t header[HeadLen / 4];
209 uint32_t expHeader[HeadLen / 4];
210 uint32_t expFrameLen;
211 uint32_t tail[TailLen / 4];
212 uint32_t id;
213 bool doWrite;
214 uint32_t fSize;
215
216 rogue::GilRelease noGil;
217 ris::FrameLockPtr frLock = frame->lock();
218
219 if (frame->getError()) {
220 log_->warning("Got errored frame = 0x%" PRIx8, frame->getError());
221 return; // Invalid frame, drop it
222 }
223
224 // Check frame size
225 if ((fSize = frame->getPayload()) < (HeadLen + TailLen)) {
226 log_->warning("Got undersized frame size = %" PRIu32, fSize);
227 return; // Invalid frame, drop it
228 }
229
230 // Get the tail
231 fIter = frame->end() - TailLen;
232 ris::fromFrame(fIter, TailLen, tail);
233
234 // Get the header
235 fIter = frame->begin();
236 ris::fromFrame(fIter, HeadLen, header);
237
238 // Extract the id
239 id = header[1];
240 log_->debug("Got frame id=%" PRIu32 ", header: 0x%0.8" PRIx32 " 0x%0.8" PRIx32 " 0x%0.8" PRIx32 " 0x%0.8" PRIx32
241 " 0x%0.8" PRIx32 " tail: 0x%0.8" PRIx32,
242 id,
243 header[0],
244 header[1],
245 header[2],
246 header[3],
247 header[4],
248 tail[0]);
249
250 // Find Transaction
251 if ((tran = getTransaction(id)) == NULL) {
252 log_->warning("Failed to find transaction id=%" PRIu32
253 ". ver=%" PRIu32 ", type=%" PRIu32,
254 id,
255 static_cast<uint32_t>(header[0] & 0xFF),
256 static_cast<uint32_t>((header[0] >> 8) & 0x3));
257 return; // Bad id or post, drop frame
258 }
259
260 // Lock transaction
261 rim::TransactionLockPtr lock = tran->lock();
262
263 // Transaction expired
264 if (tran->expired()) {
265 tran->error("Transaction expired: Id=%" PRIu32
266 " (increase root->timeout value if this ID matches a previous timeout message)",
267 id);
268 return;
269 }
270 tIter = tran->begin();
271
272 // Setup expect header and length
273 doWrite = setupHeader(tran, expHeader, expFrameLen, false);
274
275 // Check header
276 if (((header[0] & 0xFFFFC3FF) != expHeader[0]) || (header[1] != expHeader[1]) || (header[2] != expHeader[2]) ||
277 (header[3] != expHeader[3]) || (header[4] != expHeader[4])) {
278 log_->warning("Bad header for %" PRIu32, id);
279 tran->error("Received SRPV3 message did not match expected protocol. "
280 "id=%" PRIu32 ", addr=0x%08" PRIx32 "%08" PRIx32,
281 id, header[3], header[2]);
282 return;
283 }
284
285 // Check tail
286 if (tail[0] != 0) {
287 if (tail[0] & 0x2000)
288 tran->error("FPGA register bus lockup detected in hardware. Power cycle required.");
289 else if (tail[0] & 0x0100)
290 tran->error("FPGA register bus timeout detected in hardware");
291 else
292 tran->error("Non zero status message returned on fpga register bus in hardware: 0x%" PRIx32, tail[0]);
293 log_->warning("Error detected for ID id=%" PRIu32 ", tail=0x%0.8" PRIx32, id, tail[0]);
294 return;
295 }
296
297 // Verify frame size, drop frame
298 if ((fSize != expFrameLen) || (header[4] + 1) != tran->size()) {
299 log_->warning("Size mismatch id=%" PRIu32 ". fsize=%" PRIu32 ", exp=%" PRIu32 ", tsize=%" PRIu32
300 ", header=%" PRIu32,
301 id,
302 fSize,
303 expFrameLen,
304 tran->size(),
305 header[4] + 1);
306 tran->error("Received SRPV3 message had a header size mismatch. "
307 "id=%" PRIu32 ", frameSize=%" PRIu32 ", expectedSize=%" PRIu32
308 ", tranSize=%" PRIu32 ", headerSize=%" PRIu32,
309 id, fSize, expFrameLen, tran->size(), header[4] + 1);
310 return;
311 }
312
313 // Copy data if read
314 if (!doWrite) ris::fromFrame(fIter, tran->size(), tIter);
315
316 tran->done();
317}
RAII helper that releases the Python GIL for a scope.
Definition GilRelease.h:36
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
Definition Logging.cpp:95
Random-access byte iterator across a Frame payload.
std::shared_ptr< rogue::interfaces::memory::TransactionLock > TransactionLockPtr
Shared pointer alias for TransactionLock.
static const uint32_t Write
Memory write transaction type.
Definition Constants.h:43
std::shared_ptr< rogue::interfaces::memory::Transaction > TransactionPtr
Shared pointer alias for Transaction.
static const uint32_t Post
Memory posted write transaction type.
Definition Constants.h:50
static void fromFrame(rogue::interfaces::stream::FrameIterator &iter, uint32_t size, void *dst)
Copies bytes from a frame iterator to a destination pointer.
std::shared_ptr< rogue::interfaces::stream::Frame > FramePtr
Shared pointer alias for Frame.
Definition Frame.h:549
static void toFrame(rogue::interfaces::stream::FrameIterator &iter, uint32_t size, void *src)
Copies bytes from a source pointer into a frame iterator.
std::shared_ptr< rogue::interfaces::stream::FrameLock > FrameLockPtr
Shared pointer alias for FrameLock.
Definition FrameLock.h:110
std::shared_ptr< rogue::protocols::srp::SrpV3 > SrpV3Ptr
Definition SrpV3.h:168