[cru] Add Register Sequence service for UL configuration

Author: kostorr

README.md

@@ -61,25 +61,28 @@ The services are DIM RPC services. Every RPC is called with a string and expects
 * Lines prefixed with `#` are disregarded as comments.
 
 #### CRU
-##### REGISTER_READ
-* Parameter:
-  * Register address
-* Returns:
-  * Register value
+##### REGISTER_SEQUENCE
+* Parameters:
+   * Operations may be:
+     * `write` with address and value (e.g. `0x0000f00d,0x0000beef`)
+     * `read` with address (e.g `0x0000cafe`)
 
+* Returns:
+   * `write` always retuns `0`
+   * `read` returns the value read from the register
+    
 * Example:
-  * DIM input: `0x0000f00d`
-  * DIM output: `0x0000beef`
-
+  * DIM input `0xc00004\n0x00c00008, 0x0000beef\n0x00c00008`
+  * DIM output `0xcafe\n0\n0xbeef\n`
 ##### REGISTER_WRITE
 * Parameters:
-  * Register address
+  * Register address (within the range [`0x00c00000-0x00cfffff`])
   * Register value
 * Returns:
   * empty
 
 * Example:
-  * DIM input: `0x0000f00d,0x0000beef`
+  * DIM input: `0x00c0f00d,0x0000beef`
   * DIM output: ` `
 
 ##### SCA_SEQUENCE

apps/AlfClient.cxx

@@ -138,8 +138,7 @@ class AlfClient : public AliceO2::Common::Program
     }
 
     // Only CRU from this point forward
-    RegisterReadRpc registerReadRpc(names.registerRead());
-    RegisterWriteRpc registerWriteRpc(names.registerWrite());
+    RegisterSequenceRpc registerSequence(names.registerSequence());
     PatternPlayerRpc patternPlayerRpc(names.patternPlayer());
     LlaSessionStartRpc llaSessionStartRpc(names.llaSessionStart());
     LlaSessionStopRpc llaSessionStopRpc(names.llaSessionStop());
@@ -149,13 +148,15 @@ class AlfClient : public AliceO2::Common::Program
     IcSequenceRpc icSequence(names.icSequence());
     IcGbtI2cWriteRpc icGbtI2cWriteRpc(names.icGbtI2cWrite());
 
