EVRMRM Class Reference

Modular Register Map Event Receivers. More...

#include <drvem.h>

Inheritance diagram for EVRMRM:

Collaboration diagram for EVRMRM:

Classes
struct	Config

Public Member Functions
	EVRMRM (const std::string &n, bus_configuration &busConfig, const Config *c, volatile unsigned char *, epicsUInt32)
virtual	~EVRMRM ()
virtual void	lock () const OVERRIDE FINAL
virtual void	unlock () const OVERRIDE FINAL
virtual std::string	model () const OVERRIDE FINAL
	Hardware model. More...
epicsUInt32	fpgaFirmware ()
formFactor	getFormFactor ()
std::string	formFactorStr ()
virtual MRFVersion	version () const OVERRIDE FINAL
	Firmware Version. More...
virtual bool	enabled () const OVERRIDE FINAL
virtual void	enable (bool v) OVERRIDE FINAL
virtual bool	mappedOutputState () const OVERRIDE FINAL
MRMGpio *	gpio ()
virtual bool	specialMapped (epicsUInt32 code, epicsUInt32 func) const OVERRIDE FINAL
virtual void	specialSetMap (epicsUInt32 code, epicsUInt32 func, bool) OVERRIDE FINAL
virtual double	clock () const OVERRIDE FINAL
virtual void	clockSet (double) OVERRIDE FINAL
epicsUInt16	clockMode () const
void	clockModeSet (epicsUInt16 mode)
virtual bool	pllLocked () const OVERRIDE FINAL
	Internal PLL Status. More...
virtual epicsUInt32	irqCount () const OVERRIDE FINAL
virtual bool	linkStatus () const OVERRIDE FINAL
virtual IOSCANPVT	linkChanged () const OVERRIDE FINAL
virtual epicsUInt32	recvErrorCount () const OVERRIDE FINAL
virtual epicsUInt32	uSecDiv () const OVERRIDE FINAL
	Approximate divider from event clock period to 1us. More...
virtual bool	extInhib () const OVERRIDE FINAL
	Using external hardware input for inhibit? More...
virtual void	setExtInhib (bool) OVERRIDE FINAL
virtual epicsUInt32	tsDiv () const OVERRIDE FINAL
	When using internal TS source gives the divider from event clock period to TS period. More...
virtual void	setSourceTS (TSSource) OVERRIDE FINAL
	Select source which increments TS counter. More...
virtual TSSource	SourceTS () const OVERRIDE FINAL
virtual double	clockTS () const OVERRIDE FINAL
virtual void	clockTSSet (double) OVERRIDE FINAL
virtual bool	interestedInEvent (epicsUInt32 event, bool set) OVERRIDE FINAL
virtual bool	TimeStampValid () const OVERRIDE FINAL
virtual IOSCANPVT	TimeStampValidEvent () const OVERRIDE FINAL
virtual bool	getTimeStamp (epicsTimeStamp *ts, epicsUInt32 event) OVERRIDE FINAL
virtual bool	getTicks (epicsUInt32 *tks) OVERRIDE FINAL
virtual IOSCANPVT	eventOccurred (epicsUInt32 event) const OVERRIDE FINAL
virtual void	eventNotifyAdd (epicsUInt32, eventCallback, void *) OVERRIDE FINAL
virtual void	eventNotifyDel (epicsUInt32, eventCallback, void *) OVERRIDE FINAL
bool	convertTS (epicsTimeStamp *ts)
	In place conversion between raw posix sec+ticks to EPICS sec+nsec. More...
virtual epicsUInt16	dbus () const OVERRIDE FINAL
virtual epicsUInt32	heartbeatTIMOCount () const OVERRIDE FINAL
virtual IOSCANPVT	heartbeatTIMOOccured () const OVERRIDE FINAL
virtual epicsUInt32	FIFOFullCount () const OVERRIDE FINAL
virtual epicsUInt32	FIFOOverRate () const OVERRIDE FINAL
virtual epicsUInt32	FIFOEvtCount () const OVERRIDE FINAL
virtual epicsUInt32	FIFOLoopCount () const OVERRIDE FINAL
void	enableIRQ (void)
bool	dcEnabled () const
void	dcEnable (bool v)
double	dcTarget () const
void	dcTargetSet (double)
double	dcRx () const
	Measured delay. More...
double	dcInternal () const
	Delay compensation applied. More...
epicsUInt32	dcStatusRaw () const
epicsUInt32	topId () const
bool	psPolarity () const
void	psPolaritySet (bool v)
epicsUInt32	dummy () const
void	setEvtCode (epicsUInt32 code) OVERRIDE FINAL
epicsUInt32	timeSrc () const
void	setTimeSrc (epicsUInt32 mode)
Public Member Functions inherited from mrf::ObjectInst< EVRMRM, EVR >
virtual propertyBase *	getPropertyBase (const char *pname, const std::type_info &ptype)
virtual void	visitProperties (bool(*cb)(propertyBase *, void *), void *arg)
Public Member Functions inherited from EVR
	EVR (const std::string &n, bus_configuration &busConfig)
virtual	~EVR ()=0
std::string	versionStr () const
virtual std::string	versionSw () const
	Software Version. More...
virtual std::string	getCommitHash () const
virtual std::string	position () const
	Position of EVR device in enclosure. More...
bus_configuration *	getBusConfiguration ()
void	setSourceTSraw (epicsUInt32 r)
epicsUInt32	SourceTSraw () const
Public Member Functions inherited from mrf::Object
const std::string &	name () const
const Object *	parent () const
child_iterator	beginChild () const
child_iterator	endChild () const
template<typename P >
mrf::auto_ptr< property< P > >	getProperty (const char *pname)
Public Member Functions inherited from MRMSPI
	MRMSPI (volatile unsigned char *base)
virtual	~MRMSPI ()
virtual void	select (unsigned id) OVERRIDE FINAL
	Select numbered device. 0 clears selection. More...
virtual epicsUInt8	cycle (epicsUInt8 in) OVERRIDE FINAL
Public Member Functions inherited from mrf::SPIInterface
	SPIInterface ()
virtual	~SPIInterface ()
virtual void	cycles (size_t nops, const Operation *ops)
double	timeout () const
	timeout in seconds for an individual cycle() More...
void	setTimeout (double t)
Public Member Functions inherited from TimeStampSource
	TimeStampSource (double period)
virtual	~TimeStampSource ()
void	resyncSecond ()
	Call to re-initialize timestamp counter from system time. More...
void	tickSecond ()
	Call just after the start of each second. More...
bool	validSeconds () const
	Whether tickSecond() has been called for the past 5 seconds. More...
