618 lines
17 KiB
C
618 lines
17 KiB
C
/* devABBINARY.c */
|
||
/*
|
||
* Original Author: Bob Dalesio
|
||
* Current Author: Bob Dalesio, Marty Kraimer
|
||
* Date: 3/6/91
|
||
*
|
||
* Experimental Physics and Industrial Control System (EPICS)
|
||
*
|
||
* Copyright 1991, the Regents of the University of California,
|
||
* and the University of Chicago Board of Governors.
|
||
*
|
||
* This software was produced under U.S. Government contracts:
|
||
* (W-7405-ENG-36) at the Los Alamos National Laboratory,
|
||
* and (W-31-109-ENG-38) at Argonne National Laboratory.
|
||
*
|
||
* Initial development by:
|
||
* The Controls and Automation Group (AT-8)
|
||
* Ground Test Accelerator
|
||
* Accelerator Technology Division
|
||
* Los Alamos National Laboratory
|
||
*
|
||
* Co-developed with
|
||
* The Controls and Computing Group
|
||
* Accelerator Systems Division
|
||
* Advanced Photon Source
|
||
* Argonne National Laboratory
|
||
*
|
||
* Modification Log:
|
||
* -----------------
|
||
* .01 12-01-94 lrd combine the device support that was resident in the driver and
|
||
* device support to significantly reduce the amount of code
|
||
* ...
|
||
*/
|
||
|
||
|
||
#include <vxWorks.h>
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include <dbDefs.h>
|
||
#include <alarm.h>
|
||
#include <cvtTable.h>
|
||
#include <dbAccess.h>
|
||
#include <recSup.h>
|
||
#include <devSup.h>
|
||
#include <link.h>
|
||
#include <drvAb.h>
|
||
#include <dbCommon.h>
|
||
#include <biRecord.h>
|
||
#include <boRecord.h>
|
||
#include <mbbiRecord.h>
|
||
#include <mbboRecord.h>
|
||
#include <mbbiDirectRecord.h>
|
||
#include <mbboDirectRecord.h>
|
||
|
||
typedef struct {
|
||
void *drvPvt;
|
||
IOSCANPVT ioscanpvt;
|
||
}devPvt;
|
||
|
||
|
||
/* Create the dsets*/
|
||
LOCAL long ioinfo(int cmd, struct dbCommon *prec, IOSCANPVT *ppvt);
|
||
LOCAL long read_bi(struct biRecord *prec);
|
||
LOCAL long init_bi08(struct biRecord *prec);
|
||
LOCAL long init_bi16(struct biRecord *prec);
|
||
LOCAL long init_bi32(struct biRecord *prec);
|
||
LOCAL long init_bi(struct biRecord *prec,abNumBits nBits);
|
||
typedef struct {
|
||
long number;
|
||
DEVSUPFUN report;
|
||
DEVSUPFUN init;
|
||
DEVSUPFUN init_record;
|
||
DEVSUPFUN get_ioint_info;
|
||
DEVSUPFUN read_bi;} ABBIDSET;
|
||
|
||
ABBIDSET devBiAb= { 5, 0, 0, init_bi08, ioinfo, read_bi};
|
||
ABBIDSET devBiAb16= { 5, 0, 0, init_bi16, ioinfo, read_bi};
|
||
ABBIDSET devBiAb32= { 5, 0, 0, init_bi32, ioinfo, read_bi};
|
||
|
||
LOCAL long read_mbbi(struct mbbiRecord *prec);
|
||
LOCAL long init_mbbi08(struct mbbiRecord *prec);
|
||
LOCAL long init_mbbi16(struct mbbiRecord *prec);
|
||
LOCAL long init_mbbi32(struct mbbiRecord *prec);
|
||
LOCAL long init_mbbi(struct mbbiRecord *prec,abNumBits nBits);
|
||
ABBIDSET devMbbiAb= { 5, 0, 0, init_mbbi08, ioinfo, read_mbbi};
|
||
ABBIDSET devMbbiAb16={ 5, 0, 0, init_mbbi16, ioinfo, read_mbbi};
|
||
ABBIDSET devMbbiAb32={ 5, 0, 0, init_mbbi32, ioinfo, read_mbbi};
|
||
|
||
LOCAL long read_mbbiDirect(struct mbbiDirectRecord *prec);
|
||
LOCAL long init_mbbiDirect08(struct mbbiDirectRecord *prec);
|
||
LOCAL long init_mbbiDirect16(struct mbbiDirectRecord *prec);
|
||
LOCAL long init_mbbiDirect32(struct mbbiDirectRecord *prec);
|
||
LOCAL long init_mbbiDirect(struct mbbiDirectRecord *prec,abNumBits nBits);
|
||
ABBIDSET devMbbiDirectAb= { 5,0,0, init_mbbiDirect08,ioinfo, read_mbbiDirect};
|
||
ABBIDSET devMbbiDirectAb16={ 5,0,0, init_mbbiDirect16,ioinfo, read_mbbiDirect};
|
||
ABBIDSET devMbbiDirectAb32={ 5,0,0, init_mbbiDirect32,ioinfo, read_mbbiDirect};
|
||
|
||
LOCAL long write_bo(struct boRecord *prec);
|
||
LOCAL long init_bo08(struct boRecord *prec);
|
||
LOCAL long init_bo16(struct boRecord *prec);
|
||
LOCAL long init_bo32(struct boRecord *prec);
|
||
LOCAL long init_bo(struct boRecord *prec,abNumBits nBits);
|
||
typedef struct {
|
||
long number;
|
||
DEVSUPFUN report;
|
||
DEVSUPFUN init;
|
||
DEVSUPFUN init_record;
|
||
DEVSUPFUN get_ioint_info;
|
||
DEVSUPFUN write_bo;
|
||
} ABBODSET;
|
||
|
||
ABBODSET devBoAb= { 5, 0, 0, init_bo08, 0, write_bo};
|
||
ABBODSET devBoAb16= { 5, 0, 0, init_bo16, 0, write_bo};
|
||
ABBODSET devBoAb32= { 5, 0, 0, init_bo32, 0, write_bo};
|
||
|
||
LOCAL long write_mbbo(struct mbboRecord *prec);
|
||
LOCAL long init_mbbo08(struct mbboRecord *prec);
|
||
LOCAL long init_mbbo16(struct mbboRecord *prec);
|
||
LOCAL long init_mbbo32(struct mbboRecord *prec);
|
||
LOCAL long init_mbbo(struct mbboRecord *prec,abNumBits nBits);
|
||
ABBODSET devMbboAb= { 5, 0, 0, init_mbbo08, 0, write_mbbo};
|
||
ABBODSET devMbboAb16={ 5, 0, 0, init_mbbo16, 0, write_mbbo};
|
||
ABBODSET devMbboAb32={ 5, 0, 0, init_mbbo32, 0, write_mbbo};
|
||
|
||
LOCAL long write_mbboDirect(struct mbboDirectRecord *prec);
|
||
LOCAL long init_mbboDirect08(struct mbboDirectRecord *prec);
|
||
LOCAL long init_mbboDirect16(struct mbboDirectRecord *prec);
|
||
LOCAL long init_mbboDirect32(struct mbboDirectRecord *prec);
|
||
LOCAL long init_mbboDirect(struct mbboDirectRecord *prec,abNumBits nBits);
|
||
ABBODSET devMbboDirectAb= { 5, 0, 0, init_mbboDirect08, 0, write_mbboDirect};
|
||
ABBODSET devMbboDirectAb16={ 5, 0, 0, init_mbboDirect16, 0, write_mbboDirect};
|
||
ABBODSET devMbboDirectAb32={ 5, 0, 0, init_mbboDirect32, 0, write_mbboDirect};
|
||
|
||
LOCAL void devCallback(void * drvPvt)
|
||
{
|
||
devPvt *pdevPvt;
|
||
|
||
pdevPvt = (devPvt *)(*pabDrv->getUserPvt)(drvPvt);
|
||
if(!pdevPvt) return;
|
||
if(!pdevPvt->ioscanpvt) return;
|
||
scanIoRequest(pdevPvt->ioscanpvt);
|
||
}
|
||
|
||
LOCAL long ioinfo(int cmd, struct dbCommon *prec, IOSCANPVT *ppvt)
|
||
{
|
||
devPvt *pdevPvt;
|
||
|
||
pdevPvt = prec->dpvt;
|
||
if(!pdevPvt) return(0);
|
||
*ppvt = pdevPvt->ioscanpvt;
|
||
return(0);
|
||
}
|
||
LOCAL long init_bi08(struct biRecord *prec)
|
||
{
|
||
return(init_bi(prec, abBit8));
|
||
}
|
||
LOCAL long init_bi16(struct biRecord *prec)
|
||
{
|
||
return(init_bi(prec, abBit16));
|
||
}
|
||
LOCAL long init_bi32(struct biRecord *prec)
|
||
{
|
||
return(init_bi(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long init_mbbi08(struct mbbiRecord *prec)
|
||
{
|
||
return(init_mbbi(prec, abBit8));
|
||
}
|
||
LOCAL long init_mbbi16(struct mbbiRecord *prec)
|
||
{
|
||
return(init_mbbi(prec, abBit16));
|
||
}
|
||
LOCAL long init_mbbi32(struct mbbiRecord *prec)
|
||
{
|
||
return(init_mbbi(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long init_mbbiDirect08(struct mbbiDirectRecord *prec)
|
||
{
|
||
return(init_mbbiDirect(prec, abBit8));
|
||
}
|
||
LOCAL long init_mbbiDirect16(struct mbbiDirectRecord *prec)
|
||
{
|
||
return(init_mbbiDirect(prec, abBit16));
|
||
}
|
||
LOCAL long init_mbbiDirect32(struct mbbiDirectRecord *prec)
|
||
{
|
||
return(init_mbbiDirect(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long init_bo08(struct boRecord *prec)
|
||
{
|
||
return(init_bo(prec, abBit8));
|
||
}
|
||
LOCAL long init_bo16(struct boRecord *prec)
|
||
{
|
||
return(init_bo(prec, abBit16));
|
||
}
|
||
LOCAL long init_bo32(struct boRecord *prec)
|
||
{
|
||
return(init_bo(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long init_mbbo08(struct mbboRecord *prec)
|
||
{
|
||
return(init_mbbo(prec, abBit8));
|
||
}
|
||
LOCAL long init_mbbo16(struct mbboRecord *prec)
|
||
{
|
||
return(init_mbbo(prec, abBit16));
|
||
}
|
||
LOCAL long init_mbbo32(struct mbboRecord *prec)
|
||
{
|
||
return(init_mbbo(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long init_mbboDirect08(struct mbboDirectRecord *prec)
|
||
{
|
||
return(init_mbboDirect(prec, abBit8));
|
||
}
|
||
LOCAL long init_mbboDirect16(struct mbboDirectRecord *prec)
|
||
{
|
||
return(init_mbboDirect(prec, abBit16));
|
||
}
|
||
LOCAL long init_mbboDirect32(struct mbboDirectRecord *prec)
|
||
{
|
||
return(init_mbboDirect(prec, abBit32));
|
||
}
|
||
|
||
LOCAL long read_bi(struct biRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
unsigned long value;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->readBi)(drvPvt,&value,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
prec->rval = value;
|
||
return(0);
|
||
}
|
||
LOCAL long init_bi(struct biRecord *prec,abNumBits nBits)
|
||
{
|
||
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_record: bad INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->inp.value);
|
||
prec->mask=1;
|
||
prec->mask <<= pabio->signal;
|
||
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,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
break;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
LOCAL long read_mbbi(struct mbbiRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
unsigned long value;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->readBi)(drvPvt,&value,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
prec->rval = value;
|
||
return(0);
|
||
}
|
||
LOCAL long init_mbbi(struct mbbiRecord *prec,abNumBits nBits)
|
||
{
|
||
struct abio *pabio;
|
||
devPvt *pdevPvt;
|
||
abStatus drvStatus;
|
||
long status=0;
|
||
void *drvPvt;
|
||
|
||
if (prec->inp.type != AB_IO){
|
||
recGblRecordError(S_db_badField,(void *)prec, "Illegal INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->inp.value);
|
||
prec->shft = prec->inp.value.abio.signal;
|
||
prec->mask <<= prec->shft;
|
||
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,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
break;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
LOCAL long read_mbbiDirect(struct mbbiDirectRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
unsigned long value;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->readBi)(drvPvt,&value,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,READ_ALARM,INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
prec->rval = value;
|
||
return(0);
|
||
}
|
||
LOCAL long init_mbbiDirect(struct mbbiDirectRecord *prec,abNumBits nBits)
|
||
{
|
||
struct abio *pabio;
|
||
devPvt *pdevPvt;
|
||
abStatus drvStatus;
|
||
long status=0;
|
||
void *drvPvt;
|
||
|
||
if (prec->inp.type != AB_IO){
|
||
recGblRecordError(S_db_badField,(void *)prec, "Illegal INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->inp.value);
|
||
prec->shft = prec->inp.value.abio.signal;
|
||
prec->mask <<= prec->shft;
|
||
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,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
break;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
LOCAL long write_bo(struct boRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
return(0);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->updateBo)(drvPvt,prec->rval,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
}
|
||
return(0);
|
||
}
|
||
LOCAL long init_bo(struct boRecord *prec,abNumBits nBits)
|
||
{
|
||
struct abio *pabio;
|
||
devPvt *pdevPvt;
|
||
abStatus drvStatus;
|
||
long status=0;
|
||
void *drvPvt;
|
||
unsigned long value;
|
||
|
||
if (prec->out.type != AB_IO){
|
||
recGblRecordError(S_db_badField,(void *)prec, "Illegal INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->out.value);
|
||
prec->mask = 1;
|
||
prec->mask <<= pabio->signal;
|
||
drvStatus = (*pabDrv->registerCard)(pabio->link,pabio->adapter,
|
||
pabio->card,typeBo,"BINARY",NULL,&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);
|
||
drvStatus = (*pabDrv->setNbits)(drvPvt,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblRecordError(S_db_badField,(void *)prec,
|
||
"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
return(status);
|
||
}
|
||
drvStatus = (*pabDrv->readBo)(drvPvt,&value,prec->mask);
|
||
if(drvStatus==abSuccess) {
|
||
prec->rval = value;
|
||
status = 0;
|
||
} else {
|
||
status = 2;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
LOCAL long write_mbbo(struct mbboRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
return(0);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->updateBo)(drvPvt,prec->rval,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
}
|
||
return(0);
|
||
}
|
||
LOCAL long init_mbbo(struct mbboRecord *prec,abNumBits nBits)
|
||
{
|
||
struct abio *pabio;
|
||
devPvt *pdevPvt;
|
||
abStatus drvStatus;
|
||
long status=0;
|
||
void *drvPvt;
|
||
unsigned long value;
|
||
|
||
if (prec->out.type != AB_IO){
|
||
recGblRecordError(S_db_badField,(void *)prec, "Illegal INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->out.value);
|
||
prec->shft = prec->out.value.abio.signal;
|
||
prec->mask <<= prec->shft;
|
||
drvStatus = (*pabDrv->registerCard)(pabio->link,pabio->adapter,
|
||
pabio->card,typeBo,"BINARY",NULL,&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);
|
||
drvStatus = (*pabDrv->setNbits)(drvPvt,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblRecordError(S_db_badField,(void *)prec,
|
||
"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
return(status);
|
||
}
|
||
drvStatus = (*pabDrv->readBo)(drvPvt,&value,prec->mask);
|
||
if(drvStatus==abSuccess) {
|
||
prec->rval = value;
|
||
status = 0;
|
||
} else {
|
||
status = 2;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
LOCAL long write_mbboDirect(struct mbboDirectRecord *prec)
|
||
{
|
||
devPvt *pdevPvt = (devPvt *)prec->dpvt;
|
||
void *drvPvt;
|
||
abStatus drvStatus;
|
||
unsigned long value = prec->rval;
|
||
|
||
if(!pdevPvt) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
return(0);
|
||
}
|
||
drvPvt = pdevPvt->drvPvt;
|
||
drvStatus = (*pabDrv->updateBo)(drvPvt,value,prec->mask);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblSetSevr(prec,WRITE_ALARM,INVALID_ALARM);
|
||
}
|
||
return(0);
|
||
}
|
||
LOCAL long init_mbboDirect(struct mbboDirectRecord *prec,abNumBits nBits)
|
||
{
|
||
struct abio *pabio;
|
||
devPvt *pdevPvt;
|
||
abStatus drvStatus;
|
||
long status=0;
|
||
void *drvPvt;
|
||
unsigned long value;
|
||
|
||
if (prec->out.type != AB_IO){
|
||
recGblRecordError(S_db_badField,(void *)prec, "Illegal INP field");
|
||
return(S_db_badField);
|
||
}
|
||
pabio = (struct abio *)&(prec->out.value);
|
||
prec->shft = prec->out.value.abio.signal;
|
||
prec->mask <<= prec->shft;
|
||
drvStatus = (*pabDrv->registerCard)(pabio->link,pabio->adapter,
|
||
pabio->card,typeBo,"BINARY",NULL,&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);
|
||
drvStatus = (*pabDrv->setNbits)(drvPvt,nBits);
|
||
if(drvStatus!=abSuccess) {
|
||
recGblRecordError(S_db_badField,(void *)prec,
|
||
"init_record setNbits");
|
||
}
|
||
break;
|
||
default:
|
||
status = S_db_badField;
|
||
recGblRecordError(status,(void *)prec,"init_record registerCard");
|
||
return(status);
|
||
}
|
||
drvStatus = (*pabDrv->readBo)(drvPvt,&value,prec->mask);
|
||
if(drvStatus==abSuccess) {
|
||
prec->rval = value;
|
||
status = 0;
|
||
} else {
|
||
status = 2;
|
||
}
|
||
return(status);
|
||
}
|