ngcbIFC.hpp

Go to the documentation of this file.

#ifndef ngcbIFC_H
#define ngcbIFC_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbAddr.h>
#include <ngc/core/ngcbSIM.hpp>
#include <ngc/core/ngcbI2C.hpp>
#include <ngc/core/ngcbAFE.hpp>
#include <ngc/core/ngcbLIST.hpp>
#include <ngc/core/ngcbSERVICE.hpp>

#define ngcbIFC_TIMEOUT_DEFAULT 5    // Timeout in seconds
 
/*
 * Interface class internal addresses
 */
#define ngcbIFC_CLASS_VERSION 0x00000001   //< Interface class SW version
 
/*
 * I/O-operations
 */
#define ngcbIFC_OP_WR   0x0   //< Write to address
#define ngcbIFC_OP_RD   0x1   //< Read from address
#define ngcbIFC_OP_EVT  0x2   //< Poll device events
 
/*
 * Event codes
 */
#define ngcbEVT_PENDING   -1           //< Event pending
#define ngcbEVT_SUCCESS    0           //< Event received
#define ngcbEVT_TIMEOUT    1           //< Event timeout
#define ngcbEVT_FAILURE    2           //< Event failure
#define ngcbEVT_INVALID    3           //< Event invalid
#define ngcbEVT_COND_FAIL  0x00010000  //< Event fail condition
 
/*
 * RPC states
 */
#define RPC_STATE_INVALID  0x00000000  //< Invalid state
#define RPC_STATE_SEND     0x00000001  //< Request is being send
#define RPC_STATE_RECEIVED 0x00000002  //< Request received
#define RPC_STATE_WAITING  0x00000003  //< Waiting
#define RPC_STATE_DONE     0x000000FF  //< Request has been handled
#define RPC_STATE_BUSY     0x40000000  //< Busy
#define RPC_STATE_ERROR    0x80000000  //< Error
#define RPC_STATE_ERROR_UNKNOWN_CMD      (RPC_STATE_ERROR | 1) //< Unknown CMD
#define RPC_STATE_ERROR_BUSY             (RPC_STATE_ERROR | 2) //< Busy
#define RPC_STATE_ERROR_OUT_OF_MEMORY    (RPC_STATE_ERROR | 3) //< No memory
#define RPC_STATE_ERROR_TOO_LONG         (RPC_STATE_ERROR | 4) //< Too long
#define RPC_STATE_ERROR_UNKNOWN_DEVICE   (RPC_STATE_ERROR | 5) //< Unknown DEV
#define RPC_STATE_ERROR_BUFFER_TOO_SMALL (RPC_STATE_ERROR | 6) //< Too small
#define RPC_STATE_ERROR_UNKNOWN_CHANNEL  (RPC_STATE_ERROR | 7) //< Unknown chan
#define RPC_STATE_ERROR_TRANSFER_FAILED  (RPC_STATE_ERROR | 8) //< TX error

struct ngcb_route_t {
  int numHdr;
            
  int hdr[ngcbMAX_MOD];  

  ngcb_route_t(const ngcb_route_t &other) {
    int i;
    for (i=0;i<other.numHdr;i++) hdr[i] = other.hdr[i];
    for (i=other.numHdr;i<ngcbMAX_MOD;i++) hdr[i] = 0x0;
    numHdr = other.numHdr;
  }

  ngcb_route_t() {
    int i;
    numHdr = 0;
    for (i=0;i<ngcbMAX_MOD;i++) hdr[i] = 0x0;
  }
  
  explicit ngcb_route_t(int board) {
    int i;
    if (board < 1) board = 1;
    else if (board > ngcbMAX_MOD) board = ngcbMAX_MOD;
    for (i=0;i<(board - 1);i++) hdr[i] = 0x5;
    hdr[i++] = 0x2;
    numHdr = i;
    for (i=numHdr;i<ngcbMAX_MOD;i++) hdr[i] = 0x0;
  }
  