double	deltaSeconds () const
	last difference between More...
void	softSecondsSrc (bool enable)
	enable sending of event 125 by software timer. Simulation of external HW clock More...
bool	isSoftSeconds () const
std::string	nextSecond () const

Static Public Member Functions
static void	isr (EVRMRM *evr, bool pci)
static void	isr_pci (void *)
static void	isr_vme (void *)
static void	isr_poll (void *)
Static Public Member Functions inherited from mrf::ObjectInst< EVRMRM, EVR >
static int	initObject ()
Static Public Member Functions inherited from mrf::ObjectInst< EVR >
static int	initObject ()
Static Public Member Functions inherited from mrf::Object
static Object *	getObject (const std::string &name)
static Object *	getCreateObject (const std::string &name, const std::string &klass, const create_args_t &args=create_args_t())
static void	addFactory (const std::string &klass, create_factory_t fn)
static void	visitObjects (bool(*)(Object *, void *), void *)

Public Attributes
epicsMutex	evrLock
	Guards access to instance All callers must take this lock before any operations on this object. More...
const Config *const	conf
volatile unsigned char *const	base
epicsUInt32	baselen
mrmDataBufTx	buftx
mrmBufRx	bufrx
mrf::auto_ptr< SFP >	sfp

Friends
struct	EVRMRMTSBuffer

Additional Inherited Members
Public Types inherited from EVR
typedef void(*	eventCallback) (void *userarg, epicsUInt32 event)
Public Types inherited from mrf::Object
typedef m_obj_children_t::const_iterator	child_iterator
typedef std::map< std::string, std::string >	create_args_t
typedef Object *(*	create_factory_t) (const std::string &name, const std::string &klass, const create_args_t &args)
Protected Member Functions inherited from mrf::ObjectInst< EVRMRM, EVR >
	ObjectInst (const std::string &n)
	ObjectInst (const std::string &n, A &a)
virtual	~ObjectInst ()
Protected Member Functions inherited from mrf::ObjectInst< EVR >
	ObjectInst (const std::string &n)
	ObjectInst (const std::string &n, A &a)
Protected Member Functions inherited from mrf::Object
	Object (const std::string &n, const Object *par=0)
virtual	~Object ()=0
Protected Member Functions inherited from TimeStampSource
virtual void	postSoftSecondsSrc ()
Protected Attributes inherited from mrf::SPIInterface
epicsMutex	mutex

Detailed Description

Modular Register Map Event Receivers.

Definition at line 94 of file drvem.h.

Constructor & Destructor Documentation

EVRMRM()

EVRMRM::EVRMRM	(	const std::string &	n,
		bus_configuration &	busConfig,
		const Config *	c,
		volatile unsigned char *	b,
		epicsUInt32	bl
	)

