UsbFTMLInterface.cpp

Go to the documentation of this file.

//$Id: UsbFTMLInterface.cpp,v 1.1.1.1 2005/01/05 16:42:10 machefer Exp $
//------------------------------------------------------------------------------
//
//  Package    : UsbFTMLInterface
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 14 January 2004
//
//------------------------------------------------------------------------------

#include "UsbFTMLInterface.h"


//=========================================================================
//  
//=========================================================================
UsbFTMLInterface::UsbFTMLInterface ( ) : 
  m_usbId(-1),
  m_serialNum(std::string("None")),
  m_deviceDesc(std::string("None")),
  m_latencyTimer(2),
  m_txTimeOut(1000),
  m_rxTimeOut(1000),
  m_txBuffer(4096),
  m_rxBuffer(32768),
  m_nFrames (0),
  m_wordSize(WS_DWord),
  m_fakeErr (FK_LETSBETRUE),
  m_rdBlockMax(65536),
  m_wrBlockMax(65536),
  m_interrupts(true),
  m_showEpromState(false),
  m_printout(false)
{ 
  setName("usb");
  setType("UsbFTMLInterface");
  info("Todo : time efficiency by creating the buffer once for all ?");
  //  add(Attrib::INTERFACE);
}


//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::init ( ) {
  unsigned char msecs=0;
  char desc[256];
  char serial[64];      

  strcpy(desc  , m_deviceDesc.c_str());
  strcpy(serial, m_serialNum.c_str());  

  info("Start USB device initialisation.","UsbFTMLInterface::init");
  if (m_usbId>0)
  {
    error("Usb device already open.","UsbFTMLInterface::init");    
    close();
  }
  if (!USB_FindDevices(desc))
  {
    USB_Perror(USB_GetLastError());
    error("Cannot find Usb Device "+name()+" with device description "+
          m_deviceDesc,"UsbFTMLInterface::init");
  }
  else
    {  
    info("Device with device description "+m_deviceDesc+" found.","UsbFTMLInterface::init");
    info("Try to open device with serial number "+m_serialNum+".","UsbFTMLInterface::init");
    m_usbId=OpenUsbDevice(serial);
    if (m_usbId<0)
    {
      error("Could not find device with serial number "+m_serialNum,"UsbFTMLInterface::init");
      if (GetDeviceSerNum(serial,0)!=FT_OK)
      {
        error("Serial number do not match first device found.","UsbFTMLInterface::init");
      }
      else
      {
        info("Extracted serial number "+std::string(serial)+".","UsbFTMLInterface::init");
        if (GetDeviceDesc(desc,0)!=FT_OK)
        {
          USB_Perror(USB_GetLastError());  
          fatal("Device description do not match first device either. Abort",
                "UsbFTMLInterface::init");
        }
        else
        {
          info("Device found. Extracted description "+std::string(desc)+".",
               "UsbFTMLInterface::init");
          m_usbId=OpenUsbDevice(serial);
          if (m_usbId<0)
          {
            USB_Perror(USB_GetLastError());  
            fatal("Cannot open device. Abort.","UsbFTMLInterface::init"); 
          }          
        }
      }
    }
    
    info("Device opened with UsbId "+itos(m_usbId)+".","UsbFTMLInterface::init");

    m_deviceDesc = std::string(desc);
    m_serialNum  = std::string(serial);
    
    UsbSetIntCheckingState(m_interrupts);
    if (!USB_Init(m_usbId,true))
    {
      USB_Perror(USB_GetLastError());  
      fatal("Could not initialize the USB device "+name()+". Abort.",
            "UsbFTMLInterface::init");
    }

    info("Usb device initialization done.","UsbFTMLInterface::init");

    USB_SetLatencyTimer(m_usbId,m_latencyTimer);
    USB_SetTimeouts(m_usbId,m_txTimeOut,m_rxTimeOut);
    USB_SetXferSize(m_usbId,m_txBuffer ,m_rxBuffer);
    USB_GetLatencyTimer(m_usbId, &msecs);

    USB_SetSynchronousMode(m_usbId, 100);
    USB_ResetMode(m_usbId);
    //   UsbSetMaxLayer(m_usbId,1);
  }
  USB_PurgeBuffers(m_usbId); // PurgeBuffers après le reset cause une erreur lors de la première lecture effectuée via le port usb.
  USB_ResetDevice(m_usbId);
  wait(1000);
  USB_PurgeBuffers(m_usbId); 
  return StatusCode::SUCCESS;
}


