[config] Initial support for CRORC

Author: kostorr

include/ReadoutCard/CardConfigurator.h

@@ -16,6 +16,7 @@
 #ifndef ALICEO2_INCLUDE_READOUTCARD_CARDCONFIGURATOR_H_
 #define ALICEO2_INCLUDE_READOUTCARD_CARDCONFIGURATOR_H_
 
+#include "ReadoutCard/CardType.h"
 #include "ReadoutCard/Parameters.h"
 
 namespace AliceO2
@@ -30,7 +31,9 @@ class CardConfigurator
   CardConfigurator(Parameters& parameters, bool forceConfigure = false);
 
  private:
-  void parseConfigUri(std::string configUri, Parameters& parameters);
+  void parseConfigUri(CardType::type cardType, std::string configUri, Parameters& parameters);
+  void parseConfigUriCru(std::string configUri, Parameters& parameters);
+  void parseConfigUriCrorc(std::string configUri, Parameters& parameters);
 };
 
 } // namespace roc

include/ReadoutCard/Parameters.h

@@ -89,6 +89,9 @@ class Parameters
   /// Type for the clock parameter
   using ClockType = Clock::type;
 
+  /// Type for the CRORC ID
+  using CrorcIdType = Hex::type;
+
   /// Type for the CRU ID
   using CruIdType = Hex::type;
 
@@ -258,6 +261,12 @@ class Parameters
   /// \return Reference to this object for chaining calls
   auto setClock(ClockType value) -> Parameters&;
 
+  /// Sets the CrorcId parameter
+  ///
+  /// \param value The value to set
+  /// \return Reference to this object for chaining calls
+  auto setCrorcId(CrorcIdType value) -> Parameters&;
+
   /// Sets the CruId parameter
   ///
   /// \param value The value to set
@@ -332,6 +341,10 @@ class Parameters
   /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
   auto getCardId() const -> boost::optional<CardIdType>;
 
+  /// Gets the CrorcId parameter
+  /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
+  auto getCrorcId() const -> boost::optional<CrorcIdType>;
+
   /// Gets the CruId parameter
   /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
   auto getCruId() const -> boost::optional<CruIdType>;
@@ -465,6 +478,11 @@ class Parameters
   /// \return The value
   auto getClockRequired() const -> ClockType;
 
+  /// Gets the CrorcId parameter
+  /// \exception ParameterException The parameter was not present
+  /// \return The value
+  auto getCrorcIdRequired() const -> CrorcIdType;
+
   /// Gets the CruId parameter
   /// \exception ParameterException The parameter was not present
   /// \return The value

src/CardConfigurator.cxx

@@ -8,17 +8,26 @@
 #include "Cru/CruBar.h"
 #include "ReadoutCard/CardConfigurator.h"
 #include "ReadoutCard/ChannelFactory.h"