  bool operator==(const ngcb_route_t &other) const {
    if (numHdr != other.numHdr) return (false);
    else
      {
      int i;
      for (i=0;i<numHdr;i++) if (hdr[i] != other.hdr[i]) return (false);
      return (true);
      }
  }

  ngcb_route_t &operator=(const ngcb_route_t &other) {
    if (this != &other)
      {
      int i;
      for (i=0;i<other.numHdr;i++) hdr[i] = other.hdr[i];
      numHdr = other.numHdr;
      }
    return (*this);
  }

  int Board() const {
    if ((numHdr > 0) && (numHdr <= ngcbMAX_MOD))
      {
      return (numHdr);
      }
    else
      {
      return (0);
      }
  }

  int Last() const {
    if ((numHdr > 0) && (numHdr <= ngcbMAX_MOD))
      {
      return (hdr[numHdr - 1]);
      }
    else
      {
      return (0x0);
      }
  }

  void Print(char *s) const {
    int i;
    char tmp[16];
 
    s[0] = '\0';
    for (i=0;i<numHdr;i++)
      {
      if (i > 0) sprintf(tmp, ",%d", hdr[i]);
      else sprintf(tmp, "%d", hdr[i]);
      strcat(s, tmp);
      }
  }
};
 
class ngcb_reg_t {
public:
  int addr;

  ngcb_reg_t() {addr = 0x0; value_ = 0x0; setup_ = 0;}
  
  //explicit ngcb_reg_t(int a) {addr = a; value_ = 0x0; setup_ = 0;}
  
  int Value() {return (value_);}

  void Setup(int v) {value_ = v; setup_ = 1;}

  int Setup() {return (setup_);}

  void Reset() {setup_ = 0;}
protected:
private:
  int setup_;

  int value_;
};

class ngcb_rtms_cfg_t {
public:
  ngcb_reg_t topic;

  ngcb_reg_t component;

  ngcb_reg_t application;

  ngcb_reg_t leadingPadding;

  ngcb_reg_t trailingPadding;

  ngcb_reg_t littleEndian;

  ngcb_reg_t local_ip;

  ngcb_reg_t subnet;

  ngcb_reg_t gateway;

  ngcb_reg_t dest_ip;

  ngcb_reg_t srcPort;

  ngcb_reg_t destPort;

  ngcb_reg_t ttl;

  ngcb_reg_t ds;

  ngcb_reg_t *reg[14];

  bool operator==(const ngcb_rtms_cfg_t &other) const {
    size_t i;
    for (i=0;i<14;i++)
      {
      if (!(reg[i] == other.reg[i]))
    {
    return (false);
    }
      }
    return (true);
  }

  ngcb_rtms_cfg_t &operator=(const ngcb_rtms_cfg_t &other) {
    if (this != &other)
      {
      size_t i;
      Init_();
      for (i=0;i<14;i++)
    {
    if (other.reg[i]->Setup())
      {
      reg[i]->Setup(other.reg[i]->Value());
      }
    }
      }
    return (*this);
  }

  ngcb_rtms_cfg_t(const ngcb_rtms_cfg_t &other) {
    size_t i;
    Init_();
    for (i=0;i<14;i++)
      {
      if (other.reg[i]->Setup())
    {
    reg[i]->Setup(other.reg[i]->Value());
    }
      }
  }
  
  ngcb_rtms_cfg_t() {
    Init_();
  }

  void Reset() {
    size_t i;
    for (i=0;i<14;i++) reg[i]->Reset();
  }
 
protected:
private:
  void Init_() {
    topic.addr = 0x3200;
    component.addr = 0x3201;
    application.addr = 0x3202;
    leadingPadding.addr = 0x3204;
    trailingPadding.addr = 0x3205;
    littleEndian.addr = 0x3206;
    local_ip.addr = 0x3212;
    subnet.addr = 0x3213;
    gateway.addr = 0x3214;
    dest_ip.addr = 0x3215;
    srcPort.addr = 0x3216;
    destPort.addr = 0x3217;
    ttl.addr = 0x3218;
    ds.addr = 0x3219;
    reg[0] = &topic;
    reg[1] = &component;
    reg[2] = &application;
    reg[3] = &leadingPadding;
    reg[4] = &trailingPadding;
    reg[5] = &littleEndian;
    reg[6] = &local_ip;
    reg[7] = &subnet;
    reg[8] = &gateway;
    reg[9] = &dest_ip;
    reg[10] = &srcPort;
    reg[11] = &destPort;
    reg[12] = &ttl;
    reg[13] = &ds;
  }
};

