UsbSpiBus.cpp

Go to the documentation of this file.

// $Id: $
// Include files


// local
#include "UsbSpiBus.h"

//-----------------------------------------------------------------------------
// Implementation file for class : UsbSpiBus
//
// 2006-10-23 :
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
UsbSpiBus::UsbSpiBus(  ) {
  setName("UsbSpiBus");
  setType("UsbSpiBus");
  
  m_dataLength=32;
  m_aSS      = true;
  m_lSBFirst = true;
  m_txNeg    = true;
  m_rxNeg    = true;

  m_regCtrl        = new Register();
  m_regClockDivider= new Register();
  m_regSlaveSelect = new Register();
  m_regRxData      = new Register();
  m_regTxData      = new Register();

  m_regCtrl        ->setName("CtrlReg");
  m_regClockDivider->setName("ClockDividerReg");
  m_regSlaveSelect ->setName("SlaveSelectReg");
  m_regRxData      ->setName("RxDataReg");
  m_regTxData      ->setName("TxDataReg");

  m_regCtrl        ->io()->defDataU8(4);
  m_regClockDivider->io()->defDataU8(4);
  m_regSlaveSelect ->io()->defDataU8(4);
  m_regRxData      ->io()->defDataU8(4);
  m_regTxData      ->io()->defDataU8(4);

  m_regCtrl        ->io()->setAddress(64);
  m_regClockDivider->io()->setAddress(65);
  m_regSlaveSelect ->io()->setAddress(66);
  m_regRxData      ->io()->setAddress(67);
  m_regTxData      ->io()->setAddress(67);

  m_regCtrl        ->io()->setWordSize(IOdata::Byte);
  m_regClockDivider->io()->setWordSize(IOdata::Byte);
  m_regSlaveSelect ->io()->setWordSize(IOdata::Byte);
  m_regRxData      ->io()->setWordSize(IOdata::Byte);
  m_regTxData      ->io()->setWordSize(IOdata::Byte);
  
  addChild(m_regCtrl);
  addChild(m_regClockDivider);
  addChild(m_regSlaveSelect);
  addChild(m_regRxData);
  addChild(m_regTxData);
}
//=============================================================================
// Destructor
//=============================================================================
UsbSpiBus::~UsbSpiBus() {
//  delete m_regData;
//  delete m_regAddress;
}

//=============================================================================
//
//=============================================================================
StatusCode UsbSpiBus::init() {
  if (0==m_connection){
    if (0==this->parent()){
      fatal("Cannot define connection for "+type()+". No parent found.",
          "UsbSpiBus::init");
        return StatusCode::FAILURE;
    }
    return setConnection(this->parent());
  }
  else return StatusCode::SUCCESS;
}

//=============================================================================
//
//=============================================================================
void UsbSpiBus::ctrlWd(U8 length) {
  U8* buffer=m_regCtrl->io()->dataU8();
  buffer[0]=m_dataLength;
  buffer[1]=
    (m_aSS<<5)+
    (m_lSBFirst<<3)+
    (m_txNeg<<2)+
    (m_rxNeg<<1)+
    1;
  buffer[2]=length&0x1;
  buffer[3]=length&0x3F;  
}

//=============================================================================
//
//=============================================================================
StatusCode UsbSpiBus::setClockDivider(U32 value){
  Interface* connection = dynamic_cast<Interface*> (m_connection);
  U8* buffer=m_regClockDivider->io()->dataU8();
  buffer[0]= value&0xFF;
  buffer[1]= (value>>8)&0xFF;
  buffer[2]= (value>>16)&0xFF;
  buffer[3]= (value>>24)&0xFF;
  if (connection->write(m_regClockDivider->io()).isFailure()){
    warning("Cannot write ClockDivider register on UsbSpiBus",
        "UsbSpiBus::setClockDivider");
    return StatusCode::FAILURE;
  } 
  if (value!=clockDivider()){
    warning("ClockDivider read/write mismatch.","UsbSpiBus::setClockDivider");
    return StatusCode::FAILURE;
  };
  return StatusCode::SUCCESS;
}

//=============================================================================
//
//=============================================================================
unsigned int long UsbSpiBus::clockDivider(){
  Interface* connection = dynamic_cast<Interface*> (m_connection);
  U8* buffer=m_regClockDivider->io()->dataU8();
  if (connection->read(m_regClockDivider->io()).isFailure()){
    warning("Cannot read ClockDivider register on UsbSpiBus",
        "UsbSpiBus::clockDivider");
    return StatusCode::FAILURE;
  } 
  m_clockDivider=(buffer[0]+(buffer[1]<<8)+(buffer[1]<<16)+(buffer[1]<<24));
  return m_clockDivider;
}

