/* * devMpsAlgorithm.c * mpsLinkProcessor * * Created by Stephen Norum. * Copyright 2008 Stanford Linear Accelerator Center. All rights reserved. * */ #include #include #include #include #include #include #include #include #include #include #include #include "AlgorithmWrapper.h" /* * Driver private storage */ struct dpvtStruct { asynInterface asynCommon; asynInterface asynUInt32Digital; asynInterface asynOctet; int (*readFunction)(int index, char *buffer, unsigned int bufferSize); }; typedef struct dpvtStruct dpvt; #if 0 #pragma mark - #pragma mark asynCommon methods #endif /* * asynCommon methods */ static void report(void *pvt, FILE *fp, int details) { if (details >= 3) { fprintf(fp, "report\n"); } } static asynStatus connect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionConnect(pasynUser); return asynSuccess; } static asynStatus disconnect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionDisconnect(pasynUser); return asynSuccess; } static asynCommon asynCommonMethods = { report, connect, disconnect }; #if 0 #pragma mark - #pragma mark asynOctet methods #endif static asynStatus octetWriteLoadAlgorithmObject(void *pvt, asynUser *pasynUser, const char *data, size_t numchars, size_t *nbytesTransfered) { int err; err = mpsLoadAlgorithm(data); *nbytesTransfered = numchars; if (err != MPS_SUCCESS) { return asynError; } return asynSuccess; } static asynStatus octetWriteUnloadAlgorithmObject(void *pvt, asynUser *pasynUser, const char *data, size_t numchars, size_t *nbytesTransfered) { int err; err = mpsUnloadAlgorithm(data); *nbytesTransfered = numchars; if (err != MPS_SUCCESS) { return asynError; } return asynSuccess; } static asynStatus octetWriteRunAlgorithm(void *pvt, asynUser *pasynUser, const char *data, size_t numchars, size_t *nbytesTransfered) { int err; static char revision[MPSAlgorithmRevisionStringMaxLength]; unsigned int year, month, day; year = 0; month = 0; day = 0; revision[0] = '\0'; sscanf(data, "%u-%u-%u-%s", &year, &month, &day, revision); err = mpsSetAlgorithmToRun(year, month, day, revision); *nbytesTransfered = numchars; return asynSuccess; } static asynStatus octetRead(void *pvt, asynUser *pasynUser, char *data, size_t maxchars, size_t *nTransferred, int *eomReason) { dpvt *pdpvt = (dpvt *) pvt; asynStatus status; int index; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } *nTransferred = pdpvt->readFunction(index, data, maxchars); *eomReason = ASYN_EOM_END; return asynSuccess; } static asynOctet asynOctetReadMethods = { NULL, octetRead}; static asynOctet asynOctetLoadAlgorithmMethods = { octetWriteLoadAlgorithmObject, NULL }; static asynOctet asynOctetUnloadAlgorithmMethods = { octetWriteUnloadAlgorithmObject, NULL }; static asynOctet asynOctetRunAlgorithmMethods = { octetWriteRunAlgorithm, NULL }; #if 0 #pragma mark - #pragma mark asynUInt32Digital methods #endif static asynStatus uInt32DigitalReadIsRunning(void *pvt, asynUser *pasynUser, epicsUInt32 *value, epicsUInt32 mask) { asynStatus status; int index; int isRunning; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ isRunning = getAlgorithmIsRunning(index); *value = isRunning; return asynSuccess; } static asynUInt32Digital asynUInt32DigitalAlgorithmIsRunningMethods = { NULL, uInt32DigitalReadIsRunning }; #if 0 #pragma mark - #pragma mark Configure Port Instances #endif /* * Configure and register the port instances for octet ports */ void devMpsAlgorithmOctetRegistrar() { int i; int attributes; dpvt *pdpvt; asynStatus status; const char *portName; const char *portNames[7] = { "devMpsAlgorithmName", /* 0 */ "devMpsAlgorithmMpsDatabaseVersion", /* 1 */ "devMpsAlgorithmCompileDate", /* 2 */ "devMpsAlgorithmCompileTime", /* 3 */ "devMpsAlgorithmLoad", /* 4 */ "devMpsAlgorithmUnload", /* 5 */ "devMpsAlgorithmRun", /* 6 */ }; for(i = 0; i < sizeof(portNames)/sizeof(portNames[0]); i++) { portName = portNames[i]; pdpvt = callocMustSucceed(sizeof(dpvt), 1, portName); attributes = 0; switch(i) { case 0: pdpvt->readFunction = getAlgorithmName; attributes |= ASYN_MULTIDEVICE; break; case 1: pdpvt->readFunction = getAlgorithmMpsDatabaseVersion; attributes |= ASYN_MULTIDEVICE; break; case 2: pdpvt->readFunction = getAlgorithmCompileDate; attributes |= ASYN_MULTIDEVICE; break; case 3: pdpvt->readFunction = getAlgorithmCompileTime; attributes |= ASYN_MULTIDEVICE; break; case 4: pdpvt->readFunction = NULL; break; case 5: pdpvt->readFunction = NULL; break; case 6: pdpvt->readFunction = NULL; break; default: pdpvt->readFunction = NULL; printf("devMpsAlgorithmOctetRegistrar: 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, attributes, 1, 0, 0); if(status != asynSuccess) { printf("devMpsAlgorithmOctetRegistrar: 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("devMpsAlgorithmOctetRegistrar: registerInterface failed\n"); return; } pdpvt->asynOctet.interfaceType = asynOctetType; switch(i) { case 0: case 1: case 2: case 3: pdpvt->asynOctet.pinterface = (void *)&asynOctetReadMethods; break; case 4: pdpvt->asynOctet.pinterface = (void *)&asynOctetLoadAlgorithmMethods; break; case 5: pdpvt->asynOctet.pinterface = (void *)&asynOctetUnloadAlgorithmMethods; break; case 6: pdpvt->asynOctet.pinterface = (void *)&asynOctetRunAlgorithmMethods; break; default: pdpvt->asynOctet.pinterface = NULL; printf("devMpsAlgorithmOctetRegistrar: bad portname, id = %d\n", i); continue; } pdpvt->asynOctet.drvPvt = pdpvt; status = pasynOctetBase->initialize(portName, &pdpvt->asynOctet, 0, 0, 0); if (status != asynSuccess) { printf("devMpsAlgorithmOctetRegistrar: registerInterface failed\n"); return; } } } /* * Configure and register the port instances for UInt32Digital Ports */ void devMpsAlgorithmUInt32DigitalRegistrar() { int i; dpvt *pdpvt; asynStatus status; const char *portName; const char *portNames[1] = { "devMpsAlgorithmIsRunning", /* 0 */ }; for(i = 0; i < sizeof(portNames)/sizeof(portNames[0]); i++) { portName = portNames[i]; pdpvt = callocMustSucceed(sizeof(dpvt), 1, portName); /* * 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("devMpsAlgorithmUInt32DigitalRegistrar: 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("devMpsAlgorithmUInt32DigitalRegistrar: registerInterface failed\n"); return; } pdpvt->asynUInt32Digital.interfaceType = asynUInt32DigitalType; switch(i) { case 0: pdpvt->asynUInt32Digital.pinterface = (void *)&asynUInt32DigitalAlgorithmIsRunningMethods; break; default: pdpvt->asynUInt32Digital.pinterface = NULL; printf("devMpsAlgorithmUInt32DigitalRegistrar: bad portname, id = %d\n", i); continue; } pdpvt->asynUInt32Digital.drvPvt = pdpvt; status = pasynUInt32DigitalBase->initialize(portName, &pdpvt->asynUInt32Digital); if (status!=asynSuccess) { printf("devMpsAlgorithmUInt32DigitalRegistrar: registerInterface failed\n"); return; } } } epicsExportRegistrar(devMpsAlgorithmOctetRegistrar); epicsExportRegistrar(devMpsAlgorithmUInt32DigitalRegistrar);