struct ngcb_chan_ip_t {
  int ip;
            
  int port;  

  ngcb_chan_ip_t() {ip = 0; port = 0;}
};

struct ngcb_chan_mudpi_t {
  int topic;
            
  int component;  

  int application;  

  ngcb_chan_mudpi_t() {topic = 0; component = 0; application = 0;}
};

struct ngcb_chan_rtms_t {
  int leadingPadding;
            
  int trailingPadding;  

  int le;  

  ngcb_chan_rtms_t() {leadingPadding = 0; trailingPadding = 0; le = 1;}
};

struct ngcb_rtms_chan {
  int enable;
  
  int bits;
    
  int shift;
  
  int src[4];
  
  ngcb_chan_ip_t ip;
            
  ngcb_chan_mudpi_t mudpi;
            
  ngcb_chan_rtms_t rtms;
            
  ngcb_rtms_chan() {
    size_t i;
    enable = 0; bits = 16; shift = 0;
    for (i=0;i<_vecsize(src);i++) src[i] = 0;
  }
};

struct ngcb_rtms_net {
  int ip;
            
  int subnet;
            
  int gateway;  

  int port;  

  int ttl;

  int ds;

  ngcb_rtms_net() {ip = 0; subnet = 0; gateway = 0; port = 0, ttl = 0; ds = 0;}
};

struct ngcb_rtms_if {
  ngcb_rtms_chan chan[4];
  
  ngcb_rtms_net net;
  
  ngcb_rtms_if() {}
};

struct ngcb_tsu_t {
  uint64_t sec;
            
  uint64_t nsec;
            
  uint64_t start_sec;
            
  uint64_t start_nsec;
            
  uint64_t period_sec;
            
  uint64_t period_nsec;
            
  int nshot;

  int status;
  
  ngcb_tsu_t() {
    sec = 0; nsec = 0;
    start_sec = 0; start_nsec = 0;
    period_sec = 0; period_nsec = 0;
    nshot = -1; status = 0;
  }
};

struct ngcb_sctl_t {
  int fwd;
            
  int size;  

  int dvld;

  ngcb_sctl_t() {fwd = 1; size = 0; dvld = 0;}
};

struct ngcb_evt_t {
  int board;
            
  int addr;  

  int mask;  

  int reference;  

  int cond;
  
  ngcb_evt_t &operator=(const ngcb_evt_t &other) {
    if (this != &other)
      {
      board = other.board; addr = other.addr; mask = other.mask;
      reference = other.reference; cond = other.cond;
      }
    return (*this);
  }

  ngcb_evt_t(const ngcb_evt_t &other):
    board(other.board), addr(other.addr), mask(other.mask), 
    reference(other.reference), cond(other.cond) {
  }
  
  ngcb_evt_t() {
    board = 1; addr = 0x6000; 
    mask = ngcbSEQ_STAT_WAITING | ngcbSEQ_STAT_RUNNING; 
    reference = ~mask;
    cond = 1;
  }
  
  int Check(int value) {
    int x = value & mask;
    int c = cond & 0xffff;
    if (c) return (x == (reference & mask));       // equal
    else return (~(x ^ (reference | ~mask)) != 0); // non differing bits != 0
  }

  int Failure() {return ((cond & ngcbEVT_COND_FAIL) != 0x0);}

  ngcb_route_t Route() {
    ngcb_route_t r(board);
    return (r);
  }
};

struct ngcb_evt_st_t {
  int id;

  int status;
  
