Skip to content

Commit 6c65d4e

Browse files
kostorrkostorr
committed
[crorc] Add Register Sequence support for the CRORC
1 parent a6e5eb9 commit 6c65d4e

File tree

13 files changed

+196
-76
lines changed

13 files changed

+196
-76
lines changed

‎README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -94,7 +94,7 @@ The services are DIM RPC services. Every RPC is called with a string and expects
9494

9595
* Example:
9696
* DIM input `reset\n0x0000000000badc0ffee,write\nread\n0xbadf00d,write\n4,read`
97-
* DIM output `0\n0x0000000000badc0ffee\n0x000000000000badf00d\n`
97+
* DIM output `0\n0x0000000000badc0ffee\n0\n0x000000000000badf00d\n`
9898

9999
#### IC_SEQUENCE
100100

‎apps/Alf.cxx‎

Lines changed: 23 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -87,39 +87,45 @@ class Alf : public AliceO2::Common::Program
8787
AlfServer alfServer = AlfServer();
8888

8989
std::vector<roc::CardDescriptor> cardsFound = roc::findCards();
90-
int cruSequence = -1;
90+
int cardSequence = -1;
9191
for (auto const& card : cardsFound) {
9292
std::vector<AlfLink> links;
9393

94-
std::shared_ptr<roc::BarInterface> bar2;
94+
std::shared_ptr<roc::BarInterface> bar;
9595

9696
// Make the RPC services for every card & link
97-
if (card.cardType == roc::CardType::Cru) {
98-
99-
if (!mOptions.noFirmwareCheck) {
100-
try {
101-
roc::FirmwareChecker().checkFirmwareCompatibility(card.pciAddress);
102-
} catch (const roc::Exception& e) {
103-
getWarningLogger() << boost::diagnostic_information(e) << endm;
104-
continue;
105-
}
97+
if (!mOptions.noFirmwareCheck) {
98+
try {
99+
roc::FirmwareChecker().checkFirmwareCompatibility(card.pciAddress);
100+
} catch (const roc::Exception& e) {
101+
getWarningLogger() << boost::diagnostic_information(e) << endm;
102+
continue;
106103
}
104+
}
107105

108-
cruSequence++;
106+
cardSequence++;
109107

110-
getLogger() << "CRU #" << cruSequence << " : " << card.pciAddress << endm;
111-
bar2 = roc::ChannelFactory().getBar(card.pciAddress, 2);
108+
if (card.cardType == roc::CardType::Cru) {
109+
110+
getLogger() << "CRU #" << cardSequence << " : " << card.pciAddress << endm;
111+
bar = roc::ChannelFactory().getBar(card.pciAddress, 2);
112112
for (int linkId = 0; linkId < CRU_NUM_LINKS; linkId++) {
113-
links.push_back({ alfId, cruSequence, linkId, bar2 });
113+
links.push_back({ alfId, cardSequence, linkId, bar, roc::CardType::Cru });
114114
}
115115

116+
} else if (card.cardType == roc::CardType::Crorc) {
117+
getLogger() << "CRORC #" << cardSequence << " : " << card.pciAddress << endm;
118+
for (int linkId = 0; linkId < CRORC_NUM_LINKS; linkId++) {
119+
bar = roc::ChannelFactory().getBar(card.pciAddress, linkId);
120+
links.push_back({ alfId, cardSequence, linkId, bar, roc::CardType::Crorc });
121+
}
116122
} else {
117-
getLogger() << InfoLogger::InfoLogger::Severity::Warning << card.pciAddress << " is not a CRU. Skipping..." << endm;
123+
getLogger() << InfoLogger::InfoLogger::Severity::Warning << card.pciAddress << " is not a CRU or a CRORC. Skipping..." << endm;
118124
}
119125

120126
if (isVerbose()) {
121127
for (auto const& link : links) {
122-
getLogger() << link.alfId << " " << link.cruSequence << " " << link.linkId << endm;
128+
getLogger() << link.alfId << " " << link.cardSequence << " " << link.linkId << endm;
123129
}
124130
}
125131

‎apps/AlfClient.cxx‎

Lines changed: 25 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -53,15 +53,18 @@ class AlfClient : public AliceO2::Common::Program
5353
options.add_options()("dim-dns-node",
5454
po::value<std::string>(&mOptions.dimDnsNode)->default_value(""),
5555
"The DIM DNS node to connect to if the env var is not set");
56-
options.add_options()("cru-sequence",
57-
po::value<int>(&mOptions.cruSequence),
58-
"CRU sequence number");
56+
options.add_options()("card-sequence",
57+
po::value<int>(&mOptions.cardSequence),
58+
"Card sequence number");
5959
options.add_options()("link",
6060
po::value<int>(&mOptions.link),
6161
"Link number");
6262
options.add_options()("alf-id",
6363
po::value<std::string>(&mOptions.alfId)->default_value(""),
6464
"Hostname of node running the ALF server(required)");
65+
options.add_options()("crorc",
66+
po::bool_switch(&mOptions.crorc)->default_value(false),
67+
"Flag enabling the test of the crorc (exclusive)");
6568
options.add_options()("ic",
6669
po::bool_switch(&mOptions.ic)->default_value(false),
6770
"Flag enabling the ic tests");
@@ -109,11 +112,26 @@ class AlfClient : public AliceO2::Common::Program
109112
std::string alfId = mOptions.alfId;
110113
boost::to_upper(alfId);
111114

112-
getLogger() << "Starting the DIM Client using ALF ID=" << alfId << ", cru #=" << mOptions.cruSequence << " and link=" << mOptions.link << endm;
115+
getLogger() << "Starting the DIM Client using ALF ID=" << alfId << ", card #=" << mOptions.cardSequence << " and link=" << mOptions.link << endm;
113116

114-
AlfLink link = AlfLink{ alfId, mOptions.cruSequence, mOptions.link, nullptr };
117+
AlfLink link = AlfLink{ alfId, mOptions.cardSequence, mOptions.link, nullptr, roc::CardType::Cru };
115118

116119
ServiceNames names(link);
120+
121+
if (mOptions.crorc) {
122+
link.cardType = roc::CardType::Crorc;
123+
Alf::RegisterSequenceRpc registerSequence(names.registerSequence());
124+
auto regOut = registerSequence.write({ std::make_pair("0x19c", ""),
125+
std::make_pair("0xa0", ""),
126+
std::make_pair("0x1f0", ""),
127+
std::make_pair("0x1f0", "0x00080000"),
128+
std::make_pair("0x1f0", "") });
129+
getLogger() << "[REGISTER SEQUENCE] output: " << regOut << endm;
130+
131+
return;
132+
}
133+
134+
// Only CRU from this point forward
117135
Alf::RegisterReadRpc registerReadRpc(names.registerRead());
118136
Alf::RegisterWriteRpc registerWriteRpc(names.registerWrite());
119137
Alf::PatternPlayerRpc patternPlayerRpc(names.patternPlayer());
@@ -214,9 +232,10 @@ class AlfClient : public AliceO2::Common::Program
214232
private:
215233
struct OptionsStruct {
216234
std::string dimDnsNode = "";
217-
int cruSequence = -1;
235+
int cardSequence = -1;
218236
int link = -1;
219237
std::string alfId = "";
238+
bool crorc = false;
220239
bool ic = false;
221240
bool sca = false;
222241
bool swt = false;

‎src/AlfClient.h‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -144,6 +144,45 @@ class ScaSequenceRpc : DimRpcInfoWrapper
144144
}
145145
};
146146

147+
class RegisterSequenceRpc : DimRpcInfoWrapper
148+
{
149+
public:
150+
RegisterSequenceRpc(const std::string& serviceName)
151+
: DimRpcInfoWrapper(serviceName)
152+
{
153+
}
154+
155+
std::string write(const std::string& buffer)
156+
{
157+
std::cout << "Setting: " << buffer << std::endl;
158+
setString(buffer);
159+
std::string ret;
160+
try {
161+
ret = getString();
162+
} catch (const AlfException& e) {
163+
getErrorLogger() << "RegisterSequence: " << boost::diagnostic_information(e, true) << endm;
164+
return errString;
165+
}
166+
return ret;
167+
}
168+
169+
std::string write(const std::vector<std::pair<std::string, std::string>>& sequence)
170+
{
171+
std::stringstream buffer;
172+
for (size_t i = 0; i < sequence.size(); ++i) {
173+
if (sequence[i].second == "") { // It's a read
174+
buffer << sequence[i].first;
175+
} else { //It's a write
176+
buffer << sequence[i].first << pairSeparator() << sequence[i].second;
177+
}
178+
if (i + 1 < sequence.size()) {
179+
buffer << argumentSeparator();
180+
}
181+
}
182+
return write(buffer.str());
183+
}
184+
};
185+
147186
class SwtSequenceRpc : DimRpcInfoWrapper
148187
{
149188
public:

‎src/AlfServer.cxx‎

Lines changed: 82 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -33,16 +33,16 @@ AlfServer::AlfServer() : mRpcServers()
3333
{
3434
}
3535

36-
std::string AlfServer::registerRead(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar2)
36+
std::string AlfServer::registerRead(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar)
3737
{
3838
uint32_t address = Util::stringToHex(parameter); // Error from here will get picked up by the StringRpcServer try clause
3939
//Util::checkAddress(address);
4040

41-
uint32_t value = bar2->readRegister(address / 4);
41+
uint32_t value = bar->readRegister(address / 4);
4242
return Util::formatValue(value);
4343
}
4444

45-
std::string AlfServer::registerWrite(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar2)
45+
std::string AlfServer::registerWrite(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar)
4646
{
4747
std::vector<std::string> params = Util::split(parameter, pairSeparator());
4848

@@ -54,10 +54,32 @@ std::string AlfServer::registerWrite(const std::string& parameter, std::shared_p
5454
//Util::checkAddress(address);
5555
uint32_t value = Util::stringToHex(params[1]);
5656

57-
bar2->writeRegister(address / 4, value);
57+
bar->writeRegister(address / 4, value);
5858
return "";
5959
}
6060

61+
std::string AlfServer::registerBlobWrite(const std::string& parameter, AlfLink link)
62+
{
63+
std::vector<std::string> stringPairs = Util::split(parameter, argumentSeparator());
64+
std::vector<std::vector<uint32_t>> registerPairs = parseStringToRegisterPairs(stringPairs);
65+
std::stringstream resultBuffer;
66+
uint32_t value;
67+
uint32_t address;
68+
for (const auto& registerPair : registerPairs) {
69+
address = registerPair.at(0);
70+
if (registerPair.size() == 1) {
71+
value = link.bar->readRegister(address / 4);
72+
resultBuffer << Util::formatValue(value) << "\n";
73+
} else if (registerPair.size() == 2) {
74+
value = registerPair.at(1);
75+
link.bar->writeRegister(address / 4, value);
76+
resultBuffer << "0"
77+
<< "\n";
78+
}
79+
}
80+
return resultBuffer.str();
81+
}
82+
6183
std::string AlfServer::scaBlobWrite(const std::string& parameter, AlfLink link)
6284
{
6385
std::vector<std::string> stringPairs = Util::split(parameter, argumentSeparator());
@@ -177,6 +199,16 @@ roc::PatternPlayer::Info AlfServer::parseStringToPatternPlayerInfo(const std::ve
177199
return ppInfo;
178200
}
179201

202+
std::vector<uint32_t> AlfServer::stringToRegisterPair(const std::string stringPair)
203+
{
204+
std::vector<uint32_t> registers;
205+
auto stringRegisters = Util::split(stringPair, pairSeparator());
206+
for (const auto& stringRegister : stringRegisters) {
207+
registers.push_back(Util::stringToHex(stringRegister));
208+
}
209+
return registers;
210+
}
211+
180212
std::pair<Sca::Data, Sca::Operation> AlfServer::stringToScaPair(const std::string stringPair)
181213
{
182214
std::vector<std::string> scaPair = Util::split(stringPair, pairSeparator());
@@ -209,7 +241,6 @@ std::pair<Sca::Data, Sca::Operation> AlfServer::stringToScaPair(const std::strin
209241
/// Converts a 76-bit hex number string
210242
std::pair<Swt::Data, Swt::Operation> AlfServer::stringToSwtPair(const std::string stringPair)
211243
{
212-
std::cout << "trigger" << std::endl;
213244
std::vector<std::string> swtPair = Util::split(stringPair, pairSeparator());
214245
if (swtPair.size() < 1 || swtPair.size() > 2) {
215246
BOOST_THROW_EXCEPTION(
@@ -346,6 +377,17 @@ std::pair<Ic::IcData, Ic::Operation> AlfServer::stringToIcPair(const std::string
346377
return std::make_pair(icData, icOperation);
347378
}
348379

380+
std::vector<std::vector<uint32_t>> AlfServer::parseStringToRegisterPairs(std::vector<std::string> stringPairs)
381+
{
382+
std::vector<std::vector<uint32_t>> pairs;
383+
for (const auto& stringPair : stringPairs) {
384+
if (stringPair.find('#') == std::string::npos) {
385+
pairs.push_back(stringToRegisterPair(stringPair));
386+
}
387+
}
388+
return pairs;
389+
}
390+
349391
std::vector<std::pair<Sca::Data, Sca::Operation>> AlfServer::parseStringToScaPairs(std::vector<std::string> stringPairs)
350392
{
351393
std::vector<std::pair<Sca::Data, Sca::Operation>> pairs;
@@ -394,35 +436,42 @@ void AlfServer::makeRpcServers(std::vector<AlfLink> links)
394436
ServiceNames names(link);
395437

396438
// Start the RPC Servers
397-
auto& servers = mRpcServers[link.cruSequence][link.linkId];
398-
std::shared_ptr<roc::BarInterface> bar2 = link.bar2;
399-
400-
if (link.linkId == 0) { // Register Read / Write services are per card; register them as soon as possible
401-
// Register Read
402-
servers.push_back(makeServer(names.registerRead(),
403-
[bar2](auto parameter) { return registerRead(parameter, bar2); }));
404-
// Register Write
405-
servers.push_back(makeServer(names.registerWrite(),
406-
[bar2](auto parameter) { return registerWrite(parameter, bar2); }));
407-
408-
// Register Write
409-
servers.push_back(makeServer(names.patternPlayer(),
410-
[bar2](auto parameter) { return patternPlayer(parameter, bar2); }));
411-
}
439+
auto& servers = mRpcServers[link.cardSequence][link.linkId];
440+
std::shared_ptr<roc::BarInterface> bar = link.bar;
441+
442+
if (link.cardType == roc::CardType::Cru) {
443+
if (link.linkId == 0) { // Register Read / Write services are per card; register them as soon as possible
444+
// Register Read
445+
servers.push_back(makeServer(names.registerRead(),
446+
[bar](auto parameter) { return registerRead(parameter, bar); }));
447+
// Register Write
448+
servers.push_back(makeServer(names.registerWrite(),
449+
[bar](auto parameter) { return registerWrite(parameter, bar); }));
450+
451+
// Pattern Player
452+
servers.push_back(makeServer(names.patternPlayer(),
453+
[bar](auto parameter) { return patternPlayer(parameter, bar); }));
454+
}
412455

413-
// SCA Sequence
414-
servers.push_back(makeServer(names.scaSequence(),
415-
[link](auto parameter) { return scaBlobWrite(parameter, link); }));
416-
// SWT Sequence
417-
servers.push_back(makeServer(names.swtSequence(),
418-
[link](auto parameter) { return swtBlobWrite(parameter, link); }));
419-
// IC Sequence
420-
servers.push_back(makeServer(names.icSequence(),
421-
[link](auto parameter) { return icBlobWrite(parameter, link); }));
422-
423-
// IC GBT I2C write
424-
servers.push_back(makeServer(names.icGbtI2cWrite(),
425-
[link](auto parameter) { return icGbtI2cWrite(parameter, link); }));
456+
// SCA Sequence
457+
servers.push_back(makeServer(names.scaSequence(),
458+
[link](auto parameter) { return scaBlobWrite(parameter, link); }));
459+
// SWT Sequence
460+
servers.push_back(makeServer(names.swtSequence(),
461+
[link](auto parameter) { return swtBlobWrite(parameter, link); }));
462+
// IC Sequence
463+
servers.push_back(makeServer(names.icSequence(),
464+
[link](auto parameter) { return icBlobWrite(parameter, link); }));
465+
466+
// IC GBT I2C write
467+
servers.push_back(makeServer(names.icGbtI2cWrite(),
468+
[link](auto parameter) { return icGbtI2cWrite(parameter, link); }));
469+
470+
} else if (link.cardType == roc::CardType::Crorc) {
471+
// Register Sequence
472+
servers.push_back(makeServer(names.registerSequence(),
473+
[link](auto parameter) { return registerBlobWrite(parameter, link); }));
474+
}
426475
}
427476
}
428477

‎src/AlfServer.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,16 +50,19 @@ class AlfServer
5050
static std::string icBlobWrite(const std::string& parameter, AlfLink link);
5151
static std::string icGbtI2cWrite(const std::string& parameter, AlfLink link);
5252
static std::string patternPlayer(const std::string& parameter, std::shared_ptr<roc::BarInterface>);
53+
static std::string registerBlobWrite(const std::string& parameter, AlfLink link);
5354

55+
static std::vector<uint32_t> stringToRegisterPair(const std::string stringPair);
5456
static std::pair<Sca::Data, Sca::Operation> stringToScaPair(const std::string stringPair);
5557
static std::pair<Swt::Data, Swt::Operation> stringToSwtPair(const std::string stringPair);
5658
static std::pair<Ic::IcData, Ic::Operation> stringToIcPair(const std::string stringPair);
59+
static std::vector<std::vector<uint32_t>> parseStringToRegisterPairs(std::vector<std::string> stringPairs);
5760
static std::vector<std::pair<Sca::Data, Sca::Operation>> parseStringToScaPairs(std::vector<std::string> stringPairs);
5861
static std::vector<std::pair<Swt::Data, Swt::Operation>> parseStringToSwtPairs(std::vector<std::string> stringPairs);
5962
static std::vector<std::pair<Ic::IcData, Ic::Operation>> parseStringToIcPairs(std::vector<std::string> stringPairs);
6063
static roc::PatternPlayer::Info parseStringToPatternPlayerInfo(const std::vector<std::string> sringsPairs);
6164

62-
/// cruSequence -> link -> vector of RPC servers
65+
/// cardSequence -> link -> vector of RPC servers
6366
std::map<int, std::map<int, std::vector<std::unique_ptr<StringRpcServer>>>> mRpcServers;
6467
};
6568

‎src/Common.h‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919

2020
#include <chrono>
2121
#include "ReadoutCard/BarInterface.h"
22+
#include "ReadoutCard/CardType.h"
2223

2324
namespace AliceO2
2425
{
@@ -33,9 +34,10 @@ static constexpr auto CHANNEL_BUSY_TIMEOUT = std::chrono::milliseconds(10);
3334

3435
struct AlfLink {
3536
std::string alfId;
36-
int cruSequence;
37+
int cardSequence;
3738
int linkId;
38-
std::shared_ptr<roc::BarInterface> bar2;
39+
std::shared_ptr<roc::BarInterface> bar;
40+
roc::CardType::type cardType;
3941
};
4042

4143
} // namespace Alf

0 commit comments

Comments
 (0)