LSDelayChipV1.cpp

Go to the documentation of this file.

//$Id: LSDelayChipV1.h,v 1.0 2013/11/11 13:11:24 jmauricio Exp $
//------------------------------------------------------------------------------
//
//  Package    : LSDelayChipV1
//
//  Description:
//
//  Author(s)  : Joan Mauricio
//  Date       : 2013/11/11
//
//------------------------------------------------------------------------------

// local include file
#include "LSDelayChipV1.h"

//Basic reading operations...
void LSDelayChipV1::configRegBulkRead(U8 confRegAddr)
{
    //m_regConfig->io()->setAddress(confRegAddr + 128);     //+128 = read   
    U8* buffer = m_regConfig->io()->dataU8();
    buffer[2] = confRegAddr + 128;
    if (m_regConfig->read().isFailure())  warning("LSDelayChipV1 configuration register read failure.");
    else
    {
        m_rxConfigBits = ((U16)buffer[1] * 256) + (U16)buffer[0];
        debug("Config. Register phase (@"+ itohs(confRegAddr) + ") = 0x" + itohs(m_rxConfigBits),"LSDCv1::configRegBulkRead");
    }
         
    //return m_rxConfigBits; 
}

// SPI Configuration Data Frame:
//       1b       1b          5b             5b             1b           1b       2b
//  LVDS Out en  -N.U-  Phase T&H (ADC)    Phase INT    !VCNT Out En    DEBUG    LOCUS
void LSDelayChipV1::getConfigReg(U8 confRegAddr)
{
    bool ok = checkConfigAddr(confRegAddr);
    if(ok)
    {
        configRegBulkRead(confRegAddr);
        m_rxConfig.lvdsOutEn    = (m_rxConfigBits >> 15) & 0x01;
        m_rxConfig.phaseTaHAdc  = (m_rxConfigBits >> 9)  & 0x1F;
        m_rxConfig.phaseInt     = (m_rxConfigBits >> 4)  & 0x1F;
        m_rxConfig.nVControlEn  = (m_rxConfigBits >> 3)  & 0x01;
        m_rxConfig.padDebug     = (m_rxConfigBits >> 2)  & 0x01;
        m_rxConfig.locus        =  m_rxConfigBits        & 0x03;
        m_configAddr            =  confRegAddr;
confRegData tmp = m_rxConfig;       
configRegBulkRead(confRegAddr);
m_rxConfig = tmp;       
     }
     else
         warning("@" + itos(confRegAddr) + " is not a valid Configuration Register address.","LSDCv1::getConfigReg");   
}

//Basic writing operations...
void LSDelayChipV1::configRegBulkWrite(U8 confRegAddr, U16 confRegData)
{
    U8* buffer = m_regConfig->io()->dataU8();
    buffer[2] = confRegAddr;
    buffer[1] = (confRegData >> 8) & 0xFF;
    buffer[0] =  confRegData       & 0xFF;
    if(m_regConfig->write().isFailure())    warning("LSDelayChipV1 configuration register write failure.");
    else                                    debug("Config. Register phase (@"+ itohs(confRegAddr) + ") = 0x" + itohs(confRegData),"LSDCv1::configRegBulkWrite");
}

// SPI Configuration Data Frame:
//       1b       1b          5b             5b             1b           1b       2b
//  LVDS Out en  -N.U-  Phase T&H (ADC)    Phase INT    !VCNT Out En    DEBUG    LOCUS
void LSDelayChipV1::setConfigReg(U8 confRegAddr, confRegData d)
{
    U16 data;
    bool ok = checkConfigAddr(confRegAddr);
    if(ok)
    {
        data = ((d.lvdsOutEn & 0x01) << 15) | ((d.phaseTaHAdc & 0x1F) << 9) | ((d.phaseInt & 0x1F) << 4) | ((d.nVControlEn & 0x01) << 3) | ((d.padDebug & 0x01) << 2) | (d.locus & 0x03);
        configRegBulkWrite(confRegAddr,data);
configRegBulkWrite(confRegAddr,data);   
    }
    else
         warning("@" + itos(confRegAddr) + " is not a valid Configuration Register address.","LSDCv1::setConfigReg");   
}