  ngcb_evt_st_t() {id = 0; status = ngcbEVT_SUCCESS;}

  ngcb_evt_st_t(int i, int s): id(i), status(s) {}

  explicit ngcb_evt_st_t(int i): id(i), status(ngcbEVT_SUCCESS) {}
};

class ngcbEVT {
public:
  int id;

  int async;

  int cond;

  int timeout;

  int done;

  ngcb_evt_t *component;
  
  ngcbEVT(const ngcbEVT &other) {
    n_ = 0; id = other.id; async = other.async; cond = other.cond; 
    timeout = other.timeout; done = 0;
    if (other.size_ > 0)
      {
      size_t i;
      component = new ngcb_evt_t[other.size_];
      size_ = other.size_;
      for (i=0;i<other.n_;i++) Add(other.component[i]);
      }
    else
      {
      component = NULL;
      size_ = 0;
      }
    ngcbGetTime(&timeStamp_);
  }
  
  explicit ngcbEVT(size_t size) {
    n_ = 0; id = 0; async = 0; cond = 1; timeout = -1; done = 0;
    if (size > 0)
      {
      component = new ngcb_evt_t[size];
      size_ = size;
      }
    else
      {
      component = NULL;
      size_ = 0;
      }
    ngcbGetTime(&timeStamp_);
  }

  virtual ~ngcbEVT() {
    if (component != NULL)
      {
      delete[] component;
      }
  }

  ngcbEVT &operator=(const ngcbEVT &other) {
    if (this != &other)
      {
      n_ = 0; id = other.id; async = other.async; cond = other.cond; 
      timeout = other.timeout; done = 0;
      if (other.size_ > 0)
    {
    size_t i;
    component = new ngcb_evt_t[other.size_];
    size_ = other.size_;
    for (i=0;i<other.n_;i++) Add(other.component[i]);
    }
      else
    {
    component = NULL;
    size_ = 0;
    }
      ngcbGetTime(&timeStamp_);
      }
    return (*this);
  }

  size_t Size() {return (n_);}

  void Add(const ngcb_evt_t &evt) {if (n_ < size_) component[n_++] = evt;}

  void Add(int board, int addr, int mask, int reference, int cnd = 1) {
    if ((n_ < size_) && (board > 0) && (board <= ngcbMAX_MOD))
      {
      ngcb_evt_t *c = &component[n_++];
      c->board = board; c->addr = addr; 
      c->mask = mask; c->reference = reference; c->cond = cnd;
      }
  }

  void Add(const ngcb_route_t &r, int addr, int mask, int reference, 
       int cnd = 1) {
    Add(r.Board(), addr, mask, reference, cnd);
  }

  void TimeStamp() {ngcbGetTime(&timeStamp_);}

  int Timeout() {
    if (timeout > 0)
      {
      struct timeval t;
      double difft;
      ngcbGetTime(&t);
      difft = ngcbDiffTime(timeStamp_, t);
      if (difft < (double)timeout)
    {
    return (0);
    }
      else
    {
    return (1);
    }
      }
    else if (timeout < 0)
      {
      return (0);
      }
    else
      {
      return (1);
      }
  }
  
protected:
 
private:
  size_t size_;

  size_t n_;

  struct timeval timeStamp_;
};

#define ngcbIFC_HDR_SIZE (3 + ngcbMAX_MOD + 1)

class ngcbIFC {
public:
  ngcbIFC();

  explicit ngcbIFC(const char *name);

  virtual ~ngcbIFC();          

  FILE *watchdog;               

  ngcbSERVICE *services;

  int ioError; 

  int local;

  char thisHost[64]; 

  int netTimeout;

  int keeper;

  int sideLink;

  int backPlane;

  int master;

  int skip;

  int chain;
 
  ngcb_route_t cfgRoute;

  int serNo1;

  int serNo2;

  int id;

  int type;

  int version;

  int revision;

  int firmware;                

  int protocol;   

  ngcb_sctl_t sync; 

  ngcb_rtms_cfg_t rtms;