Definition at line 126 of file drvem.cpp.

  :base_t(n,busConfig)
  ,MRMSPI(b+U32_SPIDData)
  ,TimeStampSource(1.0)
  ,evrLock()
  ,conf(c)
  ,base(b)
  ,baselen(bl)
  ,buftx(n+":BUFTX", b+U32_DataTxCtrl, b+U32_DataTx_base)
  ,bufrx(n+":BUFRX", b, 10) // Sets depth of Rx queue
  ,count_recv_error(0)
  ,count_hardware_irq(0)
  ,count_heartbeat(0)
  ,shadowIRQEna(0)
  ,count_FIFO_overflow(0)
  ,outputs()
  ,prescalers()
  ,pulsers()
  ,shortcmls()
  ,gpio_(*this)
  ,drain_fifo_method(*this)
  ,drain_fifo_task(drain_fifo_method, "EVRFIFO",
                   epicsThreadGetStackSize(epicsThreadStackBig),
                   epicsThreadPriorityHigh )
  // 3 because 2 IRQ events, and 1 shutdown event
  ,drain_fifo_wakeup(3,sizeof(int))
  ,count_FIFO_sw_overrate(0)
  ,timeSrcMode(Disable)
  ,stampClock(0.0)
  ,shadowSourceTS(TSSourceInternal)
  ,shadowCounterPS(0)
  ,timestampValid(0)
  ,lastInvalidTimestamp(0)
  ,lastValidTimestamp(0)
{
try{
    const epicsUInt32 rawver = fpgaFirmware();
    const epicsUInt32 boardtype = (rawver&FWVersion_type_mask)>>FWVersion_type_shift;
    const epicsUInt32 formfactor = (rawver&FWVersion_form_mask)>>FWVersion_form_shift;
    const MRFVersion ver(rawver);

    if(boardtype!=0x1)
        throw std::runtime_error("Address does not correspond to an EVR");

    if(ver<MRFVersion(0,3))
        throw std::runtime_error("Firmware 0 version < 3 not supported");
    else if(ver.firmware()==2 && ver<MRFVersion(2,7))
        throw std::runtime_error("Firmware 2 version < 207 not supported");

    if(ver.firmware()==2 && ver<MRFVersion(2,7,6))
        printf("Warning: Recommended minimum firmware 2 version is 207.6, found %s\n", ver.str().c_str());

    if(ver.firmware()!=0 && ver.firmware()!=2)
        printf("Warning: Unknown firmware series %u.  Your milage may vary\n", ver.firmware());

    scanIoInit(&IRQmappedEvent);
    scanIoInit(&IRQheartbeat);
    scanIoInit(&IRQrxError);
    scanIoInit(&IRQfifofull);
    scanIoInit(&timestampValidChange);

    CBINIT(&data_rx_cb   , priorityHigh, &mrmBufRx::drainbuf, &this->bufrx);
    CBINIT(&poll_link_cb , priorityMedium, &EVRMRM::poll_link , this);

    if(ver>=MRFVersion(0, 5)) {
        sfp.reset(new SFP(SB() << n << ":SFP", base + U32_SFPEEPROM_base));
    }

    if(ver>=MRFVersion(2,7)) {
        printf("Sequencer capability detected\n");
        seq.reset(new EvrSeqManager(this));
    }

    /*
     * Create subunit instances
     */

    formFactor form = getFormFactor();

    printf("%s: ", formFactorStr().c_str());

    std::cout << " Model " << conf->model
              << " Pul " << conf->nPul
              << " PS " << conf->nPS
              << " OFP " << conf->nOFP
              << " OFPUNIV " << conf->nOFPUV
              << " ORB " << conf->nORB
              << " OBack " << conf->nOBack
              << " OFPDly " << conf->nOFPDly
              << " CML " << conf->nCML
              << " Kind " << static_cast<int>(conf->kind)
              << " IFP " << conf->nIFP
              << std::endl;

    inputs.resize(conf->nIFP);
    for(size_t i=0; i<conf->nIFP; i++){
        inputs[i] = new MRMInput(SB() << n << ":FPIn" << i, base, i);
    }

    // Special output for mapping bus interrupt
    outputs[std::make_pair(OutputInt,0)]=new MRMOutput(n+":Int", this, OutputInt, 0);

    for(unsigned int i=0; i<conf->nOFP; i++){
        outputs[std::make_pair(OutputFP, i)] = new MRMOutput(SB() << n << ":FrontOut" << i, this, OutputFP, i);
    }

    for(unsigned int i=0; i<conf->nOFPUV; i++){
        outputs[std::make_pair(OutputFPUniv, i)] = new MRMOutput(SB() << n << ":FrontUnivOut" << i, this, OutputFPUniv, i);
    }

    delays.resize(conf->nOFPDly);
    for(unsigned int i=0; i<conf->nOFPDly; i++){
        delays[i] = new DelayModule(SB() << n << ":UnivDlyModule" << i, this, i);
    }

    for(unsigned int i=0; i<conf->nORB; i++){
        outputs[std::make_pair(OutputRB, i)] = new MRMOutput(SB() << n << ":RearUniv" << i, this, OutputRB, i);
    }

    for(unsigned int i=0; i<conf->nOBack; i++){
        outputs[std::make_pair(OutputRB, i)] = new MRMOutput(SB() << n << ":Backplane" << i, this, OutputBackplane, i);
    }

    prescalers.resize(conf->nPS);
    for(size_t i=0; i<conf->nPS; i++){
        prescalers[i] = new MRMPreScaler(SB() << n << ":PS" << i, *this, base + U32_Scaler(i));
    }

    pulsers.resize(32);
    for(epicsUInt32 i=0; i<conf->nPul; i++){
        pulsers[i] = new MRMPulser(SB() << n << ":Pul" << i, i, *this);
    }
    if(ver>=MRFVersion(2,0)) {
        // masking pulsers
        for(epicsUInt32 i=28; i<=31; i++){
            pulsers[i] = new MRMPulser(SB() << n << ":Pul" << i, i, *this);
        }

    }

    if(formfactor==formFactor_CPCIFULL) {
        for(unsigned int i=4; i<8; i++) {
            outputs[std::make_pair(OutputFP, i)] = new MRMOutput(SB() << n << ":FrontOut" << i, this, OutputFP, i);
        }
        shortcmls.resize(8, 0);
        shortcmls[4]=new MRMCML(n+":CML4", 4,*this,MRMCML::typeCML,form);
        shortcmls[5]=new MRMCML(n+":CML5", 5,*this,MRMCML::typeCML,form);
        shortcmls[6]=new MRMCML(n+":CML6", 6,*this,MRMCML::typeTG300,form);
        shortcmls[7]=new MRMCML(n+":CML7", 7,*this,MRMCML::typeTG300,form);

    } else if(formfactor==formFactor_mTCA) {
        int u_idx;
        if (conf->nCML > 0)
            shortcmls.resize(conf->nCML);
        for (size_t i = 0; i < conf->nCML; i++)
        {
            u_idx = GTX_FPUV_OFFSET + i;
            // map GTX outputs (e.g. TCLKA/B) starting from GTX_FPUV_OFFSET (as in the documentation)
            outputs[std::make_pair(OutputFPUniv, u_idx)]
                = new MRMOutput(SB() << n << ":FrontUnivOut" << u_idx, this, OutputFPUniv, u_idx);
            // create CMLs
            if(model().compare("mTCA-EVR-300RF") == 0 && u_idx == GTX_SFP_OFFSET)
                shortcmls[i] = new MRMCML(SB() << n << ":CML" << i, i, *this, MRMCML::typeTG300, form);
            else
                shortcmls[i] = new MRMCML(SB() << n << ":CML" << i, i, *this, conf->kind, form);
        }
    } else if(conf->nCML && ver>=MRFVersion(0,4)){
        shortcmls.resize(conf->nCML);
        for(size_t i=0; i<conf->nCML; i++){
            shortcmls[i] = new MRMCML(SB() << n << ":CML" << i, (unsigned char)i, *this, conf->kind, form);
        }

    }else if(conf->nCML){
        printf("CML outputs not supported with this firmware\n");
    }

    for(epicsUInt32 i=0; i<NELEMENTS(this->events); i++) {
        events[i].code=i;
        events[i].owner=this;
        CBINIT(&events[i].done_cb, priorityLow, &EVRMRM::sentinel_done , &events[i]);
    }

    SCOPED_LOCK(evrLock);

    memset(_mapped, 0, sizeof(_mapped));
    // restore mapping ram to a clean state
    // needed when the IOC is started w/o a device reset (ie Linux)
    //TODO: find a way to do this that doesn't require clearing
    //      mapping which will shortly be set again...
    for(size_t i=0; i<255; i++) {
        WRITE32(base, MappingRam(0, i, Internal), 0);
        WRITE32(base, MappingRam(0, i, Trigger), 0);
        WRITE32(base, MappingRam(0, i, Set), 0);
        WRITE32(base, MappingRam(0, i, Reset), 0);
    }

    // restore default special mappings
    // These may be replaced later
    specialSetMap(MRF_EVENT_TS_SHIFT_0,     96, true);
    specialSetMap(MRF_EVENT_TS_SHIFT_1,     97, true);
    specialSetMap(MRF_EVENT_TS_COUNTER_INC, 98, true);
    specialSetMap(MRF_EVENT_TS_COUNTER_RST, 99, true);
    specialSetMap(MRF_EVENT_HEARTBEAT,      101, true);

    // Except for Prescaler reset, which is set with a record
    specialSetMap(MRF_EVENT_RST_PRESCALERS, 100, false);

    eventClock=FracSynthAnalyze(READ32(base, FracDiv),
                                fracref,0)*1e6;

    shadowCounterPS=READ32(base, CounterPS);

    if(tsDiv()!=0) {
        shadowSourceTS=TSSourceInternal;
    } else {
        bool usedbus4=(READ32(base, Control) & Control_tsdbus) != 0;

        if(usedbus4)
            shadowSourceTS=TSSourceDBus4;
        else
            shadowSourceTS=TSSourceEvent;
    }

    eventNotifyAdd(MRF_EVENT_TS_COUNTER_RST, &seconds_tick, (void*)this);

    drain_fifo_task.start();

    if(busConfig.busType==busType_pci)
        mrf::SPIDevice::registerDev(n+":FLASH", mrf::SPIDevice(this, 1));

    #ifndef DBR_UTAG
    std::cout << "WARNING EVRMRM::EVRMRM epicsUTag not supported." << std::endl;
    #endif

} catch (std::exception& e) {
    printf("Aborting EVR initializtion: %s\n", e.what());
    cleanup();
    throw;
}
}

