abbplugin/src/AbbDevice.cxx (r4864/r4183)

Go to the documentation of this file.

#include "roc/AbbDevice.h"

#include <iostream>
#include <fstream>
#include <stdio.h>

#include "dabc/Manager.h"
#include "dabc/Port.h"
#include "dabc/Command.h"
#include "dabc/CommandsSet.h"

#include "base/Url.h"

#include "roc/defines_roc.h"
#include "roc/defines_optic.h"
#include "roc/Commands.h"
#include "roc/Board.h"

#include "roc/AbbTransport.h"
#include "roc/AbbBoard.h"

#include "ABBdaemon.h"

const char* roc::OpticPathPar = "OpticPath";

enum { PUT_BIT = 0x80000000 };

roc::AbbDevice::AbbDevice(const char* name, const char* thrdname, dabc::Command cmd) :
   dabc::Device(name),
   fContext(),
   fTransport(0),
   fDaqRunning(false),
   fPathes(),
   fUseDlmForStartStopDaq(true)
{
   if (!dabc::mgr()->MakeThreadFor(this, thrdname)) return;
//   AssignProcessorToThread(dabc::mgr()->ProcessorThread());

   fUseDlmForStartStopDaq = Cfg(roc::xmlUseDLM, cmd).AsBool(false);

   fContext.CreateDaemon();

   DOUT2(("Create ABB device name:%s useDLM:%s", GetName(), DBOOL(fUseDlmForStartStopDaq)));
}

roc::AbbDevice::~AbbDevice()
{
   DOUT2(("Destroy ABB device %s", GetName()));
}

void roc::AbbDevice::ObjectCleanup()
{
   if (fTransport) { 
      fTransport->fDevice = 0; 
      fTransport = 0; 
    }

   dabc::Device::ObjectCleanup();
}

const char* roc::AbbDevice::ClassName() const 
{ 
   return roc::typeAbbDevice; 
}

unsigned roc::AbbDevice::GetOpticPath(const char* abburl)
{
   // optic path is specified in following form
   // abb0 - ROC, directly connected to SFP0
   // abb1 - ROC, directly connected to SFP1
   // abb00 - ROC, connected to first port on DCB via SFP0
   // abb12 - ROC, connected to third port on DCB via SFP1
   
   base::Url url(abburl);
   if (!url.GetProtocol().empty() && (url.GetProtocol()!="optic")) return UndefinedOpticPath;
   
//   DOUT0(("url %s host %s fname %s", abburl, url.GetHostName().c_str(), url.GetFileName().c_str()));

   if ((url.GetHostName().length()<4) || (url.GetHostName().length()>5)) return UndefinedOpticPath;
   
   if (url.GetHostName().find("abb", 0) != 0)  return UndefinedOpticPath;

   unsigned path = 0;
   
   switch (url.GetHostName()[3]) {
      case '0': path = 0; break;
      case '1': path = 0x20; break;
      default: return UndefinedOpticPath;
   }

   if (url.GetHostName().length() == 5)
      switch (url.GetHostName()[4]) {
         case '0': path = path | 0; break;
         case '1': path = path | 1; break;
         case '2': path = path | 2; break;
         case '3': path = path | 3; break;
         default: return UndefinedOpticPath;
      }
   
   return path;
}

unsigned roc::AbbDevice::GetOpticRetPath(unsigned path)
{
   if (path==UndefinedOpticPath) return 0x8000;
   
   return path & 0x20 ? 0x8020 : 0x8000;
}


