/* * ASYN UInt32Digital driver for MPS Buffer Readback */ #include #include #include #include #include #include #include "MachineStateBuffer.h" /* * Driver private storage */ typedef struct dpvtStruct { asynInterface asynCommon; asynInterface asynUInt32Digital; int (*readFunc)(unsigned int index); int (*writeFunc)(unsigned int index, char value); } dpvt; #if 0 #pragma mark - #pragma mark asynCommon methods #endif /* * asynCommon methods */ static void mpsBufferReport(void *pvt, FILE *fp, int details) { if (details >= 3) { fprintf(fp, "report\n"); } } static asynStatus mpsBufferConnect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionConnect(pasynUser); return asynSuccess; } static asynStatus mpsBufferDisconnect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionDisconnect(pasynUser); return asynSuccess; } static asynCommon asynCommonMethods = { mpsBufferReport, mpsBufferConnect, mpsBufferDisconnect }; #if 0 #pragma mark - #pragma mark asynUInt32Digital methods #endif /* * asynUInt32Digital Methods */ static asynStatus readMpsStatusBuffer(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { dpvt *pdpvt = (dpvt *) pvt; asynStatus status; int index; int mpsInputStatus; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ mpsInputStatus = pdpvt->readFunc(index); if (mpsInputStatus < 0) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "Invalid uint32Digital read address %d, error %d", index, mpsInputStatus); return asynError; } *value = mpsInputStatus ? 1 : 0; return asynSuccess; } static asynStatus writeMpsStatusBufferOnce(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { dpvt *pdpvt = (dpvt *) pvt; asynStatus status; int index; int writeStatus; /* pasynUser->drvUser is used to store whether or not this function has been called. * drvUser will point to NULL if it has not been called and non-NULL if it has been. */ if (pasynUser->drvUser != NULL) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "This record can be written to only once."); return asynError; } /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Write */ writeStatus = pdpvt->writeFunc(index, value ? 1 : 0); if (writeStatus < 0) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "Invalid uint32Digital write address %d, error %d", index, writeStatus); return asynError; } pasynUser->drvUser = (void *) 1; return asynSuccess; } static asynStatus noRead(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "This record is write only."); return asynError; } static asynStatus noWrite(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "This record is read only."); return asynError; } static asynUInt32Digital asynUInt32DigitalMethodsReadOnly = { noWrite, readMpsStatusBuffer }; static asynUInt32Digital asynUInt32DigitalMethodsWriteOnlyOnce = { writeMpsStatusBufferOnce, noRead }; #if 0 #pragma mark - #pragma mark Configure Port Instances #endif /* * Configure and register the port instances */ void devMpsBufferReadbackRegistrar() { dpvt *pdpvt; asynStatus status; const char *portNames[5] = {"devMpsStatusBufferReadback", /* 0 */ "devMpsBypassActiveBufferReadback", /* 1 */ "devMpsBypassValueBufferReadback", /* 2 */ "devMpsAutorecoverBufferReadback", /* 3 */ "devMpsLinkNodeActiveBufferReadback"}; /* 4 */ const char *portName; int i; for(i = 0; i < sizeof(portNames)/sizeof(portNames[0]); i++) { portName = portNames[i]; pdpvt = callocMustSucceed(sizeof(dpvt), 1, portName); switch(i) { case 0: pdpvt->readFunc = getDeviceState; break; case 1: pdpvt->readFunc = isInputByassed; break; case 2: pdpvt->readFunc = getBypassValue; break; case 3: pdpvt->writeFunc = setInputAutorecover; break; case 4: pdpvt->writeFunc = setLinkNodeActive; break; default: pdpvt->readFunc = NULL; pdpvt->writeFunc = NULL; printf("devMpsBufferReadbackRegistrar: bad portname\n"); continue; } /* * Register with ASYN * * registerPort(portName, attributes, autoConnect, priority (for worker thread), stack size (for worker thread)) * Note: I/O actions do not block read thread. Therefore, no worker thread is created. Priority and stack size should be zero. */ status = pasynManager->registerPort(portName, ASYN_MULTIDEVICE, 1, 0, 0); if(status!=asynSuccess) { printf("devMpsBufferReadbackRegistrar: registerPort failed\n"); return; } pdpvt->asynCommon.interfaceType = asynCommonType; pdpvt->asynCommon.pinterface = (void *)&asynCommonMethods; pdpvt->asynCommon.drvPvt = pdpvt; status = pasynManager->registerInterface(portName, &pdpvt->asynCommon); if (status!=asynSuccess) { printf("devMpsBufferReadbackRegistrar: registerInterface failed\n"); return; } pdpvt->asynUInt32Digital.interfaceType = asynUInt32DigitalType; switch(i) { case 0: case 1: case 2: pdpvt->asynUInt32Digital.pinterface = (void *)&asynUInt32DigitalMethodsReadOnly; break; case 3: case 4: pdpvt->asynUInt32Digital.pinterface = (void *)&asynUInt32DigitalMethodsWriteOnlyOnce; break; default: pdpvt->asynUInt32Digital.pinterface = NULL; printf("devMpsBufferReadbackRegistrar: bad portname\n"); continue; } pdpvt->asynUInt32Digital.drvPvt = pdpvt; status = pasynUInt32DigitalBase->initialize(portName, &pdpvt->asynUInt32Digital); if (status!=asynSuccess) { printf("devMpsBufferReadbackRegistrar: registerInterface failed\n"); return; } } } epicsExportRegistrar(devMpsBufferReadbackRegistrar);