~EVRMRM()

EVRMRM::~EVRMRM ( )

virtual

Definition at line 370 of file drvem.cpp.

{
    if(getBusConfiguration()->busType==busType_pci)
        mrf::SPIDevice::unregisterDev(name()+":FLASH");
    cleanup();
}

Member Function Documentation

clock()

virtual double EVRMRM::clock ( ) const

inlinevirtual

Find current LO settings

Returns

Clock rate in Hz

Implements EVR.

Definition at line 149 of file drvem.h.

        {SCOPED_LOCK(evrLock);return eventClock;}

clockMode()

epicsUInt16 EVRMRM::clockMode

(

)

const

Definition at line 611 of file drvem.cpp.

{
    return (READ32(base, ClkCtrl)&ClkCtrl_clkmd_MASK)>>ClkCtrl_clkmd_SHIFT;
}

clockModeSet()

void EVRMRM::clockModeSet

(

epicsUInt16

mode

)

Definition at line 617 of file drvem.cpp.

{
    epicsUInt32 cur = READ32(base, ClkCtrl);
    cur &= ~ClkCtrl_clkmd_MASK;
    cur |= (epicsUInt32(mode)<<ClkCtrl_clkmd_SHIFT)&ClkCtrl_clkmd_MASK;
    WRITE32(base, ClkCtrl, cur);
}

clockSet()

void EVRMRM::clockSet ( double  clk )

virtual

Set LO frequency

Parameters

clk	Clock rate in Hz

Implements EVR.

Definition at line 570 of file drvem.cpp.

{
    double err;
    // Set both the fractional synthesiser and microsecond
    // divider.
    printf("Set EVR clock %f\n",freq);

    freq/=1e6;

    epicsUInt32 newfrac=FracSynthControlWord(
                        freq, fracref, 0, &err);

    if(newfrac==0)
        throw std::out_of_range("New frequency can't be used");

    SCOPED_LOCK(evrLock);

    epicsUInt32 oldfrac=READ32(base, FracDiv);

    if(newfrac!=oldfrac){
        // Changing the control word disturbes the phase
        // of the synthesiser which will cause a glitch.
        // Don't change the control word unless needed.

        WRITE32(base, FracDiv, newfrac);

        eventClock=FracSynthAnalyze(READ32(base, FracDiv),
                                    fracref,0)*1e6;
    }

    // USecDiv is accessed as a 32 bit register, but
    // only 16 are used.
    epicsUInt16 oldudiv=READ32(base, USecDiv);
    epicsUInt16 newudiv=(epicsUInt16)freq;

    if(newudiv!=oldudiv){
        WRITE32(base, USecDiv, newudiv);
    }
}

clockTS()

double EVRMRM::clockTS ( ) const

virtual

Find current TS settings

Returns

Clock rate in Hz

Implements EVR.

Definition at line 704 of file drvem.cpp.

{
    //Note: acquires evrLock 3 times.

    TSSource src=SourceTS();
    double eclk=clock();

    if( (src!=TSSourceInternal) ||
       ((src==TSSourceInternal) && (stampClock>eclk)))
        return stampClock;

    epicsUInt16 div=tsDiv();

    return eclk/div;
}

clockTSSet()

void EVRMRM::clockTSSet ( double  )

virtual

Set TS frequency

Parameters

clk	Clock rate in Hz

Implements EVR.

Definition at line 721 of file drvem.cpp.

{
    if(clk<0.0 || !isfinite(clk))
        throw std::out_of_range("TS Clock rate invalid");

    TSSource src=SourceTS();
    double eclk=clock();

    /* There is an issue with this and the embedded EVRs of the mTCA EVM vers
     * 280b0207. The register holding the fractional synthesizer configuration
     * word is empty, so eclk always resolves to 0, and so does clk. This messes
     * up with the delay generators width/delay settings. By removing this check
     * clockTS() can be used for the calculation of the width/delay.
     * if(clk>eclk*1.01 || clk==0.0)
     */
    if(clk==0.0)
        clk=eclk;

    SCOPED_LOCK(evrLock);

    if(src==TSSourceInternal){
        epicsUInt16 div=roundToUInt(eclk/clk, 0xffff);
        WRITE32(base, CounterPS, div);

        shadowCounterPS=div;
    }

    stampClock=clk;
}

convertTS()

bool EVRMRM::convertTS

(

epicsTimeStamp *

ts

)

In place conversion between raw posix sec+ticks to EPICS sec+nsec.

Returns

false if conversion failed

Definition at line 844 of file drvem.cpp.

{
    // First validate the input

    //Has it been initialized?
    if(ts->secPastEpoch==0 || ts->nsec==0){
        return false;
    }

    // recurrence of an invalid time
    if(ts->secPastEpoch==lastInvalidTimestamp) {
        timestampValid=0;
        scanIoRequest(timestampValidChange);
        if(evrMrmTimeDebug>0)
            errlogPrintf("TS convert repeats known bad value new %08x bad %08x\n",
                         (unsigned)ts->secPastEpoch, (unsigned)lastInvalidTimestamp);
        return false;
    }

    /* Reported seconds timestamp should be no more
     * then 1sec in the future.
     * reporting values in the past should be caught by
     * generalTime
     */
    if(ts->secPastEpoch > lastValidTimestamp+1)
    {
        errlogPrintf("EVR ignoring invalid TS %08x %08x (expect %08x)\n",
                     ts->secPastEpoch, ts->nsec, lastValidTimestamp);
        timestampValid=0;
        scanIoRequest(timestampValidChange);
        return false;
    }

    // Convert ticks to nanoseconds
    double period=1e9/clockTS(); // in nanoseconds

    if(period<=0 || !isfinite(period))
        return false;

    ts->nsec=(epicsUInt32)(ts->nsec*period);

    // 1 sec. reset is late
    if(ts->nsec>=1000000000u) {
        if(evrMrmTimeDebug>0)
            errlogPrintf("TS convert NS overflow %08x %08x oflow=%u\n",
                         (unsigned)ts->secPastEpoch, (unsigned)ts->nsec,
                         unsigned(ts->nsec-1000000000u));

        // out of bounds
        if(int(ts->nsec-1000000000u)>=evrMrmTimeNSOverflowThreshold) {
            errlogPrintf("TS out of bounds %08x %08x oflow %d evrMrmTimeNSOverflowThreshold %u diff %d\n",
                         (unsigned)ts->secPastEpoch, (unsigned)ts->nsec,
                         int(ts->nsec-1000000000u), evrMrmTimeNSOverflowThreshold,
                         int(ts->nsec-1000000000u)-evrMrmTimeNSOverflowThreshold);
            timestampValid=0;
            lastInvalidTimestamp=ts->secPastEpoch;
            scanIoRequest(timestampValidChange);

            return false;
        }
        // otherwise, truncate
        ts->nsec = 999999999u;
    }

    //Link seconds counter is POSIX time
    ts->secPastEpoch-=POSIX_TIME_AT_EPICS_EPOCH;

    return true;
}