// Safe way to modify data: data is read from the register and 
// then we modify the value that we want.
void LSDelayChipV1::setConfigRegPhaseADC(U8 confRegAddr, U8 phaseADC)
{
    getConfigReg(confRegAddr);
    m_rxConfig.phaseTaHAdc = phaseADC;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegPhaseTH(U8 confRegAddr, U8 phaseTH)
{
    getConfigReg(confRegAddr);
    m_rxConfig.phaseTaHAdc = phaseTH;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegPhaseINT(U8 confRegAddr, U8 phaseINT)
{
    getConfigReg(confRegAddr);
    m_rxConfig.phaseInt = phaseINT;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegLVDSOutEn(U8 confRegAddr, bool en)
{
    getConfigReg(confRegAddr);
    m_rxConfig.lvdsOutEn = en;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegDebugMode(U8 confRegAddr, bool en)
{
    getConfigReg(confRegAddr);
    m_rxConfig.padDebug = en;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegVControlOutEn(U8 confRegAddr, bool en)
{
    getConfigReg(confRegAddr);
    m_rxConfig.nVControlEn = !en;
    setConfigReg(confRegAddr,m_rxConfig);
}

void LSDelayChipV1::setConfigRegLOCUS(U8 confRegAddr, U8 locus)
{
    getConfigReg(confRegAddr);
    m_rxConfig.locus = locus;
    setConfigReg(confRegAddr,m_rxConfig);
}

//Commands...
void LSDelayChipV1::resetPumps()
{
    configRegBulkWrite(CHARGEPUMP_SOFT_RST,0);
}

void LSDelayChipV1::bypassMisoMosi(U16 writeData)
{
    configRegBulkWrite(SC_MOSI_MISO_BYPASS,writeData);
}

//Info...
void LSDelayChipV1::showConfig()
{
    std::string lvdsCurrent;    
    if(m_rxConfig.lvdsOutEn)
    {
        if(m_rxConfig.locus == LOCUS_3000_UA) lvdsCurrent = "3.00";
        if(m_rxConfig.locus == LOCUS_2300_UA) lvdsCurrent = "2.30";
        if(m_rxConfig.locus == LOCUS_1400_UA) lvdsCurrent = "1.40";
        if(m_rxConfig.locus == LOCUS_0350_UA) lvdsCurrent = "0.35";     
    }
    else lvdsCurrent = "0.00";
    
    info("Configuration register @SPI = 0x" + itohs(m_configAddr)              ,"LSDCv1::showConfig");
    info("Integrator clock phase (ns) = " + itos(m_rxConfig.phaseInt)          ,"LSDCv1::showConfig");
    info("T&H // ADC clock phase (ns) = " + itos(m_rxConfig.phaseTaHAdc)       ,"LSDCv1::showConfig");  
    info("LVDS Clock Output enable    = " + itos((int)m_rxConfig.lvdsOutEn)    ,"LSDCv1::showConfig");
    info("LVDS Output Current (mA)    = " + lvdsCurrent                        ,"LSDCv1::showConfig");
    info("VControl Output enable      = " + itos((int)!m_rxConfig.nVControlEn) ,"LSDCv1::showConfig");
    info("CMOS Pads debug             = " + itos((int)m_rxConfig.padDebug)     ,"LSDCv1::showConfig");
}


//                      SPI Slave BER Test                         //
void LSDelayChipV1::spiBERTest(U8 confRegAddr, long nFrames)
{
    int i;
    U16 writeData = 0x0000;
    U16 readData, retry1, retry2, retry3;

    warning("Starting SPI BER test...");
    m_nBad = 0;
    for(i=0;i<nFrames;i++)
    {
        //I read and write the same register and I check if read data is OK.
        writeData = rand() + rand();    
        configRegBulkWrite(confRegAddr,writeData);
configRegBulkWrite(255,writeData);
        configRegBulkRead(confRegAddr); 
configRegBulkWrite(255,writeData);
        readData = m_rxConfigBits;
        if(writeData != readData)
        {
            //If data is not OK I check how many bits are wrong.
            m_nBad++;
            warning("Mismatch: W = 0x" + itohs(writeData) + ", R = 0x" + itohs(readData) + ".","LSDCv1::spiBERTest");
            debug("Retry...","LSDCv1::spiBERTest");
            configRegBulkRead(confRegAddr);
configRegBulkWrite(255,writeData);          
            retry1 = m_rxConfigBits;
            configRegBulkRead(confRegAddr);
configRegBulkWrite(255,writeData);          
            retry2 = m_rxConfigBits;
            configRegBulkRead(confRegAddr);
configRegBulkWrite(255,writeData);          
            retry3 = m_rxConfigBits;            
            if(retry1 == retry2 && retry1 == retry3 && retry2 == retry3)
            {
                if(retry1 == readData)  warning("It was a Write error!","LSDCv1::spiBERTest");          
                if(retry1 == writeData) warning("It was a Read error!","LSDCv1::spiBERTest");          
            } 
        }
    }
    m_fer = (double) m_nBad / nFrames;
    warning("SPI BER test finished!!!");
    warning("Bad frames = " + itos(m_nBad) + "/" + itos(nFrames) + ".");
}


void LSDelayChipV1::reset(){
/*
  U8* buffer=m_regConfig->io()->dataU8();
  buffer[2]=64;
  buffer[1]=0;
  buffer[0]=0;
  if (m_regConfig->write().isFailure()){
    warning("LSDelayChipV1 configuration register write failure. Cannot reset LSDelayChipV1",
        "LSDCv1::write");
  }
  */
}