roclib/src_roc/I2cDevice.cxx (r4864/r4162)

Go to the documentation of this file.

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

#include "roc/I2cDevice.h"

#include <stdio.h>

#include "roc/defines_roc.h"
#include "roc/defines_i2c.h"
#include "roc/defines_spi.h"

//----------------------------------------------------------------------------
roc::I2cDevice::I2cDevice() :
  base::Peripheral(), fUseSPI(false), fPort(0), fSlaveAddr(0)
{
}


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

roc::I2cDevice::I2cDevice(base::Board* board, int port, uint8_t addr) :
  base::Peripheral(board), fUseSPI(false), fPort(port), fSlaveAddr(addr)
{
   if (board->is_SPI_I2C()) fUseSPI = true;
}

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

roc::I2cDevice::~I2cDevice()
{
}

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

int roc::I2cDevice::setRegister(uint8_t reg, uint8_t val, bool veri)
{

   bool isput[7];
   uint32_t addr[7];
   uint32_t data[7];
   int rc;

   if (isSPI()) {

      isput[0] = true;   addr[0] = ROC_SPI_COMMAND;        data[0] = 0x20;
      isput[1] = true;   addr[1] = ROC_SPI_TXDATA;         data[1] = (0x1 << 24) | (fSlaveAddr << 16) | (reg << 8) | val;
      isput[2] = true;   addr[2] = ROC_SPI_TRANSMIT;       data[2] = 0x1;
      isput[3] = false;  addr[3] = ROC_SPI_RXDATA;         data[3] = 0x0;
      isput[4] = false;  addr[4] = ROC_SPI_MASTER_STATUS;  data[4] = 0x0;

      int nop = 5;

      rc = board().operGen(isput, addr, data, nop);

      if (rc==0) {
         if ((data[3] & 0xff00) != 0x2000) {
            printf("SPI-I2C RXDATA error\n");
            rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
         }

         if ((data[4] & 1) != 1) {
            printf("SPI-I2C MASTER_STATUS CRC-error\n");
            rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
         }
      }

   } else {

      isput[0] = true;  addr[0] = ROC_NX_I2C_SWITCH;    data[0] = fPort;
      isput[1] = true;  addr[1] = ROC_NX_I2C_SLAVEADDR; data[1] = fSlaveAddr;
      isput[2] = true;  addr[2] = ROC_NX_I2C_REGISTER;  data[2] = reg;
      isput[3] = true;  addr[3] = ROC_NX_I2C_DATA;      data[3] = val;
      isput[4] = false; addr[4] = ROC_NX_I2C_ERROR;
      isput[5] = false; addr[5] = ROC_NX_I2C_DATA;
      isput[6] = false; addr[6] = ROC_NX_I2C_ERROR;

      int nop = veri ? 7 : 5;

      rc = board().operGen(isput, addr, data, nop);

      if ((rc == 0) && (data[4] != 0)) {            // check I2C bus error on put
         rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
      }

      if (veri) {
         if (rc == 0 && data[6] != 0) {          // check I2C bus error on readback
            rc = base::Board::operErrBuild(base::Board::kOperBusErr, 1);
         }
         if (rc == 0 && val != (data[5]&0xff)) { // check readback value
            rc = base::Board::kOperVerifyErr;
         }
      }

   }

   return rc;
}

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

int roc::I2cDevice::getRegister(uint8_t reg, uint8_t& val)
{
  bool isput[5];
  uint32_t addr[5];
  uint32_t data[5];
  int rc;

  if (isSPI()) {

     isput[0] = true;   addr[0] = ROC_SPI_COMMAND;        data[0] = 0x30;
     isput[1] = true;   addr[1] = ROC_SPI_TXDATA;         data[1] = (0x1 << 24) | (fSlaveAddr << 16) | (reg << 8) | 0;
     isput[2] = true;   addr[2] = ROC_SPI_TRANSMIT;       data[2] = 0x1;
     isput[3] = false;  addr[3] = ROC_SPI_RXDATA;         data[3] = 0x0;
     isput[4] = false;  addr[4] = ROC_SPI_MASTER_STATUS;  data[4] = 0x0;

     int nop = 5;

     rc = board().operGen(isput, addr, data, nop);

     printf("Get I2C register %u\n", reg);

     if (rc==0) {
        val = data[3] & 0xff;

        if ((data[3] & 0xff00) != 0x3000) {
           printf("SPI-I2C error\n");
           rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
        }

        if ((data[4] & 1) != 1) {
           printf("SPI-I2C CRC-error\n");
           rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
        }
     }

     return rc;
  }


  isput[0] = true;  addr[0] = ROC_NX_I2C_SWITCH;    data[0] = fPort;
  isput[1] = true;  addr[1] = ROC_NX_I2C_SLAVEADDR; data[1] = fSlaveAddr;
  isput[2] = true;  addr[2] = ROC_NX_I2C_REGISTER;  data[2] = reg;
  isput[3] = false; addr[3] = ROC_NX_I2C_DATA;
  isput[4] = false; addr[4] = ROC_NX_I2C_ERROR;

  rc = board().operGen(isput, addr, data, 5);

  val = uint8_t(data[3]);

  if (rc == 0 && data[4] != 0) {            // check I2C bus error on get
    rc = base::Board::kOperBusErr;
  }
  
  return rc;
}

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

