lpGBT.h

#ifndef PFLIB_lpGBT_H_INCLUDED
#define PFLIB_lpGBT_H_INCLUDED
 
#include <stdint.h>
 
#include <vector>
 
#include "pflib/Exception.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);
 
  void setup_eclk(int ieclk, int rate, bool polarity = true, int strength = 4);
 
  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 group, int channel, 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 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_;
};
 
}  // namespace pflib
 
#endif  // PFLIB_lpGBT_H_INCLUDED