[flash] Add option to set the CRORC serial

Author: kostorr

include/ReadoutCard/ParameterTypes/SerialId.h

@@ -65,7 +65,8 @@ class SerialId
   std::string mSerialIdString;
 };
 
-static constexpr int SERIAL_RANGE_LOW(10000);
+//TODO: To be updated with sensible values when things are stable.
+static constexpr int SERIAL_RANGE_LOW(0);
 static constexpr int SERIAL_RANGE_HIGH(100000);
 
 static constexpr int SERIAL_DUMMY(-1);

src/CommandLineUtilities/Options.cxx

@@ -66,7 +66,7 @@ static Option<int> channel("channel", "BAR channel number");
 static Option<std::string> registerAddress("address", "Register address in hex format");
 static Option<int> registerRange("range", "Amount of registers to print past given address");
 static Option<std::string> registerValue("value", "Register value, either in decimal or hex (prefix with 0x)");
-static Option<std::string> cardId("id", "Card ID: PCI Address or sequence number, as reported by `roc-list-cards`");
+static Option<std::string> cardId("id", "Card ID: PCI Address, Serial ID, or sequence number, as reported by `roc-list-cards`");
 static Option<std::string> resetLevel("reset", "Reset level [NOTHING, INTERNAL, INTERNAL_DIU, INTERNAL_DIU_SIU]");
 } // namespace option
 

src/CommandLineUtilities/ProgramFlash.cxx

@@ -18,9 +18,11 @@
 #include <string>
 #include "ReadoutCard/ChannelFactory.h"
 #include "Crorc/Crorc.h"
+#include "Crorc/CrorcBar.h"
 #include "ExceptionInternal.h"
 
 using namespace AliceO2::roc::CommandLineUtilities;
+using namespace AliceO2::roc;
 using std::cout;
 using std::endl;
 namespace po = boost::program_options;
@@ -38,7 +40,8 @@ class ProgramCrorcFlash : public Program
   virtual void addOptions(po::options_description& options)
   {
     Options::addOptionCardId(options);
-    options.add_options()("file", po::value<std::string>(&mFilePath)->required(), "Path of file to flash");
+    options.add_options()("file", po::value<std::string>(&mFilePath), "Path of firmware file to flash");
+    options.add_options()("serial", po::value<std::string>(&mSerial), "Serial number to flash");
   }
 
   virtual void run(const boost::program_options::variables_map& map)
@@ -54,10 +57,34 @@ class ProgramCrorcFlash : public Program
       BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Only C-RORC supported for now"));
     }
 
-    Crorc::programFlash(*(channel.get()), mFilePath, 0, std::cout, &Program::getInterruptFlag());
+    if (mSerial != "") {
+      if (mFilePath != "") {
+        std::cout << "The tool supports either flashing the serial or flashing the firmware;" << std::endl
+                  << "Both operations not supported in parallel" << std::endl;
+        return;
+      }
+
+      int serial = std::stoi(mSerial);
+      if (serial < 0 || serial > 99999) {
+        std::cerr << "Invalid serial; Legal values: [0-99999]." << std::endl;
+        return;
+      }
+
+      std::cout << "Setting the serial for the CRORC: " << mSerial << std::endl;
+      auto crorcBar = std::dynamic_pointer_cast<CrorcBar>(channel);
+      crorcBar->setSerial(serial);
+
+    } else if (mFilePath != "") {
+      std::cout << "Flashing the CRORC from file: " << mFilePath << std::endl;
+      Crorc::programFlash(*(channel.get()), mFilePath, 0, std::cout, &Program::getInterruptFlag());
+
+    } else {
+      std::cout << "--file or --serial needs to be provided" << std::endl;
+    }
   }
 
   std::string mFilePath;
+  std::string mSerial = "";
 };
 } // Anonymous namespace
 

src/Crorc/Crorc.cxx

@@ -33,6 +33,8 @@
 #include "ExceptionInternal.h"
 #include "ReadoutCard/RegisterReadWriteInterface.h"
 
+#include <boost/optional/optional_io.hpp>
+
 using namespace std::chrono_literals;
 using std::this_thread::sleep_for;
 namespace b = boost;
@@ -80,6 +82,8 @@ constexpr int MAX_WAIT = 1000000;
 constexpr int REGISTER_DATA_STATUS = Rorc::Flash::IFDSR;
 constexpr int REGISTER_ADDRESS = Rorc::Flash::IADR;
 constexpr int REGISTER_READY = Rorc::Flash::LRD;
+constexpr int DDL_MAX_HW_ID = 64;
+constexpr int SN_POS = 33;
 
 // TODO figure out what these are/do
 constexpr int MAGIC_VALUE_0 = 0x80;
@@ -168,13 +172,13 @@ void eraseBlock(RegisterReadWriteInterface& bar0, uint32_t address)
 }
 
 /// Currently unused, but we'll keep it as "documentation"