  ngcb_rtms_if rtmsIf;

  ngcb_tsu_t tsu;

  int tsuCtrl;

  int sim;

  int xterm;

  int verboseLevel;

  int logLevel;

  int translate;
  
  /*
   * Error handling and logging
   */

  char *ErrMsg();

  void ErrState(const char *msg, int errorId = 0, void *origin = NULL);

  void Result2Err(char *s, int resultCode); 

  void Verbose(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  void Log(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));
 
 
  /*
   * Interface definition
   */

  const char *SofwVersion();

  char *Name();

  char *Type();

  char *Arg();

  int Instance();

  void Instance(int instance);

  int Open();

  void DefaultTimeout(int seconds);

  int SetTime(double time = 0.0);

  int BigEndian();              

  int SyncFwd(int flag);

  int SyncWithData(int flag);

  int SyncSize(int size);
 
  /*
   * High-level state handling
   */

  int Configure(const char *s);

  int Configure();

  const char *Setup();

  int Standby();

  int Online();

  int Off();                    
 
 
  /*
   * Generic i/o functions
   */
  
  int ReadAddr(const ngcb_route_t &route, int addr, int *buffer, int size);

  int WriteAddr(const ngcb_route_t &route, int addr, const int *buffer, 
        int size);

  int WriteBuffer(const int *buffer, int size, int *result); 

  int Event(ngcbEVT *evt);

  int ReadAddr(int addr, int *buffer, int size = 1);

  int WriteAddr(int addr, const int *buffer, int size);

  int WriteAddr(int addr, int value);

  int ReadAddr64(const ngcb_route_t &route, int addr, uint64_t *buffer, 
         int size);

  int WriteAddr64(const ngcb_route_t &route, int addr, const uint64_t *buffer, 
          int size);

  int ReadAddr64(int addr, uint64_t *buffer, int size = 1);

  int WriteAddr64(int addr, const uint64_t *buffer, int size);

  int WriteAddr64(int addr, uint64_t value);  
 
 
  /*
   * Device events interface
   */

  ngcbLIST evtList;

  int CheckEvent(ngcbEVT *evt, int *result);

  int Wait(ngcbEVT *evt, int interval, int *result);

  void Poll();

  int SetChanIp(int idx, ngcb_chan_ip_t ip);

  int SetChanMudpi(int idx, ngcb_chan_mudpi_t mudpi);

  int SetChanRtms(int idx, ngcb_chan_rtms_t rtms);

  int SetRtmsNet(ngcb_rtms_net net);
  
  int GetChanIp(int idx, ngcb_chan_ip_t *ip);

  int GetChanMudpi(int idx, ngcb_chan_mudpi_t *mudpi);

  int GetChanRtms(int idx, ngcb_chan_rtms_t *rtms);

  int GetRtmsNet(ngcb_rtms_net *net);
  
  int SetChanEnable(int idx, int flag);
  
  int GetChanEnable(int idx, int *flag);
  
  int SetChanSrc(int idx, int src = 0, int flag = -1);

  int GetChanSrc(int idx, int src, int *flag);

  int GetChanDrop(int idx, int src, int *flag);

  int ClearChanDrop(int idx);

  int SetChanBits(int idx, int bits);

  int GetChanBits(int idx, int *bits);

  int SetChanShift(int idx, int shift);
  
  int GetChanShift(int idx, int *shift);
  
  /*
   * Virtual Interface
   */

  virtual int Fd();

  virtual int Pid();

  virtual int Port();

  virtual const char *Host(); 

  virtual int Sim(int level);

  virtual int Open(const char *name);    

  virtual int Close();

  virtual int Connect();

  virtual int Disconnect();

  virtual int Ping();

  virtual void Keeper(int seconds);

  virtual int Reset();

  virtual int Timeout(int seconds);

  virtual int Timeout();

  virtual int SetTime(uint64_t sec, uint64_t nsec);

  virtual void RpcCopy(void *dest, const void *src, size_t size, size_t items);

