928 lines
27 KiB
C
928 lines
27 KiB
C
/* devAvme9440.c */
|
||
|
||
/*****************************************************************
|
||
*
|
||
* Author : Greg Nawrocki
|
||
* Date: 4/93
|
||
*
|
||
* Experimental Physics and Industrial Control System (EPICS)
|
||
*
|
||
*****************************************************************
|
||
* COPYRIGHT NOTIFICATION
|
||
*****************************************************************
|
||
|
||
* THE FOLLOWING IS A NOTICE OF COPYRIGHT, AVAILABILITY OF THE CODE,
|
||
* AND DISCLAIMER WHICH MUST BE INCLUDED IN THE PROLOGUE OF THE CODE
|
||
* AND IN ALL SOURCE LISTINGS OF THE CODE.
|
||
|
||
* (C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO
|
||
|
||
* Argonne National Laboratory (ANL), with facilities in the States of
|
||
* Illinois and Idaho, is owned by the United States Government, and
|
||
* operated by the University of Chicago under provision of a contract
|
||
* with the Department of Energy.
|
||
|
||
* Portions of this material resulted from work developed under a U.S.
|
||
* Government contract and are subject to the following license: For
|
||
* a period of five years from March 30, 1993, the Government is
|
||
* granted for itself and others acting on its behalf a paid-up,
|
||
* nonexclusive, irrevocable worldwide license in this computer
|
||
* software to reproduce, prepare derivative works, and perform
|
||
* publicly and display publicly. With the approval of DOE, this
|
||
* period may be renewed for two additional five year periods.
|
||
* Following the expiration of this period or periods, the Government
|
||
* is granted for itself and others acting on its behalf, a paid-up,
|
||
* nonexclusive, irrevocable worldwide license in this computer
|
||
* software to reproduce, prepare derivative works, distribute copies
|
||
* to the public, perform publicly and display publicly, and to permit
|
||
* others to do so.
|
||
|
||
*****************************************************************
|
||
* DISCLAIMER
|
||
*****************************************************************
|
||
|
||
* NEITHER THE UNITED STATES GOVERNMENT NOR ANY AGENCY THEREOF, NOR
|
||
* THE UNIVERSITY OF CHICAGO, NOR ANY OF THEIR EMPLOYEES OR OFFICERS,
|
||
* MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL
|
||
* LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR
|
||
* USEFULNESS OF ANY INFORMATION, APPARATUS, PRODUCT, OR PROCESS
|
||
* DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY
|
||
* OWNED RIGHTS.
|
||
|
||
*****************************************************************
|
||
* LICENSING INQUIRIES MAY BE DIRECTED TO THE INDUSTRIAL TECHNOLOGY
|
||
* DEVELOPMENT CENTER AT ARGONNE NATIONAL LABORATORY (708-252-2000).
|
||
*****************************************************************
|
||
|
||
* Modification Log:
|
||
* -----------------
|
||
* ...
|
||
*/
|
||
|
||
/*To Use this device, Include the following before iocInit */
|
||
/* devAvme9440Config(ncards,a16base,intvecbase) */
|
||
/* For Example */
|
||
/* devAvme9440Config(1,0x2800,0x78) */
|
||
|
||
/*
|
||
* This device support routine provides EPICS support for the *
|
||
* Acromag AVME-9440 16 bit binary input and output board. Change *
|
||
* of state I/O interrupts are available for binary input signals *
|
||
* 0 -7 only, and only for the BI record. If interrupts are *
|
||
* desired for MBBI type values, they must be done via BI records *
|
||
* linked to CALC records. As many I/O interrupt scan BI records *
|
||
* may be connected to a single binary input signal as desired. *
|
||
*
|
||
*/
|
||
|
||
/*********************************************************************/
|
||
/** **/
|
||
/** Binary Outputs 0 - 15 ========== "AVME9440 O" Signals 0 - 15 **/
|
||
/** Binary Input 0 - 15 ============ "AVME9440 I" Signals 0 - 15 **/
|
||
/** Binary Output Readback 0 - 15 == "AVME9440 I" Signals 16 - 31 **/
|
||
/** **/
|
||
/*********************************************************************/
|
||
|
||
#include <vxWorks.h>
|
||
#include <sysLib.h>
|
||
#include <vme.h>
|
||
#include <types.h>
|
||
#include <stdioLib.h>
|
||
#include <string.h>
|
||
#include <iv.h>
|
||
|
||
#include <alarm.h>
|
||
#include <dbDefs.h>
|
||
#include <dbAccess.h>
|
||
#include <recSup.h>
|
||
#include <devSup.h>
|
||
#include <module_types.h>
|
||
#include <link.h>
|
||
#include <fast_lock.h>
|
||
|
||
#include <boRecord.h>
|
||
#include <biRecord.h>
|
||
#include <mbboRecord.h>
|
||
#include <mbbiRecord.h>
|
||
|
||
#include <dbScan.h>
|
||
|
||
#define STATIC static
|
||
|
||
STATIC long init();
|
||
STATIC long report();
|
||
STATIC long init_bo_record();
|
||
STATIC long init_bi_record();
|
||
STATIC long init_mbbo_record();
|
||
STATIC long init_mbbi_record();
|
||
STATIC long write_bo();
|
||
STATIC long read_bi();
|
||
STATIC long write_mbbo();
|
||
STATIC long read_mbbi();
|
||
STATIC long write_card();
|
||
STATIC long write_mbbo_card();
|
||
STATIC long read_card();
|
||
STATIC long get_bi_int_info();
|
||
STATIC int checkLink();
|
||
STATIC void avme9440_isr();
|
||
|
||
int devAvme9440Debug = 0;
|
||
|
||
/***** devAvme9440Debug *****/
|
||
|
||
/** devAvme9440Debug == 0 --- no debugging messages **/
|
||
/** devAvme9440Debug >= 5 --- hardware initialization information **/
|
||
/** devAvme9440Debug >= 10 -- record initialization information **/
|
||
/** devAvme9440Debug >= 15 -- write commands **/
|
||
/** devAvme9440Debug >= 20 -- read commands **/
|
||
|
||
#define INPUT_REG 1
|
||
#define OUTPUT_REG 2
|
||
|
||
struct avme9440 {
|
||
unsigned char pad0[0x80];
|
||
unsigned char pad1;
|
||
unsigned char boardStatus;
|
||
unsigned char pad2[0x1e];
|
||
unsigned char pad3;
|
||
unsigned char intVector0;
|
||
unsigned char pad4;
|
||
unsigned char intVector1;
|
||
unsigned char pad5;
|
||
unsigned char intVector2;
|
||
unsigned char pad6;
|
||
unsigned char intVector3;
|
||
unsigned char pad7;
|
||
unsigned char intVector4;
|
||
unsigned char pad8;
|
||
unsigned char intVector5;
|
||
unsigned char pad9;
|
||
unsigned char intVector6;
|
||
unsigned char pada;
|
||
unsigned char intVector7;
|
||
unsigned char padb[0x10];
|
||
unsigned char padc;
|
||
unsigned char intStatus;
|
||
unsigned char padd;
|
||
unsigned char intEnable;
|
||
unsigned char pade;
|
||
unsigned char intPolarity;
|
||
unsigned char padf;
|
||
unsigned char intTypeSelect;
|
||
unsigned char padg;
|
||
unsigned char intPaternEnable;
|
||
unsigned short inputData;
|
||
unsigned short outputData;
|
||
unsigned char padh[0x332];
|
||
};
|
||
|
||
#define NUM_INT_CHAN 8
|
||
|
||
struct ioCard {
|
||
volatile struct avme9440 *card; /* address of this card's registers */
|
||
int intCnt[8]; /* array to keep track of number of */
|
||
/* interrupt records attached to a channel */
|
||
FAST_LOCK lock; /* semaphore */
|
||
IOSCANPVT ioscanpvt[NUM_INT_CHAN]; /* list or records processed upon interrupt */
|
||
};
|
||
|
||
#define CONST_NUM_LINKS 6
|
||
|
||
STATIC int devAvme9440Report();
|
||
|
||
static unsigned short BASEADD;
|
||
#define LED_INIT 0x02
|
||
#define LED_OKRUN 0x03
|
||
#define LED_OKINTS 0x0B
|
||
|
||
#define INT_LEVEL 5
|
||
static unsigned short INT_VEC_BASE;
|
||
|
||
int int_level = INT_LEVEL;
|
||
|
||
int avme9440_num_links=0;
|
||
|
||
static struct ioCard cards[CONST_NUM_LINKS];
|
||
static int init_flag = 0;
|
||
|
||
/* Create the dset for devBoAvme9440 */
|
||
struct {
|
||
long number;
|
||
DEVSUPFUN report; /* used by dbior */
|
||
DEVSUPFUN init; /* called 1 time before & after all records */
|
||
DEVSUPFUN init_record; /* called 1 time for each record */
|
||
DEVSUPFUN get_ioint_info; /* used for COS processing (not used for outputs)*/
|
||
DEVSUPFUN write_bo; /* output command goes here */
|
||
}devBoAvme9440={
|
||
5,
|
||
(DEVSUPFUN) devAvme9440Report,
|
||
init,
|
||
init_bo_record,
|
||
NULL,
|
||
write_bo
|
||
};
|
||
|
||
/* Create the dset for devBiAvme9440 */
|
||
struct {
|
||
long number;
|
||
DEVSUPFUN report; /* used by dbior */
|
||
DEVSUPFUN init; /* called 1 time before & after all records */
|
||
DEVSUPFUN init_record; /* called 1 time for each record */
|
||
DEVSUPFUN get_ioint_info; /* used for COS processing */
|
||
DEVSUPFUN read_bi; /* input command goes here */
|
||
}devBiAvme9440={
|
||
5,
|
||
NULL,
|
||
NULL,
|
||
init_bi_record,
|
||
get_bi_int_info,
|
||
read_bi
|
||
};
|
||
|
||
/* Create the dset for devMbboAvme9440 */
|
||
struct {
|
||
long number;
|
||
DEVSUPFUN report;
|
||
DEVSUPFUN init;
|
||
DEVSUPFUN init_record;
|
||
DEVSUPFUN get_ioint_info;
|
||
DEVSUPFUN write_mbbo;
|
||
}devMbboAvme9440={
|
||
5,
|
||
NULL,
|
||
NULL,
|
||
init_mbbo_record,
|
||
NULL,
|
||
write_mbbo
|
||
};
|
||
|
||
/* Create the dset for devMbbiAvme9440 */
|
||
struct {
|
||
long number;
|
||
DEVSUPFUN report;
|
||
DEVSUPFUN init;
|
||
DEVSUPFUN init_record;
|
||
DEVSUPFUN get_ioint_info;
|
||
DEVSUPFUN read_mbbi;
|
||
}devMbbiAvme9440={
|
||
5,
|
||
NULL,
|
||
NULL,
|
||
init_mbbi_record,
|
||
NULL,
|
||
read_mbbi
|
||
};
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Ultra groovy and useful reporting function called from 'dbior'.
|
||
*
|
||
**************************************************************************/
|
||
STATIC int devAvme9440Report()
|
||
{
|
||
int LinkNum = 0;
|
||
int CardBase = BASEADD;
|
||
int IntVec = INT_VEC_BASE;
|
||
|
||
while (LinkNum < avme9440_num_links)
|
||
{
|
||
if (cards[LinkNum].card != NULL)
|
||
{
|
||
printf(" Link %02.2d at 0x%4.4X, IRQ 0x%2.2X, input 0x%04.4X, output 0x%04.4X\n",
|
||
LinkNum,
|
||
CardBase,
|
||
IntVec,
|
||
cards[LinkNum].card->inputData,
|
||
cards[LinkNum].card->outputData);
|
||
|
||
}
|
||
LinkNum++;
|
||
CardBase += sizeof(struct avme9440);
|
||
IntVec++;
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Initialization of AVME9440 Binary I/O Card
|
||
*
|
||
***************************************************************************/
|
||
int devAvme9440Config(ncards,a16base,intvecbase)
|
||
int ncards;
|
||
int a16base;
|
||
int intvecbase;
|
||
{
|
||
avme9440_num_links = ncards;
|
||
BASEADD = a16base;
|
||
INT_VEC_BASE = intvecbase;
|
||
init(0);
|
||
}
|
||
|
||
STATIC long
|
||
init(flag)
|
||
int flag;
|
||
{
|
||
int cardNum, chanNum;
|
||
unsigned char probeVal, initVal;
|
||
volatile struct avme9440 *p;
|
||
|
||
if (init_flag != 0)
|
||
return(OK);
|
||
|
||
init_flag = 1;
|
||
|
||
if (sysBusToLocalAdrs(VME_AM_SUP_SHORT_IO, (char *)(int)BASEADD, (char **)&p) == ERROR)
|
||
{
|
||
if (devAvme9440Debug >= 5)
|
||
printf("devAvme9440: can not find short address space\n");
|
||
return(ERROR);
|
||
}
|
||
|
||
/* We end up here 1 time before all records are initialized */
|
||
for (cardNum=0; cardNum < avme9440_num_links; cardNum++)
|
||
{
|
||
if (devAvme9440Debug >= 5)
|
||
printf("devAvme9440: Init card %d\n", cardNum);
|
||
|
||
probeVal = LED_INIT; /* sends init value to LEDs and disables interrupts */
|
||
|
||
if (vxMemProbe((char*) &(p->boardStatus) , WRITE, 1, &probeVal) < OK)
|
||
{
|
||
|
||
if (devAvme9440Debug >= 5)
|
||
printf("devAvme9440: Probe at 0x%08.8X failed\n", &(p->boardStatus));
|
||
cards[cardNum].card = NULL; /* No card found */
|
||
}
|
||
else
|
||
{
|
||
if (devAvme9440Debug >= 5)
|
||
{
|
||
printf("devAvme9440: Probe at 0x%08.8X success, board status = 0x%02.2X\n", &(p->boardStatus), probeVal);
|
||
printf(" Beginning card %d initialization\n", cardNum);
|
||
}
|
||
|
||
probeVal = INT_VEC_BASE + cardNum;
|
||
|
||
for (chanNum=0; chanNum <= 7; chanNum++)
|
||
{
|
||
if ((vxMemProbe(((char*) &(p->intVector0) + (2 * chanNum)) , WRITE, 1, &probeVal) == OK) && (devAvme9440Debug >= 5))
|
||
{
|
||
printf("devAvme9440: Interrupt vector 0x%02.2X being written to channel %d interrupt\n", probeVal, chanNum);
|
||
printf(" vector table entry at address 0x%08.8X\n", (&(p->intVector0) + (2 * chanNum)));
|
||
|
||
cards[cardNum].intCnt[chanNum] = 0; /* clear channel interrupt counter */
|
||
}
|
||
|
||
scanIoInit(&cards[cardNum].ioscanpvt[chanNum]); /* interrupt initialized per channel */
|
||
}
|
||
|
||
probeVal = 0x00;
|
||
|
||
if ((vxMemProbe((char*) &(p->intEnable) , WRITE, 1, &probeVal) == OK) && (devAvme9440Debug >= 5))
|
||
printf("devAvme9440: Interrupts disabled for channels 0 - 7\n");
|
||
|
||
probeVal = 0xFF;
|
||
|
||
if ((vxMemProbe((char*) &(p->intTypeSelect) , WRITE, 1, &probeVal) == OK) && (devAvme9440Debug >= 5))
|
||
{
|
||
printf("devAvme9440: Change of state interrupts set for channels 0 - 7\n");
|
||
printf(" Interrupt level should be set at %d\n", int_level);
|
||
}
|
||
|
||
probeVal = 0x00;
|
||
|
||
if ((vxMemProbe((char*) &(p->intPaternEnable) , WRITE, 1, &probeVal) == OK) && (devAvme9440Debug >= 5))
|
||
printf("devAvme9440: Input pattern detection interrupts disabled for channels 0 - 7\n");
|
||
|
||
probeVal = LED_OKRUN; /* sends init value to LEDs and disables interrupts */
|
||
|
||
if ((vxMemProbe((char*) &(p->boardStatus) , WRITE, 1, &probeVal) == OK) && (devAvme9440Debug >= 5))
|
||
printf("devAvme9440: Card %d initialization complete\n", cardNum);
|
||
|
||
cards[cardNum].card = p; /* Remember address of the board */
|
||
|
||
if(intConnect(INUM_TO_IVEC(INT_VEC_BASE + cardNum),(FUNCPTR)avme9440_isr,
|
||
(int)&cards[cardNum]) != OK)
|
||
printf("devAvme9440: Interrupt connect failed for card %d\n", cardNum);
|
||
|
||
|
||
FASTLOCKINIT(&(cards[cardNum].lock));
|
||
FASTUNLOCK(&(cards[cardNum].lock)); /* Init the board lock */
|
||
}
|
||
p++;
|
||
}
|
||
return(OK);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Interrupt service routine
|
||
*
|
||
**************************************************************************/
|
||
STATIC void avme9440_isr(struct ioCard *pc)
|
||
{
|
||
volatile struct avme9440 *p = pc->card;
|
||
volatile unsigned char intStatusLocal = p->intStatus;
|
||
unsigned int chanNum;
|
||
volatile unsigned char intStatWrite = 0;
|
||
|
||
for (chanNum=0; chanNum <= 7; chanNum++)
|
||
{
|
||
if(intStatusLocal & (1 << chanNum))
|
||
{
|
||
scanIoRequest(pc -> ioscanpvt[chanNum]);
|
||
intStatWrite |= (1 << chanNum);
|
||
}
|
||
}
|
||
|
||
p->intStatus = intStatWrite;
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* BO Initialization (Called one time for each BO AVME9440 card record)
|
||
*
|
||
**************************************************************************/
|
||
STATIC long init_bo_record(pbo)
|
||
struct boRecord *pbo;
|
||
{
|
||
int status = 0;
|
||
unsigned short stupid;
|
||
|
||
/* bo.out must be an VME_IO */
|
||
switch (pbo->out.type) {
|
||
|
||
case (VME_IO) :
|
||
|
||
if (pbo->out.value.vmeio.signal > 15)
|
||
{
|
||
pbo->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal SIGNAL field ->%s<- \n", pbo->name);
|
||
|
||
recGblRecordError(status,(void *)pbo,
|
||
"devAvme9440 (init_record) Illegal SIGNAL field");
|
||
}
|
||
else
|
||
{
|
||
|
||
pbo->mask = 1;
|
||
pbo->mask <<= pbo->out.value.vmeio.signal;
|
||
|
||
if (read_card(pbo->out.value.vmeio.card, pbo->mask, &stupid, OUTPUT_REG) == OK)
|
||
{
|
||
pbo->rbv = pbo->rval = stupid;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record initialized \n", pbo->name);
|
||
}
|
||
|
||
else
|
||
{
|
||
status = 2;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record failed to initialize \n", pbo->name);
|
||
}
|
||
|
||
}
|
||
break;
|
||
|
||
default :
|
||
pbo->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal OUT field ->%s<- \n", pbo->name);
|
||
|
||
recGblRecordError(status,(void *)pbo,
|
||
"devAvme9440 (init_record) Illegal OUT field");
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* BI Initialization (Called one time for each BI AVME9440 card record)
|
||
*
|
||
**************************************************************************/
|
||
STATIC long init_bi_record(pbi)
|
||
struct biRecord *pbi;
|
||
{
|
||
int status = 0;
|
||
unsigned short stupid;
|
||
|
||
switch (pbi->inp.type) {
|
||
case (VME_IO) :
|
||
|
||
if (pbi->inp.value.vmeio.signal > 31)
|
||
{
|
||
pbi->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal SIGNAL field ->%s<- \n", pbi->name);
|
||
|
||
recGblRecordError(status,(void *)pbi,
|
||
"devAvme9440 (init_record) Illegal SIGNAL field");
|
||
|
||
}
|
||
else
|
||
{
|
||
pbi->mask = 1;
|
||
if (pbi->inp.value.vmeio.signal <= 15)
|
||
pbi->mask <<= pbi->inp.value.vmeio.signal;
|
||
else
|
||
pbi->mask <<= pbi->inp.value.vmeio.signal - 16;
|
||
if (read_card(pbi->inp.value.vmeio.card, pbi->mask, &stupid, INPUT_REG) == OK)
|
||
{
|
||
pbi->rval = stupid;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record initialized \n", pbi->name);
|
||
}
|
||
|
||
else
|
||
{
|
||
status = 2;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record failed to initialize \n", pbi->name);
|
||
}
|
||
}
|
||
|
||
break;
|
||
default:
|
||
pbi->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal INP field ->%s<- \n", pbi->name);
|
||
recGblRecordError(status,(void *)pbi,
|
||
"devAvme9440 (init_record) Illegal INP field");
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* MBBO Initialization (Called one time for each MBBO AVME9440 card record)
|
||
*
|
||
**************************************************************************/
|
||
STATIC long init_mbbo_record(pmbbo)
|
||
struct mbboRecord *pmbbo;
|
||
{
|
||
unsigned short stupid;
|
||
struct vmeio *pvmeio;
|
||
int status = 0;
|
||
|
||
/* mbbo.out must be an VME_IO */
|
||
switch (pmbbo->out.type) {
|
||
case (VME_IO) :
|
||
|
||
if (pmbbo->out.value.vmeio.signal > 15)
|
||
{
|
||
pmbbo->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal SIGNAL field ->%s<- \n", pmbbo->name);
|
||
|
||
recGblRecordError(status,(void *)pmbbo,
|
||
"devAvme9440 (init_record) Illegal SIGNAL field");
|
||
}
|
||
else
|
||
{
|
||
|
||
pvmeio = &(pmbbo->out.value.vmeio);
|
||
pmbbo->shft = pvmeio->signal;
|
||
pmbbo->mask <<= pmbbo->shft;
|
||
|
||
if (read_card(pmbbo->out.value.vmeio.card, pmbbo->mask, &stupid, OUTPUT_REG) == OK)
|
||
{
|
||
pmbbo->rbv = pmbbo->rval = stupid;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record initialized \n", pmbbo->name);
|
||
}
|
||
|
||
else
|
||
{
|
||
status = 2;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record failed to initialize \n", pmbbo->name);
|
||
}
|
||
|
||
}
|
||
break;
|
||
|
||
default :
|
||
|
||
pmbbo->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal OUT field ->%s<- \n", pmbbo->name);
|
||
|
||
recGblRecordError(status,(void *)pmbbo,
|
||
"devAvme9440 (init_record) Illegal OUT field");
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* MBBI Initialization (Called one time for each MBBI AVME9440 card record)
|
||
*
|
||
**************************************************************************/
|
||
STATIC long init_mbbi_record(pmbbi)
|
||
struct mbbiRecord *pmbbi;
|
||
{
|
||
int status = 0;
|
||
unsigned short stupid;
|
||
|
||
/* mbbi.inp must be an VME_IO */
|
||
switch (pmbbi->inp.type) {
|
||
case (VME_IO) :
|
||
|
||
if (pmbbi->inp.value.vmeio.signal > 31)
|
||
{
|
||
pmbbi->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal SIGNAL field ->%s<- \n", pmbbi->name);
|
||
|
||
recGblRecordError(status,(void *)pmbbi,
|
||
"devAvme9440 (init_record) Illegal SIGNAL field");
|
||
|
||
}
|
||
else
|
||
{
|
||
if (pmbbi->inp.value.vmeio.signal <= 15)
|
||
pmbbi->shft = pmbbi->inp.value.vmeio.signal;
|
||
else
|
||
pmbbi->shft = pmbbi->inp.value.vmeio.signal - 16;
|
||
pmbbi->mask <<= pmbbi->shft;
|
||
if (read_card(pmbbi->inp.value.vmeio.card, pmbbi->mask, &stupid, INPUT_REG) == OK)
|
||
{
|
||
pmbbi->rval = stupid;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record initialized \n", pmbbi->name);
|
||
}
|
||
else
|
||
{
|
||
status = 2;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: ->%s<- Record failed to initialize \n", pmbbi->name);
|
||
}
|
||
}
|
||
|
||
break;
|
||
|
||
default :
|
||
pmbbi->pact = 1; /* make sure we don't process this thing */
|
||
status = S_db_badField;
|
||
if (devAvme9440Debug >= 10)
|
||
printf("devAvme9440: Illegal INP field ->%s<- \n", pmbbi->name);
|
||
recGblRecordError(status,(void *)pmbbi,
|
||
"devAvme9440 (init_record) Illegal INP field");
|
||
return(status);
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Perform a write operation from a BO record
|
||
*
|
||
**************************************************************************/
|
||
STATIC long write_bo(pbo)
|
||
struct boRecord *pbo;
|
||
{
|
||
|
||
unsigned short stupid;
|
||
|
||
if (write_card(pbo->out.value.vmeio.card, pbo->mask, pbo->rval) == OK)
|
||
{
|
||
if(read_card(pbo->out.value.vmeio.card, pbo->mask, &stupid, OUTPUT_REG) == OK)
|
||
{
|
||
pbo->rbv = stupid;
|
||
return(0);
|
||
}
|
||
}
|
||
|
||
/* Set an alarm for the record */
|
||
recGblSetSevr(pbo, WRITE_ALARM, INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Perform a read operation from a BI record
|
||
*
|
||
**************************************************************************/
|
||
STATIC long read_bi(pbi)
|
||
struct biRecord *pbi;
|
||
{
|
||
|
||
unsigned short stupid;
|
||
unsigned int reg;
|
||
|
||
if (pbi->inp.value.vmeio.signal <= 15)
|
||
reg = INPUT_REG;
|
||
else
|
||
reg = OUTPUT_REG;
|
||
|
||
if (read_card(pbi->inp.value.vmeio.card, pbi->mask, &stupid, reg) == OK)
|
||
{
|
||
pbi->rval = stupid;
|
||
return(0);
|
||
}
|
||
|
||
/* Set an alarm for the record */
|
||
recGblSetSevr(pbi, READ_ALARM, INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Perform a write operation from a MBBO record
|
||
*
|
||
**************************************************************************/
|
||
STATIC long write_mbbo(pmbbo)
|
||
struct mbboRecord *pmbbo;
|
||
{
|
||
|
||
unsigned short stupid;
|
||
|
||
if (write_mbbo_card(pmbbo->out.value.vmeio.card, pmbbo->mask, pmbbo->rval) == OK)
|
||
{
|
||
if(read_card(pmbbo->out.value.vmeio.card, pmbbo->mask, &stupid, OUTPUT_REG) == OK)
|
||
{
|
||
pmbbo->rbv = stupid;
|
||
return(0);
|
||
}
|
||
}
|
||
|
||
/* Set an alarm for the record */
|
||
recGblSetSevr(pmbbo, WRITE_ALARM, INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Perform a read operation from a MBBI record
|
||
*
|
||
**************************************************************************/
|
||
STATIC long read_mbbi(pmbbi)
|
||
struct mbbiRecord *pmbbi;
|
||
{
|
||
|
||
unsigned short stupid;
|
||
unsigned int reg;
|
||
|
||
if (pmbbi->inp.value.vmeio.signal <= 15)
|
||
reg = INPUT_REG;
|
||
else
|
||
reg = OUTPUT_REG;
|
||
|
||
if (read_card(pmbbi->inp.value.vmeio.card, pmbbi->mask, &stupid, reg) == OK)
|
||
{
|
||
pmbbi->rval = stupid;
|
||
return(0);
|
||
}
|
||
/* Set an alarm for the record */
|
||
recGblSetSevr(pmbbi, READ_ALARM, INVALID_ALARM);
|
||
return(2);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Raw read a bitfield from the card
|
||
*
|
||
**************************************************************************/
|
||
STATIC long read_card(card, mask, value, reg)
|
||
short card; /* Link number from DCT */
|
||
unsigned long mask; /* created in init_bo_record() */
|
||
unsigned short *value; /* the value to return from the card */
|
||
int reg;
|
||
{
|
||
if (checkLink(card) == ERROR)
|
||
return(ERROR);
|
||
|
||
if (reg == INPUT_REG)
|
||
*value = cards[card].card->inputData & mask;
|
||
else
|
||
*value = cards[card].card->outputData & mask;
|
||
|
||
if (devAvme9440Debug >= 20)
|
||
printf("devAvme9440: read 0x%04.4X from card %d\n", *value, card);
|
||
|
||
return(OK);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Raw write a bitfield to the card
|
||
*
|
||
**************************************************************************/
|
||
STATIC long write_card(card, mask, value)
|
||
short card;
|
||
unsigned long mask;
|
||
unsigned long value;
|
||
{
|
||
if (checkLink(card) == ERROR)
|
||
return(ERROR);
|
||
|
||
FASTLOCK(&(cards[card].lock));
|
||
cards[card].card->outputData = (cards[card].card->outputData & ~mask) | value;
|
||
FASTUNLOCK(&(cards[card].lock));
|
||
|
||
if (devAvme9440Debug >= 15)
|
||
printf("devAvme9440: wrote 0x%04.4X to card %d\n", cards[card].card->outputData, card);
|
||
|
||
return(0);
|
||
}
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Raw write a bitfield to the card for MBBO records
|
||
*
|
||
**************************************************************************/
|
||
STATIC long write_mbbo_card(card, mask, value)
|
||
short card;
|
||
unsigned long mask;
|
||
unsigned long value;
|
||
{
|
||
if (checkLink(card) == ERROR)
|
||
return(ERROR);
|
||
|
||
FASTLOCK(&(cards[card].lock));
|
||
cards[card].card->outputData = ((cards[card].card->outputData & ~mask) | (value & mask));
|
||
FASTUNLOCK(&(cards[card].lock));
|
||
|
||
if (devAvme9440Debug >= 15)
|
||
printf("devAvme9440: wrote 0x%04.4X to card %d\n", cards[card].card->outputData, card);
|
||
|
||
return(0);
|
||
}
|
||
|
||
|
||
/**************************************************************************
|
||
*
|
||
* Make sure card number is valid
|
||
*
|
||
**************************************************************************/
|
||
STATIC int checkLink(card)
|
||
short card;
|
||
{
|
||
if (card >= avme9440_num_links)
|
||
return(ERROR);
|
||
if (cards[card].card == NULL)
|
||
return(ERROR);
|
||
|
||
return(OK);
|
||
}
|
||
|
||
#define ADDING 0
|
||
#define DELETING 1
|
||
/**************************************************************************
|
||
*
|
||
* BI record interrupt routine
|
||
*
|
||
**************************************************************************/
|
||
STATIC long get_bi_int_info(cmd, pbi, ppvt)
|
||
int cmd;
|
||
struct biRecord *pbi;
|
||
IOSCANPVT *ppvt;
|
||
{
|
||
|
||
struct vmeio *pvmeio = (struct vmeio *)(&pbi->inp.value);
|
||
volatile struct avme9440 *pc = cards[pvmeio->card].card;
|
||
unsigned int card;
|
||
|
||
*ppvt = cards[pvmeio->card].ioscanpvt[pvmeio->signal];
|
||
|
||
if (cmd == ADDING) /* enable interrupts */
|
||
{
|
||
sysIntEnable(int_level);
|
||
|
||
pc->boardStatus = LED_OKINTS; /* Initialize global board interrupts */
|
||
|
||
pc->intEnable |= (1 << pvmeio->signal); /* Initialize individual channel interrupts */
|
||
|
||
cards[pvmeio->card].intCnt[pvmeio->signal]++;
|
||
|
||
}
|
||
else
|
||
if(!(--(cards[pvmeio->card].intCnt[pvmeio->signal])))
|
||
pc->intEnable &= ~(1 << pvmeio->signal); /* Disable individual channel interrupts */
|
||
|
||
return(0);
|
||
}
|
||
|