int roc::AbbDevice::ExecuteCommand(dabc::Command cmd)
{
   uint32_t path = cmd.GetUInt(OpticPathPar, 0x0);
   uint32_t retpath = GetOpticRetPath(path);
   uint32_t hwtyp = cmd.GetUInt("HwTyp", 0x0);

   bool isnewnx = (hwtyp >> 16) == base::kind_newNX;

   uint32_t res = 0;
   
//   DOUT0(("AbbDevice cmd %s path 0x%x", cmd->GetName(), path));

   if (cmd.IsName(CmdPut::CmdName())) {
      uint32_t addr = cmd.GetUInt(AddrPar, 0);
      uint32_t value = cmd.GetUInt(ValuePar, 0);

      res = fContext.daemon()->submitPut(path, retpath, addr, value);

      DOUT2(("ABB::submitPut addr:%04x value:%04x res = %u", addr, value, res));
      cmd.SetUInt(ErrNoPar, res);
      return cmd_bool(res==0);
   } else
   
   if (cmd.IsName(CmdGet::CmdName())) {
      uint32_t addr = cmd.GetUInt(AddrPar, 0);
      uint32_t value = 0;

      res = fContext.daemon()->submitGet(path, retpath, addr, &value);

      DOUT2(("ABB::submitGet addr:%04x value:%04x res = %u", addr, value, res));

      cmd.SetUInt(ValuePar, value);
      cmd.SetUInt(ErrNoPar, res);

      return (res==0) ? dabc::cmd_true : dabc::cmd_false;

   } else
   if (cmd.IsName(CmdDLM::CmdName())) {
      uint32_t addr = cmd.GetUInt(AddrPar, 0);

      res = fContext.daemon()->submitPutDLM(addr);

      cmd.SetUInt(ErrNoPar, res);
      return (res==0) ? dabc::cmd_true : dabc::cmd_false;

   } else
   if (cmd.IsName(CmdNOper::CmdName())) {

      base::OperList* lst = (base::OperList*) cmd.GetPtr(OperListPar, 0);
      
      lst->setErrorOper(-1);
      lst->setErrorCode(0);

      DOUT2(("Start CmdNOper %d", lst->number()));


/*
      // work around to process lists longer than 7 commands
      
      int currpos(0);
      
      while (currpos < lst->number()) {
         int currlen = lst->number() - currpos;
         if (currlen>7) currlen = 7;

         uint32_t addrs[8], values[8], retvals[8];

         for (int n=0;n<currlen;n++) {
            addrs[n] = lst->oper(currpos + n).addr;
            values[n] = lst->oper(currpos + n).value;
            retvals[n] = 0;
            if (lst->oper(currpos + n).isput) addrs[n] = addrs[n] | 0x80000000; 
         }

         try {
            fContext.daemon()->submitNOper(path, retpath, currlen, addrs, values, retvals);

         } catch (abbdaemon::ABBexception e) {
            EOUT(("Problem with NOper  %s", e.what()));
            res = roc::Board::operErrBuild(roc::Board::kHostError, 0);
            for (int n=0;n<lst->number();n++)
               printf("Oper %d retval = %u\n", n, retvals[n]);
               
            lst->setErrorOper(currpos);
            lst->setErrorCode(roc::Board::kHostError);
            
            res = roc::Board::operErrBuild(roc::Board::kHostError, currpos);
         }
         
         if (res!=0) break;

         for (int n=0;n<currlen;n++) {
            if (retvals[n]!=0) {
               lst->setErrorOper(currpos + n);
               lst->setErrorCode(roc::Board::kOperAddrErr);
               res = roc::Board::operErrBuild(roc::Board::kOperAddrErr, currpos + n);
               break;
            }
            
            if (!lst->oper(currpos + n).isput)
               lst->oper(currpos + n).value = values[n]; 
         }
         
         if (res!=0) break;

         currpos += currlen;
      }
*/
      
      uint32_t *addrs = new uint32_t[lst->number()];
      uint32_t *values = new uint32_t[lst->number()];
      uint32_t *retvals = new uint32_t[lst->number()];
      for (int n=0;n<lst->number();n++) {
         addrs[n] = lst->oper(n).addr;
         values[n] = lst->oper(n).value;
         retvals[n] = 0;
         if (lst->oper(n).isput) addrs[n] = addrs[n] | PUT_BIT;
      }

      try {
         res = fContext.daemon()->submitNOper(path, retpath, lst->number(), addrs, values, retvals);

         for (int n=0;n<lst->number();n++) {
            if (!lst->oper(n).isput)
               lst->oper(n).value = values[n]; 
         }

      } catch (abbdaemon::ABBexception e) {
         EOUT(("Problem with NOper  %s", e.what()));
         res = base::Board::operErrBuild(roc::Board::kHostError, 0);
         for (int n=0;n<lst->number();n++)
            EOUT(("Oper %d retval = %u\n", n, retvals[n]));
            
         lst->setErrorOper(1);
         lst->setErrorCode(1);
      }

      for (int n=0;n<lst->number();n++)
         DOUT2(("Oper %d retval = %08x\n", n, retvals[n]));

      delete[] addrs;
      delete[] values;
      delete[] retvals;
  
/*
      // execute all put/get cmds sequentially

      for (int n=0;n<lst->number();n++)
        try {
           if (lst->oper(n).isput)
               fContext.daemon()->submitPut(path, retpath, lst->oper(n).addr, lst->oper(n).value);
           else
               fContext.daemon()->submitGet(path, retpath, lst->oper(n).addr, &(lst->oper(n).value));
        } catch (abbdaemon::ABBexception e) {
                EOUT(("Problem with operation  %d %s", n, e.what()));
           res = roc::Board::operErrBuild(roc::Board::kHostError, n);
           break;
        }
*/      
      DOUT2(("Did CmdNOper %d", lst->number()));
        
      //      uint32_t res = fContext.daemon()->submitNOper(num, addrs, values);

      // DOUT0(("ABB::submitNOpr num:%u  res = %u", num, res));

      cmd.SetUInt(ErrNoPar, res);
      return (res==0) ? dabc::cmd_true : dabc::cmd_false;
   } else

   if (cmd.IsName("StartABBTransport")) {
      fDaqRunning = true;
      
      fContext.daemon()->submitReset();
      
      DOUT2(("roc::AbbDevice::StartABBTransport path = 0x%02x transport %p", path, fTransport));
      
      if (isnewnx) {
         DOUT0(("!!Start DAQ for new NX readout!!"));

         uint32_t addrs[3], values[3], retvals[3];

         addrs[0] = ROC_NX_FIFO_RESET | PUT_BIT; values[0] = 1;
         addrs[1] = ROC_NX_FIFO_RESET | PUT_BIT; values[1] = 0;
         addrs[2] = ROC_OPTICS_START_DAQ | PUT_BIT; values[1] = 0;

         try {
            res = fContext.daemon()->submitNOper(path, retpath, 3, addrs, values, retvals);

         } catch (abbdaemon::ABBexception e) {
            EOUT(("Problem with StartDAQ NOper  %s", e.what()));
            res = base::Board::operErrBuild(roc::Board::kHostError, 0);
         }

      } else {

         if (path == UndefinedOpticPath) {

            if (fUseDlmForStartStopDaq || (fPathes.size()==0)) {
               DOUT0(("Issue DLM 8"));
               res = fContext.daemon()->submitPutDLM(8);
            } else {
               DOUT0(("Replace DLM 8 with PUTs num %u", fPathes.size()));
               for (unsigned n=0;n<fPathes.size();n++)
                  if (res==0)
                     res = fContext.daemon()->submitPut(fPathes[n], GetOpticRetPath(fPathes[n]), ROC_CMD_LST_NR, 0);
            }
         } else {
            res = fContext.daemon()->submitPut(path, retpath, ROC_CMD_LST_NR, 0);
         }
         
         DOUT0(("Start DAQ res = %u", res));
      }

      return (res==0) ? dabc::cmd_true : dabc::cmd_false;
   } else

   if (cmd.IsName("SuspendBoardDaq")) {

      if (isnewnx) {
         DOUT0(("!!Suspend DAQ for new NX readout!!"));
         res = fContext.daemon()->submitPut(path, retpath, ROC_OPTICS_STOP_DAQ, 0); // stop DAQ

      } else {
         res = fContext.daemon()->submitPut(path, retpath, ROC_CMD_LST_NR, 1);
      }
      return (res==0) ? dabc::cmd_true : dabc::cmd_false;
   } else
      
   if (cmd.IsName("StopABBTransport")) {
      fDaqRunning = false;

      DOUT2(("StopABBTransport 0x%02x", path));

      if (isnewnx) {
         DOUT0(("!!Stop DAQ for new NX readout!!"));

         res = fContext.daemon()->submitPut(path, retpath, ROC_OPTICS_STOP_DAQ, 0); // stop DAQ

      } else {

         if (path == UndefinedOpticPath) {

            if (fUseDlmForStartStopDaq || (fPathes.size()==0)) {
               DOUT0(("Issue DLM 9"));
               res = fContext.daemon()->submitPutDLM(9);
            } else {
               DOUT0(("Replace DLM 9 with PUTs num %u", fPathes.size()));
               for (unsigned n=0;n<fPathes.size();n++)
                  if (res==0)
                     res = fContext.daemon()->submitPut(fPathes[n], GetOpticRetPath(fPathes[n]), ROC_CMD_LST_NR, 1);
            }

         } else {
            res = fContext.daemon()->submitPut(path, retpath, ROC_CMD_LST_NR, 1);
         }
      }

      return (res==0) ? dabc::cmd_true : dabc::cmd_false;
   } else
      
   if (cmd.IsName("SetFlushTimeout")) {
      if (fTransport==0) {
         EOUT(("No ABB transports - cannot setup flush timeout"));
         return dabc::cmd_false;
      }

      fTransport->Submit(cmd);

      return dabc::cmd_postponed;
   } else

   if (cmd.IsName("AddExtraBoard")) {

      unsigned path = GetOpticPath(cmd.GetStr(roc::xmlBoardAddr, "abb0"));

      uint32_t rocid(0), res(1);

      if (path != UndefinedOpticPath) {
         fPathes.push_back(path);
         res = fContext.daemon()->submitGet(path, GetOpticRetPath(path), ROC_ROCID, &rocid);
         if (res!=0) EOUT(("Cannot get ROCID from specified ROC path %u", path));
      }

      return res!=0 ? dabc::cmd_false : rocid + 256;
   } else

   if (cmd.IsName(CmdGetBoardPtr::CmdName())) {

      unsigned path = GetOpticPath(cmd.GetStr(roc::xmlBoardAddr, "abb0"));
      
      if (path==UndefinedOpticPath) return dabc::cmd_false;

      roc::AbbBoard* brd = new roc::AbbBoard(this, path, base::roleControl);
      if (!brd->initAbbBoard()) { delete brd; return dabc::cmd_false; }

      cmd.SetPtr(CmdGetBoardPtr::Board(), brd);

      return dabc::cmd_true;
   } else

   if (cmd.IsName(CmdReturnBoardPtr::CmdName())) {
      roc::AbbBoard* brd = (roc::AbbBoard*) cmd.GetPtr(CmdReturnBoardPtr::Board());
      if (brd!=0) delete brd;
      return dabc::cmd_true;
   }

   return dabc::Device::ExecuteCommand(cmd);
}

