RMMApi.h

#pragma once
 
#include <atomic>
#include <fstream>
#include <iostream>
#include <json.hpp>
#include <string>
 
#include "RMMClocks.h"
#include "RMMInformations.h"
#include "RMMOutputQueues.h"
#include "RMMRails.h"
#include "RMMRegisterAccess.h"
#include "RMMRings.h"
#include "RMMSideChannels.h"
#include "RMMUDPCore.h"
#include "RMMUtils.h"
using json = nlohmann::json;

struct DetectorConfig {
  std::string name;                         
  std::map<uint8_t, uint8_t> ringTopology;  
};

class RMMAPI {
 public:
  RMMAPI(const std::string &serverIP, int serverPort, const char *configFile);
  ~RMMAPI();

  RMMRegisterAccess &getRMMRegAccess() { return rmmRegisterAccess; }
 
  void loadConfig(const std::string &cfgJsonPath);
 
  rmmStatus fillDetectorConfigFromJson(json &detectorConfig);
 
  void registerFrontEnd(RingId ringId, std::shared_ptr<FrontEndBase> frontend);
 
  double getTemperature();
  rmmStatus enablePowerMonitoring(int interval_ms);
  rmmStatus disablePowerMonitoring();
  rmmStatus tearDownAllRings();
  rmmStatus tearDownRing(RingId ring, bool waitTime);
  rmmStatus setupAllClocks(TimingMode timingMode);
  rmmStatus configUDPCore();
  rmmStatus bringUpAllRings();
  rmmStatus bringUpAllRingsInSequence();
  rmmStatus checkRings();
  rmmStatus checkRings(std::vector<int> &failedRings);
  rmmStatus checkRing(RingId ring);
  rmmStatus bringup(RingId ringId);
  rmmStatus configOutputQueues();
  rmmStatus configFENs(RingId ringId);
  rmmStatus configAllFE();
  rmmStatus getTimingStatus(TimingStatus *time);
  rmmStatus getCurrentTiming(uint32_t *currentTime);
  rmmStatus getFirmwareInfo(std::unordered_map<std::string, std::string> *info);
  rmmStatus getRegBankVersion(RegBankVersion *banks);
  rmmStatus configRing(RingId ringId);
  rmmStatus config(TimingMode timingMode = TimingMode::LCL, BringUpMode = BringUpMode::CONCURRENT,
                   uint32_t eventCode = 0x10);
  rmmStatus resetPacketCounters();
  rmmStatus getPacketCounters(PacketCountMap *packets);
  rmmStatus arpStatus(const int index, std::unordered_map<std::string, int> *status);
  rmmStatus getPowerVoltageCurrent(float voltageTolerancePercent, PowerResultsMap *result);
  rmmStatus getOutputQueuesData(const int ring, std::shared_ptr<OutputQueueBase> &result);
  rmmStatus getUDPCoreData(UDPCoreData *result);
  rmmStatus configSideChannels();
  rmmStatus getSideChannelStats(SideChannelStatsData &stats);
  rmmStatus getSideChannelPacketCounters(const uint8_t sideChIdx, uint32_t *value);
  rmmStatus fetchSideChannelData(const uint8_t sideChIdx, SideChannelsData &data);
  enum class LEMOImpedance : uint8_t { IMP_100K_OHM, IMP_50_OHM };
  rmmStatus setLEMOTermination(const uint8_t inLEMOIdx, LEMOImpedance impedance);
  rmmStatus getLEMOTermination(const uint8_t inLEMOIdx, LEMOImpedance &impedance);

  enum class LogTopic : uint8_t {
    ALL,
    RMM_API,
    REGISTER_ACCESS,
    CLOCK,
    OUTPUT_QUEUES,
    RAILS,
    RINGS,
    UDP_CORE,
    SIDE_CHANNELS
  };
 
  rmmStatus getLogMsg(std::string *msg, LogTopic topic = LogTopic::RMM_API);
  rmmStatus getRingLogMsg(std::string *msg, RingId ringId);
  void allLogRelays(std::string logLevel, FILE *out);
  rmmStatus setLogMasks(int logMask, LogTopic topic = LogTopic::ALL);
  rmmStatus setRingLogMask(RingId ringId, int mask);
  void setAllLogTimeouts(int milliseconds);
  void setAllFileWriteTimeouts(int milliseconds);
  rmmStatus setLogFilePathAll(std::string filePath, bool useName = false);
  rmmStatus setLogFilePathAll(std::string path, std::string name);
  rmmStatus setWriteToFileAll(bool option, char mode = 'w');
  void requestStop();
  RMMResult regRead(const std::string &regName, RegisterTag tag = RegisterTag::ALL);
  RMMResult regRead(uint32_t address);
  RMMResult regWrite(const std::string &regName, uint32_t data, RegisterTag tag = RegisterTag::ALL);
  RMMResult regWrite(uint32_t address, uint32_t data);
  RMMResult fieldRead(const std::string &reg, RegisterTag tag, int bitBegin, int bitWidth);
  RMMResult fieldRead(uint32_t reg, int bitBegin, int bitWidth);
  RMMResult fieldWrite(const std::string &reg, RegisterTag tag, int bitBegin, int bitWidth, uint32_t data);
  RMMResult fieldWrite(uint32_t reg, int bitBegin, int bitWidth, uint32_t data);
  bool isLegacyFW();
  int getPollTimeout();
  void setPollTimeout(int value);
  void setRingPollTimeout(RingId ringId, int value);
  int getRingPollTimeout(RingId ringId);
  rmmStatus setRingEnabled(RingId ringId, bool enable);
  RingState getRingStatus(RingId ringId) const;
  RMMLog rmmLog;

  json jsonConfigData;

  const std::vector<DetectorConfig> &getDetectorConfigs() const { return detConfigs; }
 
  std::vector<int> getActiveRings() const;
 
 private:
  RMMRegisterAccess rmmRegisterAccess;
 
  RMMRails rmmRails;
  RMMRings rmmRings;
  RMMClocks rmmClocks;
  RMMOutputQueues rmmOutputQueues;
  RMMInfos rmmInfos;
  RMMUDPCore rmmUDPCore;
  RMMSideChannels rmmSideChannels;
  bool hasSideChannel = false;
 
  void bringupCMAC();
  std::vector<DetectorConfig> detConfigs;
  std::mutex configRingMutex_;
  int configRunningRingId_ = -1;
};