  virtual int Str2Payload(const char *cmd, unsigned char *payload,
              unsigned int max, char *erms);

  virtual int RPC(int mod, int target, int req, void *payload,
          unsigned int size, unsigned int *status);

  virtual int Read(int *buffer, int size); 

  virtual int Write(const int *buffer, int size);

  virtual int ReadAddr(ngcb_route_t route, int addr, int *buffer, int size, 
               int *result);

  virtual int WriteAddr(ngcb_route_t route, int addr, const int *buffer, 
            int size, int *result);

  virtual int Event(ngcbEVT *evt, int *result);

  virtual int Status(int *devStatus);

  virtual int ExecServer();

  virtual int KillServer(); 

  virtual int Running();

  virtual int Connected();

  virtual int HandleFdEvt();
 
  /***
   * Start TSU trigger at given absolute time 
   * (seconds + fractional nanoseconds)
   */
  virtual int TsuStartAt(uint64_t sec, uint64_t nsec);

  virtual int TsuStart();

  virtual int TsuStop();

  virtual int TsuTrigger();

  virtual int TsuSnapshot();

  virtual int TsuStatus(int *value);

  virtual int TsuConfig(ngcb_tsu_t *cfg);
 
  /*** 
   * The function checks the TSU running status. If the status cannot be 
   * read -1 is returned and ErrMsg() contains the detailed error message. 
   * Otherwise 1 is returned if the TSU is running or zero is returned if 
   * the TSU is not running.
   */
  virtual int TsuRunning();
  
  /*
   * Bottom end i/o
   */

  virtual int _ReadAddr(ngcb_route_t route, int addr, int *buffer, int size, 
            int *result);

  virtual int _WriteAddr(ngcb_route_t route, int addr, const int *buffer,
             int size, int *result); 
 
protected:
  virtual int SetupCB(const char *buffer);       
 
private:
  void Init_();

  char thisVersion_[128]; 

  int handle_;

  int timeout_;

  int fifoSize_;

  char setupString_[64];

  int setupCode_;

  char type_[64];

  char name_[256];

  char arg_[256];

  int endian_;

  int instance_;

  ngcbSIM *simulator_;

  int testBuffer_[1024];    

  void ClrEvt_();
 
  /*
   * Error handling
   */

  int CheckErr_(int);

  char erms_[256];          
 
 
  /* 
   * Interface base class access
   */

  int IfcRead_(int addr);

  void IfcWrite_(int addr, int value);
  
 
  /* 
   * IOCTL interface
   */

  virtual int ReadLocal_(int addr, int *value);

  virtual int WriteLocal_(int addr, int value);

  virtual int ReadCfg_(int addr, int *value);

  virtual int WriteCfg_(int addr, int value);    
 
 
  /* 
   * SIDECAR ASIC interface
   */

  int ScaRead_(const ngcb_route_t &route, int addr, int sid, int flags,
           int *buffer, int size, int *result);

  int ScaWrite_(const ngcb_route_t &route, int addr, int sid, int flags, 
        const int *buffer, int size, int *result);

  int ScaReadBlock_(const ngcb_route_t &route, int addr, int sid, int flags, 
            int *buffer, int size, int *result);

  int ScaWriteBlock_(const ngcb_route_t &route, int addr, int sid, int flags, 
             const int *buffer, int size, int *result);

  int ScaCRC16_(const int *buffer, int size);
};

class ngcbI2C_IO: public ngcbI2C
{
public:
  ngcbI2C_IO(ngcbIFC *dev, ngcb_route_t r, int cnt) 
    : ngcbI2C(ngcbI2C_CLK_LINE, ngcbI2C_DATA_LINE, cnt) {
    int i;
 
    /*
     * Copy device and routing information
     */
    dev_ = dev;
    route_.numHdr = r.numHdr;
    for (i=0;i<r.numHdr;i++) route_.hdr[i] = r.hdr[i];
 
    tmo = 0;           // no sleep
    ACK_IN(2);         // acknowledge on bit 2 (TBD)
    SDA_DIR_SWITCH(3); // SDA direction switch on bit 3 (TBD)
  }

