epicsUInt32 checkVersion(volatile epicsUInt8 *base, unsigned int required) {
#ifndef __linux__
    epicsUInt32 junk;
    if(devReadProbe(sizeof(junk), (volatile void*)(base+U32_FWVersion), (void*)&junk)) {
        throw std::runtime_error("Failed to read from MRM registers (but could read CSR registers)\n");
    }
#endif
    epicsUInt32 type, ver;
    epicsUInt32 v = READ32(base, FWVersion);

    epicsPrintf("FPGA version: %08x\n", v);

    type = v >> FWVersion_type_shift;

    if(type != 0x2){
        errlogPrintf("Found type %x which does not correspond to EVG type 0x2.\n", type);
        return 0;
    }

    ver = v & FWVersion_ver_mask;

    if(ver < required) {
        errlogPrintf("Firmware version >= %x is required got %x\n", required,ver);
        return 0;
    }

    return ver;
}

/* Check the interface version of the kernel module to ensure compatibility */
static
int checkUIOVersion(int expect)
{
    FILE *fd;
    int version = -1;

    fd = fopen(ifaceversion, "r");
    if(!fd) {
        errlogPrintf("Can't open %s in order to read kernel module interface version. Is kernel module loaded?\n", ifaceversion);
        return 1;
    }
    if(fscanf(fd, "%d", &version) != 1) {
        errlogPrintf("Failed to read %s in order to get the kernel module interface version. Is kernel module loaded?\n", ifaceversion);
        fclose(fd);
        return 1;
    }
    fclose(fd);

    if(version<expect) {
        errlogPrintf("Error: Expect MRF kernel module version %d, found %d.\n", version, expect);
        return 1;
    }
    if(version > expect){
        epicsPrintf("Info: Expect MRF kernel module version %d, found %d.\n", version, expect);
    }
    return 0;
}

epicsShareFunc
int
devLibPCIUse(const char* use)
{
    ELLNODE *cur;
    devLibPCI *drv;

    if (!use)
        use="native";

    epicsThreadOnce(&devPCIReg_once, &regInit, NULL);

    epicsMutexMustLock(pciDriversLock);

    if (pdevLibPCI) {
        epicsMutexUnlock(pciDriversLock);
        errlogPrintf("PCI bus driver already selected. Can't change selection\n");
        return 1;
    }

    for(cur=ellFirst(&pciDrivers); cur; cur=ellNext(cur)) {
        drv=CONTAINER(cur, devLibPCI, node);
        if (strcmp(drv->name, use)==0) {
            pdevLibPCI = drv;
            epicsMutexUnlock(pciDriversLock);
            return 0;
        }
    }
    epicsMutexUnlock(pciDriversLock);
    errlogPrintf("PCI bus driver '%s' not found\n",use);
    return 1;
}

/*BEGIN STANDARD RECORD SUPPORT ROUTINES*/
LOCAL long init_record(ab1771IXRecord *precord,int pass)
{
    abStatus		status;
    recordPvt		*precordPvt;

    if(pass!=0) return(0);
    precord->iai1 = &mydevIai1;
    precord->dpvt = precordPvt = dbCalloc(1,sizeof(recordPvt));
    callbackSetCallback(myCallback,&precordPvt->callback);
    callbackSetUser(precord,&precordPvt->callback);
    precord->inpm = (short *)dbCalloc(NUM_WORDS_IN,sizeof(short));
    precord->outm = (short *)dbCalloc(NUM_WORDS_OUT,sizeof(short));
    status = (*pabDrv->registerCard)(precord->link,precord->rack,
	precord->slot,typeBt,"ab1771IX",drvCallback,&precordPvt->drvPvt);
    if(status!=abNewCard) {
	if(status==abSuccess)
	    errlogPrintf("record %s slot already used\n",precord->name);
	else
	    errlogPrintf("record %s init error %s\n",precord->name,
		abStatusMessage[status]);
	issueError(precord,errFatal," while registering card");
	precord->pact = TRUE; /*leave record active*/
	return(0);
    }
    (*pabDrv->setUserPvt)(precordPvt->drvPvt,(void *)precord);
    msgInit(precord);
    precord->udf = FALSE;
    return(0);
}

