DAQ++ git-vmedaq

/* -*- mode: c++ -*- */
#ifndef __RCB_8047_CORBO__
#define __RCB_8047_CORBO_
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iosfwd>
#include <daq/VMEmanager.h>

template<class T>
class Reg
{
protected:
    VMEmanager *vme;
    unsigned long addr;
    T             v;

    virtual void write() = 0;
    virtual T read() = 0;

public:
    typedef T type;
    Reg(unsigned long ad = 0, bool doRead = true) : addr(ad)
    {
        vme = VMEmanager::VME();
        SetAddress(ad, doRead);
    }
    virtual ~Reg()
    {}
    virtual Reg &Set(T x)
    {
        if (addr)
        {
            v = x;
            write();
        }
        return *this;
    }
    virtual T Get()
    {
        if (addr)
            v = read();
        return v;
    }
    T operator()()
    {
        return Get();
    }

    unsigned long GetAddress()
    {
        return addr;
    }

    void SetAddress(unsigned long ad, bool doRead = true)
    {
        addr = ad;
        if (addr && doRead)
            Get();
    }
};


class  CharReg : public Reg<unsigned char>
{
protected:
    void write();
    type read();
public:
    CharReg(unsigned long ad = 0, bool doRead = true)
        : Reg<unsigned char>(ad, doRead)
    {}
};
class  ShortReg : public Reg<unsigned short>
{
protected:
    void write();
    type read();
public:
    ShortReg(unsigned long ad = 0, bool doRead = true)
        : Reg<unsigned short>(ad, doRead)
    {}
};
class  LongReg : public Reg<unsigned long>
{
protected:
    void write();
    type read();
public:
    LongReg(unsigned long ad = 0) : Reg<unsigned long>(ad)
    {}
};

class EvtReg : public LongReg
{
private:
    unsigned long ival;
public:
    EvtReg(unsigned long ad = 0) : LongReg(ad)
    {
        ival = LongReg::Get();
    }
    unsigned long Get()
    {
        return  LongReg::Get() - ival;
    }
    Reg<unsigned long> &Set(unsigned long x)
    {
        LongReg::Set(x);
        ival = LongReg::Get();
        return *this;
    }
};

class CSR : public ShortReg
{
public:
    CSR(unsigned long ad = 0) : ShortReg(ad)
    { }
    CSR &ChnEna(unsigned int x);
    CSR &BusyMode(unsigned int x);
    CSR &InpSel(unsigned int x);
    CSR &BusyOut(unsigned int x);
    CSR &CntSel(unsigned int x);
    CSR &FastClr(unsigned int x);
    CSR &PushEna(unsigned int x);

    unsigned int ChnEna();
    unsigned int BusyMode();
    unsigned int InpSel();
    unsigned int BusyOut();
    unsigned int CntSel();
    unsigned int FastClr();
    unsigned int PushEna();
    unsigned int InpState();
    unsigned int LclBusy ();
    unsigned int DifBusy();
    unsigned int IntPend();
};



//---------------------------------------------------------------------
// Structure for the BIMCR register
//---------------------------------------------------------------------
class BIMCR : public CharReg
{
public:
    BIMCR(unsigned long ad = 0) : CharReg(ad)
    {}

    BIMCR &IRQ(unsigned int x)  ;
    BIMCR &IRAC(unsigned int x) ;
    BIMCR &IRE(unsigned int x)  ;
    BIMCR &XIN(unsigned int x)  ;
    BIMCR &FAC(unsigned int x)  ;
    BIMCR &F(unsigned int x)    ;

    unsigned int IRQ() ;
    unsigned int IRAC();
    unsigned int IRE() ;
    unsigned int XIN() ;
    unsigned int FAC() ;
    unsigned int F  () ;
};



class  ROcntl
{
private:
    unsigned long addr;
public:
    CSR        _csr[4];
    EvtReg    _evt[4];
    ShortReg  _dtim[4];
    BIMCR     _evcr[4];
    CharReg   _evvr[4];
    BIMCR     _tmcr[4];
    CharReg   _tmvr[4];
    ShortReg   _tst[4];
    ShortReg   _clr[4];

public:
    ROcntl(unsigned long ad = 0) : addr(ad)
    {
        SetAddress(ad);
    }
    void SetAddress(unsigned long x);
    unsigned long GetAddress()
    {
        return addr;
    }
    CSR         &csr(int i)
    {
        return _csr[i];
    }
    LongReg     &evtnum(int i)
    {
        return _evt[i];
    }
    ShortReg    &dtim(int i)
    {
        return _dtim[i];
    }
    BIMCR       &evcr(int i)
    {
        return _evcr[i];
    }
    CharReg     &evvr(int i)
    {
        return _evvr[i];
    }
    BIMCR       &tmcr(int i)
    {
        return _tmcr[i];
    }
    CharReg     &tmvr(int i)
    {
        return _tmvr[i];
    }
    ShortReg    &test(int i)
    {
        return _tst[i];
    }
    ShortReg    &clr(int i)
    {
        return _clr[i];
    }
    void Dump();
};

#endif