abbplugin/src/ABBdaemon.cxx (r4864/r2882)

Go to the documentation of this file.

#include "ABBdaemon.h"

#include "mprace/ABB.h"
#include "mprace/DMABuffer.h"

#include "abbdaemon/CTLpacket.h"
#include "abbdaemon/CTLresponse.h"

#include <iostream>
//#include <stdio.h>
using namespace std;

// These are FPGA registers
#define DID                     (0x0000 >> 2)
#define GSR                     (0x0020 >> 2)
#define CTL_H2R                 (0x00A0 >> 2)
#define CTL_R2H                 (0x00A0 >> 2)
#define DLM_H2R                 (0x00A4 >> 2)
#define DLM_R2H                 (0x00A4 >> 2)
#define CTL_STATUS              (0x00AC >> 2)
#define CTL_CONTROL             (0x00AC >> 2)

#define EVENT_BUFFER_STATUS     (0x0090 >> 2)

#define CTL_PACKET_AVAIL        (0x00000001)
#define CTL_FIFO_RESET          (0x0A)
#define EVENT_BUFFER_RESET      (0x0A)
#define CTL_EOP                 (0x10000)
#define CTL_SOP                 (0x20000)
#define CTL_MASK                (0x0000FFFF)
#define DLM_VALID               (0x00020000)
#define DLM_MASK                (0x0000000F)



abbdaemon::ABBdaemonClient::ABBdaemonClient(const char*, int role)
{
   try {
      board = new mprace::ABB(0);
   } catch (...) {
      board = 0;
      std::cerr << "Could not create ABB board. Is the driver properly loaded?" << std::endl;
   }

   debug = 0;

}

abbdaemon::ABBdaemonClient::~ABBdaemonClient()
{
   delete board;
   board = 0;
}

void abbdaemon::ABBdaemonClient::enableDebugMessages(bool enable)
{
   debug = enable ? &std::cout : 0;
}

uint32_t abbdaemon::ABBdaemonClient::submitReset(uint32_t what)
{
   if (board==0) return 1;

   if (debug) (*debug) << "Client wants to reset " << what << endl;
   if (what == RESET_ALL || what == RESET_CTL_FIFO) {
      if (debug) (*debug) << "Resetting CTL_FIFO" << endl;
      board->setReg(CTL_CONTROL, CTL_FIFO_RESET);
   }

   if (what == RESET_ALL || what == RESET_ABB) {
      if (debug) (*debug) << "Resetting eventbuffer" << endl;
      board->setReg(EVENT_BUFFER_STATUS, EVENT_BUFFER_RESET);
   }

   if (what == RESET_ALL || what == RESET_FIFO_TIMEOUT) {
      if (debug) (*debug) << "Resetting FIFO timeout flag" << endl;
      board->setReg(0x1E, 0x0A);
   }

   if (debug) (*debug) << "After reset status is: "
         << hex << board->getReg(CTL_STATUS) << dec << endl;

   if (debug) (*debug) << "General status register is: "
         << hex << board->getReg(GSR) << dec << endl;

   return 0;
}

uint32_t abbdaemon::ABBdaemonClient::submitNOper(uint32_t rocid, uint32_t retid, int t_number,
                                                  uint32_t *addrs, uint32_t *values,  uint32_t *retvals)
{
   if (board==0) return 1;

   uint32_t retcode = 0;
   
//   printf("submitNOper rocid = %x retid = %x noper = %d\n", rocid, retid, t_number);
   
 while ((t_number > 0) && (retcode==0)) {

   CTLpacket packet(rocid, retid);
   
   int number = t_number;
   if (number > 6) number = 6;

   for (int i = 0; i < number; i++) {
      uint32_t addr = addrs[i];

//      printf("   oper:%s addr[%d] = 0x%08x\n", (addrs[i] & 0x80000000 ? "PUT" : "GET"), i, addr & 0x7fffffff);

      /* Ignore the MSB */
      addr &= 0x7FFFFFFF;
      if (debug) (*debug) << i << " : " << addr << " = " << values[i] << endl;

      if (addrs[i] & 0x80000000)
         packet.add(CTLcommand(PUT, addr, values[i]));
      else
         packet.add(CTLcommand(GET, addr));
   }

   std::list<CTLresponse*> replies = packet.send(board);

   if (replies.size()==0) retcode = 2;

   std::list<CTLresponse*>::iterator iter = replies.begin();
   int i = 0;

   while (iter!=replies.end()) {

      CTLresponse* r = *iter++;

      CTLpacket::CTLcmd expected = ((addrs[i] & 0x80000000) ?
                           CTLpacket::ACKPUT :
                           CTLpacket::ACKGET);

      if (r->getCTLcmd() != expected) {
         retcode = 1;
         if (expected == CTLpacket::ACKGET)
            values[i] = -1;
         if (debug) (*debug) << "getCTLcmd = " << r->getCTLcmd() << ", expected = " << expected << endl;
         if (retvals) retvals[i] = -(r->getErrorCode());
         if (debug) (*debug) << "getErrorCode = " << r->getErrorCode() << ", value = " << -(r->getErrorCode()) << endl;
      } else {
         if (expected == CTLpacket::ACKGET)
            values[i] = r->getValue();

         if (retvals) retvals[i] = 0;
      }

      delete r;
      i++;
   }
     t_number -= number;
     addrs+=number;
     values+=number;
     retvals+=number;
//     if (t_number>0) printf("  Rest packet = %d\n", t_number);
 } 

 return retcode;
}