void
devPCIShowDevice(int lvl, const epicsPCIDevice *dev)
{
    int i;

    errlogPrintf("PCI %04x:%02x:%02x.%x IRQ %u\n"
           "  vendor:device %04x:%04x rev %02x\n",
           dev->domain, dev->bus, dev->device, dev->function, dev->irq,
           dev->id.vendor, dev->id.device, dev->id.revision);
    if(lvl<1)
        return;
    errlogPrintf("  subved:subdev %04x:%04x\n"
           "  class %06x %s\n",
           dev->id.sub_vendor, dev->id.sub_device,
           dev->id.pci_class,
           devPCIDeviceClassToString(dev->id.pci_class));
    if (dev->driver) errlogPrintf("  driver %s\n",
           dev->driver);
    if(lvl<2)
        return;
    for(i=0; i<PCIBARCOUNT; i++)
    {
        epicsUInt32 len;

        if ((*pdevLibPCI->pDevPCIBarLen)(dev, i, &len) == 0 && len > 0)
        {
            char* u = "";
            if (len >= 1024) { len >>= 10; u = "k"; }
            if (len >= 1024) { len >>= 10; u = "M"; }

static void deleteFromList(struct dbCommon *precord, scan_list *psl)
{
    scan_element *pse;

    epicsMutexMustLock(psl->lock);
    pse = precord->spvt;
    if (pse == NULL) {
        epicsMutexUnlock(psl->lock);
        errlogPrintf("dbScan: Tried to delete record from wrong scan list!\n"
            "\t%s.SPVT = NULL, but psl = %p\n",
            precord->name, (void *)psl);
        return;
    }
    if (pse->pscan_list != psl) {
        epicsMutexUnlock(psl->lock);
        errlogPrintf("dbScan: Tried to delete record from wrong scan list!\n"
            "\t%s.SPVT->pscan_list = %p but psl = %p\n",
            precord->name, (void *)pse, (void *)psl);
        return;
    }
    pse->pscan_list = NULL;
    ellDelete(&psl->list, (void *)pse);
    psl->modified = TRUE;
    epicsMutexUnlock(psl->lock);
}

static void initPeriodic(void)
{
    dbMenu *pmenu = dbFindMenu(pdbbase, "menuScan");
    double quantum = epicsThreadSleepQuantum();
    int i;

    if (!pmenu) {
        errlogPrintf("initPeriodic: menuScan not present\n");
        return;
    }
    nPeriodic = pmenu->nChoice - SCAN_1ST_PERIODIC;
    papPeriodic = dbCalloc(nPeriodic, sizeof(periodic_scan_list*));
    periodicTaskId = dbCalloc(nPeriodic, sizeof(void *));
    for (i = 0; i < nPeriodic; i++) {
        periodic_scan_list *ppsl = dbCalloc(1, sizeof(periodic_scan_list));
        const char *choice = pmenu->papChoiceValue[i + SCAN_1ST_PERIODIC];
        double number;
        char *unit;
        int status = epicsParseDouble(choice, &number, &unit);

        ppsl->scan_list.lock = epicsMutexMustCreate();
        ellInit(&ppsl->scan_list.list);
        ppsl->name = choice;
        if (status || number == 0) {
            errlogPrintf("initPeriodic: Bad menuScan choice '%s'\n", choice);
            ppsl->period = i;
        }
        else if (!*unit ||
                 !epicsStrCaseCmp(unit, "second") ||
                 !epicsStrCaseCmp(unit, "seconds")) {
            ppsl->period = number;
        }
        else if (!epicsStrCaseCmp(unit, "minute") ||
                 !epicsStrCaseCmp(unit, "minutes")) {
            ppsl->period = number * 60;
        }
        else if (!epicsStrCaseCmp(unit, "hour") ||
                 !epicsStrCaseCmp(unit, "hours")) {
            ppsl->period = number * 60 * 60;
        }
        else if (!epicsStrCaseCmp(unit, "Hz") ||
                 !epicsStrCaseCmp(unit, "Hertz")) {
            ppsl->period = 1 / number;
        }
        else {
            errlogPrintf("initPeriodic: Bad menuScan choice '%s'\n", choice);
            ppsl->period = i;
        }
        number = ppsl->period / quantum;
        if ((ppsl->period < 2 * quantum) ||
            (number / floor(number) > 1.1)) {
            errlogPrintf("initPeriodic: Scan rate '%s' is not achievable.\n",
                choice);
        }
        ppsl->scanCtl = ctlPause;
        ppsl->loopEvent = epicsEventMustCreate(epicsEventEmpty);

        papPeriodic[i] = ppsl;
    }
}

casBufferFactory::casBufferFactory () :
    smallBufFreeList ( 0 ), largeBufFreeList ( 0 ), largeBufferSizePriv ( 0u )
{
    long maxBytesAsALong;
    long status =  envGetLongConfigParam ( & EPICS_CA_MAX_ARRAY_BYTES, & maxBytesAsALong );
    if ( status || maxBytesAsALong < 0 ) {
        errlogPrintf ( "cas: EPICS_CA_MAX_ARRAY_BYTES was not a positive integer\n" );
        this->largeBufferSizePriv = MAX_TCP;
    }
    else {
        /* allow room for the protocol header so that they get the array size they requested */
        static const unsigned headerSize = sizeof ( caHdr ) + 2 * sizeof ( ca_uint32_t );
        ca_uint32_t maxBytes = ( unsigned ) maxBytesAsALong;
        if ( maxBytes < 0xffffffff - headerSize ) {
            maxBytes += headerSize;
        }
        else {
            maxBytes = 0xffffffff;
        }
        if ( maxBytes < MAX_TCP ) {
            errlogPrintf ( "cas: EPICS_CA_MAX_ARRAY_BYTES was rounded up to %u\n", MAX_TCP );
            this->largeBufferSizePriv = MAX_TCP;
        }
        else {
            this->largeBufferSizePriv = maxBytes;
        }
    }

    freeListInitPvt ( & this->smallBufFreeList, MAX_MSG_SIZE, 8 );
    freeListInitPvt ( & this->largeBufFreeList, this->largeBufferSizePriv, 1 );
}

/*
 * envGetInetPortConfigParam ()
 */
epicsShareFunc unsigned short epicsShareAPI envGetInetPortConfigParam 
                (const ENV_PARAM *pEnv, unsigned short defaultPort)
{
    long        longStatus;
    long        epicsParam;

    longStatus = envGetLongConfigParam (pEnv, &epicsParam);
    if (longStatus!=0) {
        epicsParam = (long) defaultPort;
        errlogPrintf ("EPICS Environment \"%s\" integer fetch failed\n", pEnv->name);
        errlogPrintf ("setting \"%s\" = %ld\n", pEnv->name, epicsParam);
    }

    if (epicsParam<=IPPORT_USERRESERVED || epicsParam>USHRT_MAX) {
        errlogPrintf ("EPICS Environment \"%s\" out of range\n", pEnv->name);
        /*
         * Quit if the port is wrong due coding error
         */
        assert (epicsParam != (long) defaultPort);
        epicsParam = (long) defaultPort;
        errlogPrintf ("Setting \"%s\" = %ld\n", pEnv->name, epicsParam);
    }

    /*
     * ok to clip to unsigned short here because we checked the range
     */
    return (unsigned short) epicsParam;
}

/*returns: (-1,0)=>(failure,success)*/
static long
init_wf_loadedSeq(waveformRecord* pwf) {
    long ret = 0;

    if(pwf->inp.type != VME_IO) {
        errlogPrintf("ERROR: Hardware link not VME_IO : %s\n", pwf->name);
        return S_db_badField;
    }
    
    try {
        std::string parm(pwf->inp.value.vmeio.parm);
        evgMrm* evg = dynamic_cast<evgMrm*>(mrf::Object::getObject(parm));
        if(!evg)
            throw std::runtime_error("Failed to lookup EVG");

        evgSeqRamMgr* seqRamMgr = evg->getSeqRamMgr();
        if(!seqRamMgr)
            throw std::runtime_error("Failed to lookup EVG Seq Ram Manager");

        pwf->dpvt = seqRamMgr;
        ret = 0;
    } catch(std::runtime_error& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
        ret = S_dev_noDevice;
    } catch(std::exception& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
        ret = S_db_noMemory;
    }

    return ret;
}

static void addAction(caLink *pca, short link_action)
{
    int callAdd;

    epicsMutexMustLock(workListLock);
    callAdd = (pca->link_action == 0);
    if (pca->link_action & CA_CLEAR_CHANNEL) {
        errlogPrintf("dbCa::addAction %d with CA_CLEAR_CHANNEL set\n",
            link_action);
        printLinks(pca);
        link_action = 0;
    }
    if (link_action & CA_CLEAR_CHANNEL) {
        if (++removesOutstanding >= removesOutstandingWarning) {
            errlogPrintf("dbCa::addAction pausing, %d channels to clear\n",
                removesOutstanding);
            printLinks(pca);
        }
        while (removesOutstanding >= removesOutstandingWarning) {
            epicsMutexUnlock(workListLock);
            epicsThreadSleep(1.0);
            epicsMutexMustLock(workListLock);
        }
    }
    pca->link_action |= link_action;
    if (callAdd)
        ellAdd(&workList, &pca->node);
    epicsMutexUnlock(workListLock);
    if (callAdd)
        epicsEventSignal(workListEvent);
}

// Extract slot details from the xml
void converter::loadSlotDetails(TiXmlHandle &hRoot)
{
	//printf("Slot details\n");
	for( TiXmlElement* pElem=hRoot.FirstChild("slot").Element(); pElem; pElem=pElem->NextSiblingElement())
	{
		std::string slotName = pElem->Attribute("name");
		
		std::map<std::string, slotData>::iterator iter = m_slots.find(slotName);
		if ( iter==m_slots.end() ) {
			errlogPrintf("sampleChanger: Unknown slot '%s' in slot details\n", slotName.c_str());
		}
		else {
			iter->second.rackType = pElem->Attribute("rack_type");
			
			if ( pElem->QueryDoubleAttribute("xoff", &(iter->second.xoff))!=TIXML_SUCCESS ) {
				errlogPrintf("sampleChanger: unable to read slot xoff attribute \"%s\"\n", slotName.c_str());
			}
			if ( m_dims>1 && pElem->QueryDoubleAttribute("yoff", &(iter->second.yoff))!=TIXML_SUCCESS ) {
				errlogPrintf("sampleChanger: unable to read slot yoff attribute \"%s\"\n", slotName.c_str());
			}
		
			//printf("Det slot %s %s %f\n", iter->second.name, iter->second.rackType, iter->second.xoff);
		}
	}
}

static long read_bi(biRecord *pbi)
{
  F3RP61_SEQ_DPVT *dpvt = (F3RP61_SEQ_DPVT *) pbi->dpvt;
  MCMD_STRUCT *pmcmdStruct = &dpvt->mcmdStruct;
  MCMD_RESPONSE *pmcmdResponse;

  if (pbi->pact) {
    pmcmdResponse = &pmcmdStruct->mcmdResponse;

    if (dpvt->ret < 0) {
      errlogPrintf("devBiF3RP61Seq: read_bi failed for %s\n", pbi->name);
      return (-1);
    }

    if (pmcmdResponse->errorCode) {
      errlogPrintf("devBiF3RP61Seq: errorCode %d returned for %s\n",
                   pmcmdResponse->errorCode, pbi->name);
      return (-1);
    }

    pbi->rval = (unsigned long) pmcmdResponse->dataBuff.wData[0];

    pbi->udf=FALSE;
  }
  else {
    if (f3rp61Seq_queueRequest(dpvt) < 0) {
      errlogPrintf("devBiF3RP61Seq: f3rp61Seq_queueRequest failed for %s\n", pbi->name);
      return (-1);
    }

    pbi->pact = 1;
  }

  return(0);
}

static long
init_record_mbbo( mbboRecord *pior)
{
	struct instio *pinstio;
	PARPROP *pp = NULL;
	void *pval;

	if( pior->out.type != INST_IO)
	{
		errlogPrintf( "%s: mbbo INP field type should be INST_IO\n", pior->name);
		return( S_db_badField);
	}

	/* parse device dependent option string and set data pointer */
	pinstio = &(pior->out.value.instio);
	if( ( pp = CAENx527ParseDevArgs( pinstio->string)) == NULL)
	{
		errlogPrintf( "%s: Invalid device parameters: \"%s\"\n", pior->name, pinstio->string);
		return(2);
	}

	pior->dpvt = pp;
	strcpy( pp->PVname, pior->name);

	/* Initialize the value from value in the crate */
	pval = CAENx527GetChParVal( pp);
	if( pval == NULL)
		return( 3);
	pior->val = CAENx527mbbi2state( pp);
	pior->rval = CAENx527mbbi2state( pp);

	pp->hvchan->epicsenabled = 1;

	return( 0);
}

static long
init_record_mbbi( mbbiRecord *pior)
{
	struct instio *pinstio;
	PARPROP *pp = NULL;

	if( pior->inp.type != INST_IO)
	{
		errlogPrintf( "%s: mbbi INP field type should be INST_IO\n", pior->name);
		return( S_db_badField);
	}

	/* parse device dependent option string and set data pointer */
	pinstio = &(pior->inp.value.instio);
	if( ( pp = CAENx527ParseDevArgs( pinstio->string)) == NULL)
	{
		errlogPrintf( "%s: Invalid device parameters: \"%s\"\n", pior->name, pinstio->string);
		return(2);
	}

	if( pp->evntno > 0)
          /*            pior->evnt = pp->evntno;*/
          sprintf(pior->evnt,"%d",pp->evntno);


	pior->dpvt = pp;
	strcpy( pp->PVname, pior->name);
	pp->hvchan->epicsenabled = 1;

	return( 0);
}

/*
 * Create and start a new thread
 */
epicsThreadId
epicsThreadCreate (const char *name,
    unsigned int priority, unsigned int stackSize,
    EPICSTHREADFUNC funptr,void *parm)
{
    rtems_id tid;
    rtems_status_code sc;
    char c[4];

    if (!initialized) epicsThreadInit();
    if (stackSize < RTEMS_MINIMUM_STACK_SIZE) {
        errlogPrintf ("Warning: epicsThreadCreate %s illegal stackSize %d\n",name,stackSize);
        stackSize = RTEMS_MINIMUM_STACK_SIZE;
    }
    strncpy (c, name, sizeof c);
    sc = rtems_task_create (rtems_build_name (c[0], c[1], c[2], c[3]),
         epicsThreadGetOssPriorityValue (priority),
         stackSize,
         RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
         RTEMS_FLOATING_POINT|RTEMS_LOCAL,
         &tid);
    if (sc !=  RTEMS_SUCCESSFUL) {
        errlogPrintf ("epicsThreadCreate create failure for %s: %s\n",name, rtems_status_text (sc));
        return 0;
    }
    setThreadInfo (tid, name, funptr,parm);
    return (epicsThreadId)tid;
}

void PvaPyLogger::log(const char* messageLevel, const char* message, va_list messageArgs) const
{
    char timeStamp[MaxTimeStampLength];
    prepareTimeStamp(timeStamp, MaxTimeStampLength, TimeStampFormat);
    if (useEpicsLog) {
        errlogPrintf("%s %s %s:  ", timeStamp, messageLevel, name);
        errlogVprintf(message, messageArgs);
        errlogPrintf("\n");
    }
    else {
        // On vxWorks fflush() fails frequently, so only use
        // fprintf() if logging goes into a file.
        if (usePrintf) {
            printf("%s %s %s:  ", timeStamp, messageLevel, name);
            vprintf(message, messageArgs);
            printf("\n");
        }
        else {
            fprintf(logFile, "%s %s %s:  ", timeStamp, messageLevel, name);
            vfprintf(logFile, message, messageArgs);
            fprintf(logFile, "\n");
            fflush(logFile);
        }
    }
}

/*returns: (-1,0)=>(failure,success)*/
static long 
write_bo_pauseSeq(boRecord* pbo) {
    long ret = 0;
    evgSoftSeq* seq = 0;

    try {
        if(!pbo->val)
            return 0;

        seq = (evgSoftSeq*)pbo->dpvt;
        if(!seq)
            return S_dev_noDevice;

        SCOPED_LOCK2(seq->m_lock, guard);
        seq->pause();
        seq->setErr("");
    } catch(std::runtime_error& e) {
        seq->setErr(e.what());
        errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
        ret = S_dev_noDevice;
    } catch(std::exception& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
        ret = S_db_noMemory;
    }

    return ret;
}

/*returns: (-1,0)=>(failure,success)*/
static long 
write_bo_softTrig(boRecord* pbo) {
    long ret = 0;

    try {
        if(!pbo->val)
            return 0;

        evgSoftSeq* seq = (evgSoftSeq*)pbo->dpvt;
        if(!seq)
            throw std::runtime_error("Device pvt field not initialized");

        SCOPED_LOCK2(seq->m_lock, guard);

        evgSeqRam* seqRam = seq->getSeqRam();
        if(!seqRam)
            throw std::runtime_error("Failed to lookup EVG Seq RAM");

        seqRam->softTrig();
    } catch(std::runtime_error& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
        ret = S_dev_noDevice;
    } catch(std::exception& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
        ret = S_db_noMemory;
    }

    return ret;
}

/*returns: (-1,0)=>(failure,success)*/
static long
read_wf_eventMask(waveformRecord* pwf) {
    long ret = 0;

    try {
        evgSoftSeq* seq = (evgSoftSeq*)pwf->dpvt;
        if(!seq)
            throw std::runtime_error("Device pvt field not initialized");

        SCOPED_LOCK2(seq->m_lock, guard);
        std::vector<epicsUInt8> eventMask = seq->getEventMaskCt();
        epicsUInt8* bptr = (epicsUInt8*)pwf->bptr;
        for(unsigned int i = 0; i < eventMask.size(); i++)
            bptr[i] = eventMask[i];

        pwf->nord = (epicsUInt32)eventMask.size();

    } catch(std::runtime_error& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
        ret = S_dev_noDevice;
    } catch(std::exception& e) {
        errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
        ret = S_db_noMemory;
    }

    return ret;
}