int roc::I2cDevice::getRegister16(uint8_t reg, uint16_t& val)
{
   if (isSPI()) {
      printf("No 16-bit read operations for SPI-I2C interface\n");
      return 1;
   }

   bool isput[7];
   uint32_t addr[7];
   uint32_t data[7];
   int rc;

   isput[0] = true;  addr[0] = ROC_NX_I2C_SWITCH;    data[0] = fPort;
   isput[1] = true;  addr[1] = ROC_NX_I2C_SLAVEADDR; data[1] = fSlaveAddr;
   isput[2] = true;  addr[2] = ROC_NX_I2C_REGISTER;  data[2] = reg;
   isput[3] = true;  addr[3] = ROC_NX_I2C_READ16;    data[3] = 1;
   isput[4] = false; addr[4] = ROC_NX_I2C_DATA;
   isput[5] = false; addr[5] = ROC_NX_I2C_ERROR;
   isput[6] = true;  addr[6] = ROC_NX_I2C_READ16;    data[6] = 0;

   rc = board().operGen(isput, addr, data, 7);

   val = uint16_t(data[4]);

   if (rc == 0 && data[5] != 0) {            // check I2C bus error on get
      rc = base::Board::kOperBusErr;
   }

   return rc;
}

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

int roc::I2cDevice::setRegisterVerify(uint8_t reg, uint8_t valset, 
                                      uint8_t& valget)
{
   if (isSPI()) {
      valget = valset;
      return setRegister(reg, valset, true);
   }


  bool isput[7];
  uint32_t addr[7];
  uint32_t data[7];
  int rc;

  isput[0] = true;  addr[0] = ROC_NX_I2C_SWITCH;    data[0] = fPort;
  isput[1] = true;  addr[1] = ROC_NX_I2C_SLAVEADDR; data[1] = fSlaveAddr;
  isput[2] = true;  addr[2] = ROC_NX_I2C_REGISTER;  data[2] = reg;
  isput[3] = true;  addr[3] = ROC_NX_I2C_DATA;      data[3] = valset;
  isput[4] = false; addr[4] = ROC_NX_I2C_ERROR;
  isput[5] = false; addr[5] = ROC_NX_I2C_DATA;
  isput[6] = false; addr[6] = ROC_NX_I2C_ERROR;

  rc = board().operGen(isput, addr, data, 7);

  valget = uint8_t(data[5]);

  if (rc == 0 && data[4] != 0) {            // check I2C bus error on put
    rc = base::Board::operErrBuild(base::Board::kOperBusErr, 0);
  }
  if (rc == 0 && data[6] != 0) {            // check I2C bus error on readback
    rc = base::Board::operErrBuild(base::Board::kOperBusErr, 1);
  }
  
  return rc;
}

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

int roc::I2cDevice::setRegisterArray(uint8_t reg, const uint8_t *val, int nreg,
                                     bool veri)
{
  for (int i=0; i<nreg; i++) {
    int rc = setRegister(reg+i, val[i], veri);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  return 0;
}

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

int roc::I2cDevice::getRegisterArray(uint8_t reg, uint8_t *val, int nreg)
{
  for (int i=0; i<nreg; i++) {
    int rc = getRegister(reg+i, val[i]);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  return 0;
}

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

int roc::I2cDevice::setMailboxRegister(uint8_t reg, const uint8_t *val, int nval)
{
  for (int i=0; i<nval; i++) {
    int rc = setRegister(reg, val[i]);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  return 0;
}

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

int roc::I2cDevice::getMailboxRegister(uint8_t reg, uint8_t *val, int nval)
{
  for (int i=0; i<nval; i++) {
    int rc = getRegister(reg, val[i]);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  return 0;
}

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

void roc::I2cDevice::addAddrMap(base::Board* board)
{
   if (board->is_SPI_I2C()) {
      board->addRegAddrMapping("ROC_SPI_COMMAND", ROC_SPI_COMMAND);
      board->addRegAddrMapping("ROC_SPI_TXDATA", ROC_SPI_TXDATA);
      board->addRegAddrMapping("ROC_SPI_TRANSMIT", ROC_SPI_TRANSMIT);
      board->addRegAddrMapping("ROC_SPI_RXDATA", ROC_SPI_RXDATA);
      board->addRegAddrMapping("ROC_SPI_MASTER_STATUS", ROC_SPI_MASTER_STATUS);
   } else {
      board->addRegAddrMapping("ROC_NX_I2C_DATA", ROC_NX_I2C_DATA);
      board->addRegAddrMapping("ROC_NX_I2C_SLAVEADDR", ROC_NX_I2C_SLAVEADDR);
      board->addRegAddrMapping("ROC_NX_I2C_REGISTER", ROC_NX_I2C_REGISTER);
      board->addRegAddrMapping("ROC_NX_I2C_ERROR", ROC_NX_I2C_ERROR);
      board->addRegAddrMapping("ROC_NX_I2C_SWITCH", ROC_NX_I2C_SWITCH);
      board->addRegAddrMapping("ROC_NX_I2C_READ16", ROC_NX_I2C_READ16);
   }
}

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