  virtual ~ngcbI2C_IO() {
  }         

  int tmo;  // in microseconds

  int OutCB(int d, int *resultCode, char *erms) {
 
    *resultCode = ngcbRES_SUCCESS;
 
    if (dev_ != NULL)
      {
      if (dev_->verboseLevel > 1)
    {
    char s[33];
    ngcbInt2Bin(s, d);
    dev_->Verbose("ngcbI2C: <%s>\n", s);
    }
 
      /*
       * Write one word to I2C-port
       */
      if (dev_->_WriteAddr(route_, ngcbI2C_PORT, &d, 1, 
               resultCode) != ngcbSUCCESS)
    {
    strcpy(erms, dev_->ErrMsg());
    return (-1);
    }
      }
 
    /*
     * Delay (if tmo > 0)
     */
    ngcbMicroSleep(-1, tmo);
 
    return (0);
  }

  int InCB(int *d, int *resultCode, char *erms) {
 
    *resultCode = ngcbRES_SUCCESS;
 
    if (dev_ != NULL)
      {
      /*
       * Read one word from I2C-port
       */
      if (dev_->_ReadAddr(route_, ngcbI2C_PORT, d, 1, 
              resultCode) != ngcbSUCCESS)
    {
    strcpy(erms, dev_->ErrMsg());
    return (-1);
    }
      }
 
    /*
     * Delay (if tmo > 0)
     */
    ngcbMicroSleep(-1, tmo);
 
    return (0);
  }
 
protected:
 
private:
  ngcbIFC *dev_;       

  ngcb_route_t route_; 
};

class ngcbAFE_IO: public ngcbAFE
{
public:
  int tmo;  // in microseconds

  ngcbAFE_IO(ngcbIFC *dev, ngcb_route_t r) {
    int i;
 
    /*
     * Copy device and routing information
     */
    dev_ = dev;
    route_.numHdr = r.numHdr;
    for (i=0;i<r.numHdr;i++) route_.hdr[i] = r.hdr[i];
 
    tmo = 0;
  }

  virtual ~ngcbAFE_IO() {
  }         

  int OutCB(int side, int d, int *resultCode, char *erms) {
    int addr;
 
    *resultCode = ngcbRES_SUCCESS;
 
    /*
     * Select address associated to side
     */
    if (side == 0) addr = ngcbAO_ADDR_AFE_L;
    else addr = ngcbAO_ADDR_AFE_R;
 
    if (dev_ != NULL)
      {
      if (dev_->verboseLevel > 1)
    {
    char s[33];
    ngcbInt2Bin(s, d);
    dev_->Verbose("ngcbAFE: <%s> <0x%04x>\n", s, d & 0xffff);
    }
 
      /*
       * Write one word to AFE-port
       */
      if (dev_->_WriteAddr(route_, addr, &d, 1, 
               resultCode) != ngcbSUCCESS)
    {
    strcpy(erms, dev_->ErrMsg());
    return (-1);
    }
      }
 
    /*
     * Delay (if tmo > 0)
     */
    ngcbMicroSleep(-1, tmo);
 
    return (0);
  }
 
protected:
 
private:
  ngcbIFC *dev_;       

  ngcb_route_t route_; 
};

struct ngcb_ifc_err {
  void *origin;     //< Application specific originator
  ngcbIFC *device;  //< Interface device reporting the error state

  ngcb_ifc_err &operator=(const ngcb_ifc_err &other) {
    if (this != &other)
      {
      origin = other.origin; device = other.device;
      }
    return (*this);
  }

  ngcb_ifc_err(const ngcb_ifc_err &other) {
    /*
     * Forward pointers
     */
    origin = other.origin; device = other.device;
  }

  ngcb_ifc_err() {origin = NULL; device = NULL;}

  ngcb_ifc_err(void *o, ngcbIFC *d): origin(o), device(d) {}
};
 
#endif