+#include "RocPciDevice.h"
 
 namespace AliceO2
 {
 namespace roc
 {
 
-CardConfigurator::CardConfigurator(Parameters::CardIdType cardId, std::string configUri, bool forceConfigure)
+CardConfigurator::CardConfigurator(Parameters::CardIdType cardId, std::string configUri, bool forceConfigure) //TODO: Currently only supports the CRU
 {
-  auto parameters = Parameters::makeParameters(cardId, 2); //have to make parameters for this case, bar2
+  auto cardType = RocPciDevice(cardId).getCardDescriptor().cardType;
+  Parameters parameters;
+  if (cardType == CardType::Cru) {
+    parameters = Parameters::makeParameters(cardId, 2); //have to make parameters for this case, bar2
+  } else if (cardType == CardType::Crorc) {
+    parameters = Parameters::makeParameters(cardId, 0); //have to make parameters for this case, bar0
+  } else {
+    BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Unknown card type"));
+  }
   try {
-    parseConfigUri(configUri, parameters);
+    parseConfigUri(cardType, configUri, parameters);
   } catch (...) {
     throw;
   }
@@ -33,16 +42,39 @@ CardConfigurator::CardConfigurator(Parameters::CardIdType cardId, std::string co
 
 CardConfigurator::CardConfigurator(Parameters& parameters, bool forceConfigure)
 {
-  auto bar2 = ChannelFactory().getBar(parameters);
+  auto cardType = RocPciDevice(parameters.getCardId().get()).getCardDescriptor().cardType;
   try {
-    bar2->configure(forceConfigure);
+    if (cardType == CardType::Cru) {
+      auto bar2 = ChannelFactory().getBar(parameters);
+      bar2->configure(forceConfigure);
+    } else if (cardType == CardType::Crorc) {
+      parameters.setChannelNumber(0); // we need to change bar 0
+      auto bar0 = ChannelFactory().getBar(parameters);
+      bar0->configure(forceConfigure);
+    }
   } catch (const Exception& e) {
     BOOST_THROW_EXCEPTION(e);
   }
 }
 
+void CardConfigurator::parseConfigUri(CardType::type cardType, std::string configUri, Parameters& parameters)
+{
+  if (cardType == CardType::Cru) {
+    parseConfigUriCru(configUri, parameters);
+  } else if (cardType == CardType::Crorc) {
+    parseConfigUriCrorc(configUri, parameters);
+  } else {
+    BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Unknown card type"));
+  }
+}
+
+void CardConfigurator::parseConfigUriCrorc(std::string /*configUri*/, Parameters& /*parameters*/) //TODO: Fill me
+{
+  std::cout << "Non-parameter configuration not supported for the CRORC yet" << std::endl;
+  BOOST_THROW_EXCEPTION(Exception());
+}
 /// configUri has to start with "ini://", "json://" or "consul://"
-void CardConfigurator::parseConfigUri(std::string configUri, Parameters& parameters)
+void CardConfigurator::parseConfigUriCru(std::string configUri, Parameters& parameters)
 {
   std::set<uint32_t> linkMask;
   std::map<uint32_t, GbtMux::type> gbtMuxMap;

src/CommandLineUtilities/ProgramConfig.cxx

@@ -34,9 +34,10 @@ class ProgramConfig : public Program
  public:
   virtual Description getDescription()
   {
-    return { "Config", "Configure the CRU(s)",
+    return { "Config", "Configure the ReadoutCard(s)",
              "roc-config --config-uri ini:///home/flp/roc.cfg\n"
-             "roc-config --id 42:00.0 --links 0-23 --clock local --datapathmode packet --loopback --gbtmux ttc\n" };
+             "roc-config --id 42:00.0 --links 0-23 --clock local --datapathmode packet --loopback --gbtmux ttc #CRU\n"
+             "roc-config --id #0 --crorc-id 0x42 --dyn-offset #CRORC\n" };
   }
 
   virtual void addOptions(boost::program_options::options_description& options)
@@ -47,6 +48,9 @@ class ProgramConfig : public Program
     options.add_options()("clock",
                           po::value<std::string>(&mOptions.clock)->default_value("LOCAL"),
                           "Clock [LOCAL, TTC]");
+    options.add_options()("crorc-id",
+                          po::value<std::string>(&mOptions.crorcId)->default_value("0x0"),
+                          "12-bit CRORC ID");
     options.add_options()("cru-id",
                           po::value<std::string>(&mOptions.cruId)->default_value("0x0"),
                           "12-bit CRU ID");
@@ -127,7 +131,7 @@ class ProgramConfig : public Program
     }
 
     // Configure specific card
-    auto cardId = Options::getOptionCardId(map);
+    auto cardId = Options::getOptionCardId(map); //TODO: Parameters not planned for the CRORC should throw an exception when used
     if (!mOptions.bypassFirmwareCheck) {
       try {
         FirmwareChecker().checkFirmwareCompatibility(cardId);
@@ -142,6 +146,7 @@ class ProgramConfig : public Program
       params.setLinkMask(Parameters::linkMaskFromString(mOptions.links));
       params.setAllowRejection(mOptions.allowRejection);
       params.setClock(Clock::fromString(mOptions.clock));
+      params.setCrorcId(strtoul(mOptions.crorcId.c_str(), NULL, 16)); //TODO: Clean up common / per type parameters
       params.setCruId(strtoul(mOptions.cruId.c_str(), NULL, 16));
       params.setDatapathMode(DatapathMode::fromString(mOptions.datapathMode));
       params.setDownstreamData(DownstreamData::fromString(mOptions.downstreamData));
@@ -154,7 +159,7 @@ class ProgramConfig : public Program
       params.setTriggerWindowSize(mOptions.triggerWindowSize);
 
       // Generate a configuration file base on the parameters provided
-      if (mOptions.genConfigFile != "") {
+      if (mOptions.genConfigFile != "") { //TODO: To be updated for the CRORC
         std::cout << "Generating a configuration file at: " << mOptions.genConfigFile << std::endl;
         std::ofstream cfgFile;
         cfgFile.open(mOptions.genConfigFile);
@@ -221,6 +226,7 @@ class ProgramConfig : public Program
     bool dynamicOffsetEnabled = false;
     uint32_t onuAddress = 0;
     std::string cruId = "0x0";
+    std::string crorcId = "0x0";
     uint32_t triggerWindowSize = 1000;
   } mOptions;
 

src/CommandLineUtilities/ProgramListCards.cxx

@@ -92,7 +92,7 @@ class ProgramListCards : public Program
 
       if (!mOptions.jsonOut) {
         auto format = boost::format(formatRow) % i % CardType::toString(card.cardType) % card.pciAddress.toString() % serial %
-          endpoint % card.numaNode % firmware;
+                      endpoint % card.numaNode % firmware;
 
         table << format;
         std::cout << table.str();

src/Crorc/Constants.h

@@ -12,10 +12,13 @@
 /// \brief Definitions of RORC related constants
 /// Based on ddl_def.h and rorc.h
 /// \author Pascal Boeschoten ([email protected])
+/// \author Kostas Alexopoulos ([email protected])
 
 #ifndef ALICEO2_SRC_READOUTCARD_CRORC_CONSTANTS_H_
 #define ALICEO2_SRC_READOUTCARD_CRORC_CONSTANTS_H_
 
+#include "ReadoutCard/Register.h"
+
 namespace AliceO2
 {
 namespace roc
@@ -343,6 +346,29 @@ constexpr int OFFL = 0x00001000;   ///< SIU in Offline state
 constexpr int POR = 0x00000000;    ///< SIU in Power On Reset state
 } // namespace PortState
 } // namespace Siu
+
+namespace Crorc
+{
+namespace Registers
+{
+///*** bar0 ***///
+
+// Register to check the status of the link
+static constexpr Register LINK_STATUS(0x000000A0);
+
+// Register to send an I2C command
+static constexpr Register I2C_CMD(0x000000D0);
+
+// Register to control CRORC configuration
+// [15-4] -> CRORC ID
+// [0]    -> FIXED/DYNAMIC OFFSET
+static constexpr Register CFG_CONTROL(0x000001f0);
+
+// Register that contains the firmware hash
+static constexpr Register FIRMWARE_HASH(0x0000019C);
+} // namespace Registers
+} //namespace Crorc
+
 } // namespace roc
 } // namespace AliceO2
 

src/Crorc/CrorcBar.cxx

@@ -14,57 +14,94 @@
 /// \author Pascal Boeschoten ([email protected])
 /// \author Kostas Alexopoulos ([email protected])
 
+#include "Crorc/Constants.h"
 #include "Crorc/CrorcBar.h"
 
+#include "boost/format.hpp"
+
 namespace AliceO2
 {
 namespace roc
 {
 
 CrorcBar::CrorcBar(const Parameters& parameters, std::unique_ptr<RocPciDevice> rocPciDevice)
-  : BarInterfaceBase(parameters, std::move(rocPciDevice))
+  : BarInterfaceBase(parameters, std::move(rocPciDevice)),
+    mCrorcId(parameters.getCrorcId().get_value_or(0x0)),
+    mDynamicOffset(parameters.getDynamicOffsetEnabled().get_value_or(false))
 {
 }
 
 CrorcBar::~CrorcBar()
 {
 }
 
+boost::optional<std::string> CrorcBar::getFirmwareInfo()
+{
+  uint32_t fwHash = readRegister(Crorc::Registers::FIRMWARE_HASH.index);
+  return (boost::format("%x") % fwHash).str();
+}
+
 boost::optional<int32_t> CrorcBar::getSerial()
 {
   return Crorc::getSerial(*(mPdaBar.get()));
 }
 
-boost::optional<std::string> CrorcBar::getFirmwareInfo()
+void CrorcBar::setSerial(int serial)
 {
-  uint32_t version = mPdaBar->readRegister(Rorc::RFID);
-  auto bits = [&](int lsb, int msb) { return Utilities::getBits(version, lsb, msb); };
-
-  uint32_t reserved = bits(24, 31);
-  uint32_t major = bits(20, 23);
-  uint32_t minor = bits(13, 19);
-  uint32_t year = bits(9, 12) + 2000;
-  uint32_t month = bits(5, 8);
-  uint32_t day = bits(0, 4);
-
-  if (reserved != 0x2) {
-    BOOST_THROW_EXCEPTION(CrorcException()
-                          << ErrorInfo::Message("Static field of version register did not equal 0x2"));
-  }
-
-  std::ostringstream stream;
-  stream << major << '.' << minor << ':' << year << '-' << month << '-' << day;
-  return stream.str();
+  Crorc::setSerial(*(mPdaBar.get()), serial);
 }
 
 int CrorcBar::getEndpointNumber()
 {
   return 0;
 }
 
-void CrorcBar::setSerial(int serial)
+void CrorcBar::configure(bool /*force*/)
 {
-  Crorc::setSerial(*(mPdaBar.get()), serial);
+  // enable laser
+  log("Enabling the laser");
+  setQsfpEnabled();
+
+  log("Configuring fixed/dynamic offset");
+  // choose between fixed and dynamic offset
+  setDynamicOffsetEnabled(mDynamicOffset);
+
+  // set crorc id
+  log("Setting the CRORC ID");
+  setCrorcId(mCrorcId);
+}
+
+void CrorcBar::setQsfpEnabled()
+{
+  uint32_t qsfpStatus = (readRegister(Crorc::Registers::LINK_STATUS.index) >> 31) & 0x1;
+  if (qsfpStatus == 0) {
+    writeRegister(Crorc::Registers::I2C_CMD.index, 0x80);
+  }
+}
+
+bool CrorcBar::getQsfpEnabled()
+{
+  return (readRegister(Crorc::Registers::LINK_STATUS.index) >> 31) & 0x1;
+}
+
+void CrorcBar::setCrorcId(uint16_t crorcId)
+{
+  modifyRegister(Crorc::Registers::CFG_CONTROL.index, 4, 12, crorcId);
+}
+
+uint16_t CrorcBar::getCrorcId()
+{
+  return (readRegister(Crorc::Registers::CFG_CONTROL.index) >> 4) & 0x0fff;
+}
+
+void CrorcBar::setDynamicOffsetEnabled(bool enabled)
+{
+  modifyRegister(Crorc::Registers::CFG_CONTROL.index, 0, 1, enabled ? 0x1 : 0x0);
+}
+
+bool CrorcBar::getDynamicOffsetEnabled()
+{
+  return (readRegister(Crorc::Registers::CFG_CONTROL.index) & 0x1);
 }
 
 } // namespace roc

src/Crorc/CrorcBar.h

@@ -45,6 +45,19 @@ class CrorcBar final : public BarInterfaceBase
   virtual int getEndpointNumber() override;
 
   void setSerial(int serial);
+
+  void configure(bool force = false) override;
+
+ private:
+  void setQsfpEnabled();
+  bool getQsfpEnabled();
+  void setDynamicOffsetEnabled(bool enabled);
+  bool getDynamicOffsetEnabled();
+  void setCrorcId(uint16_t cruId);
+  uint16_t getCrorcId();
+
+  uint16_t mCrorcId;
+  bool mDynamicOffset;
 };
 
 } // namespace roc

src/Cru/CruBar.cxx

@@ -102,7 +102,8 @@ boost::optional<float> CruBar::getTemperature()
 
 boost::optional<std::string> CruBar::getFirmwareInfo()
 {
-  return (boost::format("%x-%x-%x") % getFirmwareDate() % getFirmwareTime() % getFirmwareGitHash()).str();
+  //return (boost::format("%x-%x-%x") % getFirmwareDate() % getFirmwareTime() % getFirmwareGitHash()).str();
+  return (boost::format("%x") % getFirmwareGitHash()).str();
 }
 
 boost::optional<std::string> CruBar::getCardId()