RMMRegisterAccess.h

#pragma once
 
#include <arpa/inet.h>
#include <sys/socket.h>
#include <unistd.h>
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "RMMException.h"
#include "RMMLog.h"
#include "RMMMaps.h"
#include "RMMParams.h"
#include "RMMUtils.h"
#include "RegMutex.h"
 
#define MAX_NODES 192
#define I2C_MUTEX_SCTL_ID 1  // one-hot value (RMM microblaze is 2, RMM Power readout is 4)
#define I2C_MUTEX_IDLE_ID 0

struct RMMResult {
  uint32_t value;    
  rmmStatus status;  
  RMMResult(uint32_t val, rmmStatus stats = rmmSuccess) : value(val), status(stats) {}
};

class RMMRegisterAccess {
 public:
  RMMRegisterAccess(const std::string &serverIP, int serverPort);
  ~RMMRegisterAccess();

  enum class RegisterTag {
    CTRL,      
    ENG,       
    TIME,      
    RING_MST,  
    CMAC,      
    ALL,       
  };
 
  std::unordered_map<RegisterTag, std::unordered_map<std::string, uint32_t>> fillAllAddressMaps();
  std::list<std::string> getAllRegMaps();
  void addRegMapMutexes(FENRegMap map);
  unsigned int addRegsMutexes(std::list<std::string> regs, bool critic = true);
  bool addRegMutex(std::string reg, std::string tag = "NoTag", bool critic = true);
  RegLockGuard regLockGuard(std::string reg, std::string tag = "NoTag");
  std::string addrLookUp(const std::string &name, RegisterTag tag = RegisterTag::ALL);
  RMMResult feaFwRegRead(const std::string &reg_name, int ring_id, int node_id, const std::string &tag = "");
  RMMResult feaFwRegWrite(const std::string &reg_name, int ring_id, int node_id, uint32_t data,
                          const std::string &tag = "");
  RMMResult regRead(const std::string &regName, RegisterTag tag = RegisterTag::ALL);
  void regAssert(const std::string &reg_name, uint32_t exp_data, RegisterTag tag = RegisterTag::ALL);
  RMMResult regWrite(const std::string &regName, uint32_t data, RegisterTag tag = RegisterTag::ALL);
  rmmStatus regPoll(const std::string &regName, uint32_t expData, double pollDelay = 1.0, uint32_t timeout = 0,
                    RegisterTag regTag = RegisterTag::ALL, std::function<bool(uint32_t)> stopCondition = nullptr,
                    std::function<bool()> checkStop = nullptr);
  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);
  rmmStatus i2cWriteByte(int i2c_addr, uint32_t data);
  rmmStatus i2cWrite8bReg(int i2c_addr, int reg_addr, uint32_t data);
  rmmStatus i2cWrite16bReg(int i2c_addr, int reg_addr, uint32_t data);
  uint32_t i2cRead8bRegSi570(int i2c_addr, int reg_addr);
  RMMResult regMaskWrite(const std::string &regName, uint32_t data, uint32_t mask, RegisterTag tag = RegisterTag::ALL);
  rmmStatus i2cDelay(uint32_t delay);
  RMMResult rawRead(const std::string &addr);  // move to private after
  RMMResult rawWrite(const std::string &addr, uint32_t data);
 
  RMMLog rmmLog;  
 
  void requestStop();
  void resetStop();
  bool isStopRequested() const;
 
  bool isLegacyFW() const;
 
 private:
  enum class I2C_CMD {
    WRITE_ONE_BYTE = 1,
    WRITE_TWO_BYTES = 2,
    WRITE_THREE_BYTES = 3,
    READ_BYTE = 4,
    READ_TWO_BYTES = 5,
    DELAY = 6,
    READ_BYTE_SI570 = 7
  };
 
  int sock;
  RegMutex regMutex;
  std::recursive_mutex i2cMut;
  struct sockaddr_in serverAddr;
  std::atomic<uint32_t> requestCount{0};
  std::atomic<uint32_t> replyCount{0};
  std::mutex soft_mutex;
  std::atomic<bool> _legacyFW{false};
  std::unordered_map<RegisterTag, std::unordered_map<std::string, uint32_t>> addressMaps;
  std::unordered_map<int, std::map<int, std::unordered_map<std::string, uint32_t>>> feaFwAddressMaps;
 
  struct ReplyData {
    std::string header;
    std::string addr;
    std::string data;
    std::string status;
  };
  void i2cClaimMutex(uint32_t id = I2C_MUTEX_SCTL_ID, double poll_delay = 1.0, int poll_attempts_timeout = -1);
  void i2cReleaseMutex();
  rmmStatus i2cSendWaitDone();
  std::string sendSlowControlPacket(const std::string &pkt);
  bool isTimeout(std::string sent_data, std::string ans);
  RMMResult parseReplayRecvData(const std::string sent_data, const std::string rec_data);
  rmmStatus checkProtocolReply(std::string sent, std::string received);
 
  uint32_t getFrontendRegAddress(const std::string &reg_name, int ring, int node);
 
  std::vector<int> whichBitsAreSet(int data);
 
  sockaddr_in socketConnect(const std::string &server_ip, int server_port);
  bool sendMessage(const char *message, size_t length);
  std::vector<uint8_t> receiveBinaryMessage();
  rmmStatus setSocketTimeout(int seconds, int microseconds);
 
  std::atomic<bool> _stopRequested{false};
 
  RMMResult fieldReadImpl(std::function<RMMResult()> readFunc, int bitBegin, int bitWidth);
  RMMResult fieldWriteImpl(std::function<RMMResult()> readFunc, std::function<RMMResult(uint32_t)> writeFunc,
                           int bitBegin, int bitWidth, std::string reg, uint32_t data);
 
  bool defineFwVersion();
 
  friend class I2CMutex;
};
 
using RegisterTag = RMMRegisterAccess::RegisterTag;