[cru] Parse the card's serial from the EEPROM

Author: kostorr

CMakeLists.txt

@@ -127,6 +127,7 @@ if(PDA_FOUND)
     src/Cru/CruDmaChannel.cxx
     src/Cru/CruBar.cxx
     src/Cru/DatapathWrapper.cxx
+    src/Cru/Eeprom.cxx
     src/Cru/Gbt.cxx
     src/Cru/I2c.cxx
     src/Cru/Ttc.cxx

src/CardConfigurator.cxx

@@ -30,7 +30,7 @@ CardConfigurator::CardConfigurator(Parameters::CardIdType cardId, std::string pa
       bar2->reconfigure();
     }
   } catch (const Exception& e) {
-    throw std::runtime_error(boost::diagnostic_information(e));
+    BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message(boost::diagnostic_information(e)));
   }
 }
 
@@ -44,7 +44,7 @@ CardConfigurator::CardConfigurator(Parameters& parameters, bool forceConfigure)
       bar2->reconfigure();
     }
   } catch (const Exception& e) {
-    throw std::runtime_error(boost::diagnostic_information(e));
+    BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message(boost::diagnostic_information(e)));
   }
 }
 

src/Cru/Constants.h

@@ -166,6 +166,9 @@ static constexpr Register BSP_USER_CONTROL(0x00000018);
 /// Register to access I2C minipod information
 static constexpr Register BSP_I2C_MINIPODS(0x00030300);
 
+/// Register to access the EEPROM flash
+static constexpr Register BSP_I2C_EEPROM(0x00030800);
+
 //** TTC **//
 /// Register for setting the Clock
 static constexpr Register CLOCK_CONTROL(0x00240010);

src/Cru/CruBar.cxx

@@ -21,6 +21,7 @@
 #include <map>
 #include <thread>
 #include "CruBar.h"
+#include "Eeprom.h"
 #include "Gbt.h"
 #include "I2c.h"
 #include "Ttc.h"
@@ -220,14 +221,11 @@ int32_t CruBar::getLinksPerWrapper(int wrapper)
 /// Gets the serial number from the card.
 /// Note that not all firmwares have a serial number. You should make sure this firmware feature is enabled before
 /// calling this function, or the card may crash. See parseFirmwareFeatures().
-uint32_t CruBar::getSerialNumber()
+boost::optional<int32_t> CruBar::getSerialNumber()
 {
   assertBarIndex(2, "Can only get serial number from BAR 2");
-  auto serial = readRegister(Cru::Registers::SERIAL_NUMBER.index);
-  if (serial == 0xFfffFfff) {
-    BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("CRU reported invalid serial number 0xffffffff, "
-                                                            "a fatal error may have occurred"));
-  }
+  Eeprom eeprom = Eeprom(mPdaBar);
+  boost::optional<int32_t> serial = eeprom.getSerial();
   return serial;
 }
 

src/Cru/CruBar.h

@@ -88,7 +88,7 @@ class CruBar final : public BarInterfaceBase
   bool getDebugModeEnabled();
 
  private:
-  uint32_t getSerialNumber();
+  boost::optional<int32_t> getSerialNumber();
   uint32_t getTemperatureRaw();
   boost::optional<float> convertTemperatureRaw(uint32_t registerValue);
   boost::optional<float> getTemperatureCelsius();

src/Cru/Eeprom.cxx

