Added analog input support for temperature

could be updated to NOT cause an extra sample from port zero to be taken
at the end of the sequence.  As it turns out, it causes more harm than
good.  There must be something wrong with my understanding on how it works.
For now, the misfeature of the extra sample at the end of the sequence will
have to stay.

src/db/dbScan.c

@@ -486,7 +486,7 @@ got_record:
 		recGblDbaddrError(status,&dbAddr,"initPeriodic");
 		exit(1);
 	}
-	papPeriodic = dbCalloc(nPeriodic,sizeof(struct scan_list));
+	papPeriodic = dbCalloc(nPeriodic,sizeof(struct scan_list*));
 	periodicTaskId = dbCalloc(nPeriodic,sizeof(int));
 	for(i=0; i<nPeriodic; i++) {
 		psl = dbCalloc(1,sizeof(struct scan_list));

src/db/dbTest.c

@@ -813,6 +813,7 @@ int dbhcr(void)
 	return(0);
     }
     dbReportDeviceConfig(pdbBase,stdout);
+    fflush(stdout);
     return(0);
 }
 

src/db/drvTS.c

@@ -1,6 +1,10 @@
 
 /*
  * $Log$
+ * Revision 1.4  1994/10/28  20:15:10  jbk
+ * increased the USP packet time-out to 250ms, added a parm to the configure()
+ * routine to let user specify it.
+ *
  */
 
 /**************************************************************************
@@ -653,7 +657,23 @@ static void TSerrorHandler(int Card, int ErrorNum)
 		Could put the slave on the vxworks timer until next sync
 	*/
 
-	logMsg("***TSerrorHandler: error number %d=n",ErrorNum,0,0,0,0,0);
+	if(MAKE_DEBUG)
+	{
+		switch(ErrorNum)
+		{
+		case 1:
+		  logMsg("***TSerrorHandler: event system error: TAXI violation",0,0,0,0,0,0);
+		  break;
+		case 2:
+		  logMsg("***TSerrorHandler: event system error: lost heartbeat",0,0,0,0,0,0);
+		  break;
+		case 3:
+		  logMsg("***TSerrorHandler: event system error: lost events",0,0,0,0,0,0);
+		  break;
+		default:
+			logMsg("***TSerrorHandler: unknown error %d from event system", ErrorNum,0,0,0,0,0);
+		}
+	}
 	return;
 }
 

src/db/iocInit.c

@@ -772,9 +772,10 @@ static long initDatabase(void)
                             *    Severity/No Maximize Severity(MS/NMS), and output NMS
                             *    links ... The following code checks for this.
                             */