uint32_t abbdaemon::ABBdaemonClient::submitPut(uint32_t rocid, uint32_t retid, uint32_t addr, uint32_t value)
{
   addr |= 0x80000000;
   return submitNOper(rocid, retid, 1, &addr, &value, 0);
}

uint32_t abbdaemon::ABBdaemonClient::submitNPut(uint32_t rocid, uint32_t retid, int number,
                                                 uint32_t *addrs, uint32_t *values, uint32_t *retvals)
{
   for (int i=0;i<number;i++) addrs[i] |= 0x80000000;

   uint32_t retcode = submitNOper(rocid, retid, number, addrs, values, retvals);

   for (int i=0;i<number;i++) addrs[i] &= 0x7FFFFFFF;

   return retcode;
}

uint32_t abbdaemon::ABBdaemonClient::submitGet(uint32_t rocid, uint32_t retid, uint32_t addr, uint32_t *value)
{
   return submitNOper(rocid, retid, 1, &addr, value, 0);
}

uint32_t abbdaemon::ABBdaemonClient::submitNGet(uint32_t rocid, uint32_t retid, int number,
                                                 uint32_t *addrs, uint32_t *values, uint32_t *retvals)
{
   return submitNOper(rocid, retid, number, addrs, values, retvals);
}

uint32_t abbdaemon::ABBdaemonClient::submitPutDLM(uint32_t value)
{
   if (board==0) return 1;
   if (debug) (*debug) << "Requested DLM put with value: " << value << endl;

   try {
      board->setReg(DLM_H2R, (value & DLM_MASK) );
   } catch (mprace::Exception &e) {
      return 1;
   }

   return 0;
}

uint32_t abbdaemon::ABBdaemonClient::submitGetDLM(uint32_t *retvalue)
{
   if (board==0) return 1;

   try {
      volatile unsigned int valid;
      unsigned int value;

      if (debug) (*debug) << "Waiting for incoming data: " << flush;

      do {
         value = board->getReg(DLM_R2H);
         valid = (value & DLM_VALID);
         if (debug) (*debug) << "." << flush;
      } while (valid == 0);

      if (debug) (*debug) << " got a DLM!" << endl;
      if (debug) (*debug) << "Got DLM message: " << hex << value << dec << endl;

      if (retvalue) *retvalue = (value & DLM_MASK);
   } catch (mprace::Exception &e) {
      return 1;
   }

   return 0;
}

uint32_t abbdaemon::ABBdaemonClient::readDMAserialized(const unsigned int address,
                           DMABUFFER_HANDLE buffer_handle, const unsigned int count,
                           const unsigned int offset, const bool inc,
                           const bool lock, const float timeout)
{
   if (board==0) return 1;

   try {
      board->readDMAFIFO(address, *reinterpret_cast<mprace::DMABuffer*>(buffer_handle), count, offset, inc, lock, timeout);
      if (debug) (*debug) << "FIFO status: " << hex << board->getReg(0x24) << dec << endl;
      //if (lock) this->syncBuffer(buffer_handle); // already done in readDMAFIFO JAM
   } catch (mprace::Exception &e) {
      cerr << "Something failed" << endl;
      return 1;
   }

   return 0;
}

abbdaemon::DMABUFFER_HANDLE abbdaemon::ABBdaemonClient::registerBuffer(unsigned int len, void *address)
{
   if (debug) (*debug) << "Registering buffer at " << address << " of size " << len << endl;

   mprace::DMABuffer *buffer = new mprace::DMABuffer(*board, len, (unsigned int*)address);

   return (DMABUFFER_HANDLE) buffer;
}

void abbdaemon::ABBdaemonClient::syncBuffer(DMABUFFER_HANDLE buffer)
{
   if (buffer)
      (reinterpret_cast<mprace::DMABuffer*>(buffer))->sync(mprace::DMABuffer::FROMDEVICE);

}

void abbdaemon::ABBdaemonClient::unregisterBuffer(DMABUFFER_HANDLE buffer)
{
   if (debug) (*debug) << "Unregistering buffer at " << buffer << endl;

   if (buffer)
      delete reinterpret_cast<mprace::DMABuffer*>(buffer);
}

uint32_t abbdaemon::ABBdaemonClient::getFIFOStatus()
{
   if (board==0) return 0;

   /* Ignore the lower three bits ("almost full" and "empty" bit) */
   return  board->getReg(EVENT_BUFFER_STATUS) & 0xFFFFFFF8;
}

uint32_t abbdaemon::ABBdaemonClient::getCTLStatus()
{
   if (board==0) return 0;

   return board->getReg(CTL_STATUS);
}

void abbdaemon::ABBdaemonClient::getDesignID(uint32_t *version, uint32_t *major, uint32_t *author, uint32_t *minor)
{
   if (board==0) return;

   uint32_t id = board->getReg(DID);

   if (version) *version = (id & 0xFF000000) >> 24;
   if (major)   *major   = (id & 0x00FF0000) >> 16;
   if (author)  *author  = (id & 0x0000F000) >> 12;
   if (minor)   *minor   = (id & 0x00000FFF);
}

void abbdaemon::ABBdaemonClient::setReg(uint32_t reg, uint32_t value)
{
   if (board) board->setReg(reg, value);
  
}