@@ -0,0 +1,73 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Eeprom.cxx
+/// \brief Implementation of the Eeprom class
+///
+/// \author Kostas Alexopoulos ([email protected])
+
+#include <regex>
+#include "Constants.h"
+#include "I2c.h"
+#include "Eeprom.h"
+
+namespace AliceO2
+{
+namespace roc
+{
+
+Eeprom::Eeprom(std::shared_ptr<Pda::PdaBar> pdaBar) : mPdaBar(pdaBar)
+{
+}
+
+std::string Eeprom::readContent()
+{
+  uint32_t chipAddress = 0x50; // fixed address
+  I2c i2c = I2c(Cru::Registers::BSP_I2C_EEPROM.address, chipAddress, mPdaBar);
+
+  i2c.resetI2c();
+
+  std::string content;
+  for (int i = 0; i < 1000/8; i++) { // EEPROM size is 1KB
+    uint32_t res = i2c.readI2c(i);
+    content += (char)res;
+    if ((char)res == '}') {
+      break;
+    }
+  }
+
+  return content;
+}
+
+boost::optional<int32_t> Eeprom::getSerial()
+{
+  // parse the serial from the content
+  const std::string content = readContent();
+
+  // Example content:
+  // {"cn": "FEDD", "dt": "2019-06-17", "io": "24/24", "pn": "p40_fv22b10241", "serial_number_p40": "18-02409 - 0136"}
+  // p40_fv22b -> production CRUs
+  // p40_tv20pr -> testing CRUs
+
+  std::string startDelimiter = "\"pn\": \"p40_(?:fv22b|tv20pr)";
+  std::string endDelimiter = "\", \"serial_number_p40\":";
+
+  std::regex expression(startDelimiter + "(.*)" + endDelimiter);
+  std::smatch match;
+
+  if (std::regex_search(content.begin(), content.end(), match, expression)) {
+    return std::stol(match[1], NULL, 0);
+  }
+
+  return {};
+}
+
+} // namespace roc
+} // namespace AliceO2

src/Cru/Eeprom.h

@@ -0,0 +1,30 @@
+/// \file Eeprom.h
+/// \brief Definition of the Eeprom class
+///
+/// \author Kostas Alexopoulos ([email protected])
+
+#ifndef ALICEO2_READOUTCARD_CRU_EEPROM_H_
+#define ALICEO2_READOUTCARD_CRU_EEPROM_H_
+
+#include "Pda/PdaBar.h"
+
+namespace AliceO2
+{
+namespace roc
+{
+
+class Eeprom
+{
+ public:
+  Eeprom(std::shared_ptr<Pda::PdaBar> pdaBar);
+
+  boost::optional<int32_t> getSerial();
+
+ private:
+  std::string readContent();
+  std::shared_ptr<Pda::PdaBar> mPdaBar;
+};
+} // namespace roc
+} // namespace AliceO2
+
+#endif // ALICEO2_READOUTCARD_CRU_EEPROM_H_

src/Cru/Gbt.cxx

@@ -84,14 +84,14 @@ void Gbt::getGbtModes()
   for (auto& el : mLinkMap) {
     auto& link = el.second;
     uint32_t rxControl = mPdaBar->readRegister(getRxControlAddress(link) / 4);
-    if (((rxControl >> 8) & 0x1) == Cru::GBT_MODE_WB) { //TODO: Change with Constants
+    if (((rxControl >> 8) & 0x1) == Cru::GBT_MODE_WB) {
       link.gbtRxMode = GbtMode::type::Wb;
     } else {
       link.gbtRxMode = GbtMode::type::Gbt;
     }
 
     uint32_t txControl = mPdaBar->readRegister(getTxControlAddress(link) / 4);
-    if (((txControl >> 8) & 0x1) == Cru::GBT_MODE_WB) { //TODO: Change with Constants
+    if (((txControl >> 8) & 0x1) == Cru::GBT_MODE_WB) {
       link.gbtTxMode = GbtMode::type::Wb;
     } else {
       link.gbtTxMode = GbtMode::type::Gbt;

src/Cru/I2c.h

@@ -40,11 +40,11 @@ class I2c
   void configurePll();
   uint32_t getSelectedClock();
   void getOpticalPower(std::map<int, Link>& linkMap);
+  uint32_t readI2c(uint32_t address);
 
  private:
   //std::map<uint32_t, uint32_t> readRegisterMap(std::string file);
   void writeI2c(uint32_t address, uint32_t data);
-  uint32_t readI2c(uint32_t address);
   void waitForI2cReady();
   std::vector<uint32_t> getChipAddresses();
 

src/Cru/cru_constants_populate.py

@@ -67,6 +67,7 @@
 'add_flowctrl_ctrlreg':'FLOW_CONTROL_REGISTER',
 'add_gbt_wrapper_atx_pll':'GBT_WRAPPER_ATX_PLL',
 'add_gbt_bank_fpll':'GBT_BANK_FPLL',
+'add_bsp_i2c_eeprom':"BSP_I2C_EEPROM",
 'add_bsp_i2c_minipods':"BSP_I2C_MINIPODS",
 'add_bsp_i2c_si5345_1':'SI5345_1',
 'add_bsp_i2c_si5345_2':'SI5345_2',