roclib/src_nxyter/NxI2c.cxx (r4864/r4112)

Go to the documentation of this file.

//============================================================================
//============================================================================

#include "nxyter/NxI2c.h"

//----------------------------------------------------------------------------

nxyter::NxI2c::NxI2c(base::Board* board, int port,
                     uint8_t addr) :
  roc::I2cDevice(board, port, addr)
{
}

//----------------------------------------------------------------------------

nxyter::NxI2c::~NxI2c()
{
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setContext(NxContext& cntx, int domask, bool veri)
{
  int rc;
  NxContext data;
  
  if (domask & kDoMask) {
    rc = setRegMask(cntx.dataRegisterMain());
    if (rc) return rc;
  }
  if (domask & kDoCore) {
    rc = setRegCore(cntx.dataRegisterMain());
    if (rc) return base::Board::operErrBuildInc(rc, 16);
  }
  
  if (domask & kDoTrim) {
    rc = setRegTrim(cntx.dataRegisterTrim());
    if (rc) return base::Board::operErrBuildInc(rc, 128);
  }

  if (veri) {
    rc = getContext(data, domask);
    if (rc) return base::Board::operErrBuildInc(rc, 1000);
    if (!cntx.equal(data, domask))
      return base::Board::operErrBuild(base::Board::kOperVerifyErr,2000);
  }
  
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::getContext(NxContext& cntx, int domask)
{
  int rc;

  if (domask & kDoMask) {
    rc = getRegMask(cntx.dataRegisterMain());
    if (rc) return rc;
  }
  if (domask & kDoCore) {
    rc = getRegCore(cntx.dataRegisterMain());
    if (rc) return base::Board::operErrBuildInc(rc, 16);
  }
  if (domask & kDoTrim) {
    rc = getRegTrim(cntx.dataRegisterTrim());
    if (rc) return base::Board::operErrBuildInc(rc, 128);
  }
  
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::getCounters(uint16_t& overflow, uint16_t& tokenmiss)
{
  int rc;
  uint8_t data[4];

  overflow  = 0;
  tokenmiss = 0;

  rc = getRegisterArray(34, data, 4);       // read 34 - 37
  if (rc) return rc;

  overflow  = data[0] + (uint16_t(data[1]) << 8); // reg 34/35
  tokenmiss = data[2] + (uint16_t(data[3]) << 8); // reg 36/37

  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setTestModes(bool testpuls, bool testtrig, 
                                int calselect)
{
  int rc;
  uint8_t conf0;
  uint8_t conf1;
  rc = getRegister(kNxRegConfig0, conf0);
  if (rc) return base::Board::operErrBuild(rc, 0);
  rc = getRegister(kNxRegConfig1, conf1);
  if (rc) return base::Board::operErrBuild(rc, 1);

  if (testpuls) {
    conf0 |=  kNxC0TestPulsEnable;
  } else {
    conf0 &= ~kNxC0TestPulsEnable;
  }

  if (testtrig) {
    conf0 |=  kNxC0TestTrigEnable;
  } else {
    conf0 &= ~kNxC0TestTrigEnable;
  }
  
  if (conf1 & kNxC1FrontEndPolarity) {
    conf0 |=  kNxC0TestPulsPolarity;
  } else {
    conf0 &= ~kNxC0TestPulsPolarity;
  }
  
  conf1 &= ~kNxC1CalibSelectMask;
  conf1 |= uint8_t(calselect) & kNxC1CalibSelectMask;
  
  rc = setRegister(kNxRegConfig0, conf0, true);
  if (rc) return base::Board::operErrBuild(rc, 2);
  rc = setRegister(kNxRegConfig1, conf1, true);
  if (rc) return base::Board::operErrBuild(rc, 3);
  
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::probe()
{
  int rc(0), res(0);
  uint8_t regs[3] = {kNxRegcal, kNxRegdelayTestPuls, kNxRegdelayTestTrig};
  uint8_t save[3];
  uint8_t back[3];
  uint8_t patt[3] = {0x55, 0xaa, 0x5f};

  // read and save registers
  for (int i=0; i<3; i++) {
    rc = getRegister(regs[i], save[i]);
    if (rc) return base::Board::operErrBuild(rc, i);
  }

  // write pattern
  for (int i=0; i<3; i++) {
    rc = setRegister(regs[i], patt[i]);
    if (rc && (res==0)) res = base::Board::operErrBuild(rc, 3+i);
  }

  // read and check pattern
  for (int i=0; i<3; i++) {
    rc = getRegister(regs[i], back[i]);
    if (rc && (res==0)) res = base::Board::operErrBuild(rc, 6+i);
    if ((back[i] != patt[i]) && (res==0))
      res = base::Board::operErrBuild(base::Board::kOperVerifyErr, 6+i);
  }

  // restore registers in any case
  for (int i=0; i<3; i++)
    setRegister(regs[i], save[i], true);

  return res;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setToDefault(bool ispos, int maskon, int poweron)
{
  nxyter::NxContext cntx;
  cntx.setToDefault(ispos, maskon, poweron);
  return setContext(cntx);
}

//----------------------------------------------------------------------------

void nxyter::NxI2c::printRegisters(std::ostream& os, int domask)
{
   nxyter::NxContext cntx;
   int rc = getContext(cntx, domask);
   if (rc) {
      os << std::dec;
      os << "Failed to read nx context port: " << getPortNumber()
             << " addr: " << std::dec << uint16_t(getSlaveAddr())
             << " " << base::Board::operErrToString(rc) << std::endl;
   } else {
      cntx.print(os, domask);
   }
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setRegMask(const uint8_t *val)
{
  return setRegisterArray(0, val, 16);    // regs  0 - 15
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setRegCore(const uint8_t *val)
{
  int rc;

  rc = setRegisterArray(16, val+16, 14);    // regs 16 - 29
  if (rc) return rc;
  rc = setRegisterArray(32, val+32,  2);    // regs 32 - 33
  if (rc) return base::Board::operErrBuildInc(rc, 14);
  rc = setRegisterArray(38, val+38,  2);    // regs 38 - 39
  if (rc) return base::Board::operErrBuildInc(rc, 16);
  rc = setRegisterArray(43, val+43,  3);    // regs 43 - 45
  if (rc) return base::Board::operErrBuildInc(rc, 19);
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::setRegTrim(const uint8_t *val)
{
   int rc = setRegister(kNxRegTrimDAQPower, val[128]);
   if (rc) return base::Board::operErrBuild(rc, 128);
   rc = setMailboxRegister(kNxRegTrimDAQPower, val, 128);
   if (rc) return base::Board::operErrBuildInc(rc, 1);
   return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::getRegMask(uint8_t *val)
{
  int rc;
  uint8_t conf0;
  rc = getRegister(kNxRegConfig0, conf0);
  if (rc) return rc;
  if (conf0 & kNxC0TestTrigEnable) {        // temporary test trigger disable
    rc = setRegister(kNxRegConfig0, (conf0 & ~kNxC0TestTrigEnable));
    if (rc) return rc;
  }

  rc = getRegisterArray(0, val, 16);    // regs  0 - 15
  if (rc) return rc;

  if (conf0 & kNxC0TestTrigEnable) {        // reenable test trigger
    rc = setRegister(kNxRegConfig0, conf0);
    if (rc) return rc;
  }
  
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::getRegCore(uint8_t *val)
{
  int rc = getRegisterArray(16, val+16, 14);    // regs 16 - 29
  if (rc) return rc;
  rc = getRegisterArray(32, val+32,  2);    // regs 32 - 33
  if (rc) return base::Board::operErrBuildInc(rc, 14);
  rc = getRegisterArray(38, val+38,  2);    // regs 38 - 39
  if (rc) return base::Board::operErrBuildInc(rc, 16);
  rc = getRegisterArray(43, val+43,  3);    // regs 43 - 45
  if (rc) return base::Board::operErrBuildInc(rc, 19);
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::NxI2c::getRegTrim(uint8_t *val)
{
  int rc;

  // The trimdaq register is a 129 stage shift register
  // Reg 42 must be read and rewritten 129 times to retrieve the contents
  // The code below uses setRegisterVerify() to combine a write and read
  // into a single transaction and gain thus some speed.

  rc = getRegister(kNxRegTrimDAQPower, val[128]);
  if (rc) return base::Board::operErrBuild(rc, 128);

  uint8_t valrewrite = val[128];

  for (int i=0; i<128; i++) {
    rc = setRegisterVerify(kNxRegTrimDAQPower, valrewrite, val[i]);
    valrewrite = val[i];
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  rc = setRegister(kNxRegTrimDAQPower, valrewrite);
  if (rc) return base::Board::operErrBuild(rc, 127);
  return 0;
}

//----------------------------------------------------------------------------

const char* nxyter::NxI2c::registerName(int reg) 
{
  static const char* names[46] = {"mask_000_007", // reg  0
                                  "mask_008_015",
                                  "mask_016_023",
                                  "mask_024_031",
                                  "mask_032_039",
                                  "mask_040_047",
                                  "mask_048_055",
                                  "mask_056_063",
                                  "mask_064_071", // reg  7
                                  "mask_072_079",
                                  "mask_080_087",
                                  "mask_088_095",
                                  "mask_096_103",
                                  "mask_104_111",
                                  "mask_112_119",
                                  "mask_120_127",
                                  "Vcg",            // reg 16
                                  "Icgfoll",        // reg 17
                                  "Vth",            // reg 18
                                  "Vbfb",           // reg 19
                                  "VbiasF",         // reg 20
                                  "VbiasS",         // reg 21
                                  "VbiasS2",        // reg 22
                                  "Vcm",            // reg 23
                                  "cal",            // reg 24
                                  "iCOMP",          // reg 25
                                  "iDUR",           // reg 26
                                  "iINV",           // reg 27
                                  "iPDH",           // reg 28
                                  "iTWC",           // reg 29
                                  "",               // reg 30
                                  "",               // reg 31
                                  "Config0",        // reg 32
                                  "Config1",        // reg 33
                                  "OverflowLSB",  // reg 34
                                  "OverflowMSB",  // reg 35
                                  "MissTokenLSB", // reg 36
                                  "MissTokenMSB", // reg 37
                                  "delayTestPuls",// reg 38
                                  "delayTestTrig",// reg 39
                                  "",               // reg 40
                                  "",               // reg 41
                                  "TrimDAQ-Power",// reg 42
                                  "delayClock1",  // reg 43
                                  "delayClock2",  // reg 44
                                  "delayClock3"   // reg 45
  };
  
  if (reg < 0 || reg >=46) return "";
  return names[reg];
}

//----------------------------------------------------------------------------

const char* nxyter::NxI2c::configurationBitName(int bit) 
{
  static const char* names[12] = {"test pulse enable",        // 0-0 
                                  "test pulse synchronize",   // 0-1
                                  "test pulse polarity",      // 0-2
                                  "test trigger enable",      // 0-3
                                  "test trigger synchronize", // 0-4
                                  "disable 32MHz clock",      // 0-5
                                  "disable 128 MHz clock",    // 0-6
                                  "TS LSB clock select",      // 0-7
                                  "calibration select bit 0", // 1-0
                                  "calibration select bit 1", // 1-1
                                  "front-end polarity",       // 1-2
                                  "readout clock select"      // 1-3
  };
  
  if (bit < 0 || bit >=12) return "";
  return names[bit];
}

//----------------------------------------------------------------------------

uint8_t nxyter::NxI2c::delayToSetting(uint8_t delay)
{
  static const uint8_t d2s[81] = {
      0,   1,   3,   4,  16,  64,  48,   5,  12,  17, 
    192,  65,   7,  19,  49,  67,  68,  13,  51,  20, 
    193, 195,  80, 196,  15,  69,  52,  76,  21,  71, 
     81, 112, 208, 197,  23, 204,  53,  83,  77,  28, 
    199,  55, 113,  84, 209,  79, 205, 240, 115, 211, 
     29,  60, 207,  85, 212,  31, 116, 241,  87,  61, 
    243,  92, 213, 117,  63, 244, 215, 119,  93, 220, 
    124, 245,  95, 221, 247, 125, 223, 252, 127, 253, 
    255
  };
  
  return (delay <= 80) ? d2s[delay] : 0xff;
}

//----------------------------------------------------------------------------

uint8_t nxyter::NxI2c::settingToDelay(uint8_t val)
{
  for (uint8_t delay=0; delay<=80; delay++) {
    if (delayToSetting(delay) == val) return delay;
  }
  return 0xff;
}

//----------------------------------------------------------------------------