-                            if (plink->value.db_link.process_passive
+                            if (errVerbose &&
+				(plink->value.db_link.process_passive
                                 || (pfldDes->field_type == DBF_OUTLINK
-                                    && plink->value.db_link.maximize_sevr))
+                                    && plink->value.db_link.maximize_sevr)))
                             {
                                /*
                                 * Link PP and/or Outlink MS ...
@@ -789,7 +790,7 @@ static long initDatabase(void)
                                 strcat(message," PP and/or MS illegal");
                                 status = S_db_badField;
                                 errMessage(status,message);
-                                if(rtnval==OK) rtnval=status;
+				status = 0;
                             }
 			}
 		    }

src/dev/devApsEr.c

@@ -774,6 +774,9 @@ STATIC int ErResetAll(ApsErStruct *pParm)
  *
  * Receive a hardware IRQ from an ER board.
  *
+ * BUG -- should add errMessage calls for problem events & include storm
+ *        control on them.
+ *
  ******************************************************************************/
 STATIC void ErIrqHandler(ErLinkStruct *pLink)
 {

src/dev/devBoSoftRaw.c

@@ -77,10 +77,7 @@ struct boRecord *pbo;
     long status;
  
     status = recGblInitFastOutLink(&(pbo->out), (void *) pbo, DBR_LONG, "RVAL");
-
-    if (pbo->out.type != CA_LINK)
-        status = 2;
- 
+    status = 2;
     return status;
  
 } /* end init_record() */

src/dev/devCommonGpib.c

@@ -2,6 +2,8 @@
 /* base/src/dev $Id$ */
 
 /*
+ * $Log$
+ *
  *      Author: 		John Winans
  *      Origional Author:	Ned D. Arnold
  *      Date:   		11-20-91

src/dev/devMbboDirectXVme220.c

@@ -81,7 +81,7 @@ static long init_record(pmbbo)
     case (VME_IO) :
 	pvmeio = &(pmbbo->out.value.vmeio);
 	pmbbo->shft = pvmeio->signal;
-	pmbbo->mask = pmbbo->shft;
+	pmbbo->mask <<= pmbbo->shft;
 	status = xy220_read(pvmeio->card,pmbbo->mask,&value);
 	if(status==0) pmbbo->rbv = pmbbo->rval = value;
 	else status = 2;

src/dev/devMbboSoftRaw.c

@@ -77,10 +77,7 @@ struct mbboRecord *pmbbo;
     long status;
  
     status = recGblInitFastOutLink(&(pmbbo->out), (void *) pmbbo, DBR_ULONG, "RVAL");
-
-    if (pmbbo->out.type == CA_LINK)
-       status = 2;
- 
+    status = 2;
     return status;
  
 } /* end init_record() */

src/dev/devMbboXVme220.c

@@ -83,7 +83,7 @@ static long init_record(pmbbo)
     case (VME_IO) :
 	pvmeio = &(pmbbo->out.value.vmeio);
 	pmbbo->shft = pvmeio->signal;
-	pmbbo->mask = pmbbo->shft;
+	pmbbo->mask <<= pmbbo->shft;
 	status = xy220_read(pvmeio->card,pmbbo->mask,&value);
 	if(status==0) pmbbo->rbv = pmbbo->rval = value;
 	else status = 2;

src/dev/devSysmon.c

@@ -59,6 +59,15 @@
  *      ...
  *
  * $Log$
+ * Revision 1.7  1995/01/09  20:28:42  winans
+ * Added AI support for temperature input
+ *
+ * Revision 1.6  1995/01/06  16:55:04  winans
+ * enabled irq services and rearranged the parm names and meanings.
+ *
+ * Revision 1.5  1994/12/07  15:11:13  winans
+ * Fixed array index for temerature reading.
+ *
  * Revision 1.4  1994/11/30  15:10:23  winans
  * Added IRQ mode stuff
  *
@@ -81,27 +90,29 @@
 #include	<alarm.h>
 #include	<dbDefs.h>
 #include	<dbAccess.h>
-#include        <recSup.h>
+#include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
 #include	<fast_lock.h>
 
-#include        <boRecord.h>
-#include        <biRecord.h>
-#include        <mbboRecord.h>
-#include        <mbbiRecord.h>
+#include	<aiRecord.h>
+#include	<boRecord.h>
+#include	<biRecord.h>
+#include	<mbboRecord.h>
+#include	<mbbiRecord.h>
 
-#include        <dbScan.h>
-#include        <errMdef.h>
-#include        <eventRecord.h>
+#include	<dbScan.h>
+#include	<errMdef.h>
+#include	<eventRecord.h>
 
 
 #define		NUM_LINKS	1	/* max number of allowed sysmon cards */
-#define         STATIC
+#define		STATIC
 
 int SysmonConfig();
 STATIC long SysmonInit();
 STATIC long SysmonReport();
+STATIC long SysmonInitAiRec(), SysmonReadAi();
 STATIC long SysmonInitBoRec(), SysmonInitBiRec();
 STATIC long SysmonInitMbboRec(), SysmonInitMbbiRec();
 STATIC long SysmonWriteBo(), SysmonReadBi();
@@ -123,39 +134,62 @@ int  devSysmonDebug = 0;
 typedef struct ParmTableStruct 
 {
     char *parm_name;
-    int  index;
 } ParmTableStruct;
 
 #define SYSMON_PARM_STATUS	0
-#define SYSMON_PARM_DIO		1
+#define SYSMON_PARM_DI		1
 #define SYSMON_PARM_TEMP	2
-#define SYSMON_PARM_WATCHDOG	3
+#define SYSMON_PARM_BOOTWATCHDOG 3
+#define SYSMON_PARM_DO		4
+
+#define	SYSMON_PARM_LED		5
+
+#define	SYSMON_PARM_RXWATCHDOG	6
+#define	SYSMON_PARM_RXTEMP	7
+#define	SYSMON_PARM_RXSTAT	8
+#define	SYSMON_PARM_RXRUN	9
+#define	SYSMON_PARM_RX12V	10
+#define	SYSMON_PARM_RX5V	11
+#define	SYSMON_PARM_RXFAIL	12
+
+#define	SYSMON_PARM_TXWATCHDOG	13
+#define	SYSMON_PARM_TXTEMP	14
+#define	SYSMON_PARM_TXSTAT	15
+#define	SYSMON_PARM_TXRUN	16
+#define	SYSMON_PARM_TX12V	17
+#define	SYSMON_PARM_TX5V	18
+#define	SYSMON_PARM_TXFAIL	19
 
 static ParmTableStruct ParmTable[]=
 {
-  {"StatusLink", SYSMON_PARM_STATUS},
-  {"Dio", SYSMON_PARM_DIO},
-  {"Temperature", SYSMON_PARM_TEMP},
-  {"Watchdog", SYSMON_PARM_WATCHDOG},
+  {"StatusLink"},
+  {"Di"},
+  {"Temperature"},
+  {"BootWatchdog"},
+  {"Do"},
 
-#if 0		/* This crap is pointless -- JRW */
+  {"Led"},
 
-  {"IntMask", 2},
-  {"VXIVector", 5},
-  {"IntVector", 6},
-  {"IRQ1", 7},
-  {"IRQ2", 8},
-  {"IRQ3", 9},
-  {"IRQ4", 10},
-  {"IRQ5", 11},
-  {"IRQ6", 12},
-  {"IRQ7", 13}
-#endif
+  {"RxWatchdog"},
+  {"RxTemp"},
+  {"RxStat"},
+  {"RxRun"},
+  {"Rx12v"},
+  {"Rx5v"},
+  {"RxFail"},
+
+  {"TxWatchdog"},
+  {"TxTemp"},
+  {"TxStat"},
+  {"TxRun"},
+  {"Tx12v"},
+  {"Tx5v"},
+  {"TxFail"}
 };
 #define	PARM_TABLE_SIZE	(sizeof(ParmTable)/sizeof(ParmTable[0]))
 
 /*** SysMonStatusLink   Rx, Tx ***/
-/*** SysmonDio          output, input ***/
+/*** SysmonDio          output, input *** 0-7=out, 8-15=in***/
 /*** SysmonIntMask      interrupt mask ***/
 /*** SysmonTemperature  temperature monitor ***/
 /*** SysmonWatchdog     watchdog & 4 status LEDs ***/
@@ -194,8 +228,9 @@ typedef struct SysmonStruct {
  *****************************************************************************/
 typedef struct PvtStruct 
 {
-    int index;
-    unsigned short mask;
+	int		index;	/* Parameter/operation type */
+	volatile unsigned short	*pReg;	/* Pointer to actual register */
+	unsigned short	mask;	/* value mask derived from signal number */
 } PvtStruct;
 
 /*****************************************************************************
@@ -215,8 +250,6 @@ struct ioCard {			/* structure maintained for each card */
     int		IrqInfo[2];
 };
 
-
-
 #define         INITLEDS        0x01
 
 static struct ioCard cards[NUM_LINKS];        /* card information structure */
@@ -231,6 +264,26 @@ struct dset_sysmon {
 };
 typedef struct dset_sysmon DSET_SYSMON;
 
+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_write;	/* output command goes here */
+	DEVSUPFUN	dumb_lincov_thing;
+}
+devAiSysmon=
+{
+	6,
+	NULL,
+	SysmonInit,
+	SysmonInitAiRec,
+	NULL,
+	SysmonReadAi,
+	NULL
+};
+
 DSET_SYSMON devBoSysmon={
 	5,
 	NULL,
@@ -269,7 +322,6 @@ DSET_SYSMON devMbbiSysmon={
         NULL,
         SysmonReadMbbi
 };
-
 
 STATIC long SysmonReport(void)
 {
@@ -300,7 +352,7 @@ int SysmonConfig(
   if ((Card < 0) || (Card >= NUM_LINKS))
   {
     printf("ERROR: Invalid card number specified %d\n", Card);
-    return(-1);
+    return(0);
   }
 
   cards[Card].CardValid = 0;
@@ -314,7 +366,7 @@ int SysmonConfig(
   if ((VMEintVector < 64) || (VMEintVector > 255))
   {
     printf("devSysmon: ERROR VME IRQ vector out of range\n");
-    return(-1);
+    return(0);
   }
   if (devSysmonDebug >= 5)
     printf("devSysmon: SysmonInit VME int vector = 0x%2.2X\n", VMEintVector);
@@ -322,7 +374,7 @@ int SysmonConfig(
   if ((VMEintLevel < 0) || (VMEintLevel > 7))
   {
     printf("devSysmon: ERROR VME IRQ level out of range\n");
-    return(-1);
+    return(0);
   }
   if (devSysmonDebug >= 5)
     printf("devSysmon: SysmonInit VME int level = %d\n", VMEintLevel);
@@ -330,7 +382,7 @@ int SysmonConfig(
   if ((VXIintVector < 64) || (VXIintVector > 255))
   {
     printf("devSysmon: ERROR VXI IRQ vector out of range\n");
-    return(-1);
+    return(0);
   }
   if (devSysmonDebug >= 5)
     printf("devSysmon: SysmonInit VXI int vector = 0x%2.2X\n", VXIintVector);
@@ -338,7 +390,7 @@ int SysmonConfig(
   if ((SysmonBaseA16 > 0xffff) || (SysmonBaseA16 & 0x003f))
   {
     printf("devSysmon: ERROR Invalid address specified 0x4.4X\n", SysmonBaseA16);
-    return(-1);
+    return(0);
   }
   if (devSysmonDebug >= 5)
     printf("devSysmon: SysmonInit VME (VXI) base address = %p\n", SysmonBaseA16);
@@ -390,25 +442,25 @@ STATIC long SysmonInit(int flag)
     if (cards[Card].CardValid != 0)
     {
       if (devSysmonDebug >= 5)
-	  printf("devSysmon: init link %d\n", Card);
+	  logMsg("devSysmon: init link %d\n", Card);
 
       if (sysBusToLocalAdrs(VME_AM_SUP_SHORT_IO, (char *)cards[Card].SysmonBaseA16, (char **)&(cards[Card].SysmonBase)) == ERROR)
       {
         if (devSysmonDebug >= 5)
-           printf("devSysmon: can not find short address space\n");
+           logMsg("devSysmon: can not find short address space\n");
         return(ERROR);	/* BUG */
       }
 
       probeVal = INITLEDS;
 
       if (devSysmonDebug >= 5)
-	  printf("devSysmon: init SysmonWatchdog 0x%X\n", (char *)&cards[Card].SysmonBase->SysmonWatchdog);
+	  logMsg("devSysmon: init SysmonWatchdog 0x%X\n", (char *)&cards[Card].SysmonBase->SysmonWatchdog);
 
       if (vxMemProbe((char *)&cards[Card].SysmonBase->SysmonWatchdog, WRITE, sizeof(cards[Card].SysmonBase->SysmonWatchdog), (char *)&probeVal) != OK)
       {
 	  cards[Card].CardValid = 0;		/* No card found */
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init vxMemProbe FAILED\n");
+	      logMsg("devSysmon: init vxMemProbe FAILED\n");
       }
       else
       {
@@ -418,33 +470,33 @@ STATIC long SysmonInit(int flag)
 	  /* FASTUNLOCK(&(cards[Card].lock));	/* Init the board lock */
 
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init address\n");
+	      logMsg("devSysmon: init address\n");
 
 	  scanIoInit(&cards[Card].ioscanpvt);  /* interrupt initialized */
 
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init ScanIoInit \n");
+	      logMsg("devSysmon: init ScanIoInit \n");
 
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init address of System Monitor %8.8x \n", cards[Card].SysmonBase);
+	      logMsg("devSysmon: init address of System Monitor %8.8x \n", cards[Card].SysmonBase);
 	  
 	  cards[Card].SysmonBase->SysmonIntVector = cards[Card].VMEintVector;
 
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init Interrupt vector loaded \n");
+	      logMsg("devSysmon: init Interrupt vector loaded \n");
 
 	  if(intConnect(INUM_TO_IVEC(cards[Card].VMEintVector),(FUNCPTR)SysmonIsr, Card)!=OK)
 	  {
-	      printf("devSysmon (init) intConnect failed \n");
+	      logMsg("devSysmon (init) intConnect failed \n");
 	      return(ERROR);
 
 	      if (devSysmonDebug >= 5)
-		  printf("devSysmon: init intConnect\n");
+		  logMsg("devSysmon: init intConnect\n");
 
 	      }
 
 	  if (devSysmonDebug >= 5)
-	      printf("devSysmon: init vxMemProbe OK\n");
+	      logMsg("devSysmon: init vxMemProbe OK\n");
 
       }
       sysIntEnable(cards[Card].VMEintLevel);
@@ -471,12 +523,12 @@ static long generic_init_record(struct dbCommon *pr, DBLINK *link)
     }
 
     /* make sure that signal is valid */
-    if ((pvmeio->signal > 15) || (pvmeio->signal < 0))
+    if ((pvmeio->signal > 7) || (pvmeio->signal < 0))
     {
 	pr->pact = 1;          /* make sure we don't process this thing */
 
 	if (devSysmonDebug >= 10)
-	    printf("devSysmon: Illegal SIGNAL field ->%s<- \n", pr->name);
+	    logMsg("devSysmon: Illegal SIGNAL field ->%s<- \n", pr->name);
 
 	recGblRecordError(S_dev_badSignal,(void *)pr,
 			  "devSysmon (init_record) Illegal SIGNAL field");
@@ -490,9 +542,9 @@ static long generic_init_record(struct dbCommon *pr, DBLINK *link)
 
 	if (devSysmonDebug >= 10)
 	{
-	    printf("devSysmon: Illegal CARD field ->%s, %d<- \n", pr->name, pvmeio->card);
+	    logMsg("devSysmon: Illegal CARD field ->%s, %d<- \n", pr->name, pvmeio->card);
 	    if(!cards[pvmeio->card].CardValid)
-		printf("devSysmon: Illegal CARD field card NOT VALID \n\n");
+		logMsg("devSysmon: Illegal CARD field card NOT VALID \n\n");
 	}
 
 	recGblRecordError(S_dev_badCard,(void *)pr,
@@ -505,17 +557,15 @@ static long generic_init_record(struct dbCommon *pr, DBLINK *link)
 
     if (j >= PARM_TABLE_SIZE)
     {
-	pr->pact = 1;          /* make sure we don't process this thing */
-	
 	if (devSysmonDebug >= 10)
-	    printf("devSysmon: Illegal parm field ->%s<- \n", pr->name);
+	    logMsg("devSysmon: Illegal parm field ->%s<- \n", pr->name);
 
 	recGblRecordError(S_dev_badSignal,(void *)pr,
 			  "devSysmon (init_record) Illegal parm field");
 	return(S_dev_badSignal);
     }
     if (devSysmonDebug >= 10)
-	printf("devSysmon: %s of record type %d - %s\n", pr->name, j, ParmTable[j].parm_name);
+	logMsg("devSysmon: %s of record type %d - %s\n", pr->name, j, ParmTable[j].parm_name);
 
     pvt = (PvtStruct *) malloc(sizeof(PvtStruct));
     pvt->index = j;
@@ -524,7 +574,75 @@ static long generic_init_record(struct dbCommon *pr, DBLINK *link)
     
     return(0);
 }
+
+/***************************************************************************
+ *
+ ***************************************************************************/
+STATIC long SysmonInitAiRec(struct aiRecord *pRecord)
+{
+	struct vmeio*	pvmeio = (struct vmeio*)&(pRecord->inp.value);
+	int 			status = 0;
+	PvtStruct		*pvt;
 
+	status = generic_init_record((struct dbCommon *)pRecord, &pRecord->inp);
+	if(status)
+	{
+		pRecord->dpvt = NULL;
+		return(status);
+	}
+
+	pvt = (PvtStruct *)(pRecord->dpvt);
+
+	if (pvt->index != SYSMON_PARM_TEMP)
+	{
+		pRecord->dpvt = NULL;
+		if (devSysmonDebug >= 10)
+			logMsg("devSysmon: Illegal parm field ->%s<- \n", pvmeio->parm);
+
+		recGblRecordError(S_dev_badSignal,(void *)pRecord, "devSysmon (init_record) Illegal parm field");
+		return(S_dev_badSignal);
+	}
+	return(0);
+}
+
+/***************************************************************************
+ *
+ ***************************************************************************/
+STATIC long SysmonReadAi(struct aiRecord *pRecord)
+{
+    struct			vmeio *pvmeio = (struct vmeio*)&(pRecord->inp.value);
+    unsigned short	regVal;
+    PvtStruct		*pvt = (PvtStruct *)pRecord->dpvt;
+
+    if (pvt == NULL)
+		return(0);
+
+    FASTLOCK(&cards[pvmeio->card].lock);
+
+    regVal = cards[pvmeio->card].SysmonBase->SysmonTemperature & 0xff;
+
+    FASTUNLOCK(&cards[pvmeio->card].lock);
+
+	if (devSysmonDebug)
+		printf("Sysmon AI temperature raw value %d\n", regVal);
+    
+    switch(regVal)
+	{
+	case 0xfe: pRecord->val = 20; break;
+	case 0xfc: pRecord->val = 25; break;
+	case 0xf8: pRecord->val = 30; break;
+	case 0xf0: pRecord->val = 35; break;
+	case 0xe0: pRecord->val = 40; break;
+	case 0xc0: pRecord->val = 45; break;
+	case 0x80: pRecord->val = 50; break;
+	case 0x00: pRecord->val = 55; break;
+	default:
+		devGpibLib_setPvSevr(pRecord,MAJOR_ALARM,INVALID_ALARM);
+		return(0);
+	}
+    pRecord->udf = FALSE;
+    return(2);		/* Don't do a conversion */
+}
 
 /**************************************************************************
  *
@@ -535,14 +653,55 @@ STATIC long SysmonInitBoRec(struct boRecord *pbo)
 {
     struct vmeio* pvmeio = (struct vmeio*)&(pbo->out.value);
     int status = 0;
+    PvtStruct	*pvt;
 
     status = generic_init_record((struct dbCommon *)pbo, &pbo->out);
 
     if(status)
+    {
+        pbo->dpvt = NULL;
 	return(status);
+    }
 
-    ((PvtStruct *)(pbo->dpvt))->mask = 1<<pvmeio->signal;
+    pvt = (PvtStruct *)pbo->dpvt;
 
+    switch (pvt->index)
+    {
+    case SYSMON_PARM_DO:
+    	pvt->mask = 1<<pvmeio->signal;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonDio);
+	break;
+
+    case SYSMON_PARM_LED:
+	if (pvmeio->signal > 3)
+	{
+	    recGblRecordError(S_dev_badSignal,(void *)pbo,
+		"devSysmon (init_record) Illegal signal value (0-3 for LED)");
+	    return(S_dev_badSignal);
+	}
+    	pvt->mask = 1<<pvmeio->signal;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonWatchdog);
+	break;
+
+    case SYSMON_PARM_BOOTWATCHDOG:
+	pvt->mask = 1<<7;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonWatchdog);
+	break;
+
+#if 0
+    case SYSMON_PARM_DI:
+    	pvt->mask = 1<< (pvmeio->signal + 8);
+	break;
+#endif
+    default:
+	pbo->dpvt = NULL;
+	if (devSysmonDebug >= 10)
+	    logMsg("devSysmon: Illegal parm field ->%s<- \n", pvmeio->parm);
+
+	recGblRecordError(S_dev_badSignal,(void *)pbo,
+			  "devSysmon (init_record) Illegal parm field");
+	return(S_dev_badSignal);
+    }
     return (0);
 }
 
@@ -554,18 +713,132 @@ STATIC long SysmonInitBoRec(struct boRecord *pbo)
 STATIC long SysmonInitBiRec(struct biRecord *pbi)
 {
     struct vmeio* pvmeio = (struct vmeio*)&(pbi->inp.value);
+    PvtStruct   *pvt;
     int status = 0;
-    
+    int	signal;
+
     status = generic_init_record((struct dbCommon *)pbi, &pbi->inp);
 
     if(status)
+    {
+        pbi->dpvt = NULL;
 	return(status);
+    }
 
-    ((PvtStruct *)(pbi->dpvt))->mask = 1<<pvmeio->signal;
+    pvt = (PvtStruct *)pbi->dpvt;
+    switch (pvt->index)
+    {
+    case SYSMON_PARM_DO:
+    	pvt->mask = 1 << pvmeio->signal;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonDio);
+	break;
+
+    case SYSMON_PARM_DI:
+    	pvt->mask = 1<< (pvmeio->signal + 8);
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonDio);
+	break;
+
+    case SYSMON_PARM_LED:
+	if (pvmeio->signal > 3)
+	{
+	    recGblRecordError(S_dev_badSignal,(void *)pbi,
+		"devSysmon (init_record) Illegal signal value (0-3 for LED)");
+	    return(S_dev_badSignal);
+	}
+    	pvt->mask = 1<<pvmeio->signal;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonWatchdog);
+	break;
+
+    case SYSMON_PARM_BOOTWATCHDOG:
+	pvt->mask = 1<<7;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonWatchdog);
+	break;
+
+    case SYSMON_PARM_RXWATCHDOG:
+	pvt->mask = 1<<0;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RXTEMP:
+	pvt->mask = 1<<1;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RXSTAT:
+	pvt->mask = 1<<2;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RXRUN:
+	pvt->mask = 1<<3;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RX12V:
+	pvt->mask = 1<<4;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RX5V:
+	pvt->mask = 1<<5;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_RXFAIL:
+	pvt->mask = 1<<6;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+
+    case SYSMON_PARM_TXWATCHDOG:
+	pvt->mask = 1<<8;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TXTEMP:
+	pvt->mask = 1<<9;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TXSTAT:
+	pvt->mask = 1<<10;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TXRUN:
+	pvt->mask = 1<<11;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TX12V:
+	pvt->mask = 1<<12;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TX5V:
+	pvt->mask = 1<<13;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    case SYSMON_PARM_TXFAIL:
+	pvt->mask = 1<<14;
+	pvt->pReg = &(cards[pvmeio->card].SysmonBase->SysmonStatusLink);
+	break;
+
+    default:
+	pbi->dpvt = NULL;
+	if (devSysmonDebug >= 10)
+	    logMsg("devSysmon: Illegal parm field ->%s<- \n", pvmeio->parm);
+
+	recGblRecordError(S_dev_badSignal,(void *)pbi,
+			  "devSysmon (init_record) Illegal parm field");
+	return(S_dev_badSignal);
+    }
 
     return (0);
 }
 
+#if 1 /* This looks completely insane JRW */
 
 /**************************************************************************
  *
@@ -575,12 +848,28 @@ STATIC long SysmonInitBiRec(struct biRecord *pbi)
 STATIC long SysmonInitMbboRec(struct mbboRecord *pmbbo)
 {
     struct vmeio* pvmeio = (struct vmeio*)&(pmbbo->out.value);
+    PvtStruct   *pvt;
     int status = 0;
     
     status = generic_init_record((struct dbCommon *)pmbbo, &pmbbo->out);
 
     if(status)
+    {
+        pmbbo->dpvt = NULL;
 	return(status);
+    }
+    pvt = (PvtStruct *)pmbbo->dpvt;
+
+    if (pvt->index != SYSMON_PARM_TEMP)
+    {
+	pmbbo->dpvt = NULL;
+        if (devSysmonDebug >= 10)
+            logMsg("devSysmon: Illegal parm field ->%s<- \n", pvmeio->parm);
+
+        recGblRecordError(S_dev_badSignal,(void *)pmbbo,
+                          "devSysmon (init_record) Illegal parm field");
+        return(S_dev_badSignal);
+    }
 
     pmbbo->shft = pvmeio->signal;
     pmbbo->mask <<= pmbbo->shft;
@@ -588,6 +877,7 @@ STATIC long SysmonInitMbboRec(struct mbboRecord *pmbbo)
     return(0);
 
 }
+#endif
 
 /**************************************************************************
  *
@@ -598,16 +888,35 @@ STATIC long SysmonInitMbboRec(struct mbboRecord *pmbbo)
 STATIC long SysmonInitMbbiRec(struct mbbiRecord *pmbbi)
 {
     struct vmeio* pvmeio = (struct vmeio*)&(pmbbi->inp.value);
+    PvtStruct *pvt;
     int status = 0;
     
     status = generic_init_record((struct dbCommon *)pmbbi, &pmbbi->inp);
 
+    if(status)
+    {
+        pmbbi->dpvt = NULL;
+	return(status);
+    }
+
+    pvt = (PvtStruct *)pmbbi->dpvt;
+    if (pvt->index != SYSMON_PARM_TEMP)
+    {
+	pmbbi->dpvt = NULL;
+        if (devSysmonDebug >= 10)
+            logMsg("devSysmon: Illegal parm field ->%s<- \n", pvmeio->parm);
+
+        recGblRecordError(S_dev_badSignal,(void *)pmbbi,
+                          "devSysmon (init_record) Illegal parm field");
+        return(S_dev_badSignal);
+    }
+
     /* load temperature values up */
 
     if (!strcmp(ParmTable[SYSMON_PARM_TEMP].parm_name, pvmeio->parm))
     {
     	if (devSysmonDebug >= 10)
-		printf("devSysmon: mbbi record is Temperature\n");
+		logMsg("devSysmon: mbbi record is Temperature\n");
 
 	pmbbi->nobt = 0x08; /* make sure 8 bits wide */
 
@@ -630,7 +939,7 @@ STATIC long SysmonInitMbbiRec(struct mbbiRecord *pmbbi)
 	pmbbi->ffvl = 0x55;
 
 	/* load up proper string values, if you don't like it, change the strings somewhere else */
-	strcpy(pmbbi->zrst,"Calibration Error (Boy is it cold)");
+	strcpy(pmbbi->zrst,"Cal Error");
 	strcpy(pmbbi->onst,"20");
 	strcpy(pmbbi->twst,"25");
 	strcpy(pmbbi->thst,"30");
@@ -639,18 +948,15 @@ STATIC long SysmonInitMbbiRec(struct mbbiRecord *pmbbi)
 	strcpy(pmbbi->sxst,"45");
 	strcpy(pmbbi->svst,"50");
 	strcpy(pmbbi->eist,"Danger 55");
-	strcpy(pmbbi->nist,"way too hot");
-	strcpy(pmbbi->test,"undefined");
-	strcpy(pmbbi->elst,"undefined");
-	strcpy(pmbbi->tvst,"undefined");
-	strcpy(pmbbi->ttst,"undefined");
-	strcpy(pmbbi->ftst,"undefined");
-	strcpy(pmbbi->ffst,"undefined");
+	strcpy(pmbbi->nist,"Danger!");
+	strcpy(pmbbi->test,"Danger!!");
+	strcpy(pmbbi->elst,"Danger!!!");
+	strcpy(pmbbi->tvst,"Danger!!!!");
+	strcpy(pmbbi->ttst,"Danger!!!!!");
+	strcpy(pmbbi->ftst,"Danger!!!!!!");
+	strcpy(pmbbi->ffst,"AAAARRRGHH!!!");
     }
     
-    if(status)
-	return(status);
-
     pmbbi->shft = pvmeio->signal;
     pmbbi->mask <<= pmbbi->shft;
 
@@ -667,11 +973,16 @@ STATIC long SysmonWriteBo(struct boRecord *pbo)
     struct vmeio *pvmeio = (struct vmeio*)&(pbo->out.value);
     PvtStruct	*pvt = (PvtStruct *)pbo->dpvt;
 
+    if (pvt == NULL)
+	return(0);
+
     FASTLOCK(&cards[pvmeio->card].lock);
-    
+
+#if 0
     switch (pvt->index)
     {
-    case SYSMON_PARM_DIO:
+    case SYSMON_PARM_DO:
+    case SYSMON_PARM_DI:
 
       if (pbo->val)
 	cards[pvmeio->card].SysmonBase->SysmonDio |= pvt->mask;
@@ -687,6 +998,13 @@ STATIC long SysmonWriteBo(struct boRecord *pbo)
 	cards[pvmeio->card].SysmonBase->SysmonWatchdog &= ~pvt->mask;
       break;
     }
+#else
+
+    if (pbo->val)
+	*(pvt->pReg) |= pvt->mask;
+    else
+	*(pvt->pReg) &= ~pvt->mask;
+#endif
 
     FASTUNLOCK(&cards[pvmeio->card].lock);
     return(0);
@@ -702,24 +1020,14 @@ STATIC long SysmonReadBi(struct biRecord *pbi)
     struct vmeio *pvmeio = (struct vmeio*)&(pbi->inp.value);
     unsigned short regVal = 0;
     PvtStruct	*pvt = (PvtStruct *)pbi->dpvt;
-    FASTLOCK(&cards[pvmeio->card].lock);
 
-    switch (pvt->index)
-    {
-    case SYSMON_PARM_STATUS:
-      regVal = cards[pvmeio->card].SysmonBase->SysmonStatusLink;
-      break;
-    case SYSMON_PARM_DIO:
-      regVal = cards[pvmeio->card].SysmonBase->SysmonDio;
-      break;
-    case SYSMON_PARM_WATCHDOG:
-      regVal = cards[pvmeio->card].SysmonBase->SysmonWatchdog;
-      break;
-    }
-    FASTUNLOCK(&cards[pvmeio->card].lock);
+    if (pvt == NULL)
+	return(0);
+
+    regVal = *(pvt->pReg);
     
     if (devSysmonDebug)
-      printf("read 0x%2.2X, masking with 0x%2.2X\n", regVal, pvt->mask);
+      logMsg("read 0x%4.4X, masking with 0x%4.4X\n", regVal, pvt->mask);
 
     regVal &= pvt->mask;
 
@@ -727,11 +1035,15 @@ STATIC long SysmonReadBi(struct biRecord *pbi)
 	pbi->rval = 1;
     else
 	pbi->rval = 0;
+
+    /* Damn board's BI logic is bass-ackwards */
+    if (pvt->index == SYSMON_PARM_DI)
+	pbi->rval = pbi->rval?0:1;
     
     return(0);
 }
 
-
+#if 1 /* This looks completely insane JRW */
 /**************************************************************************
  *
  * Perform a write operation from a MBBO record
@@ -741,9 +1053,14 @@ STATIC long SysmonWriteMbbo(struct mbboRecord *pmbbo)
 {
     struct vmeio *pvmeio = (struct vmeio*)&(pmbbo->out.value);
     unsigned short regVal;
+    PvtStruct	*pvt = (PvtStruct *)pmbbo->dpvt;
+
+    if (pvt == NULL)
+	return(0);
 
     FASTLOCK(&cards[pvmeio->card].lock);
 
+	/* BUG -- this looks broken, what about the shift? -- JRW */
     regVal = cards[pvmeio->card].SysmonBase->SysmonTemperature;
     regVal = (regVal & ~pmbbo->mask) | (pmbbo->rval & pmbbo->mask);
     cards[pvmeio->card].SysmonBase->SysmonTemperature = regVal;
@@ -752,6 +1069,7 @@ STATIC long SysmonWriteMbbo(struct mbboRecord *pmbbo)
     
     return(0);
 }
+#endif
 
 /**************************************************************************
  *
@@ -760,9 +1078,12 @@ STATIC long SysmonWriteMbbo(struct mbboRecord *pmbbo)
  **************************************************************************/
 STATIC long SysmonReadMbbi(struct mbbiRecord *pmbbi)
 {
-
     struct vmeio *pvmeio = (struct vmeio*)&(pmbbi->inp.value);
     unsigned short regVal;
+    PvtStruct	*pvt = (PvtStruct *)pmbbi->dpvt;
+
+    if (pvt == NULL)
+	return(0);
 
     FASTLOCK(&cards[pvmeio->card].lock);
 
@@ -770,11 +1091,12 @@ STATIC long SysmonReadMbbi(struct mbbiRecord *pmbbi)
 
     FASTUNLOCK(&cards[pvmeio->card].lock);
     
+	/* BUG -- this looks broken, what about the shift? -- JRW */
     pmbbi->rval=regVal & pmbbi->mask;
     pmbbi->udf = 0;
     return(0);
 }
-
+
 /*****************************************************
   record support interrupt routine
  *
@@ -791,6 +1113,9 @@ static long SysmonGetIointInfoBi(
     struct vmeio *pvmeio = (struct vmeio *)(&pr->inp.value);
     int		intmask;
 
+    if (pr->dpvt == NULL)
+	return(0);
+
     if(pvmeio->card > NUM_LINKS) {
 	recGblRecordError(S_dev_badCard,(void *)pr,
 			  "devSysmon (get_int_info) exceeded maximum supported cards");
@@ -803,7 +1128,7 @@ static long SysmonGetIointInfoBi(
       intmask = (((PvtStruct *)(pr->dpvt))->mask)>>8;
 
       if (devSysmonDebug)
-	printf("SysmonGetIointInfoBi mask is %2.2X\n", intmask);
+	logMsg("SysmonGetIointInfoBi mask is %2.2X\n", intmask);
 
       cards[pvmeio->card].SysmonBase->SysmonIntMask |= intmask;
     }

src/devOpt/Makefile.Vx

@@ -7,13 +7,20 @@ USR_INCLUDES = -I../../drv
 SRCS.c = \
 	../devAnalytekGpib.c ../devXxDg535Gpib.c  ../devBBInteract.c \
 	../devGpibInteract.c ../devXxSr620Gpib.c ../devK486Gpib.c \
-	../devXxK196Gpib.c ../devXxDc5009Gpib.c ../devXxK263Gpib.c
+	../devXxK196Gpib.c ../devXxDc5009Gpib.c ../devXxK263Gpib.c \
+	../devXxSkeletonGpib.c
 
-PROD = \
+OBJS = \
         devAnalytekGpib.o devXxDg535Gpib.o devBBInteract.o \
 	devGpibInteract.o  devXxSr620Gpib.o devK486Gpib.o \
-	devXxK196Gpib.o devXxDc5009Gpib.o devXxK263Gpib.o
+	devXxK196Gpib.o devXxDc5009Gpib.o devXxK263Gpib.o \
+	devXxSkeletonGpib.o
 
+PROD = devLibOpt  $(OBJS)
 
 include $(EPICS)/config/RULES.Vx
 
+devLibOpt: $(OBJS)
+	$(RM) $@
+	$(LINK.c) $@ $(OBJS) $(LDLIBS)
+

src/devOpt/devXxSkeletonGpib.c

@@ -404,9 +404,9 @@ STATIC int srqHandler(struct hwpvt *phwpvt, int srqStatus)
         printf("dc5009 srqHandler: Unsolicited SRQ being handled from link %d, device %d, status = 0x%02.2X\n",
           phwpvt->link, phwpvt->device, srqStatus);
 
-      ((struct gpibDpvt*)(phwpvt->unsolicitedDpvt))->head.header.callback.callback = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->process;
-      ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->head.header.callback.priority = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->processPri;
-      callbackRequest(phwpvt->unsolicitedDpvt);
+      ((struct gpibDpvt*)(phwpvt->unsolicitedDpvt))->head.callback.callback = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->process;
+      ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->head.callback.priority = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->processPri;
+      callbackRequest((CALLBACK*)phwpvt->unsolicitedDpvt);
     }
     else
     {

src/drv/drvBitBus.c

@@ -65,6 +65,12 @@
  * This driver currently needs work on error message generation.
  *
  * $Log$
+ * Revision 1.35  1994/12/12  16:02:57  winans
+ * Rewrote the init code so that it always returns a zero (don't kill the
+ * startup.cmd file.)  It is possible that this could cause some confusion
+ * to the database, should it decide to then use a link that did not init
+ * properly.
+ *
  * Revision 1.34  1994/10/19  18:31:22  winans
  * ANSIfied the bitbus driver so that the compiler stopped warning about
  * exery third line of code.
@@ -163,7 +169,7 @@ int	XycomMaxOutstandMsgs = XYCOM_BB_MAX_OUTSTAND_MSGS;
  *		To disable this feature, set one of them to -1.
  *
  *****************************************************************************/
-int	bbDebug = 0;
+int	bbDebug = 1;
 int	bbDebugLink=-1;
 int	bbDebugNode=-1;
 
@@ -434,7 +440,7 @@ STATIC long reportBB(void)
 {
   int	i;
 
-  if (bbDebug)
+  if (bbDebug>1)
     printf("Bitbus debugging flag is set to %d\n", bbDebug);
 
   for (i=0; i< BB_NUM_LINKS; i++)
@@ -483,8 +489,10 @@ pepReset(int link)
 
   taskDelay(20);                   /* give the 80152 time to self check */
 
-  if ((pBBLink[link]->l.PepLink.bbRegs->stat_ctl & 0x10) != 0x0) {
-    printf("pepReset(%d): PB-BIT firmware reset failed!\n", link);
+  if ((pBBLink[link]->l.PepLink.bbRegs->stat_ctl & 0x10) != 0x0) 
+  {
+    if (bbDebug)
+      printf("pepReset(%d): PB-BIT firmware reset failed!\n", link);
     return(ERROR);
   }
 
@@ -495,7 +503,8 @@ pepReset(int link)
 
   if (!j) 
   {
-    printf("pepReset(%d): receive fifo will not clear after reset!\n", link);
+    if (bbDebug)
+      printf("pepReset(%d): receive fifo will not clear after reset!\n", link);
     return(ERROR);
   }
 
@@ -547,7 +556,8 @@ STATIC int xvmeReset(int link)
 
   if (!j)
   {
-    printf("xvmeReset(%d): Command buffer will not clear after reset!\n", link);
+    if (bbDebug)
+      printf("xvmeReset(%d): Command buffer will not clear after reset!\n", link);
     return(ERROR);
   }
 
@@ -557,13 +567,15 @@ STATIC int xvmeReset(int link)
 
   if (!j)
   {
-    printf("xvmeReset(%d): Data buffer will not clear after reset!\n", link);
+    if (bbDebug)
+      printf("xvmeReset(%d): Data buffer will not clear after reset!\n", link);
     return(ERROR);
   }
 
   if ((pBBLink[link]->l.XycomLink.bbRegs->fifo_stat & XVME_FSVALID) != XVME_FSIDLE)
   {
-    printf("xvmeReset(%d): XVME board not returning to idle status after reset!\n", link);
+    if (bbDebug)
+      printf("xvmeReset(%d): XVME board not returning to idle status after reset!\n", link);
     return(ERROR);
   }
 
@@ -861,7 +873,8 @@ xvmeRxTask(int link)
 	      { /* something bad happened... inject a delay to the */
 		/* requested timeout duration. */
 
-		printf("xvmeRxTask(%d): 0x91 from node %d, invoking synthetic delay\n", link, rxHead[2]);
+		if (bbDebug)
+		  printf("xvmeRxTask(%d): 0x91 from node %d, invoking synthetic delay\n", link, rxHead[2]);
 		(pBBLink[link]->syntheticDelay[rxDpvtHead->txMsg.node]) = rxDpvtHead->retire;
 		pBBLink[link]->DelayCount++;
               }
@@ -907,17 +920,6 @@ xvmeRxTask(int link)
 
         rxDpvtHead->status = BB_OK;	/* OK, unless BB_LENGTH */
         rxState = BBRX_DATA;		/* finish reading till RCMD */
-
-#if 0
-	  if (bbDebug)
-	  {
-            printf("xvmeRxTask(%d): msg from node %d unsolicited!\nHeader:", link, rxHead[2]);
-	    rxDpvtHead->rxMsg.length = 7;	/* we just have the header now */
-	    drvBitBusDumpMsg(&(rxDpvtHead->rxMsg));
-	  }
-	  semGive(pXvmeLink[link]->pbbLink->busyList.sem);
-          rxState = BBRX_IGN;	/* nothing waiting... toss it */
-#endif
       }
       break;
 
@@ -950,7 +952,8 @@ xvmeRxTask(int link)
       if (rxDpvtHead == NULL)
       {
         ch = pBBLink[link]->l.XycomLink.bbRegs->cmnd;
-        printf("xvmeRxTask(%d): got unexpected XVME_RCMD\n", link);
+	if (bbDebug)
+          printf("xvmeRxTask(%d): got unexpected XVME_RCMD\n", link);
 #ifdef BB_SUPER_DEBUG
           BBSetHistEvent(link, NULL, XACT_HIST_STATE_RX_URCMD);
 #endif
@@ -960,7 +963,7 @@ xvmeRxTask(int link)
 	rxDpvtHead->status = BB_OK;
 	rxDpvtHead->rxCmd = pBBLink[link]->l.XycomLink.bbRegs->cmnd;
 
-	/* if (bbDebug) */
+	if (bbDebug)
 	{
           printf("xvmeRxTask(%d): msg from node %d unsolicited:", link, rxDpvtHead->rxMsg.node);
 	  drvBitBusDumpMsg(&(rxDpvtHead->rxMsg));
@@ -1023,14 +1026,14 @@ xvmeRxTask(int link)
     /* Tell the watch dog I am ready for the reset (reset in the dog task) */
     pBBLink[link]->rxAbortAck = 1;
 
-    /* if (bbDebug) */
+    if (bbDebug)
       printf("xvmeRxTask(%d): resetting due to abort status\n", link);
 
     /* wait for link state to become active again */
     while (pBBLink[link]->abortFlag != 0)
       taskDelay(RESET_POLL_TIME);
 
-    /* if bbDebug) */
+    if (bbDebug)
       printf("xvmeRxTask(%d): restarting after abort\n", link);
   }
   }
@@ -1149,7 +1152,7 @@ xvmeWdTask(int link)
 	/* Get rid of the request and set error status etc... */
 	listDel(&(pBBLink[link]->busyList), pnode);
 
-	/*if (bbDebug)*/
+	if (bbDebug)
 	{
 #ifdef BB_SUPER_DEBUG
           BBSetHistEvent(link, pnode, XACT_HIST_STATE_WD_TIMEOUT);
@@ -1187,7 +1190,8 @@ xvmeWdTask(int link)
 	{ /* Send out a RAC_NODE_OFFLINE to the controller */
 	  semGive(pBBLink[link]->busyList.sem);
 
-printf("issuing a node offline for link %d node %d\n", link, resetNodeData);
+	  if (bbDebug)
+	    printf("issuing a node offline for link %d node %d\n", link, resetNodeData);
 
 	  semTake(pBBLink[link]->queue[BB_Q_HIGH].sem, WAIT_FOREVER);
 	  listAddHead(&(pBBLink[link]->queue[BB_Q_HIGH]), &resetNode);
@@ -1197,7 +1201,8 @@ printf("issuing a node offline for link %d node %d\n", link, resetNodeData);
 
 	  if (semTake(syncSem, sysClkRateGet()/4) == ERROR)
           {
-	    printf("xvmeWdTask(%d): link dead, trying manual reboot\n", link);
+	    if (bbDebug)
+	      printf("xvmeWdTask(%d): link dead, trying manual reboot\n", link);
 	    pBBLink[link]->nukeEm = 1;
 
             pBBLink[link]->abortFlag = 1; /* Start the abort sequence */
@@ -1301,13 +1306,13 @@ xvmeTxTask(int link)
       BBSetHistEvent(link, NULL, XACT_HIST_STATE_TX_ABORT);
 #endif
 
-      /* if (bbDebug) */
+      if (bbDebug)
         printf("xvmeTxTask(%d): resetting due to abort status\n", link);
 
       while (pBBLink[link]->abortFlag != 0)
         taskDelay(RESET_POLL_TIME);	/* wait for link to reset */
 
-      /* if (bbDebug) */
+      if (bbDebug)
         printf("xvmeTxTask(%d): restarting after abort\n", link);
     }
     else
@@ -1340,7 +1345,8 @@ xvmeTxTask(int link)
 	    if ((pBBLink[link]->syntheticDelay[pnode->txMsg.node] != 0)
 		&& (pBBLink[link]->syntheticDelay[pnode->txMsg.node] < now))
 	    {
-	      printf("xvmeTxTask(%d): terminating synthetic idle on node %d\n", link, pnode->txMsg.node);
+	      if (bbDebug)
+	        printf("xvmeTxTask(%d): terminating synthetic idle on node %d\n", link, pnode->txMsg.node);
 	      (pBBLink[link]->deviceStatus[pnode->txMsg.node])--;
 	      pBBLink[link]->syntheticDelay[pnode->txMsg.node] = 0;
 	      pBBLink[link]-> DelayCount--;
@@ -1412,7 +1418,7 @@ xvmeTxTask(int link)
 #ifdef BB_SUPER_DEBUG
               BBSetHistEvent(link, pnode, XACT_HIST_STATE_TX_RESET);
 #endif
-              /* if (bbDebug) */
+              if (bbDebug)
                 printf("xvmeTxTask(%d): RAC_RESET_SLAVE sent, resetting node %d\n", link, pnode->txMsg.node);
   
 	      pnode->status = BB_OK;
@@ -1486,8 +1492,11 @@ xvmeTxTask(int link)
 #ifdef BB_SUPER_DEBUG
             BBSetHistEvent(link, pnode, XACT_HIST_STATE_TX_ABORT);
 #endif
-	    printf("Message in progress when abort issued:\n");
-	    drvBitBusDumpMsg(&pnode->txMsg);
+	    if (bbDebug)
+	    {
+	      printf("Message in progress when abort issued:\n");
+	      drvBitBusDumpMsg(&pnode->txMsg);
+	    }
 	  }
 /* BUG -- I don't really need this */
 	/* break;*/			/* stop checking the fifo queues */
@@ -1510,7 +1519,7 @@ xvmeTxTask(int link)
  ******************************************************************************/
 STATIC int txStuck(int link)
 {
-  /* if (bbDebug) */
+  if (bbDebug)
     printf("bitbus transmitter task stuck, resetting link %d\n", link);
 
   bbReset(link);
@@ -1538,14 +1547,6 @@ STATIC long qBBReq(struct  dpvtBitBusHead *pdpvt, int prio)
     errMessage(S_BB_badPrio, message);
     return(ERROR);
   }
-#if 0
-  if (checkLink(pdpvt->link) == ERROR)
-  {
-    sprintf(message, "invalid link requested in call to qbbreq(%8.8X, %d)\n", pdpvt, prio);
-    errMessage(S_BB_rfu1, message);
-    return(ERROR);
-  }
-#else
   if (checkLink(pdpvt->link) == ERROR)
   {
     if (pdpvt->link >= BB_NUM_LINKS)
@@ -1561,7 +1562,6 @@ STATIC long qBBReq(struct  dpvtBitBusHead *pdpvt, int prio)
     }
     return(ERROR);
   }
-#endif
 
 #ifdef BB_SUPER_DEBUG
   BBSetHistEvent(pdpvt->link, pdpvt, XACT_HIST_STATE_QUEUE);
@@ -1960,7 +1960,8 @@ pepRxTask(int link)
 		if (rxHead[6] == 0x91)
 		{ /* something bad happened... inject a delay to the */
 		  /* requested timeout duration. */
-		  printf("pepRxTask(%d): 0x91 from node %d, invoking synthetic delay\n", link, rxHead[4]);
+		  if (bbDebug)
+		    printf("pepRxTask(%d): 0x91 from node %d, invoking synthetic delay\n", link, rxHead[4]);
 		  (pBBLink[link]->syntheticDelay[rxDpvtHead->txMsg.node]) = rxDpvtHead->retire;
 		  pBBLink[link]->DelayCount++;
 		}
@@ -2005,21 +2006,6 @@ pepRxTask(int link)
 
 	  rxDpvtHead->status = BB_OK;     /* OK, unless BB_LENGTH */
 	  rxState = BBRX_DATA;            /* finish reading till RCMD */
-
-#if 0	/* relocated to later spot in function */
-	  if (rxDpvtHead == NULL) 
-	  {
-	    if (bbDebug > 9) 
-	    {
-	      printf("pepRxTask(%d): msg from node %d unsolicited!\n", 
-		     link, rxHead[4]);
-	      printf("contents: %2.2x %2.2x %2.2x %2.2x %2.2x\n",rxHead[2],
-		     rxHead[3],rxHead[4],rxHead[5],rxHead[6]);
-	    }
-	    semGive(pXvmeLink[link]->pbbLink->busyList.sem);
-	    rxState = BBRX_IGN;	              /* nothing waiting... toss it */
-	  }
-#endif
 	}
 	break;
 	
@@ -2059,7 +2045,7 @@ pepRxTask(int link)
 	else if (rxDpvtHead == &UselessMsg)
 	{
           rxDpvtHead->status = BB_OK;
-          /* if (bbDebug) */
+          if (bbDebug)
           {
             printf("pepRxTask(%d): msg from node %d unsolicited:\n", link, rxDpvtHead->rxMsg.node);
             drvBitBusDumpMsg(&(rxDpvtHead->rxMsg));
@@ -2122,15 +2108,15 @@ pepRxTask(int link)
       /* Tell the watch dog I am ready for the reset (reset in the dog task) */
       pBBLink[link]->rxAbortAck = 1;
       
-      /* if (bbDebug) */
-      printf("pepRxTask(%d): resetting due to abort status\n", link);
+      if (bbDebug)
+        printf("pepRxTask(%d): resetting due to abort status\n", link);
       
       /* wait for link state to become active again */
       while (pBBLink[link]->abortFlag != 0)
 	taskDelay(RESET_POLL_TIME);
       
-      /* if bbDebug) */
-      printf("pepRxTask(%d): restarting after abort\n", link);
+      if (bbDebug)
+        printf("pepRxTask(%d): restarting after abort\n", link);
     }
   }
 }
@@ -2248,9 +2234,11 @@ STATIC int pepWdTask(int link)
 #ifdef BB_SUPER_DEBUG
         BBSetHistEvent(link, pnode, XACT_HIST_STATE_WD_TIMEOUT);
 #endif
-	/* printf("pepWdTask(%d): TIMEOUT on xact 0x%8.8X\n", link, pnode);*/
-	printf("pepWdTask(%d): TIMEOUT on bitbus message:\n", link);
-	drvBitBusDumpMsg(&pnode->txMsg);
+	if (bbDebug)
+	{
+	  printf("pepWdTask(%d): TIMEOUT on bitbus message:\n", link);
+	  drvBitBusDumpMsg(&pnode->txMsg);
+	}
 	
 	/* BUG -- do this here or defer until RX gets a response? */
         (pBBLink[link]->deviceStatus[pnode->txMsg.node])--; /* fix device status */
@@ -2299,8 +2287,11 @@ STATIC int pepWdTask(int link)
 
 	  semGive(pBBLink[link]->linkEventSem); /* Tell TxTask to send the messages */
 
-	  if (semTake(syncSem, (sysClkRateGet()) ) == ERROR) {
-	    printf("pepWdTask(%d): link dead, trying manual reboot\n", link);
+	  if (semTake(syncSem, (sysClkRateGet()) ) == ERROR) 
+	  {
+	    if (bbDebug)
+	      printf("pepWdTask(%d): link dead, trying manual reboot\n", link);
+
 	    pBBLink[link]->nukeEm = 1;
             pBBLink[link]->abortFlag = 1;
             semGive(pBBLink[link]->linkEventSem);
@@ -2388,7 +2379,7 @@ STATIC int pepTxTask(int link)
   register	int	x;
   unsigned	long	now;
   
-  if (bbDebug)
+  if (bbDebug>1)
     printf("pepTxTask started for link %d\n", link);
 
   while(1) {
@@ -2400,12 +2391,14 @@ STATIC int pepTxTask(int link)
       BBSetHistEvent(link, NULL, XACT_HIST_STATE_TX_ABORT);
 #endif
       
-      printf("pepTxTask(%d): resetting due to abort status\n", link);
+      if (bbDebug)
+        printf("pepTxTask(%d): resetting due to abort status\n", link);
       
       while (pBBLink[link]->abortFlag != 0)
 	taskDelay(RESET_POLL_TIME);	/* wait for link to reset */
       
-      printf("pepTxTask(%d): restarting after abort\n", link);
+      if (bbDebug)
+        printf("pepTxTask(%d): restarting after abort\n", link);
     }
     else
     {
@@ -2435,7 +2428,8 @@ STATIC int pepTxTask(int link)
 	    if ((pBBLink[link]->syntheticDelay[pnode->txMsg.node] != 0)
 		&& (pBBLink[link]->syntheticDelay[pnode->txMsg.node] < now))
 	    {
-	      printf("pepTxTask(%d): terminating synthetic idle on node %d\n", link, pnode->txMsg.node);
+	      if (bbDebug)
+	        printf("pepTxTask(%d): terminating synthetic idle on node %d\n", link, pnode->txMsg.node);
 	      (pBBLink[link]->deviceStatus[pnode->txMsg.node])--;
 	      pBBLink[link]->syntheticDelay[pnode->txMsg.node] = 0;
 	      pBBLink[link]->DelayCount--;
@@ -2519,7 +2513,8 @@ STATIC int pepTxTask(int link)
 #ifdef BB_SUPER_DEBUG
               BBSetHistEvent(link, pnode, XACT_HIST_STATE_TX_RESET);
 #endif
-	      printf("pepTxTask(%d): RAC_RESET_SLAVE sent\n", link);
+	      if (bbDebug)
+	        printf("pepTxTask(%d): RAC_RESET_SLAVE sent\n", link);
 	      
 	      pnode->status = BB_OK;
 	      

src/drv/drvDvx.c

@@ -120,6 +120,9 @@
  * BUGS:
  *  The driver should inspect the VXI make and model codes and use a data type
  *  for the DMA buffer that is appropriate.
+ *
+ * $Log$
+ *
  */ 
 
 static char *SccsId = "$Id$";
@@ -884,14 +887,13 @@ int sramld(int card)
   if (dvxDebug)
     printf("Total channels read in %d\n", dvx[card].numChan);
 
-#if 0 /* Force the user to reference board 7 on their own */
-  /* Make the extender system reset by referencing board 7 (No sample taken) */
-  *ramptr++ = GAIN_CHANNEL | ((0xF0 >> 3) & 3);
-  *ramptr++ = (((0xF0 & 7) << 3) | ((0xF0 & 0xE0) >> 5));
-#endif
-
+#if 1	/* This causes an extra sample to be taken at the end of the scan */
   *ramptr++ = 0;	/* mark the end of the sequence program */
   *ramptr++ = 0;
+#else	/* This was supposed to get rid of the extra one, but does not work */
+  *(ramptr-1) &= 0xff3f;
+  *ramptr = *(ramptr-1);
+#endif
 
   /* set scan rate and run it once */
   dvx[card].pdvx2502->samp_rate = DVX_DRATE;

src/iocCore/Makefile.Vx

@@ -22,12 +22,12 @@ PROD = iocCore vxWorks vxWorks.sym
 include $(EPICS)/config/RULES.Vx
 
 vxWorks: $(VX_IMAGE)
+	$(RM) $@
 	cp $< .
-	chmod 444 $@
 
 vxWorks.sym: $(VX_IMAGE_SYM)
+	$(RM) $@
 	cp $< .
-	chmod 444 $@
 
 iocCore: $(IOC_CORE_OBJS)
 	$(LINK.c) $@ $(IOC_CORE_OBJS)

src/rec/recBi.c

@@ -235,7 +235,7 @@ static long get_enum_strs(paddr,pes)
 {
     struct biRecord	*pbi=(struct biRecord *)paddr->precord;
 
-    pes->no_str = 0;
+    pes->no_str = 2;
     memset(pes->strs,'\0',sizeof(pes->strs));
     strncpy(pes->strs[0],pbi->znam,sizeof(pbi->znam));
     if(*pbi->znam!=0) pes->no_str=1;

src/rec/recBo.c

@@ -368,7 +368,8 @@ static long get_enum_strs(paddr,pes)
 {
     struct boRecord	*pbo=(struct boRecord *)paddr->precord;
 
-    pes->no_str = 0;
+    /*SETTING no_str=0 breaks channel access clients*/
+    pes->no_str = 2;
     memset(pes->strs,'\0',sizeof(pes->strs));
     strncpy(pes->strs[0],pbo->znam,sizeof(pbo->znam));
     if(*pbo->znam!=0) pes->no_str=1;

src/rec/recScan.c

@@ -43,9 +43,11 @@
  * .07  10-21-94  nda     changed linear scan parameter algorithms so changing
  *                        start/end modifies step/width unless frozen. This
  *                        seems more intuitive.
+ * .08  12-06-94  nda     added support for .FFO .When set to 1, frzFlag values
+ *                        are saved in recPvtStruct. Restored when FFO set to 0.
  */
 
-#define VERSION 1.07
+#define VERSION 1.08
 
 
 
@@ -144,6 +146,28 @@ struct recPvtStruct {
     struct p_limits   *pP2Limits;
     struct p_limits   *pP3Limits;
     struct p_limits   *pP4Limits;
+    short              pffo;          /* previouss state of ffo */
+    short              fpts;          /* backup copy of all freeze flags */
+    short              p1fs;
+    short              p1fi;
+    short              p1fc;
+    short              p1fe;
+    short              p1fw;
+    short              p2fs;
+    short              p2fi;
+    short              p2fc;
+    short              p2fe;
+    short              p2fw;
+    short              p3fs;
+    short              p3fi;
+    short              p3fc;
+    short              p3fe;
+    short              p3fw;
+    short              p4fs;
+    short              p4fi;
+    short              p4fc;
+    short              p4fe;
+    short              p4fw;
     unsigned long      tickStart;     /* used to time the scan */
     unsigned char      scanErr;
     unsigned char      nptsCause;     /* who caused the "# of points to change:
@@ -208,6 +232,9 @@ static void adjLinParms();
 static void changedNpts();
 static void checkScanLimits();
 static void drawPos1Scan();
+static void saveFrzFlags();
+static void resetFrzFlags();
+static void restoreFrzFlags();
 /* variables ... */
 long    scanRecDebug=0;
 long    viewScanPos=0; 
@@ -286,6 +313,11 @@ static long init_record(pscan,pass)
     precPvt->nptsCause = 0; /* resolve all positioner parameters */
     changedNpts(pscan);
 
+    if(pscan->ffo) {
+       saveFrzFlags(pscan);
+       resetFrzFlags(pscan);
+    }
+
     /* init field values */
     pscan->exsc = 0;
     pscan->pxsc = 0;
@@ -344,6 +376,7 @@ static long special(paddr,after)
     unsigned char       prevAlrt;
 
     if(!after) {
+        precPvt->pffo = pscan->ffo; /* save previous ffo flag */
         return(0);
     }
     switch(special_type) {
@@ -417,6 +450,25 @@ static long special(paddr,after)
         } 
         break;
 
+    case(SPC_SC_FFO):
+        /* Freeze Flag Override field */
+        if((pscan->ffo) && (!precPvt->pffo)) {
+           saveFrzFlags(pscan);
+           resetFrzFlags(pscan);
+        }
+        else if(!pscan->ffo && precPvt->pffo) /* only on 1->0 */
+           restoreFrzFlags(pscan);
+    
+        break;
+
+    case(SPC_SC_F):
+        /* Freeze Flag Override field */
+        if(pscan->ffo)
+           resetFrzFlags(pscan);
+
+        break;
+
+
     default:
 /*      recGblDbaddrError(S_db_badChoice,paddr,"scan: special");
 	return(S_db_badChoice);
@@ -1993,3 +2045,267 @@ static void drawPos1Scan(pscan)
 }
         
  
+static void saveFrzFlags(pscan)
+    struct scanRecord   *pscan;
+{
+
+    struct recPvtStruct *precPvt = (struct recPvtStruct *)pscan->rpvt;
+
+    /* save state of each freeze flag */
+    precPvt->fpts = pscan->fpts;
+    precPvt->p1fs = pscan->p1fs;
+    precPvt->p1fi = pscan->p1fi;
+    precPvt->p1fc = pscan->p1fc;
+    precPvt->p1fe = pscan->p1fe;
+    precPvt->p1fw = pscan->p1fw;
+    precPvt->p2fs = pscan->p2fs;
+    precPvt->p2fi = pscan->p2fi;
+    precPvt->p2fc = pscan->p2fc;
+    precPvt->p2fe = pscan->p2fe;
+    precPvt->p2fw = pscan->p2fw;
+    precPvt->p3fs = pscan->p3fs;
+    precPvt->p3fi = pscan->p3fi;
+    precPvt->p3fc = pscan->p3fc;
+    precPvt->p3fe = pscan->p3fe;
+    precPvt->p3fw = pscan->p3fw;
+    precPvt->p4fs = pscan->p4fs;
+    precPvt->p4fi = pscan->p4fi;
+    precPvt->p4fc = pscan->p4fc;
+    precPvt->p4fe = pscan->p4fe;
+    precPvt->p4fw = pscan->p4fw;
+}
+
+static void resetFrzFlags(pscan)
+    struct scanRecord   *pscan;
+{
+
+    struct recPvtStruct *precPvt = (struct recPvtStruct *)pscan->rpvt;
+
+    /* reset each frzFlag, post monitor if changed */
+
+    if(pscan->fpts) {
+       pscan->fpts = 0;
+       db_post_events(pscan,&pscan->fpts, DBE_VALUE);
+    }
+
+    if(pscan->p1fs) {
+       pscan->p1fs = 0;
+       db_post_events(pscan,&pscan->p1fs, DBE_VALUE);
+    }
+
+    if(pscan->p1fi) {
+       pscan->p1fi = 0;
+       db_post_events(pscan,&pscan->p1fi, DBE_VALUE);
+    }
+
+    if(pscan->p1fc) {
+       pscan->p1fc = 0;
+       db_post_events(pscan,&pscan->p1fc, DBE_VALUE);
+    }
+
+    if(pscan->p1fe) {
+       pscan->p1fe = 0;
+       db_post_events(pscan,&pscan->p1fe, DBE_VALUE);
+    }
+
+    if(pscan->p1fw) {
+       pscan->p1fw = 0;
+       db_post_events(pscan,&pscan->p1fw, DBE_VALUE);
+    }
+
+    if(pscan->p2fs) {
+       pscan->p2fs = 0;
+       db_post_events(pscan,&pscan->p2fs, DBE_VALUE);
+    }
+
+    if(pscan->p2fi) {
+       pscan->p2fi = 0;
+       db_post_events(pscan,&pscan->p2fi, DBE_VALUE);
+    }
+
+    if(pscan->p2fc) {
+       pscan->p2fc = 0;
+       db_post_events(pscan,&pscan->p2fc, DBE_VALUE);
+    }
+
+    if(pscan->p2fe) {
+       pscan->p2fe = 0;
+       db_post_events(pscan,&pscan->p2fe, DBE_VALUE);
+    }
+
+    if(pscan->p2fw) {
+       pscan->p2fw = 0;
+       db_post_events(pscan,&pscan->p2fw, DBE_VALUE);
+    }
+
+    if(pscan->p3fs) {
+       pscan->p3fs = 0;
+       db_post_events(pscan,&pscan->p3fs, DBE_VALUE);
+    }
+
+    if(pscan->p3fi) {
+       pscan->p3fi = 0;
+       db_post_events(pscan,&pscan->p3fi, DBE_VALUE);
+    }
+
+    if(pscan->p3fc) {
+       pscan->p3fc = 0;
+       db_post_events(pscan,&pscan->p3fc, DBE_VALUE);
+    }
+
+    if(pscan->p3fe) {
+       pscan->p3fe = 0;
+       db_post_events(pscan,&pscan->p3fe, DBE_VALUE);
+    }
+
+    if(pscan->p3fw) {
+       pscan->p3fw = 0;
+       db_post_events(pscan,&pscan->p3fw, DBE_VALUE);
+    }
+
+    if(pscan->p4fs) {
+       pscan->p4fs = 0;
+       db_post_events(pscan,&pscan->p4fs, DBE_VALUE);
+    }
+
+    if(pscan->p4fi) {
+       pscan->p4fi = 0;
+       db_post_events(pscan,&pscan->p4fi, DBE_VALUE);
+    }
+
+    if(pscan->p4fc) {
+       pscan->p4fc = 0;
+       db_post_events(pscan,&pscan->p4fc, DBE_VALUE);
+    }
+
+    if(pscan->p4fe) {
+       pscan->p4fe = 0;
+       db_post_events(pscan,&pscan->p4fe, DBE_VALUE);
+    }
+
+    if(pscan->p4fw) {
+       pscan->p4fw = 0;
+       db_post_events(pscan,&pscan->p4fw, DBE_VALUE);
+    }
+}
+
+
+
+
+
+/* Restores Freeze Flags to the state they were in */
+static void restoreFrzFlags(pscan)
+    struct scanRecord   *pscan;
+{
+
+    struct recPvtStruct *precPvt = (struct recPvtStruct *)pscan->rpvt;
+
+    /* restore state of each freeze flag, post if changed */
+    pscan->fpts = precPvt->fpts;
+    if(pscan->fpts) {
+       db_post_events(pscan,&pscan->fpts, DBE_VALUE);
+    }
+
+    pscan->p1fs = precPvt->p1fs;
+    if(pscan->p1fs) {
+       db_post_events(pscan,&pscan->p1fs, DBE_VALUE);
+    }
+
+    pscan->p1fi = precPvt->p1fi;
+    if(pscan->p1fi) {
+       db_post_events(pscan,&pscan->p1fi, DBE_VALUE);
+    }
+
+    pscan->p1fc = precPvt->p1fc;
+    if(pscan->p1fc) {
+       db_post_events(pscan,&pscan->p1fc, DBE_VALUE);
+    }
+
+    pscan->p1fe = precPvt->p1fe;
+    if(pscan->p1fe) {
+       db_post_events(pscan,&pscan->p1fe, DBE_VALUE);
+    }
+
+    pscan->p1fw = precPvt->p1fw;
+    if(pscan->p1fw) {
+       db_post_events(pscan,&pscan->p1fw, DBE_VALUE);
+    }
+
+    pscan->p2fs = precPvt->p2fs;
+    if(pscan->p2fs) {
+       db_post_events(pscan,&pscan->p2fs, DBE_VALUE);
+    }
+
+    pscan->p2fi = precPvt->p2fi;
+    if(pscan->p2fi) {
+       db_post_events(pscan,&pscan->p2fi, DBE_VALUE);
+    }
+
+    pscan->p2fc = precPvt->p2fc;
+    if(pscan->p2fc) {
+       db_post_events(pscan,&pscan->p2fc, DBE_VALUE);
+    }
+
+    pscan->p2fe = precPvt->p2fe;
+    if(pscan->p2fe) {
+       db_post_events(pscan,&pscan->p2fe, DBE_VALUE);
+    }
+
+    pscan->p2fw = precPvt->p2fw;
+    if(pscan->p2fw) {
+       db_post_events(pscan,&pscan->p2fw, DBE_VALUE);
+    }
+
+    pscan->p3fs = precPvt->p3fs;
+    if(pscan->p3fs) {
+       db_post_events(pscan,&pscan->p3fs, DBE_VALUE);
+    }
+
+    pscan->p3fi = precPvt->p3fi;
+    if(pscan->p3fi) {
+       db_post_events(pscan,&pscan->p3fi, DBE_VALUE);
+    }
+
+    pscan->p3fc = precPvt->p3fc;
+    if(pscan->p3fc) {
+       db_post_events(pscan,&pscan->p3fc, DBE_VALUE);
+    }
+
+    pscan->p3fe = precPvt->p3fe;
+    if(pscan->p3fe) {
+       db_post_events(pscan,&pscan->p3fe, DBE_VALUE);
+    }
+
+    pscan->p3fw = precPvt->p3fw;
+    if(pscan->p3fw) {
+       db_post_events(pscan,&pscan->p3fw, DBE_VALUE);
+    }
+
+    pscan->p4fs = precPvt->p4fs;
+    if(pscan->p4fs) {
+       db_post_events(pscan,&pscan->p4fs, DBE_VALUE);
+    }
+
+    pscan->p4fi = precPvt->p4fi;
+    if(pscan->p4fi) {
+       db_post_events(pscan,&pscan->p4fi, DBE_VALUE);
+    }
+
+    pscan->p4fc = precPvt->p4fc;
+    if(pscan->p4fc) {
+       db_post_events(pscan,&pscan->p4fc, DBE_VALUE);
+    }
+
+    pscan->p4fe = precPvt->p4fe;
+    if(pscan->p4fe) {
+       db_post_events(pscan,&pscan->p4fe, DBE_VALUE);
+    }
+
+    pscan->p4fw = precPvt->p4fw;
+    if(pscan->p4fw) {
+       db_post_events(pscan,&pscan->p4fw, DBE_VALUE);
+    }
+
+}
+
+

src/vxWorks/db/drvTS.c

@@ -1,6 +1,10 @@
 
 /*
  * $Log$
+ * Revision 1.4  1994/10/28  20:15:10  jbk
+ * increased the USP packet time-out to 250ms, added a parm to the configure()
+ * routine to let user specify it.
+ *
  */
 
 /**************************************************************************
@@ -653,7 +657,23 @@ static void TSerrorHandler(int Card, int ErrorNum)
 		Could put the slave on the vxworks timer until next sync
 	*/
 
-	logMsg("***TSerrorHandler: error number %d=n",ErrorNum,0,0,0,0,0);
+	if(MAKE_DEBUG)
+	{
+		switch(ErrorNum)
+		{
+		case 1:
+		  logMsg("***TSerrorHandler: event system error: TAXI violation",0,0,0,0,0,0);
+		  break;
+		case 2:
+		  logMsg("***TSerrorHandler: event system error: lost heartbeat",0,0,0,0,0,0);
+		  break;
+		case 3:
+		  logMsg("***TSerrorHandler: event system error: lost events",0,0,0,0,0,0);
+		  break;
+		default:
+			logMsg("***TSerrorHandler: unknown error %d from event system", ErrorNum,0,0,0,0,0);
+		}
+	}
 	return;
 }
 

src/vxWorks/devOpt/devXxSkeletonGpib.c

@@ -404,9 +404,9 @@ STATIC int srqHandler(struct hwpvt *phwpvt, int srqStatus)
         printf("dc5009 srqHandler: Unsolicited SRQ being handled from link %d, device %d, status = 0x%02.2X\n",
           phwpvt->link, phwpvt->device, srqStatus);
 
-      ((struct gpibDpvt*)(phwpvt->unsolicitedDpvt))->head.header.callback.callback = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->process;
-      ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->head.header.callback.priority = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->processPri;
-      callbackRequest(phwpvt->unsolicitedDpvt);
+      ((struct gpibDpvt*)(phwpvt->unsolicitedDpvt))->head.callback.callback = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->process;
+      ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->head.callback.priority = ((struct gpibDpvt *)(phwpvt->unsolicitedDpvt))->processPri;
+      callbackRequest((CALLBACK*)phwpvt->unsolicitedDpvt);
     }
     else
     {