//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::read(unsigned long int address,
                                unsigned long int nWords,
                                boost::python::list &obj)
{
  StatusCode status;
  verbose("USB Reading :","UsbFTMLInterface::read");
  switch (m_wordSize)
  {
  case WS_Byte:
    {  
      unsigned char *data=new unsigned char[nWords];
      status = usbReadU8( address, nWords, data);
      info("Data format is "+itos(WS_Byte),"UsbFTMLInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      status = usbReadU16( address, nWords, data);
      verbose("Data format is "+itos(WS_Word),"UsbFTMLInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      status = usbReadU32( address, nWords, data);
      verbose("Data format is "+itos(WS_DWord),"UsbFTMLInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;    
  default:
    error("Wrong word size.","UsbFTMLInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::write(unsigned long int address,
                                 boost::python::list obj) 
{
  unsigned long int nWords = len(obj);
  StatusCode status;
  verbose("USB Writing :");
  switch (m_wordSize)
  {
  case WS_Byte:
    {  
      unsigned char *data=new unsigned char[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=(boost::python::extract<unsigned char>(obj[i]));
        verbose("Data format is "+itos(WS_Byte),"UsbFTMLInterface::write");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::write");
      };
      status = usbWriteU8(address, nWords, data);
      delete data;
    }
    break;
  case WS_Word:
    { 
      unsigned short *data=new unsigned short[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        verbose("Data format is "+itos(WS_Word),"UsbFTMLInterface::write");
        data[i]=(boost::python::extract<unsigned short>(obj[i]));
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::write");
      };
      status = usbWriteU16(address, nWords, data);
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=(boost::python::extract<unsigned long>(obj[i]));
        verbose("Data format is "+itos(WS_DWord),"UsbFTMLInterface::write");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::write");
      }    
      status = usbWriteU32(address, nWords, data);
      delete data;
    }
    break;
  default:
    error("Wrong word size.","read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbRead(unsigned long int address,
                                  unsigned long int nWords,
                                  std::vector<U32> &words)
{
  StatusCode status;
  verbose("USB Reading :","UsbFTMLInterface::read");
  words.clear();
  words.reserve(nWords);
  switch (m_wordSize)
  {
  case WS_Byte:
    {
      unsigned char *data=new unsigned char[nWords];
      status = usbReadU8( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      status = usbReadU16( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      status = usbReadU32( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  default:
    error("Wrong word size.","UsbFTMLInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTMLInterface::usbWrite(unsigned long int address,
                                    std::vector<U32> words)
{
  unsigned long int nWords = words.size();
  StatusCode status;
  verbose("USB Writing :");
  switch (m_wordSize)
  {
  case WS_Byte:
    {
      unsigned char *data=new unsigned char[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_Byte),"UsbFTMLInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::usbWrite");
      };
      status = usbWriteU8(address, nWords, data);
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_Word),"UsbFTMLInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::usbWrite");
      };
      status = usbWriteU16(address, nWords, data);
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_DWord),"UsbFTMLInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]) ,"UsbFTMLInterface::usbWrite");
      }
      status = usbWriteU32(address, nWords, data);
      delete data;
    }
    break;
  default:
    error("Wrong word size.","read");
    status=StatusCode::FAILURE;
  }
  return status;
}
//=========================================================================
//
//=========================================================================
StatusCode UsbFTMLInterface::usbReadU8 ( unsigned long int address, 
                                       unsigned long int nWords, 
                                       unsigned char *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

  long int nData = (long int)(nWords);

  int path = -1;
  
  bytecount=UsbReadML(m_usbId, &path, address, data, nData);

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTMLInterface::usbRead8");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTMLInterface::usbRead8");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead8");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead8");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbReadU16 ( unsigned long int address, 
                                        unsigned long int nWords, 
                                        unsigned short *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

  verbose("in UsbReadU16.");


  long int nData = (long int)(2*nWords);
  
  unsigned char *buff=new unsigned char [nData];

  
  verbose("before usbread");

  int path  = -1;
  bytecount=UsbReadML(m_usbId, &path, address, buff, nData);
  
  verbose("after usbread");
  
  for (unsigned long word=0; word<nWords; ++word)
  {
    data[word]=buff[2*word+1];
    data[word]=(data[word]<<8)|buff[2*word];
  }

  delete buff;

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTMLInterface::usbReadU16");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTMLInterface::usbReadU16");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".",
          "UsbFTMLInterface::usbReadU16");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.",
          "UsbFTMLInterface::usbReadU16");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//========================================================================= 
StatusCode UsbFTMLInterface::usbReadU32 ( unsigned long int address, 
                                        unsigned long int nWords, 
                                        unsigned long *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

  long int nData = (long int)(4*nWords);
  
  unsigned char *buff=new unsigned char [nData];

  int path = -1;
  
  bytecount=UsbReadML(m_usbId, &path, address, buff, nData);

  for (unsigned long word=0; word<nWords; ++word)
  {
    data[word]=buff[4*word+3];
    data[word]=(data[word]<<8)|buff[4*word+2];
    data[word]=(data[word]<<8)|buff[4*word+1];
    data[word]=(data[word]<<8)|buff[4*word];
  }

  delete buff;

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTMLInterface::usbRead");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTMLInterface::usbRead32");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead32");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead32");
    return StatusCode::FAILURE;    
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbWriteU8 (unsigned long int address ,
                                       unsigned long int nWords, 
                                       unsigned char *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(nWords);

  int path = -1;
  bytecount=UsbWrtML(m_usbId, &path, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTMLInterface::usbWrite8");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTMLInterface::usbWrite8");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::usbWrite8");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTMLInterface::usbWrite8");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbWriteU16 (unsigned long int address ,
                                        unsigned long int nWords, 
                                        unsigned short *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(2*nWords);

  int path = -1;
  bytecount=UsbWrtML(m_usbId, &path, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTMLInterface::usbWrite16");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTMLInterface::usbWrite16");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::usbWrite16");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTMLInterface::usbWrite16");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbWriteU32 (unsigned long int address ,
                                        unsigned long int nWords, 
                                        unsigned long *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(4*nWords);

  int path = -1;
  bytecount=UsbWrtML(m_usbId, &path, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTMLInterface::usbWrite32");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTMLInterface::usbWrite32");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::usbWrite32");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTMLInterface::usbWrite32");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTMLInterface::usbWriteRead ( unsigned long int address, 
                                          std::vector<U8> dataWrite, 
                                          std::vector<U8> &dataRead ) {
  USB_Error rdErr=USB_NoErr, wrErr=USB_NoErr;
  long int bytecount=0;
  long int nData=dataWrite.size();
  const unsigned long int bufSize=nData+4;
  U8* bufWr=new U8[bufSize];
  U8* bufRd=new U8[bufSize];

  for(int j=0; j<nData; ++j) bufWr[j] = static_cast<unsigned char>(dataWrite[j]);

  int path = -1;
  bytecount=UsbWrtML(m_usbId, &path, address, bufWr, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTMLInterface::usbWriteRead");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTMLInterface::usbWriteRead");

    int path = -1;
    bytecount=UsbReadML(m_usbId, &path, address, bufRd, nData);

    if (nData==bytecount){
      verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
              "UsbFTMLInterface::usbRead");
      for(int j=0; j<nData; ++j) dataRead[j] = static_cast<unsigned char>(bufRd[j]);
      return StatusCode::SUCCESS;
    }

    if (bytecount<0){
      rdErr=USB_GetLastError();
      error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
              " UsbFTMLInterface::usbWriteRead");
      if (rdErr==USB_INT_FRAME){
        PrintFrameInfo();
      } 
      return StatusCode::FAILURE;
    }
  
    if (0==bytecount){
      error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead");
      return StatusCode::FAILURE;
    }

    if (nData!=bytecount){
      error(itos(bytecount)+" byte(s) read from USB interface "+name()+
              " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead");
      return StatusCode::FAILURE;    
    } 
  }
  
  
  if (0==bytecount){
    error(" O Byte written n USB interface "+name()+".","UsbFTMLInterface::usbWrite");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTMLInterface::usbWrite");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;    return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
void UsbFTMLInterface::close ( ) {
  if (m_usbId>0)
  {    
    info("Close USB device "+name()+" [id="+itos(m_usbId)+"]","UsbFTMLInterface::close");
    CloseUsbDevice( m_usbId );
  }
  m_usbId=-1;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTMLInterface::read(IOdata *io){

  unsigned long int address = io->address();
  unsigned long int nWords = io->length();

  StatusCode status;
  switch (io->wordSize())
  {
  case (IOdata::Byte):
    if (nWords<m_rdBlockMax+1){
      verbose("Reading a single block "+itos(nWords)+"/"+itos(m_rdBlockMax),
              "UsbFTMLInterface::read");
      status = usbReadU8( address, nWords, io->dataU8());        
    }
    else {
      //      int nwords=nWords;
      U8* data=io->dataU8();
      int nXfer=(int)(nWords/m_rdBlockMax)+1;
      for (int i=0; i<nXfer ; ++i){
        if (i<nXfer-1){
          verbose("Reading block "+itos(i)+
                  " of size "+itos(m_rdBlockMax),
                  "UsbFTMLInterface::read");
          status = usbReadU8( address, 
                              m_rdBlockMax , 
                              data);
          data+=sizeof(U8*)*m_rdBlockMax;
        }
        else {
          verbose("Reading last block "+itos(i)+
                  " of size "+itos(nWords%m_rdBlockMax),
                  "UsbFTMLInterface::read");
          status = usbReadU8( address, 
                              nWords%m_rdBlockMax , 
                              data); 
          data+=sizeof(U8*)*(nWords%m_rdBlockMax);
        }
      }
    }
    break;
  case (IOdata::Word):
    status = usbReadU16( address, nWords, io->dataU16());
    break;
  case (IOdata::DWord):
    status = usbReadU32( address, nWords, io->dataU32());
    break;
  default:
    error("Wrong word size.","UsbFTMLInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTMLInterface::write(IOdata *io){

  unsigned long int address = io->address();
  unsigned long int nWords  = io->length();
  StatusCode status;
  switch (io->wordSize())
  {
  case (IOdata::Byte):
    if (nWords<m_wrBlockMax+1){
      verbose("Writing a single block "+itos(nWords)+"/"+itos(m_wrBlockMax),
              "UsbFTMLInterface::write");
      status = usbWriteU8(address, nWords, io->dataU8());
    }
    else {
      //      int nwords=nWords;
      U8* data=io->dataU8();
      int nXfer=(int)ceil((float)(nWords)/(float)(m_wrBlockMax));
      verbose("number of Xfer="+itos(nXfer)+
              " "+itos(m_wrBlockMax)+
              " "+itos(nWords),"");
      for (int i=0; i<nXfer ; ++i){
        if (i<nXfer-1){
          verbose("Writing block "+itos(i)+
                  " of size "+itos(m_wrBlockMax),
                  "UsbFTMLInterface::write");
          status = usbWriteU8( address, 
                               m_wrBlockMax , 
                               data);
          data+=sizeof(U8)*m_wrBlockMax;
        }
        else {
          //nWords%m_wrBlockMax
          unsigned int nwords=nWords-(nXfer-1)*m_wrBlockMax;
          verbose("Writing last block "+itos(i)+
                  " of size "+itos(nwords),
                  "UsbFTMLInterface::write");
          status = usbWriteU8( address, 
                               nwords, 
                               data); 
          data+=sizeof(U8)*(nwords);
        }
      }
    }
    break;
  case (IOdata::Word):
    status = usbWriteU16(address, nWords, io->dataU16());
    break;
  case (IOdata::DWord):
    status = usbWriteU32(address, nWords, io->dataU32());
    break;
  default:
    error("Wrong word size.","UsbFTMLInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}