RMMRings.h

#pragma once
 
#include <chrono>
#include <future>
#include <iostream>
#include <json.hpp>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#include "RMMRegisterAccess.h"
#include "RMMRingTimestamps.h"
#include "Topology.h"
using json = nlohmann::json;
 
constexpr int MAX_NUM_RINGS = 12;
constexpr int MAX_NODES_PER_RING = 31;
 
constexpr int FE_WATCHDOG_TIMEOUT = 30;  // seconds
constexpr int STATUS_UPDATE_GAP = 1;     // seconds
 
enum class FSMState { IDLE = 0, SYNC = 1, SLOW_CTRL = 2 };

struct PacketCountsData {
  uint32_t oddCount;                
  uint32_t evenCount;               
  uint32_t oddOverflow;             
  uint32_t evenOverflow;            
  std::map<int, uint32_t> perNode;  
};

using PacketCountMap = std::map<uint8_t, PacketCountsData>;

class RMMRings {
 public:
  RMMRings(RMMRegisterAccess& RMMRegs, Topology& topology);
 
  rmmStatus teardownAllRings();
  rmmStatus tearDownRing(int ring, bool waitTime = true);
  void bringUpAllRings();
  void bringUpAllRingsInSequence();
  ringStatus checkRings();
  void readyForBulkData();
  void resetPacketCounters();
  int getPollTimeout();
  void setPollTimeout(int value);
  rmmStatus getPacketCounters(PacketCountMap* packets);
  rmmStatus getSideChannelPacketCounter(uint8_t node, uint32_t* value);
 
  RMMLog rmmLog;                                   
  static constexpr int FE_DEFAULT_LOCK_TIME = 16;  // seconds, typical for a FE jitter cleaner to lock to 95BC.
 
 private:
  static constexpr int NODE_STATUS_ATTEMPTING_LOCK = 1;  // microblaze touchscreen status
  static constexpr int NODE_STATUS_LOCKED = 2;           // microblaze touchscreen status
  static constexpr int NODEID_ON_RESET = 31;             // 0-indexed nodeid's (31 reserved for 'unassigned')
  static constexpr int BUCKET_SIZE = 7;
 
  RMMRegisterAccess& RMMRegs;
  Topology& topology_;
  std::mutex cout_mutex;  // Mutex for std::cout
  std::mutex tearing_down[MAX_NUM_RINGS];
 
  std::atomic<bool> _stopRequested{false};
 
  void commonRingSetup();
  uint32_t getCfgMask();
  rmmStatus ringSetup(int ring);
 
  RMMResult maskedSetXcvrEngineState(int ring, std::string txrx, FSMState fsm_st, bool use_dom_xcvr = true);
  std::string get3regSuffix(int ring);
  int getXcvrNum(int ring, bool use_dom_xcvr = true);
  int getXcvrOffset(bool use_dom_xcvr = true);
  rmmStatus nodeSetup(int ring, int node);
  rmmStatus finalRingSetup(int ring, int final_node_id);
  void finalEnterSlowCtrl(int ring);
  void updateTouchScreenRingStatusRegister(int current_node, int ring, int lock_status, bool ring_complete);
  void beginNodeSync(int ring, bool use_dom_xcvr = true);
  RMMResult pollForLock(int ring, int node, bool use_dom_xcvr = true);
  void enterSlowCtrl(int ring, bool use_dom_xcvr);
 
  void setDomXcvr(DomFiber val);
  void setNonDomXcvr(int val);
 
  std::atomic<int> poll_timeout{10};
 
  friend class FrontEndBase;
};