SoftSequence::SoftSequence(SeqManager *o, const std::string& name)
:base_t(name)
,owner(o)
,hw(0)
,is_enabled(false)
,is_committed(false)
,is_insync(false)
,numStart(0u)
,numEnd(0u)
,timeScale(0u) // raw/ticks
{
scanIoInit(&changed);
scanIoInit(&onStart);
scanIoInit(&onEnd);
scanIoInit(&onErr);
}
int myBoard_findIndex( const char *devicePath ) {
int i;
fprintf( stderr, "try to find %s\n", devicePath );
for (i = 0; i < numBoard; ++i) {
if (!strcmp( myHardwareBoardList[i].devicePath, devicePath )) {
fprintf( stderr, "found %s at board[%d]\n", devicePath, i );
return i;
}
}
if (numBoard >= MAX_BOARD) {
fprintf( stderr, "exceed MAX_BOARD\n" );
return -1;
}
/* create new one: i==numBoard */
fprintf( stderr, "create new %s at board[%d]\n", devicePath, i );
strcpy( myHardwareBoardList[i].devicePath, devicePath );
mySoftwareBoardList[i].boardLock = epicsMutexMustCreate();
scanIoInit( &mySoftwareBoardList[i].ioScanPvt );
myHardwareBoardList[i].analogReference = AREF_DIFF;
mySoftwareBoardList[i].numberOfActiveAnalogInputs = MAX_CHANNEL_PER_BOARD / 2;
if (openBoard( i )) {
return -1;
}
++numBoard;
return i;
}
static drvM6802_taskConfig* make_taskConfig(char *taskName, uint16 vme_addr)
{
static uint16 boardcnt = 1;
drvM6802_taskConfig *ptaskConfig = NULL;
char task_name[60];
int i;
strcpy(task_name, taskName);
ptaskConfig = (drvM6802_taskConfig*) malloc(sizeof(drvM6802_taskConfig));
if(!ptaskConfig) return ptaskConfig;
ptaskConfig->BoardID = boardcnt;
ptaskConfig->vme_addr = vme_addr;
strcpy(ptaskConfig->taskName, task_name);
ptaskConfig->taskLock = epicsMutexCreate();
ptaskConfig->bufferLock = epicsMutexCreate();
scanIoInit(&ptaskConfig->ioScanPvt);
/* ptaskConfig->masterMode = 0; */
ptaskConfig->masterMode = ( ptaskConfig->BoardID == 1 ) ? 1 : 0;
ptaskConfig->samplingRate = INIT_SAMPLING;
ptaskConfig->appSampleRate = INIT_SAMPLING;
ptaskConfig->channelMask = INIT_CH_MASK;
ptaskConfig->clockSource = (ptaskConfig->BoardID == 1) ? 0 : 1; /* default 0 : internal clock , 1: external*/
/* ptaskConfig->msgFPDP = 0; */
ptaskConfig->cnt_DMAcallback = 0;
ptaskConfig->nTrigPolarity = INIT_TRIG_POLARITY;
/* ptaskConfig->pcallback = (CALLBACK*) taskCallback; */
ptaskConfig->fT0 = 1.;
ptaskConfig->fT1 = 2.;
boardcnt++;
ptaskConfig->pcontrolThreadConfig = NULL;
ptaskConfig->pfpdpThreadConfig = NULL;
for( i=0; i< 16 ; i++)
ptaskConfig->register_m6802[i] = DUMMY_DATA;
ptaskConfig->adjTime_smplRate_Usec = 0.;
ptaskConfig->adjTime_Gain_Usec = 0.;
ptaskConfig->adjCount_smplRate = 0;
ptaskConfig->adjCount_Gain = 0;
ptaskConfig->pchannelConfig = (ELLLIST*) malloc(sizeof(ELLLIST));
if(!ptaskConfig->pchannelConfig) return NULL;
else ellInit(ptaskConfig->pchannelConfig);
ptaskConfig->taskStatus = TASK_NOT_INIT;
return ptaskConfig;
}
evgSoftSeq::evgSoftSeq(const epicsUInt32 id, evgMrm* const owner):
m_lock(),
m_id(id),
m_owner(owner),
m_pReg(owner->getRegAddr()),
m_timestampInpMode(EGU),
m_trigSrc(None),
m_runMode(Single),
m_trigSrcCt(None),
m_runModeCt(Single),
m_seqRam(0),
m_seqRamMgr(owner->getSeqRamMgr()),
m_isEnabled(0),
m_isCommited(0),
m_isSynced(0),
m_numOfRuns(0) {
m_eventCodeCt.push_back(0x7f);
m_timestampCt.push_back(evgEndOfSeqBuf);
scanIoInit(&ioscanpvt);
scanIoInit(&ioScanPvtErr);
scanIoInit(&iorunscan);
}
LOCAL long init_signed_ai (struct aiRecord *prec)
{
struct abio *pabio;
devPvt *pdevPvt;
abStatus drvStatus;
long status = 0;
void *drvPvt;
if (prec->inp.type != AB_IO)
{
recGblRecordError (S_db_badField, (void *) prec, "init_signed_ai: Bad INP field");
return (S_db_badField);
}
/* set linear conversion slope*/
prec->eslo = (prec->eguf -prec->egul)/65535.0;
/* pointer to the data addess structure */
pabio = (struct abio *) &(prec->inp.value);
drvStatus = (*pabDrv->registerCard) (pabio->link, pabio->adapter, pabio->card,
typeBi, "BINARY", devCallback, &drvPvt);
switch (drvStatus)
{
case abSuccess :
pdevPvt = (devPvt *) (*pabDrv->getUserPvt) (drvPvt);
prec->dpvt = pdevPvt;
break;
case abNewCard :
pdevPvt = calloc (1, sizeof (devPvt));
pdevPvt->drvPvt = drvPvt;
prec->dpvt = pdevPvt;
(*pabDrv->setUserPvt) (drvPvt, (void *) pdevPvt);
scanIoInit (&pdevPvt->ioscanpvt);
drvStatus = (*pabDrv->setNbits) (drvPvt, abBit16);
if (drvStatus != abSuccess)
{
status = S_db_badField;
recGblRecordError (status, (void *) prec, "init_signed_ai: setNbits");
}
break;
default:
status = S_db_badField;
recGblRecordError (status, (void *)prec, "init_signed_ai: registerCard");
break;
}
return (status);
}
LOCAL long init_1771Il(struct aiRecord *prec)
{
struct abio *pabio;
devPvt *pdevPvt;
abStatus drvStatus;
long status=0;
void *drvPvt;
/* ai.inp must be an AB_IO */
if (prec->inp.type != AB_IO){
recGblRecordError(S_db_badField,(void *)prec,
"devAiAb1771Il (init_record) Illegal INP field");
return(S_db_badField);
}
prec->eslo = (prec->eguf -prec->egul)/4095.0;
/* pointer to the data addess structure */
pabio = (struct abio *)&(prec->inp.value);
drvStatus = (*pabDrv->registerCard)(pabio->link,pabio->adapter,
pabio->card,typeAi,"IL",devCallback,&drvPvt);
switch(drvStatus) {
case abSuccess :
pdevPvt = (devPvt *)(*pabDrv->getUserPvt)(drvPvt);
prec->dpvt = pdevPvt;
break;
case abNewCard :
pdevPvt = calloc(1,sizeof(devPvt));
pdevPvt->drvPvt = drvPvt;
prec->dpvt = pdevPvt;
(*pabDrv->setUserPvt)(drvPvt,(void *)pdevPvt);
scanIoInit(&pdevPvt->ioscanpvt);
pdevPvt->pinit_msg = initMsg;
drvStatus = (*pabDrv->startScan)(drvPvt,IL_SCAN_RATE,
pdevPvt->pinit_msg,IL_INITMSG_LENGTH,
&pdevPvt->read_msg[0],IL_READMSG_LENGTH);
if(drvStatus != abSuccess) {
status = S_db_badField;
recGblRecordError(status,(void *)prec,
"devAiAb1771Il (init_record) startScan");
}
break;
default:
status = S_db_badField;
recGblRecordError(status,(void *)prec,
"devAiAb1771Il (init_record) registerCard");
break;
}
return(status);
}
static long ai_init(int pass)
{
long i;
if (pass) return 0;
/* Create timers */
for (i = 0; i < TOTAL_TYPES; i++) {
scanIoInit(&scan[i].ioscan);
scan[i].wd = wdogCreate(scan_time, i);
scan[i].total = 0;
scan[i].on = 0;
scan[i].rate_sec = parmTypes[i].scan_rate;
}
/* Init OSD stuff */
scan_mutex = epicsMutexMustCreate();
devIocStatsInitCpuUsage();
devIocStatsInitCpuUtilization(&loadinfo);
devIocStatsInitFDUsage();
devIocStatsInitMemUsage();
devIocStatsInitWorkspaceUsage();
devIocStatsInitSuspTasks();
devIocStatsInitIFErrors();
/* Get initial values of a few things that don't change much */
devIocStatsGetClusterInfo(SYS_POOL, &clustinfo[SYS_POOL]);
devIocStatsGetClusterInfo(DATA_POOL, &clustinfo[DATA_POOL]);
devIocStatsGetClusterUsage(SYS_POOL, &mbufnumber[SYS_POOL]);
devIocStatsGetClusterUsage(DATA_POOL, &mbufnumber[DATA_POOL]);
devIocStatsGetCpuUtilization(&loadinfo);
devIocStatsGetIFErrors(&iferrors);
devIocStatsGetFDUsage(&fdusage);
/* Count EPICS records */
if (pdbbase) {
DBENTRY dbentry;
long status;
dbInitEntry(pdbbase,&dbentry);
status = dbFirstRecordType(&dbentry);
while (!status) {
recordnumber += dbGetNRecords(&dbentry);
status = dbNextRecordType(&dbentry);
}
dbFinishEntry(&dbentry);
}
return 0;
}
Sim::Sim(const std::string& n)
:name(n)
,stop(false)
,doSim(false)
,valid(false)
,level(0)
,worker(*this, "flame",
epicsThreadGetStackSize(epicsThreadStackSmall),
epicsThreadPriorityMedium)
{
scanIoInit(&aftersim);
memset(&last_run, 0, sizeof(last_run));
last_duration = -1;
worker.start();
}
/* Common initialization for all record types */
static long init_record(dbCommon *rec, const DBLINK *link)
{
DEVRTPData *pvt = calloc (sizeof (DEVRTPData), 1);
if (! pvt)
{
errlogPrintf("devRTP (%s): cannot allocate DPVT\n", rec->name);
return -1;
}
if (link->type != INST_IO)
{
errlogPrintf("devRTP (%s): INP is not INST_IO\n", rec->name);
return -1;
}
scanIoInit(&pvt->ioscanpvt);
rec->dpvt = pvt;
return 0;
}
LOCAL int get_ioint_info(void *ab1771IXPvt,int cmd, IOSCANPVT *ppvt)
{
deviceData *pdeviceData = (deviceData *)ab1771IXPvt;
ab1771IXRecord *precord;
recordPvt *precordPvt;
int signal;
if(!pdeviceData) return(ab1771IXFatalError);
if(!(precord = pdeviceData->precord)) return(ab1771IXFatalError);
if(!(precordPvt = (recordPvt *)precord->dpvt)) return(ab1771IXFatalError);
signal = pdeviceData->signal;
if(!precordPvt->ioscanpvtInited[signal]) {
scanIoInit(&precordPvt->ioscanpvt[signal]);
precordPvt->ioscanpvtInited[pdeviceData->signal] = TRUE;
}
*ppvt = precordPvt->ioscanpvt[signal];
return(0);
}
int simRegDevConfigure(
const char* name,
size_t size,
int swapEndianFlag,
int async)
{
regDevice* device;
if (name == NULL)
{
printf("usage: simRegDevConfigure(\"name\", size, swapEndianFlag)\n");
printf("maps allocated memory block to device \"name\"");
printf("\"name\" must be a unique string on this IOC\n");
return S_dev_success;
}
device = (regDevice*)calloc(sizeof(regDevice)+size-1,1);
if (device == NULL)
{
errlogSevPrintf(errlogFatal,
"simRegDevConfigure %s: out of memory\n",
name);
return errno;
}
device->magic = MAGIC;
device->name = strdup(name);
device->size = size;
device->connected = 1;
device->swap = swapEndianFlag;
if (async)
{
int i;
device->lock = epicsMutexCreate();
for (i = 0; i < NUM_CALLBACK_PRIORITIES; i++)
{
const unsigned int prio [3] =
{epicsThreadPriorityLow, epicsThreadPriorityMedium, epicsThreadPriorityHigh};
device->queue[i] = epicsTimerQueueAllocate(FALSE, prio[i]);
}
}
regDevRegisterDevice(name, &simRegDevSupport, device, size);
scanIoInit(&device->ioscanpvt);
return S_dev_success;
}
static long ai_init(int pass)
{
int i;
if(pass) return 0;
for(i=0;i<TOTAL_TYPES;i++)
{
scanIoInit(&scan[i].ioscan);
scan[i].wd=wdCreate();
scan[i].total=0;
scan[i].on=0;
scan[i].rate_sec=scan_rate_sec[i];
scan[i].rate_tick=scan_rate_sec[i]*sysClkRateGet();
scan[i].last_read_sec=1000000;
}
cpuUsageInit();
return 0;
}
static long ai_init(int pass)
{
long i;
if (pass) return 0;
/* Create timers */
for (i = 0; i < TOTAL_TYPES; i++) {
scanIoInit(&scan[i].ioscan);
scan[i].wd = wdogCreate(scan_time, i);
scan[i].total = 0;
scan[i].on = 0;
scan[i].rate_sec = scan_rate_sec[i];
scan[i].last_read_sec = 1000000;
}
/* Init OSD stuff */
devIocStatsInitCpuUsage();
devIocStatsInitCpuUtilization(&loadinfo);
devIocStatsInitFDUsage();
devIocStatsInitMemUsage();
devIocStatsInitWorkspaceUsage();
devIocStatsInitSuspTasks();
devIocStatsInitIFErrors();
/* Count EPICS records */
if (pdbbase) {
DBENTRY dbentry;
long status;
dbInitEntry(pdbbase,&dbentry);
status = dbFirstRecordType(&dbentry);
while (!status) {
recordnumber += dbGetNRecords(&dbentry);
status = dbNextRecordType(&dbentry);
}
dbFinishEntry(&dbentry);
}
return 0;
}
long snmp_Init(void *precord)
{
snmpRecord *psnmp = (snmpRecord *)precord;
/* psnmp->dpvt = (SNMP_INFO*)gsnmpInfo; */
printf("snmpInit()****** Message: %s, version: %s, ip: %s, name: %s, authpass: %s, privpass: %s\n",snmpinfo->msg, snmpinfo->version, snmpinfo->hostaddr, snmpinfo->username, snmpinfo->authpass, snmpinfo->privpass);
if(recGblInitConstantLink(&psnmp->inp,DBF_DOUBLE,&psnmp->val))
psnmp->udf = FALSE;
devSNMPPvt *pdev = (devSNMPPvt *)malloc(sizeof (devSNMPPvt));
if(pdev == NULL) return -1;
pdev->mutexId = epicsMutexCreate();
scanIoInit(&pdev->ioScanPvt);
psnmp->dpvt = pdev;
pdev->prec = (dbCommon*)precord;
ellAdd(&devSNMPList, &(((devSNMPPvt*)psnmp->dpvt)->devSNMPNode));
initialize(psnmp);
return(0);
}
static long initCommon(dbCommon *pr, DBLINK *plink,
userCallback processCallback,interruptCallbackFloat64 interruptCallback)
{
devPvt *pPvt;
asynStatus status;
asynUser *pasynUser;
asynInterface *pasynInterface;
pPvt = callocMustSucceed(1, sizeof(*pPvt), "devAsynFloat64::initCommon");
pr->dpvt = pPvt;
pPvt->pr = pr;
/* Create asynUser */
pasynUser = pasynManager->createAsynUser(processCallback, 0);
pasynUser->userPvt = pPvt;
pPvt->pasynUser = pasynUser;
pPvt->ringBufferLock = epicsMutexCreate();
/* Parse the link to get addr and port */
status = pasynEpicsUtils->parseLink(pasynUser, plink,
&pPvt->portName, &pPvt->addr,&pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/* Connect to device */
status = pasynManager->connectDevice(pasynUser, pPvt->portName, pPvt->addr);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon connectDevice failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
status = pasynManager->canBlock(pPvt->pasynUser, &pPvt->canBlock);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon canBlock failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/*call drvUserCreate*/
pasynInterface = pasynManager->findInterface(pasynUser,asynDrvUserType,1);
if(pasynInterface && pPvt->userParam) {
asynDrvUser *pasynDrvUser;
void *drvPvt;
pasynDrvUser = (asynDrvUser *)pasynInterface->pinterface;
drvPvt = pasynInterface->drvPvt;
status = pasynDrvUser->create(drvPvt,pasynUser,pPvt->userParam,0,0);
if(status!=asynSuccess) {
printf("%s devAsynFloat64::initCommon drvUserCreate %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
}
/* Get interface asynFloat64 */
pasynInterface = pasynManager->findInterface(pasynUser, asynFloat64Type, 1);
if (!pasynInterface) {
printf("%s devAsynFloat64::initCommon findInterface asynFloat64Type %s\n",
pr->name,pasynUser->errorMessage);
goto bad;
}
pPvt->pfloat64 = pasynInterface->pinterface;
pPvt->float64Pvt = pasynInterface->drvPvt;
/* Initialize synchronous interface */
status = pasynFloat64SyncIO->connect(pPvt->portName, pPvt->addr,
&pPvt->pasynUserSync, pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon Float64SyncIO->connect failed %s\n",
pr->name, pPvt->pasynUserSync->errorMessage);
goto bad;
}
scanIoInit(&pPvt->ioScanPvt);
pPvt->interruptCallback = interruptCallback;
/* If the info field "asyn:READBACK" is 1 and interruptCallback is not NULL
* then register for callbacks on output records */
if (interruptCallback) {
int enableCallbacks=0;
const char *callbackString;
DBENTRY *pdbentry = dbAllocEntry(pdbbase);
status = dbFindRecord(pdbentry, pr->name);
if (status) {
asynPrint(pPvt->pasynUser, ASYN_TRACE_ERROR,
"%s devAsynFloat64::initCommon error finding record\n",
pr->name);
goto bad;
}
callbackString = dbGetInfo(pdbentry, "asyn:READBACK");
if (callbackString) enableCallbacks = atoi(callbackString);
if (enableCallbacks) {
status = createRingBuffer(pr);
if (status!=asynSuccess) goto bad;
status = pPvt->pfloat64->registerInterruptUser(
pPvt->float64Pvt,pPvt->pasynUser,
pPvt->interruptCallback,pPvt,&pPvt->registrarPvt);
if(status!=asynSuccess) {
printf("%s devAsynFloat64::initRecord error calling registerInterruptUser %s\n",
pr->name,pPvt->pasynUser->errorMessage);
}
}
}
return INIT_OK;
bad:
recGblSetSevr(pr,LINK_ALARM,INVALID_ALARM);
pr->pact=1;
return INIT_ERROR;
}
static void ntpShmInit()
{
scanIoInit(&ntpShm.lastUpdate);
}
static long initCommon(dbCommon *pr, DBLINK *plink,
userCallback processCallback,interruptCallbackInt32 interruptCallback)
{
devInt32Pvt *pPvt;
asynStatus status;
asynUser *pasynUser;
asynInterface *pasynInterface;
epicsUInt32 mask=0;
int nbits;
pPvt = callocMustSucceed(1, sizeof(*pPvt), "devAsynInt32::initCommon");
pr->dpvt = pPvt;
pPvt->pr = pr;
/* Create asynUser */
pasynUser = pasynManager->createAsynUser(processCallback, 0);
pasynUser->userPvt = pPvt;
pPvt->pasynUser = pasynUser;
pPvt->mutexId = epicsMutexCreate();
/* Parse the link to get addr and port */
/* We accept 2 different link syntax (@asyn(...) and @asynMask(...)
* If parseLink returns an error then try parseLinkMask. */
status = pasynEpicsUtils->parseLink(pasynUser, plink,
&pPvt->portName, &pPvt->addr, &pPvt->userParam);
if (status != asynSuccess) {
status = pasynEpicsUtils->parseLinkMask(pasynUser, plink,
&pPvt->portName, &pPvt->addr, &mask, &pPvt->userParam);
}
if (status != asynSuccess) {
printf("%s devAsynInt32::initCommon %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/* Parse nbits if it was specified */
nbits = (int)mask;
if (nbits) {
if (nbits < 0) {
nbits = -nbits;
pPvt->bipolar = 1;
}
pPvt->signBit = (epicsInt32) ldexp(1.0, nbits-1);
pPvt->mask = pPvt->signBit*2 - 1;
if (pPvt->bipolar) {
pPvt->deviceLow = ~(pPvt->mask/2)+1;
pPvt->deviceHigh = (pPvt->mask/2);
} else {
pPvt->deviceLow = 0;
pPvt->deviceHigh = pPvt->mask;
}
}
/* Connect to device */
status = pasynManager->connectDevice(pasynUser, pPvt->portName, pPvt->addr);
if (status != asynSuccess) {
printf("%s devAsynInt32::initCommon connectDevice failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
status = pasynManager->canBlock(pPvt->pasynUser, &pPvt->canBlock);
if (status != asynSuccess) {
printf("%s devAsynInt32::initCommon canBlock failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/*call drvUserCreate*/
pasynInterface = pasynManager->findInterface(pasynUser,asynDrvUserType,1);
if(pasynInterface && pPvt->userParam) {
asynDrvUser *pasynDrvUser;
void *drvPvt;
pasynDrvUser = (asynDrvUser *)pasynInterface->pinterface;
drvPvt = pasynInterface->drvPvt;
status = pasynDrvUser->create(drvPvt,pasynUser,pPvt->userParam,0,0);
if(status!=asynSuccess) {
printf("%s devAsynInt32::initCommon drvUserCreate %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
}
/* Get interface asynInt32 */
pasynInterface = pasynManager->findInterface(pasynUser, asynInt32Type, 1);
if (!pasynInterface) {
printf("%s devAsynInt32::initCommon findInterface asynInt32Type %s\n",
pr->name,pasynUser->errorMessage);
goto bad;
}
pPvt->pint32 = pasynInterface->pinterface;
pPvt->int32Pvt = pasynInterface->drvPvt;
scanIoInit(&pPvt->ioScanPvt);
pPvt->interruptCallback = interruptCallback;
/* Initialize synchronous interface */
status = pasynInt32SyncIO->connect(pPvt->portName, pPvt->addr,
&pPvt->pasynUserSync, pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynInt32::initCommon Int32SyncIO->connect failed %s\n",
pr->name, pPvt->pasynUserSync->errorMessage);
goto bad;
}
return 0;
bad:
pr->pact=1;
return -1;
}
static long initCommon(dbCommon *pr, DBLINK *plink,
userCallback processCallback,interruptCallbackUInt32Digital interruptCallback, interruptCallbackEnum callbackEnum,
int maxEnums, char *pFirstString, int *pFirstValue, epicsEnum16 *pFirstSeverity)
{
devPvt *pPvt;
asynStatus status;
asynUser *pasynUser;
asynInterface *pasynInterface;
pPvt = callocMustSucceed(1, sizeof(*pPvt), "devAsynUInt32Digital::initCommon");
pr->dpvt = pPvt;
pPvt->pr = pr;
/* Create asynUser */
pasynUser = pasynManager->createAsynUser(processCallback, 0);
pasynUser->userPvt = pPvt;
pPvt->pasynUser = pasynUser;
pPvt->ringBufferLock = epicsMutexCreate();
/* Parse the link to get addr and port */
status = pasynEpicsUtils->parseLinkMask(pasynUser, plink,
&pPvt->portName, &pPvt->addr, &pPvt->mask,&pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/* Connect to device */
status = pasynManager->connectDevice(pasynUser, pPvt->portName, pPvt->addr);
if (status != asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon connectDevice failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
status = pasynManager->canBlock(pPvt->pasynUser, &pPvt->canBlock);
if (status != asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon canBlock failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/*call drvUserCreate*/
pasynInterface = pasynManager->findInterface(pasynUser,asynDrvUserType,1);
if(pasynInterface && pPvt->userParam) {
asynDrvUser *pasynDrvUser;
void *drvPvt;
pasynDrvUser = (asynDrvUser *)pasynInterface->pinterface;
drvPvt = pasynInterface->drvPvt;
status = pasynDrvUser->create(drvPvt,pasynUser,pPvt->userParam,0,0);
if(status!=asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon drvUserCreate %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
}
/* Get interface asynUInt32Digital */
pasynInterface = pasynManager->findInterface(pasynUser, asynUInt32DigitalType, 1);
if (!pasynInterface) {
printf("%s devAsynUInt32Digital::initCommon "
"findInterface asynUInt32DigitalType %s\n",
pr->name,pasynUser->errorMessage);
goto bad;
}
pPvt->puint32 = pasynInterface->pinterface;
pPvt->uint32Pvt = pasynInterface->drvPvt;
/* Initialize synchronous interface */
status = pasynUInt32DigitalSyncIO->connect(pPvt->portName, pPvt->addr,
&pPvt->pasynUserSync, pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon UInt32DigitalSyncIO->connect failed %s\n",
pr->name, pPvt->pasynUserSync->errorMessage);
goto bad;
}
pPvt->interruptCallback = interruptCallback;
scanIoInit(&pPvt->ioScanPvt);
/* Initialize asynEnum interfaces */
pasynInterface = pasynManager->findInterface(pPvt->pasynUser,asynEnumType,1);
if (pasynInterface && (maxEnums > 0)) {
size_t numRead;
asynEnum *pasynEnum = pasynInterface->pinterface;
void *registrarPvt;
status = pasynEnumSyncIO->connect(pPvt->portName, pPvt->addr,
&pPvt->pasynUserEnumSync, pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynUInt32Digital::initCommon EnumSyncIO->connect failed %s\n",
pr->name, pPvt->pasynUserEnumSync->errorMessage);
goto bad;
}
status = pasynEnumSyncIO->read(pPvt->pasynUserEnumSync,
pPvt->enumStrings, pPvt->enumValues, pPvt->enumSeverities, maxEnums,
&numRead, pPvt->pasynUser->timeout);
if (status == asynSuccess) {
setEnums(pFirstString, pFirstValue, pFirstSeverity,
pPvt->enumStrings, pPvt->enumValues, pPvt->enumSeverities, numRead, maxEnums);
}
status = pasynEnum->registerInterruptUser(
pasynInterface->drvPvt, pPvt->pasynUser,
callbackEnum, pPvt, ®istrarPvt);
if(status!=asynSuccess) {
printf("%s devAsynUInt32Digital enum registerInterruptUser %s\n",
pr->name,pPvt->pasynUser->errorMessage);
}
}
/* If the info field "asyn:READBACK" is 1 and interruptCallback is not NULL
* then register for callbacks on output records */
if (interruptCallback) {
int enableCallbacks=0;
const char *callbackString;
DBENTRY *pdbentry = dbAllocEntry(pdbbase);
status = dbFindRecord(pdbentry, pr->name);
if (status) {
asynPrint(pPvt->pasynUser, ASYN_TRACE_ERROR,
"%s devAsynUInt32Digital::initCommon error finding record\n",
pr->name);
goto bad;
}
callbackString = dbGetInfo(pdbentry, "asyn:READBACK");
if (callbackString) enableCallbacks = atoi(callbackString);
if (enableCallbacks) {
status = createRingBuffer(pr);
if (status!=asynSuccess) goto bad;
status = pPvt->puint32->registerInterruptUser(
pPvt->uint32Pvt,pPvt->pasynUser,
pPvt->interruptCallback,pPvt,pPvt->mask, &pPvt->registrarPvt);
if(status!=asynSuccess) {
printf("%s devAsynUInt32Digital::initRecord error calling registerInterruptUser %s\n",
pr->name,pPvt->pasynUser->errorMessage);
}
}
}
return INIT_OK;
bad:
recGblSetSevr(pr,LINK_ALARM,INVALID_ALARM);
pr->pact=1;
return INIT_ERROR;
}
LOCAL long drvTPG262_init(char *portName, char *unitName, double devTimeout, double cbTimeout, double scanInterval)
{
static int firstTime = 1;
drvTPG262Config* pdrvTPG262Config = NULL;
TPG262_read* pTPG262_read = NULL;
asynUser* pasynTPG262User = NULL;
asynTPG262UserData* pasynTPG262UserData = NULL;
asynInterface* pasynTPG262Interface = NULL;
asynStatus asynTPG262Status;
char port_name[40];
char unit_name[40];
if(firstTime) {
firstTime = 0;
epicsThreadCreate("drvTPG262ScanTask",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC) drvTPG262_scanTask,
0);
}
strcpy(port_name,portName);
strcpy(unit_name,unitName);
if(!pdrvTPG262_ellList) {
pdrvTPG262_ellList = (ELLLIST *) malloc(sizeof(ELLLIST));
ellInit(pdrvTPG262_ellList);
}
if(drvTPG262_find(port_name)) return 0; /* driver was intialized alrady, nothing to do */
pdrvTPG262Config = (drvTPG262Config*) malloc(sizeof(drvTPG262Config));
pTPG262_read = (TPG262_read*) malloc(sizeof(TPG262_read));
pasynTPG262UserData = (asynTPG262UserData*) malloc(sizeof(asynTPG262UserData));
if(!pdrvTPG262Config || !pTPG262_read || !pasynTPG262UserData) return 0;
pdrvTPG262Config->devTimeout = devTimeout;
pdrvTPG262Config->cbTimeout = cbTimeout;
pdrvTPG262Config->scanInterval = scanInterval;
strcpy(pdrvTPG262Config->port_name, port_name);
pdrvTPG262Config->cbCount = 0;
pdrvTPG262Config->timeoutCount = 0;
pdrvTPG262Config->reconnCount = 0;
pTPG262_read->unit = drvTPG262_findUnit(unit_name);
if(pTPG262_read->unit<0) pTPG262_read->unit = 1; /* default unit */
pTPG262_read->unit_str = tUnitList[vUnitList[pTPG262_read->unit]];
pTPG262_read->gst0 = TPG262GST_TIMEOUT;
pTPG262_read->gst1 = TPG262GST_TIMEOUT;
pTPG262_read->prs0 = 0.;
pTPG262_read->prs1 = 0.;
pTPG262_read->gst_str0 = tSenStList[vSenStList[pTPG262_read->gst0]];
pTPG262_read->gst_str1 = tSenStList[vSenStList[pTPG262_read->gst1]];
strcpy(pTPG262_read->gid_str0, TPG262GID_UNKNOWN_STR);
strcpy(pTPG262_read->gid_str1, TPG262GID_UNKNOWN_STR);
strcpy(pTPG262_read->progver_str, TPG262PROGVER_UNKNOWN_STR);
pasynTPG262UserData->pdrvTPG262Config = (void*) pdrvTPG262Config;
pasynTPG262User = pasynManager->createAsynUser(drvTPG262_queueCallback, drvTPG262_timeoutCallback);
pasynTPG262User->timeout = pdrvTPG262Config->devTimeout;
pasynTPG262User->userPvt = pasynTPG262UserData;
asynTPG262Status = pasynManager->connectDevice(pasynTPG262User, port_name, 0);
if(asynTPG262Status != asynSuccess) {
goto end;
}
pasynTPG262Interface = pasynManager->findInterface(pasynTPG262User, asynOctetType, 1);
if(!pasynTPG262Interface){
goto end;
}
pasynTPG262UserData->pasynTPG262Octet = (asynOctet*)pasynTPG262Interface->pinterface;
pasynTPG262UserData->pdrvPvt = pasynTPG262Interface->drvPvt;
pdrvTPG262Config->lock = epicsMutexCreate();
scanIoInit(&pdrvTPG262Config->ioScanPvt);
pdrvTPG262Config->pTPG262_read = pTPG262_read;
pdrvTPG262Config->pasynTPG262User = pasynTPG262User;
pdrvTPG262Config->pasynTPG262UserData = pasynTPG262UserData;
pdrvTPG262Config->status = TPG262STATUS_TIMEOUT_MASK |
TPG262STATUS_SETUNIT_MASK |
TPG262STATUS_GETGID_MASK |
TPG262STATUS_GETPROGVER_MASK;
ellAdd(pdrvTPG262_ellList, &pdrvTPG262Config->node);
return 0;
end:
/* relase allocated memory and asynInterface */
return 0;
}
void
xycom566setup(
int id,
int cbase,
int dbase,
int level,
int vec,
int bipol
){
xy566 *card;
volatile epicsUInt8 **cb;
volatile epicsUInt16 **db;
epicsUInt16 junk;
if(cbase<0 || cbase>0xffff){
printf("config (A16) out of range\n");
return;
}
if(dbase<0 || dbase>0xffffff){
printf("data (A24) out of range\n");
return;
}
if(level<0 || level>7){
printf("Level out of range (0->7)\n");
return;
}
if(vec<0 || vec>0xff){
printf("Vector out of range (0->255)\n");
return;
}
card=get566(id);
if(!!card){
printf("ID %d already exists\n",id);
return;
}
card=malloc(sizeof(xy566));
if(!card){
printf("Out of memory!\n");
return;
}
memset(&card->dlen,0,sizeof(card->dlen));
memset(&card->cb_irq,0,sizeof(card->cb_irq));
card->id=id;
card->fail=0;
card->clk_div=0; /* stc uninitialized */
card->use_seq_clk=0;
ellInit(&card->seq_ctor);
if(!bipol)
card->nchan=32;
else
card->nchan=16;
card->ivec=vec;
card->base_addr=cbase;
card->data_addr=dbase;
cb=&card->base;
db=&card->data_base;
if(devBusToLocalAddr(atVMEA16, card->base_addr, (volatile void **)cb)){
printf("Failed to map A16 %lx for card %x\n", (unsigned long)card->base_addr,id);
free(card);
return;
}
if(devBusToLocalAddr(atVMEA24, card->data_addr, (volatile void **)db)){
printf("Failed to map A24 %lx for card %x\n", (unsigned long)card->data_base,id);
free(card);
return;
}
if(devReadProbe(2, card->base+U16_XY566_CSR, &junk)){
printf("Failed to read A16 %lx for card %x\n", (unsigned long)(card->base+U16_XY566_CSR),id);
free(card);
return;
}
if(devReadProbe(2, card->data_base, &junk)){
printf("Failed to read A24 %lx for card %x\n", (unsigned long)(card->data_base),id);
free(card);
return;
}
WRITE16(card->base, XY566_CSR, XY566_CSR_RST); /* Reset */
/* turn on green and red to indicate init start */
WRITE16(card->base, XY566_CSR, XY566_CSR_GRN);
WRITE16(card->base, XY566_RAM, 0);
WRITE8(card->base, XY566_SEQ, 0);
card->guard=epicsMutexMustCreate();
scanIoInit(&card->seq_irq);
callbackSetCallback(xycom566isrcb, &card->cb_irq);
callbackSetPriority(priorityHigh, &card->cb_irq);
callbackSetUser(card, &card->cb_irq);
WRITE8(card->base, XY566_VEC, vec);
devEnableInterruptLevelVME(level);
assert(devConnectInterruptVME(vec, xycom566isr, card)==0);
/* Configure card
* Mode: continuous sequence (default)
* 16 bit conversion (default)
* sequence controller disable (will be enabled during drvsup init)
*/
WRITE16(card->base, XY566_CSR,
XY566_CSR_GRN);
ellAdd(&xy566s,&card->node);
}
static long drvMK80S_init(char *portName, double devTimeout, double cbTimeout, double scanInterval)
{
static int firstTime = 1;
char port_name[40];
drvMK80SConfig *pdrvMK80SConfig = NULL;
MK80S_read *pMK80S_read = NULL;
asynUser *pasynMK80SUser = NULL;
asynMK80SUserData *pasynMK80SUserData = NULL;
asynInterface *pasynMK80SInterface= NULL;
asynStatus asynMK80SStatus;
if(firstTime) {
firstTime = 0;
epicsThreadCreate("drvMK80SScanTask",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC) drvMK80S_scanTask,
0);
}
strcpy(port_name,portName);
if(!pdrvMK80S_ellList) {
pdrvMK80S_ellList = (ELLLIST *) malloc(sizeof(ELLLIST));
ellInit(pdrvMK80S_ellList);
}
if(!pdrvMK80SBitInputList) {
pdrvMK80SBitInputList = (drvMK80SInputList *) calloc(1, sizeof(drvMK80SInputList));
pdrvMK80SBitInputList->num = 0;
}
if(!pdrvMK80SWordInputList) {
pdrvMK80SWordInputList = (drvMK80SInputList *) calloc(1, sizeof(drvMK80SInputList));
pdrvMK80SWordInputList->num = 0;
}
if(drvMK80S_find(port_name)) return 0; /* driver was intialized alrady, nothing to do */
pdrvMK80SConfig = (drvMK80SConfig*) malloc(sizeof(drvMK80SConfig));
pMK80S_read = (MK80S_read*) malloc(sizeof(MK80S_read));
pasynMK80SUserData = (asynMK80SUserData*) malloc(sizeof(asynMK80SUserData));
if(!pdrvMK80SConfig || !pMK80S_read || !pasynMK80SUserData) return 0;
pdrvMK80SConfig->devTimeout = devTimeout;
pdrvMK80SConfig->cbTimeout = cbTimeout;
pdrvMK80SConfig->scanInterval = scanInterval;
strcpy(pdrvMK80SConfig->port_name, port_name);
pdrvMK80SConfig->cbCount = 0;
pdrvMK80SConfig->timeoutCount = 0;
memset (pMK80S_read, 0x00, sizeof(MK80S_read));
pasynMK80SUserData->pdrvMK80SConfig = (void*) pdrvMK80SConfig;
pasynMK80SUser = pasynManager->createAsynUser(drvMK80S_queueCallback, drvMK80S_timeoutCallback);
pasynMK80SUser->timeout = pdrvMK80SConfig->devTimeout;
pasynMK80SUser->userPvt = pasynMK80SUserData;
asynMK80SStatus = pasynManager->connectDevice(pasynMK80SUser, port_name, 0);
if(asynMK80SStatus != asynSuccess) {
goto end;
}
pasynMK80SInterface = pasynManager->findInterface(pasynMK80SUser, asynOctetType, 1);
if(!pasynMK80SInterface){
goto end;
}
pasynMK80SUserData->pasynMK80SOctet = (asynOctet*)pasynMK80SInterface->pinterface;
// set EOS(end of string) of receive message
pasynMK80SUserData->pasynMK80SOctet->setInputEos(pasynMK80SInterface->drvPvt, pasynMK80SUser, ETX_STR, 1);
pasynMK80SUserData->pdrvPvt = pasynMK80SInterface->drvPvt;
pdrvMK80SConfig->lock = epicsMutexCreate();
scanIoInit(&pdrvMK80SConfig->ioScanPvt);
pdrvMK80SConfig->pMK80S_read = pMK80S_read;
pdrvMK80SConfig->pasynMK80SUser = pasynMK80SUser;
pdrvMK80SConfig->pasynMK80SUserData = pasynMK80SUserData;
pdrvMK80SConfig->status = MK80SSTATUS_TIMEOUT_MASK;
ellAdd(pdrvMK80S_ellList, &pdrvMK80SConfig->node);
return 0;
end:
/* relase allocated memory and asynInterface */
kuDebug (kuERR, "[drvMK80S_init] init failed for %s!!!\n", port_name);
return 0;
}
evgMrm::evgMrm(const std::string& id, volatile epicsUInt8* const pReg):
mrf::ObjectInst<evgMrm>(id),
irqStop0_queued(0),
irqStop1_queued(0),
irqExtInp_queued(0),
m_syncTimestamp(false),
m_buftx(id+":BUFTX",pReg+U32_DataBufferControl, pReg+U8_DataBuffer_base),
m_id(id),
m_pReg(pReg),
m_acTrig(id+":AcTrig", pReg),
m_evtClk(id+":EvtClk", pReg),
m_softEvt(id+":SoftEvt", pReg),
m_seqRamMgr(this),
m_softSeqMgr(this) {
try{
for(int i = 0; i < evgNumEvtTrig; i++) {
std::ostringstream name;
name<<id<<":TrigEvt"<<i;
m_trigEvt.push_back(new evgTrigEvt(name.str(), i, pReg));
}
for(int i = 0; i < evgNumMxc; i++) {
std::ostringstream name;
name<<id<<":Mxc"<<i;
m_muxCounter.push_back(new evgMxc(name.str(), i, this));
}
for(int i = 0; i < evgNumDbusBit; i++) {
std::ostringstream name;
name<<id<<":Dbus"<<i;
m_dbus.push_back(new evgDbus(name.str(), i, pReg));
}
for(int i = 0; i < evgNumFrontInp; i++) {
std::ostringstream name;
name<<id<<":FrontInp"<<i;
m_input[ std::pair<epicsUInt32, InputType>(i, FrontInp) ] =
new evgInput(name.str(), i, FrontInp, pReg + U32_FrontInMap(i));
}
for(int i = 0; i < evgNumUnivInp; i++) {
std::ostringstream name;
name<<id<<":UnivInp"<<i;
m_input[ std::pair<epicsUInt32, InputType>(i, UnivInp) ] =
new evgInput(name.str(), i, UnivInp, pReg + U32_UnivInMap(i));
}
for(int i = 0; i < evgNumRearInp; i++) {
std::ostringstream name;
name<<id<<":RearInp"<<i;
m_input[ std::pair<epicsUInt32, InputType>(i, RearInp) ] =
new evgInput(name.str(), i, RearInp, pReg + U32_RearInMap(i));
}
for(int i = 0; i < evgNumFrontOut; i++) {
std::ostringstream name;
name<<id<<":FrontOut"<<i;
m_output[std::pair<epicsUInt32, evgOutputType>(i, FrontOut)] =
new evgOutput(name.str(), i, FrontOut, pReg + U16_FrontOutMap(i));
}
for(int i = 0; i < evgNumUnivOut; i++) {
std::ostringstream name;
name<<id<<":UnivOut"<<i;
m_output[std::pair<epicsUInt32, evgOutputType>(i, UnivOut)] =
new evgOutput(name.str(), i, UnivOut, pReg + U16_UnivOutMap(i));
}
m_wdTimer = new wdTimer("Watch Dog Timer", this);
m_timerEvent = new epicsEvent();
init_cb(&irqStop0_cb, priorityHigh, &evgMrm::process_eos0_cb,
m_seqRamMgr.getSeqRam(0));
init_cb(&irqStop1_cb, priorityHigh, &evgMrm::process_eos1_cb,
m_seqRamMgr.getSeqRam(1));
init_cb(&irqExtInp_cb, priorityHigh, &evgMrm::process_inp_cb, this);
scanIoInit(&ioScanTimestamp);
} catch(std::exception& e) {
errlogPrintf("Error: %s\n", e.what());
}
}
static long initCommon(dbCommon *pr, DBLINK *plink,
userCallback processCallback,interruptCallbackFloat64 interruptCallback)
{
devPvt *pPvt;
asynStatus status;
asynUser *pasynUser;
asynInterface *pasynInterface;
pPvt = callocMustSucceed(1, sizeof(*pPvt), "devAsynFloat64::initCommon");
pr->dpvt = pPvt;
pPvt->pr = pr;
/* Create asynUser */
pasynUser = pasynManager->createAsynUser(processCallback, 0);
pasynUser->userPvt = pPvt;
pPvt->pasynUser = pasynUser;
pPvt->mutexId = epicsMutexCreate();
/* Parse the link to get addr and port */
status = pasynEpicsUtils->parseLink(pasynUser, plink,
&pPvt->portName, &pPvt->addr,&pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/* Connect to device */
status = pasynManager->connectDevice(pasynUser, pPvt->portName, pPvt->addr);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon connectDevice failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
status = pasynManager->canBlock(pPvt->pasynUser, &pPvt->canBlock);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon canBlock failed %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
/*call drvUserCreate*/
pasynInterface = pasynManager->findInterface(pasynUser,asynDrvUserType,1);
if(pasynInterface && pPvt->userParam) {
asynDrvUser *pasynDrvUser;
void *drvPvt;
pasynDrvUser = (asynDrvUser *)pasynInterface->pinterface;
drvPvt = pasynInterface->drvPvt;
status = pasynDrvUser->create(drvPvt,pasynUser,pPvt->userParam,0,0);
if(status!=asynSuccess) {
printf("%s devAsynFloat64::initCommon drvUserCreate %s\n",
pr->name, pasynUser->errorMessage);
goto bad;
}
}
/* Get interface asynFloat64 */
pasynInterface = pasynManager->findInterface(pasynUser, asynFloat64Type, 1);
if (!pasynInterface) {
printf("%s devAsynFloat64::initCommon findInterface asynFloat64Type %s\n",
pr->name,pasynUser->errorMessage);
goto bad;
}
pPvt->pfloat64 = pasynInterface->pinterface;
pPvt->float64Pvt = pasynInterface->drvPvt;
/* Initialize synchronous interface */
status = pasynFloat64SyncIO->connect(pPvt->portName, pPvt->addr,
&pPvt->pasynUserSync, pPvt->userParam);
if (status != asynSuccess) {
printf("%s devAsynFloat64::initCommon Float64SyncIO->connect failed %s\n",
pr->name, pPvt->pasynUserSync->errorMessage);
goto bad;
}
scanIoInit(&pPvt->ioScanPvt);
pPvt->interruptCallback = interruptCallback;
return 0;
bad:
pr->pact=1;
return -1;
}