-/*void writeWord(RegisterReadWriteInterface& bar0, uint32_t address, int value)
+void writeWord(RegisterReadWriteInterface& bar0, uint32_t address, int value)
 {
   writeStatusSleep(bar0, address);
   writeStatusSleep(bar0, MAGIC_VALUE_9);
   writeStatusSleep(bar0, value);
   checkStatus(bar0);
-}*/
+}
 
 /// Reads a 16-bit flash word and writes it into the given buffer
 void readWord(RegisterReadWriteInterface& bar0, uint32_t address, char* data)
@@ -1030,6 +1034,39 @@ boost::optional<int32_t> getSerial(RegisterReadWriteInterface& bar0)
   return { int32_t(serial) };
 }
 
+void setSerial(RegisterReadWriteInterface& bar0, int serial)
+{
+
+  uint32_t address = Rorc::Serial::FLASH_ADDRESS;
+  Flash::init(bar0, address);
+  Flash::unlockBlock(bar0, address);
+  Flash::eraseBlock(bar0, address);
+
+  // Prepare the data string
+  // It needs to be DDL_MAX_HW_ID long and
+  // initialized with ' '
+  char serialCString[Flash::DDL_MAX_HW_ID + 1];
+  serialCString[0] = '\0';
+
+  for (int i = 0; i < Flash::DDL_MAX_HW_ID - 1; i++) {
+    serialCString[i] = ' ';
+  }
+
+  // "S/N: vwxyz" needs to start at SN_POS
+  // followed by a ' '
+  sprintf(&serialCString[Flash::SN_POS - 5], "S/N: %05d", serial);
+  serialCString[Flash::SN_POS + 5] = ' ';
+  serialCString[Flash::DDL_MAX_HW_ID - 1] = '\0';
+
+  // Write the data to the flash
+  uint32_t hexValue = 0x0;
+  for (int i = 0; i < Flash::DDL_MAX_HW_ID; i += 2, address++) {
+    hexValue = Flash::MAGIC_VALUE_13 +
+               (serialCString[i] << 8) + serialCString[i + 1];
+    Flash::writeWord(bar0, address, hexValue);
+  }
+}
+
 uint8_t Crorc::ddlReadHw(int destination, int address, long long int time)
 {
   // prepare and send DDL command

src/Crorc/Crorc.h

@@ -36,6 +36,9 @@ namespace Crorc
 /// Note that the BAR must be from channel 0, other channels do not have access to the flash.
 boost::optional<int32_t> getSerial(RegisterReadWriteInterface& bar0);
 
+/// Set the serial number on the C-RORC's flash memory.
+void setSerial(RegisterReadWriteInterface& bar0, int serial);
+
 /// Program flash using given data file
 void programFlash(RegisterReadWriteInterface& bar0, std::string dataFilePath, int addressFlash, std::ostream& out,
                   const std::atomic<bool>* interrupt = nullptr);

src/Crorc/CrorcBar.cxx

@@ -62,5 +62,10 @@ int CrorcBar::getEndpointNumber()
   return 0;
 }
 
+void CrorcBar::setSerial(int serial)
+{
+  Crorc::setSerial(*(mPdaBar.get()), serial);
+}
+
 } // namespace roc
 } // namespace AliceO2

src/Crorc/CrorcBar.h

@@ -43,6 +43,8 @@ class CrorcBar final : public BarInterfaceBase
   virtual boost::optional<int32_t> getSerial() override;
   virtual boost::optional<std::string> getFirmwareInfo() override;
   virtual int getEndpointNumber() override;
+
+  void setSerial(int serial);
 };
 
 } // namespace roc

src/RocPciDevice.cxx

@@ -96,16 +96,22 @@ void RocPciDevice::initWithSerialId(const SerialId& serialId)
     for (const auto& typedPciDevice : Pda::PdaDevice::getPciDevices()) {
       PciDevice* pciDevice = typedPciDevice.pciDevice;
       DeviceType type;
+
+      Utilities::resetSmartPtr(mPdaBar0, pciDevice, 0);
+      Utilities::resetSmartPtr(mPdaBar2, pciDevice, 2);
+
+      int serial;
+      int endpoint;
       if (typedPciDevice.cardType == CardType::Crorc) {
         type = DeviceType(deviceTypes.at(0));
+        serial = type.getSerial(mPdaBar0);
       } else {
         type = DeviceType(deviceTypes.at(1));
+        serial = type.getSerial(mPdaBar2);
       }
+      endpoint = type.getEndpoint(mPdaBar0);
 
-      Utilities::resetSmartPtr(mPdaBar0, pciDevice, 0);
-      Utilities::resetSmartPtr(mPdaBar2, pciDevice, 2);
-
-      if (type.getSerial(mPdaBar2) == serialId.getSerial() && type.getEndpoint(mPdaBar0) == serialId.getEndpoint()) {
+      if (serial == serialId.getSerial() && endpoint == serialId.getEndpoint()) {
         mPciDevice = pciDevice;
         mDescriptor = CardDescriptor{ type.cardType, serialId, type.pciId, addressFromDevice(pciDevice), PciDevice_getNumaNode(pciDevice) };
         return;