dbus()

epicsUInt16 EVRMRM::dbus ( ) const

virtual

Implements EVR.

Definition at line 957 of file drvem.cpp.

{
    return (READ32(base, Status) & Status_dbus_mask) >> Status_dbus_shift;
}

dcEnable()

void EVRMRM::dcEnable

(

bool

v

)

Definition at line 969 of file drvem.cpp.

{
    if(v)
        BITSET32(base, Control, Control_DCEna);
    else
        BITCLR32(base, Control, Control_DCEna);
}

dcEnabled()

bool EVRMRM::dcEnabled

(

)

const

Definition at line 963 of file drvem.cpp.

{
    return READ32(base, Control) & Control_DCEna;
}

dcInternal()

double EVRMRM::dcInternal

(

)

const

Delay compensation applied.

Definition at line 1002 of file drvem.cpp.

{
    double period=1e9/clock(); // in nanoseconds
    return double(READ32(base, DCIntVal))/65536.0*period;
}

dcRx()

double EVRMRM::dcRx

(

)

const

Measured delay.

Definition at line 995 of file drvem.cpp.

{
    double period=1e9/clock(); // in nanoseconds
    return double(READ32(base, DCRxVal))/65536.0*period;
}

dcStatusRaw()

epicsUInt32 EVRMRM::dcStatusRaw

(

)

const

Definition at line 1009 of file drvem.cpp.

{
    return READ32(base, DCStatus);
}

dcTarget()

double EVRMRM::dcTarget

(

)

const

Definition at line 978 of file drvem.cpp.

{
    double period=1e9/clock(); // in nanoseconds
    return double(READ32(base, DCTarget))/65536.0*period;
}

dcTargetSet()

void EVRMRM::dcTargetSet

(

double

val

)

Definition at line 985 of file drvem.cpp.

{
    double period=1e9/clock(); // in nanoseconds

    val /= period;
    val *= 65536.0;
    WRITE32(base, DCTarget, val);
}

dummy()

epicsUInt32 EVRMRM::dummy ( ) const

inline

Definition at line 222 of file drvem.h.

{ return 0; }

enable()

void EVRMRM::enable ( bool  v )

virtual

Implements EVR.

Definition at line 483 of file drvem.cpp.

{
    SCOPED_LOCK(evrLock);
    if(v)
        BITSET(NAT,32,base, Control, Control_enable|Control_mapena|Control_outena|Control_evtfwd);
    else
        BITCLR(NAT,32,base, Control, Control_enable|Control_mapena|Control_outena|Control_evtfwd);
}

enabled()

bool EVRMRM::enabled ( ) const

virtual

Implements EVR.

Definition at line 476 of file drvem.cpp.

{
    epicsUInt32 v = READ32(base, Control);
    return (v&Control_enable) != 0;
}

enableIRQ()

void EVRMRM::enableIRQ

(

void

)

Definition at line 1116 of file drvem.cpp.

{
    interruptLock I;

    shadowIRQEna =  IRQ_Enable
                   |IRQ_RXErr    |IRQ_BufFull
                   |IRQ_Heartbeat
                   |IRQ_Event    |IRQ_FIFOFull
                   |IRQ_SoS      |IRQ_EoS;

    // IRQ PCIe enable flag should not be changed. Possible RACER here
    shadowIRQEna |= (IRQ_PCIee & (READ32(base, IRQEnable)));

    WRITE32(base, IRQEnable, shadowIRQEna);
}

eventNotifyAdd()

void EVRMRM::eventNotifyAdd ( epicsUInt32  event, eventCallback  cb, void *  arg  )

virtual

Implements EVR.

Definition at line 931 of file drvem.cpp.

{
    if (event==0 || event>255)
        throw std::out_of_range("Invalid event number");

    SCOPED_LOCK2(evrLock, guard);

    events[event].notifiees.push_back( std::make_pair(cb,arg));

    interestedInEvent(event, true);
}

eventNotifyDel()

void EVRMRM::eventNotifyDel ( epicsUInt32  event, eventCallback  cb, void *  arg  )

virtual

Implements EVR.

Definition at line 944 of file drvem.cpp.

{
    if (event==0 || event>255)
        throw std::out_of_range("Invalid event number");

    SCOPED_LOCK2(evrLock, guard);

    events[event].notifiees.remove(std::make_pair(cb,arg));

    interestedInEvent(event, false);
}

eventOccurred()

IOSCANPVT EVRMRM::eventOccurred ( epicsUInt32  event ) const

virtual

Implements EVR.

Definition at line 922 of file drvem.cpp.

{
    if (event>0 && event<=255)
        return events[event].occured;
    else
        return NULL;
}

extInhib()

bool EVRMRM::extInhib ( ) const

virtual

Using external hardware input for inhibit?

Implements EVR.

Definition at line 632 of file drvem.cpp.

{
    epicsUInt32 v = READ32(base, Control);
    return (v&Control_GTXio) != 0;
}

FIFOEvtCount()

virtual epicsUInt32 EVRMRM::FIFOEvtCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 200 of file drvem.h.

{return count_fifo_events;}

FIFOFullCount()

virtual epicsUInt32 EVRMRM::FIFOFullCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 196 of file drvem.h.

    {SCOPED_LOCK(evrLock);return count_FIFO_overflow;}

FIFOLoopCount()

virtual epicsUInt32 EVRMRM::FIFOLoopCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 201 of file drvem.h.

{return count_fifo_loops;}

FIFOOverRate()

virtual epicsUInt32 EVRMRM::FIFOOverRate ( ) const

inlinevirtual

Implements EVR.

Definition at line 198 of file drvem.h.

    {SCOPED_LOCK(evrLock);return count_FIFO_sw_overrate;}

formFactorStr()

std::string EVRMRM::formFactorStr

(

)