dabc::Transport* roc::AbbDevice::CreateTransport(dabc::Command cmd, dabc::Reference port)
{
   if (fContext.daemon() == 0) return 0;
   
   if (fTransport!=0) {
      EOUT(("There are transports already created !!!!"));
      return 0;
   }

   std::string spath = cmd.GetStdStr(roc::xmlBoardAddr, "abb0");
   unsigned path = GetOpticPath(spath.c_str());

   uint32_t brdid(0), hwtyp(0);
   
   DOUT2(("roc::AbbDevice::CreateTransport path 0x%02x", path));

   if (path != UndefinedOpticPath) {

      fPathes.push_back(path);

      uint32_t res = fContext.daemon()->submitGet(path, GetOpticRetPath(path), base::addr_BoardId, &brdid);
      if (res!=0) { EOUT(("Cannot get board ID from path %s", spath.c_str())); return 0; }

      res = fContext.daemon()->submitGet(path, GetOpticRetPath(path), base::addr_HardwareType, &hwtyp);
      if (res!=0) { EOUT(("Cannot get hardware type from path %s", spath.c_str())); return 0; }

      DOUT2(("roc::AbbDevice::CreateTransport  brdid %u hwtyp 0x%08x", (unsigned) brdid, (unsigned) hwtyp));

   } else
      DOUT2(("Create transport with undefined path"));

   fTransport = new AbbTransport(this, port, path, brdid, hwtyp, cmd);

   return fTransport;
}