-    // Test register write and read
-    uint32_t wAddress = 0x00f00078;
-    uint32_t wValue = 0x4;
-    uint32_t rAddress = 0x00f0005c;
-    registerWriteRpc.writeRegister(wAddress, wValue);
-    uint32_t rValue = registerReadRpc.readRegister(rAddress);
-    std::cout << "[REGISTER] Wrote: " << Util::formatValue(wValue) << " Read: " << Util::formatValue(rValue) << std::endl;
+    // Test register sequence
+    auto regOut = registerSequence.write({ std::make_pair("0x00c00000", ""),
+                                           std::make_pair("0x00c00004", ""),
+                                           std::make_pair("0x00c00008", ""),
+                                           std::make_pair("0x00cfffff", "0x00080000"),
+                                           std::make_pair("0x00c00004", "0x00080000"),
+                                           std::make_pair("0x00c00004", ""),
+                                           std::make_pair("0x0badadd7", "") });
+    std::cout << "[REGISTER SEQUENCE] output: " << regOut << std::endl;
 
     if (mOptions.swt) {
       auto swtOut = swtSequence.write({ std::make_pair("", "lock"),

src/AlfServer.cxx

@@ -32,32 +32,7 @@ AlfServer::AlfServer() : mRpcServers()
 {
 }
 
-std::string AlfServer::registerRead(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar)
-{
-  uint32_t address = Util::stringToHex(parameter); // Error from here will get picked up by the StringRpcServer try clause
-  //Util::checkAddress(address);
-
-  uint32_t value = bar->readRegister(address / 4);
-  return Util::formatValue(value);
-}
-
-std::string AlfServer::registerWrite(const std::string& parameter, std::shared_ptr<roc::BarInterface> bar)
-{
-  std::vector<std::string> params = Util::split(parameter, pairSeparator());
-
-  if (params.size() != 2) {
-    BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Wrong number of parameters for RPC write call"));
-  }
-
-  uint32_t address = Util::stringToHex(params[0]);
-  //Util::checkAddress(address);
-  uint32_t value = Util::stringToHex(params[1]);
-
-  bar->writeRegister(address / 4, value);
-  return "";
-}
-
-std::string AlfServer::registerBlobWrite(const std::string& parameter, AlfLink link)
+std::string AlfServer::registerBlobWrite(const std::string& parameter, AlfLink link, bool isCru)
 {
   std::vector<std::string> stringPairs = Util::split(parameter, argumentSeparator());
   std::vector<std::vector<uint32_t>> registerPairs = parseStringToRegisterPairs(stringPairs);
@@ -66,6 +41,14 @@ std::string AlfServer::registerBlobWrite(const std::string& parameter, AlfLink l
   uint32_t address;
   for (const auto& registerPair : registerPairs) {
     address = registerPair.at(0);
+    // If it's a CRU, check address range
+    if (isCru && (address < 0x00c00000 || address > 0x00cfffff)) {
+      resultBuffer << "Illegal address 0x" << std::hex << address
+                   << ", allowed: [0x00c0_0000-0x00cf_ffff]"
+                   << "\n";
+      BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message(resultBuffer.str()));
+    }
+
     if (registerPair.size() == 1) {
       value = link.bar->readRegister(address / 4);
       resultBuffer << Util::formatValue(value) << "\n";
@@ -588,13 +571,10 @@ void AlfServer::makeRpcServers(std::vector<AlfLink> links)
       }
 
       if (link.linkId == 0 && link.serialId.getEndpoint() == 0) { // Services per card
-        // Register Read
-        servers.push_back(makeServer(names.registerRead(),
-                                     [bar](auto parameter) { return registerRead(parameter, bar); }));
-        // Register Write
-        servers.push_back(makeServer(names.registerWrite(),
-                                     [bar](auto parameter) { return registerWrite(parameter, bar); }));
 
+        // Register Sequence
+        servers.push_back(makeServer(names.registerSequence(),
+                                     [link](auto parameter) { return registerBlobWrite(parameter, link, true); }));
         // Pattern Player
         servers.push_back(makeServer(names.patternPlayer(),
                                      [bar](auto parameter) { return patternPlayer(parameter, bar); }));

src/AlfServer.h

@@ -49,15 +49,13 @@ class AlfServer
   void makeRpcServers(std::vector<AlfLink> links);
 
  private:
-  static std::string registerRead(const std::string& parameter, std::shared_ptr<roc::BarInterface>);
-  static std::string registerWrite(const std::string& parameter, std::shared_ptr<roc::BarInterface>);
   std::string scaBlobWrite(const std::string& parameter, AlfLink link);
   std::string scaMftPsuBlobWrite(const std::string& parameter, AlfLink link);
   std::string swtBlobWrite(const std::string& parameter, AlfLink link);
   std::string icBlobWrite(const std::string& parameter, AlfLink link);
   std::string icGbtI2cWrite(const std::string& parameter, AlfLink link);
   static std::string patternPlayer(const std::string& parameter, std::shared_ptr<roc::BarInterface>);
-  static std::string registerBlobWrite(const std::string& parameter, AlfLink link);
+  static std::string registerBlobWrite(const std::string& parameter, AlfLink link, bool isCru = false);
   std::string llaSessionStart(const std::string& parameter, roc::SerialId serialId);
   std::string llaSessionStop(const std::string& parameter, roc::SerialId serialId);
 

src/DimServices/ServiceNames.cxx

@@ -38,8 +38,6 @@ namespace alf
 DEFCARDSERVICENAME(patternPlayer, "PATTERN_PLAYER")
 DEFCARDSERVICENAME(llaSessionStart, "LLA_SESSION_START")
 DEFCARDSERVICENAME(llaSessionStop, "LLA_SESSION_STOP")
-DEFCARDSERVICENAME(registerRead, "REGISTER_READ")
-DEFCARDSERVICENAME(registerWrite, "REGISTER_WRITE")
 
 DEFLINKSERVICENAME(scaSequence, "SCA_SEQUENCE")
 DEFLINKSERVICENAME(scaMftPsuSequence, "SCA_MFT_PSU_SEQUENCE")

src/DimServices/ServiceNames.h

@@ -33,8 +33,6 @@ class ServiceNames
   {
   }
 
-  std::string registerRead() const;
-  std::string registerWrite() const;
   std::string scaSequence() const;
   std::string scaMftPsuSequence() const;
   std::string swtSequence() const;