lpGBT.h

#ifndef PFLIB_lpGBT_H_INCLUDED
#define PFLIB_lpGBT_H_INCLUDED
 
#include <stdint.h>
#include <yaml-cpp/yaml.h>
 
#include <vector>
 
#include "pflib/Exception.h"
#include "pflib/logging/Logging.h"
#include "pflib/lpgbt/GPIO.h"
 
namespace pflib {
 
class lpGBT_ConfigTransport {
 public:
  virtual ~lpGBT_ConfigTransport() {}
  virtual uint8_t read_reg(uint16_t reg) = 0;
  virtual void write_reg(uint16_t reg, uint8_t value) = 0;
  virtual std::vector<uint8_t> read_regs(uint16_t reg, int n);
  virtual void write_regs(uint16_t reg, const std::vector<uint8_t>& value);
};
 
class lpGBT {
 public:
  lpGBT(lpGBT_ConfigTransport& transport);
 
  void write(uint16_t reg, uint8_t value) { tport_.write_reg(reg, value); }
  uint8_t read(uint16_t reg) { return tport_.read_reg(reg); }
  std::vector<uint8_t> read(uint16_t reg, int len) {
    return tport_.read_regs(reg, len);
  }
 
  typedef std::pair<uint16_t, uint8_t> RegisterValue;
  typedef std::vector<RegisterValue> RegisterValueVector;
  void write(const RegisterValueVector& regvalues);
 
  RegisterValueVector read(const std::vector<uint16_t>& registers);
 
  void bit_set(uint16_t reg, int ibit);
  void bit_clr(uint16_t reg, int ibit);
 
  /* -------------------------------------------------------
     Medium-level interfaces
  */
 
  uint32_t serial_number();
 
  int status();
  std::string status_name(int pusm);
 
  void gpio_set(int ibit, bool high);
  bool gpio_get(int ibit);
  void gpio_set(uint16_t values);
  uint16_t gpio_get();
 
  static const int GPIO_IS_OUTPUT = 0x01;
  static const int GPIO_IS_PULLUP = 0x02;
  static const int GPIO_IS_PULLDOWN = 0x04;
  static const int GPIO_IS_STRONG = 0x08;
 
  int gpio_cfg_get(int ibit);
  void gpio_cfg_set(int ibit, int cfg, const std::string& name = "");
  GPIO& gpio_interface() { return gpio_; }
 
  uint16_t adc_read(int ipos, int ineg, int gain = 1);
 
  uint16_t adc_resistance_read(int ipos, int current, int gain = 1);
 
  double adc_average();
 
  int find_vref_tune(double vref_slope, double vref_offset,
                     double temp_uncal_slope, double temp_uncal_offset);
 
  static constexpr double AVG_ADC_X2_OFFSET = -3.29456020e-02;
  static constexpr double AVG_ADC_X2_OFFSET_TEMP = 1.33582562e-06;
  static constexpr double AVG_ADC_X2_SLOPE = 1.04131896e-03;
  static constexpr double AVG_ADC_X2_SLOPE_TEMP = -2.57597742e-09;
  static constexpr double AVG_TEMPERATURE_OFFSET = -1.84069912e+02;
  static constexpr double AVG_TEMPERATURE_SLOPE = 4.10623053e+02;
  static constexpr double AVG_TEMPERATURE_UNCALVREF_OFFSET = -2.10640722e+02;
  static constexpr double AVG_TEMPERATURE_UNCALVREF_SLOPE = 4.56134956e-01;
  static constexpr double AVG_VREF_OFFSET = 1.34761703e+02;
  static constexpr double AVG_VREF_SLOPE = -3.35998109e-01;
 
  void read_internal_temp_avg();
 
  void read_internal_temp_precise(YAML::Node cal_data);
 
  void setup_eclk(int ieclk, int rate, bool polarity = true, int strength = 4);
 
  void setup_line_driver(int modulation_current, bool enable_pre_emphasis,
                         bool short_pre_emphasis, int pre_emphasis_amplitude);
 
  void setup_erx(int ierx, int align, int alignphase = 0, int speed = 3,
                 bool invert = false, bool term = true, int equalization = 0,
                 bool acbias = false);
 
  void check_prbs_errors_erx(int ierx, bool check_all_phases = false,
                             bool lpgbt_only = false, int data_rate_code = 3,
                             uint8_t bert_time_code = 4);
 
  void setup_etx(int ietx, bool enable, bool invert = false, int drive = 4,
                 int pe_mode = 0, int pe_strength = 0, int pe_width = 0);
 
  void setup_ec(bool invert_tx = false, int drive = 4, bool fixed = false,
                int alignphase = 0, bool invert_rx = false, bool term = true,
                bool acbias = false, bool pullup = false);
 
  uint32_t read_efuse(uint16_t addr);
 
  void setup_i2c(int ibus, int speed_khz, bool scl_drive = false,
                 bool strong_scl = true, bool strong_sda = true,
                 bool pull_up_scl = false, bool pull_up_sda = false);
 
  void setup_i2c_speed(int ibus, int speed_khz);
 
  int get_i2c_speed(int ibus);
 
  void start_i2c_read(int ibus, uint8_t i2c_addr, int len = 1);
 
  void i2c_write(int ibus, uint8_t i2c_addr, uint8_t value);
 
  void i2c_write(int ibus, uint8_t i2c_addr,
                 const std::vector<uint8_t>& values);
 
  bool i2c_transaction_check(int ibus, bool wait = false);
 
  std::vector<uint8_t> i2c_read_data(int ibus);
 
  void finalize_setup();
 
 private:
  lpGBT_ConfigTransport& tport_;
  struct I2C {
    uint8_t ctl_reg;
    uint8_t read_len;
  } i2c_[3];
  ::pflib::lpgbt::GPIO gpio_;
  mutable logging::logger the_log_{logging::get("lpGBT")};
};
 
}  // namespace pflib
 
#endif  // PFLIB_lpGBT_H_INCLUDED