Definition at line 430 of file drvem.cpp.

                     {
    std::string text;
    formFactor form;

    form = getFormFactor();
    switch(form){
    case formFactor_CPCI:
        text = "CompactPCI 3U";
        break;

    case formFactor_CPCIFULL:
        text = "CompactPCI 6U";
        break;

    case formFactor_CRIO:
        text = "CompactRIO";
        break;

    case formFactor_PCIe:
        text = "PCIe";
        break;

    case formFactor_mTCA:
        text = "mTCA";
        break;

    case formFactor_PXIe:
        text = "PXIe";
        break;

    case formFactor_PMC:
        text = "PMC";
        break;

    case formFactor_VME64:
        text = "VME 64";
        break;

    default:
        text = "Unknown form factor";
    }

    return text;
}

fpgaFirmware()

epicsUInt32 EVRMRM::fpgaFirmware

(

)

Definition at line 411 of file drvem.cpp.

                    {
    return READ32(base, FWVersion);
}

getFormFactor()

formFactor EVRMRM::getFormFactor

(

)

Definition at line 421 of file drvem.cpp.

                     {
    epicsUInt32 v = READ32(base, FWVersion);
    epicsUInt32 form = (v&FWVersion_form_mask)>>FWVersion_form_shift;

    if(form <= formFactor_mTCA) return (formFactor)form;
    else return formFactor_unknown;
}

getTicks()

bool EVRMRM::getTicks ( epicsUInt32 *  tks )

virtual

Returns the current value of the Timestamp Event Counter

Parameters

tks	Pointer to be filled with the counter value

Returns

false if the counter value is not valid

Implements EVR.

Definition at line 915 of file drvem.cpp.

{
    *tks=READ32(base, TSEvt);
    return true;
}

getTimeStamp()

bool EVRMRM::getTimeStamp ( epicsTimeStamp *  ts, epicsUInt32  event  )

virtual

Gives the current time stamp as sec+nsec

Parameters

ts	This pointer will be filled in with the current time
event	N<=0 Return the current wall clock time
event	N>0 Return the time the most recent event # N was received.

Returns

true When ts was updated

false When ts could not be updated

Implements EVR.

Definition at line 782 of file drvem.cpp.

{
    if(!ret) throw std::runtime_error("Invalid argument");
    epicsTimeStamp ts;

    SCOPED_LOCK(evrLock);
    if(timestampValid<TSValidThreshold) return false;

    if(event>0 && event<=255) {
        // Get time of last event code #

        eventCode *entry=&events[event];

        // Fail if event is not mapped
        if (!entry->interested ||
            ( entry->last_sec==0 &&
              entry->last_evt==0) )
        {
            return false;
        }

        ts.secPastEpoch=entry->last_sec;
        ts.nsec=entry->last_evt;


    } else {
        // Get current absolute time

        epicsUInt32 ctrl=READ32(base, Control);

        // Latch timestamp
        WRITE32(base, Control, ctrl|Control_tsltch);

        ts.secPastEpoch=READ32(base, TSSecLatch);
        ts.nsec=READ32(base, TSEvtLatch);

        /* BUG: There was a firmware bug which occasionally
         * causes the previous write to fail with a VME bus
         * error, and 0 the Control register.
         *
         * This issues has been fixed in VME firmwares EVRv 5
         * pre2 and EVG v3 pre2.  Feb 2011
         */
        epicsUInt32 ctrl2=READ32(base, Control);
        if (ctrl2!=ctrl) { // tsltch bit is write-only
            printf("Get timestamp: control register write fault. Written: %08x, readback: %08x\n",ctrl,ctrl2);
            WRITE32(base, Control, ctrl);
        }

    }

    if(!convertTS(&ts))
        return false;

    *ret = ts;
    return true;
}

gpio()

MRMGpio * EVRMRM::gpio

(

)

Definition at line 500 of file drvem.cpp.

            {
    return &gpio_;
}

heartbeatTIMOCount()

virtual epicsUInt32 EVRMRM::heartbeatTIMOCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 193 of file drvem.h.

{return count_heartbeat;}

heartbeatTIMOOccured()

virtual IOSCANPVT EVRMRM::heartbeatTIMOOccured ( ) const

inlinevirtual

Implements EVR.

Definition at line 194 of file drvem.h.

{return IRQheartbeat;}

interestedInEvent()

bool EVRMRM::interestedInEvent ( epicsUInt32  event, bool  set  )

virtual

Indicate (lack of) interest in a particular event code. This allows an EVR to ignore event codes which are not needed.

Implements EVR.

Definition at line 752 of file drvem.cpp.

{
    if (!event || event>255) return false;

    eventCode *entry=&events[event];

    SCOPED_LOCK(evrLock);

    if (   (set  && entry->interested==0) // first interested
        || (!set && entry->interested==1) // or last un-interested
    ) {
        specialSetMap(event, ActionFIFOSave, set);
    }

    if (set)
        entry->interested++;
    else
        entry->interested--;

    return true;
}

irqCount()

virtual epicsUInt32 EVRMRM::irqCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 158 of file drvem.h.

{return count_hardware_irq;}

isr()

void EVRMRM::isr ( EVRMRM *  evr, bool  pci  )

static

Definition at line 1168 of file drvem.cpp.

{

    epicsUInt32 flags=READ32(evr->base, IRQFlag);

    epicsUInt32 active=flags&evr->shadowIRQEna;

#if defined(vxWorks) || defined(__rtems__)
    if(!active) {
#  ifdef __rtems__
        if(!pci)
            printk("EVRMRM::isr with no active VME IRQ 0x%08x 0x%08x\n", flags, evr->shadowIRQEna);
#else
        (void)pci;
#  endif
        // this is a shared interrupt
        return;
    }
    // Note that VME devices do not normally shared interrupts
#else
    // for Linux, shared interrupts are detected by the kernel module
    // so any notifications to userspace are real interrupts by this device
    (void)pci;
#endif

    if(active&IRQ_RXErr){
        evr->count_recv_error++;
        scanIoRequest(evr->IRQrxError);

        evr->shadowIRQEna &= ~IRQ_RXErr;
        callbackRequest(&evr->poll_link_cb);
    }
    if(active&IRQ_BufFull){
        // Silence interrupt
        BITSET(NAT,32,evr->base, DataBufCtrl, DataBufCtrl_stop);

        callbackRequest(&evr->data_rx_cb);
    }
    if(active&IRQ_HWMapped){
        evr->shadowIRQEna &= ~IRQ_HWMapped;
        //TODO: think of a way to use this feature...
    }
    if(active&IRQ_Event){
        //FIFO not-empty
        evr->shadowIRQEna &= ~IRQ_Event;
        int wakeup=0;
        evr->drain_fifo_wakeup.trySend(&wakeup, sizeof(wakeup));
    }
    if(active&IRQ_Heartbeat){
        evr->count_heartbeat++;
        scanIoRequest(evr->IRQheartbeat);
    }
    if(active&IRQ_FIFOFull){
        evr->shadowIRQEna &= ~IRQ_FIFOFull;
        int wakeup=0;
        evr->drain_fifo_wakeup.trySend(&wakeup, sizeof(wakeup));

        scanIoRequest(evr->IRQfifofull);
    }
    if(active&IRQ_SoS && evr->seq.get()){
        evr->seq->doStartOfSequence(0);
    }
    if(active&IRQ_EoS && evr->seq.get()){
        evr->seq->doEndOfSequence(0);
    }
    evr->count_hardware_irq++;

    // IRQ PCIe enable flag should not be changed. Possible RACER here
    evr->shadowIRQEna |= (IRQ_PCIee & (READ32(evr->base, IRQEnable)));

    WRITE32(evr->base, IRQFlag, flags);
    WRITE32(evr->base, IRQEnable, evr->shadowIRQEna);
    // Ensure IRQFlags is written before returning.
    evrMrmIsrFlagsTrashCan=READ32(evr->base, IRQFlag);
}

