Esempio n. 1
0
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;
}
Esempio n. 2
0
/* 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;
}
Esempio n. 3
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;
}
Esempio n. 4
0
/*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);
}
Esempio n. 5
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"; }
Esempio n. 6
0
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);
}
Esempio n. 7
0
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;
    }
}
Esempio n. 8
0
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 );
}
Esempio n. 9
0
/*
 * 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;
}
Esempio n. 11
0
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);
		}
	}
}
Esempio n. 13
0
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);
}
Esempio n. 14
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);
}
Esempio n. 15
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);
}
// Extract the definitions of the rack types from the xml
void converter::loadRackDefs(TiXmlHandle &hRoot)
{
	m_racks.clear();
	//printf("Loading rack defs\n");
	
	for( TiXmlElement* pElem=hRoot.FirstChild("racks").FirstChild("rack").Element(); pElem; pElem=pElem->NextSiblingElement())
	{
		//printf("Loading rack defs - racks\n");
		std::map<std::string, samplePosn> posns;
		std::string rackName = pElem->Attribute("name");
		for ( TiXmlElement *pRack = pElem->FirstChildElement("position") ; pRack ; pRack=pRack->NextSiblingElement() ) {
			samplePosn posn;
			const char *attrib = pRack->Attribute("name");
			if ( attrib!=NULL ) {
				posn.name = attrib;
			}
			else {
				errlogPrintf("sampleChanger: rack has no name attribute \"%s\"\n", rackName.c_str());
			}
			//printf("Loading rack defs - %s\n", posn.name.c_str());
			if ( pRack->QueryDoubleAttribute("x", &posn.x)!=TIXML_SUCCESS ) {
				errlogPrintf("sampleChanger: unable to read x attribute \"%s\" \"%s\"\n", rackName.c_str(), posn.name.c_str());
			}
			if ( m_dims>1 && pRack->QueryDoubleAttribute("y", &posn.y)!=TIXML_SUCCESS ) {
				errlogPrintf("sampleChanger: unable to read y attribute \"%s\" \"%s\"\n", rackName.c_str(), posn.name.c_str());
			}
			posns[posn.name] = posn;
		}
		m_racks[rackName] = posns;
	}
}
Esempio n. 17
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;
}
Esempio n. 18
0
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;
}
static long 
init_record(dbCommon *pRec, DBLINK* lnk) {
    long ret = 0;

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

        evgSoftSeqMgr* seqMgr = evg->getSoftSeqMgr();
        if(!seqMgr)
            throw std::runtime_error("Failed to lookup EVG Seq Manager");

        evgSoftSeq* seq = seqMgr->getSoftSeq(lnk->value.vmeio.signal);
        if(!seq)
            throw std::runtime_error("Failed to lookup EVG Sequence");

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

    return ret;
}
Esempio n. 23
0
void epicsAssert (const char *pFile, const unsigned line,
    const char *pExp, const char *pAuthorName)
{
    epicsTimeStamp current;

    errlogPrintf("\n\n\n"
        "A call to 'assert(%s)'\n"
        "    by thread '%s' failed in %s line %u.\n",
        pExp, epicsThreadGetNameSelf(), pFile, line);
    errlogPrintf("EPICS Release %s.\n", epicsReleaseVersion);

    if (epicsTimeGetCurrent(&current) == 0) {
        char date[64];

        epicsTimeToStrftime(date, sizeof(date),
            "%Y-%m-%d %H:%M:%S.%f %Z", &current);
        errlogPrintf("Local time is %s\n", date);
    }

    if (!pAuthorName) {
        pAuthorName = "the author";
    }
    errlogPrintf("Please E-mail this message to %s or to [email protected]\n",
        pAuthorName);

    errlogPrintf("Calling epicsThreadSuspendSelf()\n");
    epicsThreadSuspendSelf ();
}
/*returns: (-1,0)=>(failure,success)*/
static long 
read_wf_loadedSeq(waveformRecord* pwf) {
    long ret = 0;

    try {
        evgSeqRamMgr* seqRamMgr = (evgSeqRamMgr*)pwf->dpvt;
        if(!seqRamMgr) {
            errlogPrintf("Device pvt field not initialized\n");
            return -1;
        }

        epicsInt32* pBuf = (epicsInt32*)pwf->bptr;
        evgSoftSeq* seq;

        for(int i = 0; i < evgNumSeqRam; i++) {
            seq = seqRamMgr->getSeqRam(i)->getSoftSeq();
            if(seq)
                pBuf[i] = seq->getId();
            else
                pBuf[i] = -1;
        }
        pwf->nord = evgNumSeqRam;
        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;
}
Esempio n. 25
0
static int iocBuild_1(void)
{
    if (iocState != iocVirgin && iocState != iocStopped) {
        errlogPrintf("iocBuild: IOC can only be initialized from uninitialized or stopped state\n");
        return -1;
    }
    errlogInit(0);
    initHookAnnounce(initHookAtIocBuild);

    if (!epicsThreadIsOkToBlock()) {
        epicsThreadSetOkToBlock(1);
    }

    errlogPrintf("Starting iocInit\n");
    if (checkDatabase(pdbbase)) {
        errlogPrintf("iocBuild: Aborting, bad database definition (DBD)!\n");
        return -1;
    }
    epicsSignalInstallSigHupIgnore();
    initHookAnnounce(initHookAtBeginning);

    coreRelease();
    iocState = iocBuilding;

    taskwdInit();
    callbackInit();
    initHookAnnounce(initHookAfterCallbackInit);

    return 0;
}
Esempio n. 26
0
int iocRun(void)
{
    if (iocState != iocPaused && iocState != iocBuilt) {
        errlogPrintf("iocRun: IOC not paused\n");
        return -1;
    }
    initHookAnnounce(initHookAtIocRun);

   /* Enable scan tasks and some driver support functions.  */
    scanRun();
    dbCaRun();
    initHookAnnounce(initHookAfterDatabaseRunning);
    if (iocState == iocBuilt)
        initHookAnnounce(initHookAfterInterruptAccept);

    rsrv_run();
    initHookAnnounce(initHookAfterCaServerRunning);
    if (iocState == iocBuilt)
        initHookAnnounce(initHookAtEnd);

    errlogPrintf("iocRun: %s\n", iocState == iocBuilt ?
        "All initialization complete" :
        "IOC restarted");
    iocState = iocRunning;
    initHookAnnounce(initHookAfterIocRunning);
    return 0;
}
Esempio n. 27
0
void omsMAXvEncFunc::initialize()
{
    const char* functionName = "initialize";

    Debug(5, "omsMAXvEncFunc::initialize: start initialize\n" );

    int encIndex = numAxes;
    if (encIndex > MAXENCFUNC) encIndex = MAXENCFUNC;

    /* auxiliary encoders */
    for (int i=0; i < encIndex; ++i){
        if (createParam(i, motorEncoderFunctionString, asynParamInt32, &encFuncIndex[i]) != asynSuccess)
                errlogPrintf("%s:%s:%s: unable to create param motorEncoderFunctionString, index %d\n",
                              driverName, functionName, portName, i);
        if (createParam(i, motorEncoderRawPosString, asynParamFloat64, &encRawPosIndex[i]) != asynSuccess)
                errlogPrintf("%s:%s:%s: unable to create param motorEncoderRawPosString, index %d\n",
                              driverName, functionName, portName, i);
    }
    createParam(0, motorAuxEncoderPositionString, asynParamFloat64, &encPosIndex[0]);
    createParam(1, motorAuxEncoderPositionString, asynParamFloat64, &encPosIndex[1]);
    Debug(3, "omsMAXvEncFunc::initialize: auxiliary encoder 0 position index %d\n", encPosIndex[0] );
    Debug(3, "omsMAXvEncFunc::initialize: auxiliary encoder 1 position index %d\n", encPosIndex[1] );
    for (int i=0; i < encIndex; ++i) Debug(3, "omsMAXvEncFunc::initialize: encFuncIndex %d => %d\n", i, encFuncIndex[i] );
    lock();
    for (int i=0; i < encIndex; ++i){
        setIntegerParam(i, encFuncIndex[i], 0);
        setDoubleParam(i, encRawPosIndex[i], 0.0);
    }
    setDoubleParam(0, encPosIndex[0], 0.0);
    setDoubleParam(1, encPosIndex[1], 0.0);
    for (int i=0; i < encIndex; ++i) {
        callParamCallbacks(i, i);
    }
    unlock();
}
Esempio n. 28
0
void omsMAXv::motorIsrSetup(volatile unsigned int vector, volatile epicsUInt8 level)
{
    const char* functionName = "motorIsrSetup";
    STATUS1 status1_irq;
    long status;

    Debug(64, "omsMAXv::isrSetup: start\n");

    status = pdevLibVirtualOS->pDevConnectInterruptVME( vector, &omsMAXv::InterruptHandler, this);

    if (status) {
        errlogPrintf("%s:%s:%s: Can't connect to interrupt vector %d\n",
                driverName, functionName, portName, vector);
        return;
    }

    Debug(64, "omsMAXv::isrSetup: set level\n");
    status = devEnableInterruptLevel(intVME, level);
    if (status) {
        errlogPrintf("%s:%s:%s: Can't enable interrupt level %d\n",
                driverName, functionName, portName, level);
        return;
    }

    /* Setup card for interrupt-on-done */
    status1_irq.All = 0;
    status1_irq.Bits.done = 0xFF;
    status1_irq.Bits.cmndError = 1;

    pmotor->status1_irq_enable.All = status1_irq.All;   /* Enable interrupts. */
    pmotor->status2_irq_enable = 0x0;

    Debug(64, "omsMAXv::isrSetup: done\n");
    return;
}
Esempio n. 29
0
/* Function init_record initializes record - parses INP/OUT field string,
 * allocates private data storage area and sets initial configure values */
static long init_record(boRecord *pbo)
{
  struct link *plink = &pbo->out;
  int size;
  char *buf;
  F3RP61SysCtl_BO_DPVT *dpvt;
  char device;
  char led;

  if (pbo->out.type != INST_IO) {
    recGblRecordError(S_db_badField,(void *)pbo,
		      "devBoF3RP61SysCtl (init_record) Illegal OUT field");
    pbo->pact = 1;
    return(S_db_badField);
  }

  size = strlen(plink->value.instio.string) + 1;
  buf = (char *) callocMustSucceed(size, sizeof(char), "calloc failed");
  strncpy(buf, plink->value.instio.string, size);
  buf[size - 1] = '\0';

  /* Parse 'device' and possibly 'led'*/
    if (sscanf(buf, "SYS,%c%c,", &device, &led) < 2) {
      if (sscanf(buf, "SYS,%c", &device) < 1) {
        errlogPrintf("devBoF3RP61SysCtl: can't get device for %s\n", pbo->name);
        pbo->pact = 1;
        return (-1);
      }
    }

  /* Check device validity*/
  if (!(device == 'L')) {
    errlogPrintf("devBoF3RP61SysCtl: illegal device for %s\n",
		 pbo->name);
    pbo->pact = 1;
    return (-1);
  }

  /* Check 'led' validity*/
    if(device == 'L') {
    	  if (!(led == 'R' || led == 'A' || led == 'E')) {
    		  errlogPrintf("devBoF3RP61SysCtl: illegal LED address for %s\n", pbo->name);
    		  pbo->pact = 1;
    		  return (-1);
    	  }
    }

  dpvt = (F3RP61SysCtl_BO_DPVT *) callocMustSucceed(1,
						      sizeof(F3RP61SysCtl_BO_DPVT),
						      "calloc failed");
  dpvt->device = device;
  if (device == 'L') {
      dpvt->led = led;
  }

  pbo->dpvt = dpvt;

  return(0);
}
Esempio n. 30
0
/* init routine */
int drvFzoomAsynConfigure(const char *portName, const char *octetPortName)
{
    FZOOM_ID pfzoomPvt;
    asynStatus status;

    assert(sizeof(unsigned short) == 2); /* 32 bits required */
    pfzoomPvt  = callocMustSucceed(1, sizeof(*pfzoomPvt), "drvFzoomAsynConfigure");
    pfzoomPvt->portName = epicsStrDup(portName);
    pfzoomPvt->octetPortName = epicsStrDup(octetPortName);
    pfzoomPvt->mutexId = epicsMutexMustCreate();

    /* initialise position, error threshold */
    pfzoomPvt->devInfo.zoomPosition = 1;
    pfzoomPvt->devInfo.posThreshold = 1010;
    pfzoomPvt->devInfo.timeoutDelay = 1025;

    /* connect to asyn octet port with asynOctetSyncIO */ 
    status = pasynOctetSyncIO->connect(octetPortName, 0, &pfzoomPvt->pasynUserOctet,
                                       0);
    if (status != asynSuccess) {
        errlogPrintf("%s::drvFzoomAsynConfigure port %s"
                     " can't connect to Octet port %s.\n",
                     driver, portName, octetPortName);
        return asynError;
    }

    /* Create asynUser for asynTrace */
    pfzoomPvt->pasynUserTrace = pasynManager->createAsynUser(0, 0);
    pfzoomPvt->pasynUserTrace->userPvt = pfzoomPvt;

    status = pasynManager->registerPort(pfzoomPvt->portName,
                                        ASYN_CANBLOCK,
                                        1, /* autoconnect */
                                        0, /* medium priority */
                                        0); /* default stack size */
    if (status != asynSuccess) {
        errlogPrintf("%s::drvFzoomAsynConfigure port %s"
                     "%s:: can't register port\n",
                     driver, pfzoomPvt->portName, pfzoomPvt->octetPortName);
        return(asynError);
    }

    /* Create asyn interfaces and register with asynManager */
    pfzoomPvt->asynStdInterfaces.common.pinterface          = (void *)&drvCommon;
    pfzoomPvt->asynStdInterfaces.drvUser.pinterface         = (void *)&drvUser;
    pfzoomPvt->asynStdInterfaces.int32.pinterface           = (void *)&drvInt32;

    status = pasynStandardInterfacesBase->initialize(pfzoomPvt->portName, &pfzoomPvt->asynStdInterfaces,
                                                     pfzoomPvt->pasynUserTrace, pfzoomPvt);
    if (status != asynSuccess) {
        errlogPrintf("%s::drvFzoomAsynConfigure port %s"
                     " can't register standard interfaces: %s\n",
                     driver, pfzoomPvt->portName, pfzoomPvt->pasynUserTrace->errorMessage);
        return(asynError);
    }
    return (asynSuccess);
}