//=============================================================================
//
//=============================================================================
StatusCode UsbSpiBus::read(IOdata* io){
  Interface* connection = dynamic_cast<Interface*> (m_connection);
  U8* buffer=m_regSlaveSelect->io()->dataU8();
  buffer[0]=(U8)(io->address());
  buffer[1]=(U8)(0);
  buffer[2]=(U8)(0);
  buffer[3]=(U8)(0);
  info("1) chipselect register:");
  m_regSlaveSelect->io()->dump(0);
  if (connection->write(m_regSlaveSelect->io()).isFailure()){
    warning("Cannot write SlaveSelect register on UsbSpiBus",
      "UsbSpiBus::read");
    return StatusCode::FAILURE;
  }
  m_dataLength=8*io->length();
  buffer=m_regTxData->io()->dataU8();
  //  for (int i=0; i<(io->length()-1); ++i) buffer[i]=10;
  buffer[io->length()-1]=io->dataU8(io->length()-1);
  m_regTxData->io()->dump(0); 
  if (connection->write(m_regTxData->io()).isFailure()){
    warning("Cannot write TxData register on UsbSpiBus","UsbSpiBus::write");
    return StatusCode::FAILURE;
  }
  info("2) spi read length (header included): "+itos(m_dataLength));
  ctrlWd(m_dataLength);
  info("3) Control word:");
  m_regCtrl->io()->dump(0);
  if (connection->write(m_regCtrl->io()).isFailure()){
    warning("Cannot write Ctrl register on UsbSpiBus","UsbSpiBus::write");
    return StatusCode::FAILURE;
  }
  if (connection->read(m_regRxData->io()).isFailure()){
    warning("Cannot read RxData register on UsbSpiBus",
        "UsbSpiBus::read");  ;
    return StatusCode::FAILURE;
  }
  info("4) spi data read:");
  m_regRxData->io()->dump(0);
  buffer=io->dataU8();
  for (unsigned int i=0; i<io->length()-1; ++i){
    if (i>3) {
      warning("Not implemented yet: cannot read more than 32 bits.",
          "UsbSpiBus::write");
      return StatusCode::FAILURE;
    }
    buffer[i]=m_regRxData->io()->dataU8(i);    
  }
  return StatusCode::SUCCESS;
}

//=============================================================================
//
//=============================================================================
StatusCode UsbSpiBus::write(IOdata* io){
  U8* buffer=m_regSlaveSelect->io()->dataU8();
  buffer[0]=(U8)(io->address());
  buffer[1]=(U8)(0);
  buffer[2]=(U8)(0);
  buffer[3]=(U8)(0);
  m_dataLength=8*io->length();
  info("1) spi write length (header included): "+itos(m_dataLength));
  Interface* connection = dynamic_cast<Interface*> (m_connection);
  info("2) chip select register:");
  m_regSlaveSelect->io()->dump(0);
  if (connection->write(m_regSlaveSelect->io()).isFailure()){
    warning("Cannot write SlaveSelect register on UsbSpiBus",
        "UsbSpiBus::write");
    return StatusCode::FAILURE;
  }
  info("3) spi data to be sent:");
  buffer=m_regTxData->io()->dataU8();
  for (unsigned int i=0; i<io->length(); ++i) {
    if (i>3) {
      warning("Not implemented yet: cannot send more than 32 bits.",
          "UsbSpiBus::write");
      return StatusCode::FAILURE;
    }
    buffer[i]=io->dataU8(i);
  }  
  m_regTxData->io()->dump(0);
  if (connection->write(m_regTxData->io()).isFailure()){
    warning("Cannot write TxData register on UsbSpiBus","UsbSpiBus::write");
    return StatusCode::FAILURE;
  }
  info("4) Control word:");
  ctrlWd(m_dataLength);
  m_regCtrl->io()->dump(0);
  if (connection->write(m_regCtrl->io()).isFailure()){
    warning("Cannot write Ctrl register on UsbSpiBus","UsbSpiBus::write");
    return StatusCode::FAILURE;
  }
  info("5) Spi transmission done.");
  return StatusCode::SUCCESS;
}

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