isr_pci()

void EVRMRM::isr_pci ( void *  arg )

static

Definition at line 1133 of file drvem.cpp.

                         {
    EVRMRM *evr=static_cast<EVRMRM*>(arg);

    // Calling the default platform-independent interrupt routine
    evr->isr(evr, true);

#if defined(__linux__) || defined(_WIN32)
    if(devPCIEnableInterrupt((const epicsPCIDevice*)evr->isrLinuxPvt)) {
        printf("Failed to re-enable interrupt.  Stuck...\n");
    }
#endif
}

isr_poll()

void EVRMRM::isr_poll ( void *  arg )

static

Definition at line 1155 of file drvem.cpp.

                          {
    EVRMRM *evr=static_cast<EVRMRM*>(arg);

    // Calling the default platform-independent interrupt routine
    evr->isr(evr, true);
}

isr_vme()

void EVRMRM::isr_vme ( void *  arg )

static

Definition at line 1147 of file drvem.cpp.

                         {
    EVRMRM *evr=static_cast<EVRMRM*>(arg);

    // Calling the default platform-independent interrupt routine
    evr->isr(evr, false);
}

linkChanged()

virtual IOSCANPVT EVRMRM::linkChanged ( ) const

inlinevirtual

Implements EVR.

Definition at line 161 of file drvem.h.

{return IRQrxError;}

linkStatus()

bool EVRMRM::linkStatus ( ) const

virtual

Implements EVR.

Definition at line 659 of file drvem.cpp.

{
    return !(READ32(base, Status) & Status_legvio);
}

lock()

virtual void EVRMRM::lock ( ) const

inlinevirtual

Implements mrf::Object.

Definition at line 129 of file drvem.h.

{evrLock.lock();}

mappedOutputState()

bool EVRMRM::mappedOutputState ( ) const

virtual

Implements EVR.

Definition at line 493 of file drvem.cpp.

{
    NAT_WRITE32(base, IRQFlag, IRQ_HWMapped);
    return NAT_READ32(base, IRQFlag) & IRQ_HWMapped;
}

model()

string EVRMRM::model ( ) const

virtual

Hardware model.

Implements EVR.

Definition at line 405 of file drvem.cpp.

{
    return conf->model;
}

pllLocked()

bool EVRMRM::pllLocked ( ) const

virtual

Internal PLL Status.

Implements EVR.

Definition at line 649 of file drvem.cpp.

{
    epicsUInt32 cur = READ32(base, ClkCtrl);
    epicsUInt32 mask = ClkCtrl_cglock;
    if(version()>=MRFVersion(2, 7, 0))
        mask |= ClkCtrl_plllock;
    return (cur&mask)==mask;
}

psPolarity()

bool EVRMRM::psPolarity

(

)

const

Definition at line 1015 of file drvem.cpp.

                         {
        return READ32(base, Control) & Control_pspol;
}

psPolaritySet()

void EVRMRM::psPolaritySet

(

bool

v

)

Definition at line 1020 of file drvem.cpp.

{
    if(v)
        BITSET32(base, Control, Control_pspol);
    else
        BITCLR32(base, Control, Control_pspol);
}

recvErrorCount()

virtual epicsUInt32 EVRMRM::recvErrorCount ( ) const

inlinevirtual

Implements EVR.

Definition at line 162 of file drvem.h.

{return count_recv_error;}

setEvtCode()

void EVRMRM::setEvtCode ( epicsUInt32  code )

virtual

Implements TimeStampSource.

Definition at line 1035 of file drvem.cpp.

{
    if(code==0) return;
    else if(code>255) throw std::runtime_error("Event code out of range");
    SCOPED_LOCK(evrLock);

    unsigned i;

    // spin fast
    for(i=0; i<100 && READ32(base, SwEvent) & SwEvent_Pend; i++) {}

    if(i==100) {
        // spin slow for <= 50ms
        for(i=0; i<5 && READ32(base, SwEvent) & SwEvent_Pend; i++)
            epicsThreadSleep(0.01);

        if(i==5)
            throw std::runtime_error("SwEvent timeout");
    }

    WRITE32(base, SwEvent, (code<<SwEvent_Code_SHIFT)|SwEvent_Ena);
}

setExtInhib()

void EVRMRM::setExtInhib ( bool  v )

virtual

Implements EVR.

Definition at line 639 of file drvem.cpp.

{
    SCOPED_LOCK(evrLock);
    if(v)
        BITSET(NAT,32,base, Control, Control_GTXio);
    else
        BITCLR(NAT,32,base, Control, Control_GTXio);
}

setSourceTS()

void EVRMRM::setSourceTS ( TSSource  )

virtual

Select source which increments TS counter.

Implements EVR.

Definition at line 665 of file drvem.cpp.

{
    double clk=clockTS(), eclk=clock();
    epicsUInt16 div=0;

    if(clk<=0 || !isfinite(clk))
        throw std::out_of_range("TS Clock rate invalid");

    switch(src){
    case TSSourceInternal:
    case TSSourceEvent:
    case TSSourceDBus4:
        break;
    default:
        throw std::out_of_range("TS source invalid");
    }

    SCOPED_LOCK(evrLock);

    switch(src){
    case TSSourceInternal:
        // div!=0 selects src internal
        div=roundToUInt(eclk/clk, 0xffff);
        break;
    case TSSourceEvent:
        BITCLR(NAT,32, base, Control, Control_tsdbus);
        // div=0
        break;
    case TSSourceDBus4:
        BITSET(NAT,32, base, Control, Control_tsdbus);
        // div=0
        break;
    }
    WRITE32(base, CounterPS, div);
    shadowCounterPS=div;
    shadowSourceTS=src;
}

setTimeSrc()

void EVRMRM::setTimeSrc

(

epicsUInt32

mode

)

Definition at line 1064 of file drvem.cpp.

{
    switch((timeSrcMode_t)raw) {
    case Disable:
    case External:
    case SysClk:
        break;
    default:
        throw std::runtime_error("Unsupported time source mode");
    }
    timeSrcMode_t mode((timeSrcMode_t)raw);

    bool changed;
    {
        SCOPED_LOCK(evrLock);

        changed = timeSrcMode!=mode;

        timeSrcMode = mode;
    }

    if(changed)
        softSecondsSrc(mode==SysClk);
}

SourceTS()

virtual TSSource EVRMRM::SourceTS ( ) const

inlinevirtual

Implements EVR.

Definition at line 174 of file drvem.h.

        {SCOPED_LOCK(evrLock);return shadowSourceTS;}

specialMapped()

bool EVRMRM::specialMapped ( epicsUInt32  code, epicsUInt32  func  ) const

virtual

Hook to handle general event mapping table manipulation. Allows 'special' events only (ie heartbeat, log, led, etc) Normal mappings (pulsers, outputs) must be made through the appropriate class (Pulser, Output).

Note: this is one place where Device Support will have some depth.

Implements EVR.

Definition at line 505 of file drvem.cpp.

{
    if(code>255)
        throw std::out_of_range("Event code is out of range (0-255)");
    if(func>127 || func<96 ||
        (func<=121 && func>=102) )
    {
        throw std::out_of_range("Special function code is out of range. Valid ranges: 96-101 and 122-127");
    }

    if(code==0)
        return false;

    SCOPED_LOCK(evrLock);

    return _ismap(code,func-96);
}

specialSetMap()

void EVRMRM::specialSetMap ( epicsUInt32  code, epicsUInt32  func, bool  v  )

virtual

Implements EVR.

Definition at line 524 of file drvem.cpp.

{
    if(code>255)
        throw std::out_of_range("Event code is out of range");
    /* The special function codes are the range 96 to 127, excluding 102 to 121
     */
    if(func>127 || func<96 ||
        (func<=121 && func>=102) )
    {
        errlogPrintf("EVR %s code %02x func %3d out of range. Code range is 0-255, where function rangs are 96-101 and 122-127\n",
            name().c_str(), code, func);
        throw std::out_of_range("Special function code is out of range.  Valid ranges: 96-101 and 122-127");
    }

    if(code==0)
      return;

    /* The way the latch timestamp is implimented in hardware (no status bit)
     * makes it impossible to use the latch mapping and the latch control register
     * bits at the same time.  We use the control register bits.
     * However, there is not much loss of functionality since all events
     * can be timestamped in the FIFO.
     */
    if(func==126)
        throw std::out_of_range("Use of latch timestamp special function code is not allowed");

    epicsUInt32 bit  =func%32;
    epicsUInt32 mask=1<<bit;

    SCOPED_LOCK(evrLock);

    epicsUInt32 val=READ32(base, MappingRam(0, code, Internal));

    if (v == _ismap(code,func-96)) {
        // mapping already set defined

    } else if(v) {
        _map(code,func-96);
        WRITE32(base, MappingRam(0, code, Internal), val|mask);
    } else {
        _unmap(code,func-96);
        WRITE32(base, MappingRam(0, code, Internal), val&~mask);
    }
}

timeSrc()

epicsUInt32 EVRMRM::timeSrc

(

)

const

Definition at line 1058 of file drvem.cpp.

{
    SCOPED_LOCK(evrLock);
    return timeSrcMode;
}

TimeStampValid()

bool EVRMRM::TimeStampValid ( ) const

virtual

Implements EVR.

Definition at line 775 of file drvem.cpp.

{
    SCOPED_LOCK(evrLock);
    return timestampValid>=TSValidThreshold;
}

TimeStampValidEvent()

virtual IOSCANPVT EVRMRM::TimeStampValidEvent ( ) const

inlinevirtual

Implements EVR.

Definition at line 181 of file drvem.h.

{return timestampValidChange;}

topId()

epicsUInt32 EVRMRM::topId

(

)

const

Definition at line 1029 of file drvem.cpp.

{
    return READ32(base, TOPID);
}

tsDiv()

virtual epicsUInt32 EVRMRM::tsDiv ( ) const

inlinevirtual

When using internal TS source gives the divider from event clock period to TS period.

Implements EVR.

Definition at line 170 of file drvem.h.

        {SCOPED_LOCK(evrLock);return shadowCounterPS;}

unlock()

virtual void EVRMRM::unlock ( ) const

inlinevirtual

Implements mrf::Object.

Definition at line 130 of file drvem.h.

{evrLock.unlock();};

uSecDiv()

epicsUInt32 EVRMRM::uSecDiv ( ) const

virtual

Approximate divider from event clock period to 1us.

Implements EVR.

Definition at line 626 of file drvem.cpp.

{
    return READ32(base, USecDiv);
}

version()

MRFVersion EVRMRM::version ( ) const

virtual

Firmware Version.

Implements EVR.

Definition at line 415 of file drvem.cpp.

{
    return MRFVersion(READ32(base, FWVersion));
}

Friends And Related Function Documentation

EVRMRMTSBuffer

friend struct EVRMRMTSBuffer

friend

Definition at line 336 of file drvem.h.

Member Data Documentation

base

volatile unsigned char* const EVRMRM::base

Definition at line 237 of file drvem.h.

baselen

epicsUInt32 EVRMRM::baselen

Definition at line 238 of file drvem.h.

bufrx

mrmBufRx EVRMRM::bufrx

Definition at line 240 of file drvem.h.

buftx

mrmDataBufTx EVRMRM::buftx

Definition at line 239 of file drvem.h.

conf

const Config* const EVRMRM::conf

Definition at line 236 of file drvem.h.

evrLock

epicsMutex EVRMRM::evrLock

mutable

Guards access to instance All callers must take this lock before any operations on this object.

Definition at line 104 of file drvem.h.

sfp

mrf::auto_ptr<SFP> EVRMRM::sfp

Definition at line 241 of file drvem.h.

---

The documentation for this class was generated from the following files:

• drvem.h
• drvem.cpp