Added analog input support for temperature

Must flush for dbhcr
Added AI support for temperature input
1995-01-09 20:52:02 +00:00 · 1995-01-09 20:41:59 +00:00 · 1995-01-09 20:28:42 +00:00 · 1995-01-09 19:39:25 +00:00 · 1995-01-09 19:36:46 +00:00 · 1995-01-06 17:03:43 +00:00
30 changed files with 1253 additions and 295 deletions
--- a/src/db/dbScan.c
+++ b/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));
--- a/src/db/dbTest.c
+++ b/src/db/dbTest.c
@@ -813,6 +813,7 @@ int dbhcr(void)
 	return(0);
    }
    dbReportDeviceConfig(pdbBase,stdout);
+    fflush(stdout);
    return(0);
 }

--- a/src/db/devLib.c
+++ b/src/db/devLib.c
@@ -1270,13 +1270,15 @@ void *devLibA24Malloc(size_t size)
  void		*ret;

  if (devLibA24Debug)
-    printf("devLibA24Malloc(%d) entered\n", size);
+    logMsg("devLibA24Malloc(%d) entered\n", size, 0,0,0,0,0);

  if (A24MallocFunc == NULL)
  {
    /* See if the sysA24Malloc() function is present. */
    if(symFindByName(sysSymTbl,"_sysA24Malloc", (char**)&A24MallocFunc,&stype)==ERROR)
    { /* Could not find sysA24Malloc... use the malloc one and hope we are OK */
+      if (devLibA24Debug)
+	logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
      A24MallocFunc = malloc;
      A24FreeFunc   = free;
    }
@@ -1284,6 +1286,8 @@ void *devLibA24Malloc(size_t size)
    {
      if(symFindByName(sysSymTbl,"_sysA24Free", (char**)&A24FreeFunc, &stype) == ERROR)
      { /* That's strange... we have malloc, but no free! */
+        if (devLibA24Debug)
+	  logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
        A24MallocFunc = malloc;
        A24FreeFunc   = free;
      }
@@ -1301,5 +1305,8 @@ void *devLibA24Malloc(size_t size)

 void devLibA24Free(void *pBlock)
 {
+  if (devLibA24Debug)
+    logMsg("devLibA24Free(%p) entered\n", (unsigned long)pBlock,0,0,0,0,0);
+
  A24FreeFunc(pBlock);
 }
--- a/src/db/drvTS.c
+++ b/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;
 }

--- a/src/db/iocInit.c
+++ b/src/db/iocInit.c
@@ -53,7 +53,6 @@
 * .23	09-10-92	rcz	changed funcptr pinitHooks from ret long to void 
 * .24	09-11-92	rcz	moved setMasterTimeToSelf to a seperate C file
 * .25	07-15-93	mrk	Changed dbLoad for new dbStaticLib support
-<<<<<<< iocInit.c
 * .26	02-09-94	jbk	changed to new time stamp support software ts_init()
 * .27	03-18-94	mcn	added comments
 * .28	03-23-94	mrk	Added asInit
@@ -176,11 +175,6 @@ int iocInit(char * pResourceFilename)
    *  Read EPICS resources.
    */
    status = getResources(pResourceFilename);
-    if (status != 0) {
-	logMsg("iocInit aborting because getResources failed\n",0,0,0,0,0,0);
-	return(-1);
-    }
-
   /* Call hook for after resources are read. */
    if (pinitHooks) (*pinitHooks)(INITHOOKafterGetResources);

@@ -778,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 ...
@@ -795,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;
                            }
 			}
 		    }
@@ -1078,7 +1073,7 @@ static long getResources(char  *fname)
 	    sprintf(message,
 		    "getResources: Line too long - line=%d", lineNum);
 	    errMessage(-1L, message);
-	    return (-1);
+	    continue;
 	}
 	for (i = 0; i < len; i++) {
 	    if (buff[i] == '!') {
@@ -1090,7 +1085,7 @@ static long getResources(char  *fname)
 	    sprintf(message,
 		    "getResources: Not enough fields - line=%d", lineNum);
 	    errMessage(-1L, message);
-	    return (-1);
+	    continue;
 	}
 	found = 0;
 	len2 = strlen(s2);
@@ -1107,7 +1102,7 @@ static long getResources(char  *fname)
 	    sprintf(message,
 		    "getResources: Field 2 not defined - line=%d", lineNum);
 	    errMessage(-1L, message);
-	    return (-1);
+	    continue;
 	}
 	strcpy(name, "_");
 	strcat(name, s1);
@@ -1116,7 +1111,7 @@ static long getResources(char  *fname)
 	    sprintf(message,
 		  "getResources: Symbol name not found - line=%d", lineNum);
 	    errMessage(-1L, message);
-	    return (-1);
+	    continue;
 	}
 	if ( (strncmp(s1,"EPICS_",6)) == SAME)
            epicsFlag = 1;
@@ -1143,7 +1138,7 @@ static long getResources(char  *fname)
 		sprintf(message,
 		      "getResources: conversion failed - line=%d", lineNum);
 		errMessage(-1L, message);
-	        return (-1);
+	        continue;
 	    }
            if ( epicsFlag ) {
                sprintf(message,
@@ -1160,7 +1155,7 @@ static long getResources(char  *fname)
 		sprintf(message,
 		      "getResources: conversion failed - line=%d", lineNum);
 		errMessage(-1L, message);
-	        return (-1);
+	        continue;
 	    }
            if ( epicsFlag ) {
                sprintf(message,
@@ -1176,7 +1171,7 @@ static long getResources(char  *fname)
 		sprintf(message,
 		      "getResources: conversion failed - line=%d", lineNum);
 		errMessage(-1L, message);
-	        return (-1);
+	        continue;
 	    }
            if ( epicsFlag ) {
                sprintf(message,
@@ -1193,7 +1188,7 @@ static long getResources(char  *fname)
 		sprintf(message,
 		      "getResources: conversion failed - line=%d", lineNum);
 		errMessage(-1L, message);
-	        return (-1);
+	        continue;
 	    }
            if ( epicsFlag ) {
                sprintf(message,
@@ -1209,7 +1204,7 @@ static long getResources(char  *fname)
 	    sprintf(message,
 		 "getResources: switch default reached - line=%d", lineNum);
 	    errMessage(-1L, message);
-	    return (-1);
+	    continue;
 	    break;
 	}
 CLEAR:	memset(buff, '\0',  MAX);
--- a/src/dev/devApsEr.c
+++ b/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)
 {
--- a/src/dev/devBoSoftRaw.c
+++ b/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() */
--- a/src/dev/devCommonGpib.c
+++ b/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
@@ -172,6 +174,15 @@ gDset	*dset;	/* pointer to dset used to reference the init function */

  return(OK);
 }
+
+static void RegisterProcessCallback(CALLBACK *pCallback, int Priority, void *Parm)
+{
+	callbackSetCallback(devGpibLib_processCallback, pCallback);
+	callbackSetPriority(Priority, pCallback);
+	callbackSetUser(Parm, pCallback);
+	callbackRequest(pCallback);
+	return;
+}

 /******************************************************************************
 *
@@ -1288,9 +1299,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(pai,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else
    {
@@ -1335,9 +1350,13 @@ int		srqStatus;
    {
        devGpibLib_setPvSevr(pai,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_aiGpibFinish(pdpvt);	/* and finish the processing */
@@ -1382,9 +1401,13 @@ struct gpibDpvt *pdpvt;
            devGpibLib_setPvSevr(pai,READ_ALARM,VALID_ALARM);
        }
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
@@ -1426,9 +1449,14 @@ struct gpibDpvt *pdpvt;
 	devGpibLib_setPvSevr(pao,WRITE_ALARM,VALID_ALARM);
    }

-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
+
    return(IDLE);
 }

@@ -1458,9 +1486,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(pli,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else
    {
@@ -1505,9 +1537,13 @@ int		srqStatus;
    {
        devGpibLib_setPvSevr(pli,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_liGpibFinish(pdpvt);	/* and finish the processing */
@@ -1551,9 +1587,13 @@ struct gpibDpvt *pdpvt;
            devGpibLib_setPvSevr(pli,READ_ALARM,VALID_ALARM);
        }
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
@@ -1595,9 +1635,13 @@ struct gpibDpvt *pdpvt;
        devGpibLib_setPvSevr(plo,WRITE_ALARM,VALID_ALARM);
    }

-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    return(IDLE);
 }

@@ -1624,9 +1668,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(pbi,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else   	/* interpret response that came back */   
    {
@@ -1669,9 +1717,13 @@ int             srqStatus;
    {
        devGpibLib_setPvSevr(pbi,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_biGpibFinish(pdpvt);        /* and finish the processing */
@@ -1718,9 +1770,13 @@ struct gpibDpvt *pdpvt;
 		devGpibLib_setPvSevr(pbi,READ_ALARM,VALID_ALARM);
 	}
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);             /* jrw */
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
@@ -1763,9 +1819,14 @@ struct gpibDpvt *pdpvt;
 	devGpibLib_setPvSevr(pbo,WRITE_ALARM,VALID_ALARM);
    }

-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
+
    return(IDLE);
 }

@@ -1792,9 +1853,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(pmbbi,WRITE_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else 
    {
@@ -1839,9 +1904,13 @@ int             srqStatus;
    {
        devGpibLib_setPvSevr(pmbbi,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_mbbiGpibFinish(pdpvt);        /* and finish the processing */
@@ -1888,9 +1957,13 @@ struct gpibDpvt *pdpvt;
 		devGpibLib_setPvSevr(pmbbi,READ_ALARM,VALID_ALARM);
 	}
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
@@ -1934,9 +2007,13 @@ struct gpibDpvt *pdpvt;
 	devGpibLib_setPvSevr(pmbbo,WRITE_ALARM,VALID_ALARM);
    }

-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);		/* jrw */
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    return(IDLE);
 }

@@ -1966,9 +2043,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(psi,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
-        callbackRequest(&pdpvt->head.header.callback);             /* jrw */
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else 
    {
@@ -2013,9 +2094,13 @@ int             srqStatus;
    {
        devGpibLib_setPvSevr(psi,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_stringinGpibFinish(pdpvt);        /* and finish the processing */
@@ -2051,9 +2136,13 @@ struct gpibDpvt *pdpvt;
        psi->val[40] = '\0';
 	psi->udf = FALSE;
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);             /* jrw */
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
@@ -2094,9 +2183,13 @@ struct gpibDpvt *pdpvt;
 	devGpibLib_setPvSevr(pso,WRITE_ALARM,VALID_ALARM);
    }

-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest(&pdpvt->head.header.callback);		/* jrw */
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    return(IDLE);
 }

@@ -2279,14 +2372,16 @@ unsigned short	val;	/* used for EFAST operations only */
 *
 * The reason it is done this way is because the process() call may
 * recursively call itself when records are chained and the callback
- * task's stack is larger... just for this purpose.
+ * task's stack is larger... just for that reason.
 *
 ******************************************************************************/

 void 
-devGpibLib_processCallback(pDpvt)
-struct  gpibDpvt       *pDpvt;
+devGpibLib_processCallback(CALLBACK *pCallback)
 {
+    struct  gpibDpvt       *pDpvt;
+    callbackGetUser(pDpvt, pCallback);
+
    dbScanLock(pDpvt->precord);
    (*(struct rset *)(pDpvt->precord->rset)).process(pDpvt->precord);
    dbScanUnlock(pDpvt->precord);
@@ -2462,9 +2557,13 @@ struct gpibDpvt *pdpvt;
    {
 	devGpibLib_setPvSevr(pwf,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
-        callbackRequest((void *)pdpvt);
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }
    else
    {
@@ -2509,9 +2608,13 @@ int		srqStatus;
    {
        devGpibLib_setPvSevr(pwf,READ_ALARM,VALID_ALARM);

+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
        pdpvt->head.header.callback.priority = priorityLow;
-        callbackRequest((void *)pdpvt);
+        callbackRequest(&pdpvt->head.header.callback);
+#endif
    }

    devGpibLib_wfGpibFinish(pdpvt);	/* and finish the processing */
@@ -2547,9 +2650,14 @@ struct gpibDpvt *pdpvt;
    {
               devGpibLib_setPvSevr(pwf,READ_ALARM,VALID_ALARM);
    }
-    pdpvt->head.header.callback.callback = devGpibLib_processCallback;
-    pdpvt->head.header.callback.priority = priorityLow;
-    callbackRequest((void *)pdpvt);
+
+#if 1
+	RegisterProcessCallback(&pdpvt->head.callback, priorityLow, pdpvt);
+#else
+        pdpvt->head.header.callback.callback = devGpibLib_processCallback;
+        pdpvt->head.header.callback.priority = priorityLow;
+        callbackRequest(&pdpvt->head.header.callback);
+#endif

    return(0);
 }
--- a/src/dev/devMbboDirectXVme220.c
+++ b/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;
--- a/src/dev/devMbboSoftRaw.c
+++ b/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() */
--- a/src/dev/devMbboXVme220.c
+++ b/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;
--- a/src/dev/devSysmon.c
+++ b/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;
    }
--- a/src/devOpt/Makefile.Vx
+++ b/src/devOpt/Makefile.Vx
@@ -7,17 +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

 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
+PROD = devLibOpt  $(OBJS)

 include $(EPICS)/config/RULES.Vx

 devLibOpt: $(OBJS)
 	$(RM) $@
 	$(LINK.c) $@ $(OBJS) $(LDLIBS)
+
--- a/src/devOpt/devGpibInteract.c
+++ b/src/devOpt/devGpibInteract.c
@@ -139,8 +139,10 @@ int GI(void)
   for (cnt=0; cnt < LIST_SIZE; cnt++)
   {   /* init the elements of the command table */

+#if 0
 	gpibIntCmds[cnt].head.header.list.list1 = NULL;
 	gpibIntCmds[cnt].head.header.list.list2 = NULL;
+#endif
 	gpibIntCmds[cnt].head.workStart = gpibWork;
 	gpibIntCmds[cnt].head.link = 0;
 	gpibIntCmds[cnt].head.device = 0;
@@ -155,7 +157,7 @@ int GI(void)
  }

  ans = 0;                /* set loop not to exit */
-  printf("\n\n");
+  logMsg("\n\n");

  while ((ans != 'q') && (ans != 'Q'))
  {
@@ -380,6 +382,8 @@ static int sendMsg(void)

  if (replyIsBack)
  {
+    if (ibDebug)
+	taskDelay(60);		/* Allow debug printing to complete */
    showGpibMsg(msgNum);
  }
  else
@@ -438,7 +442,7 @@ static int gpibWork(struct gpibIntCmd *pCmd)
      }
      else if (status > (MAX_MSG_LENGTH - 1)) /* check length of resp */
      {
-        printf("GPIB Response length equaled allocated space !!!\n");
+        logMsg("GPIB Response length equaled allocated space !!!\n");
        pCmd->resp[(MAX_MSG_LENGTH)] = '\0';    /* place \0 at end */
      }
      else
--- a/src/devOpt/devXxDc5009Gpib.c
+++ b/src/devOpt/devXxDc5009Gpib.c
@@ -391,8 +391,8 @@ 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;
+      ((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
--- a/src/devOpt/devXxSkeletonGpib.c
+++ b/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
    {
--- a/src/devOpt/devXxSr620Gpib.c
+++ b/src/devOpt/devXxSr620Gpib.c
@@ -282,8 +282,8 @@ STATIC int srqHandler(struct hwpvt *phwpvt, int srqStatus)
      logMsg("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;
+      ((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
--- a/src/drv/drvBitBus.c
+++ b/src/drv/drvBitBus.c
@@ -65,6 +65,16 @@
 * 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.
+ *
 * Revision 1.33  1994/10/04  18:42:42  winans
 * Added an extensive debugging facility.
 *
@@ -129,6 +139,8 @@ STATIC int	bbKill(int link);
 STATIC void	BBrebootFunc(void);

 STATIC int	txStuck(int link);
+int BBConfig(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);
+int __BBConfig(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);

 #ifdef BB_SUPER_DEBUG
 int BBHistDump(int link);
@@ -157,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;

@@ -199,7 +211,16 @@ int BBConfig(unsigned long Link,
 	unsigned long IrqVector,
 	unsigned long IrqLevel)
 {
+  __BBConfig(Link, LinkType, BaseAddr, IrqVector, IrqLevel);
+  return(0);
+}

+int __BBConfig(unsigned long Link, 
+	unsigned long LinkType,
+	unsigned long BaseAddr,
+	unsigned long IrqVector,
+	unsigned long IrqLevel)
+{
  void		*pVoid;
  int		j;
  static int	FirstTime = 1;
@@ -419,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++)
@@ -468,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);
  }

@@ -480,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);
  }

@@ -532,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);
  }

@@ -542,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);
  }

@@ -846,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++;
              }
@@ -892,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;

@@ -935,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
@@ -945,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));
@@ -1008,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);
  }
  }
@@ -1134,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);
@@ -1172,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);
@@ -1182,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 */
@@ -1286,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
@@ -1325,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--;
@@ -1397,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;
@@ -1471,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 */
@@ -1495,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);
@@ -1523,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)
@@ -1546,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);
@@ -1945,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++;
 		}
@@ -1990,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;
 	
@@ -2044,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));
@@ -2107,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);
    }
  }
 }
@@ -2233,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 */
@@ -2284,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);
@@ -2373,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) {
@@ -2385,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
    {
@@ -2420,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--;
@@ -2504,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;
 	      
--- a/src/drv/drvDvx.c
+++ b/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;
--- a/src/drv/drvGpib.c
+++ b/src/drv/drvGpib.c
@@ -1,7 +1,17 @@
 /* drvGpib.c */
 /* share/src/drv/drvGpib.c %W% %G% */

-/*      Author: John Winans
+/******************************************************************************
+ *
+ * TODO:
+ * - Autodetect the need to use a bounce buffer (saves time on boards that have
+ *   "malloc"-able A24 space.
+ *
+ * - Launch campaign against the use of National Instruments hardware.
+ *
+ ******************************************************************************
+ *
+ *	Author: John Winans
 *      Date:   09-10-91
 *      GPIB driver for the NI-1014 and NI-1014D VME cards.
 *
@@ -52,6 +62,15 @@
 *
 *
 * $Log$
+ * Revision 1.26  1994/12/12  16:03:00  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.25  1994/10/28  19:55:30  winans
+ * Added VME bus violation prevention code/bug fix from LANL.
+ *
 * Revision 1.24  1994/10/04  18:42:46  winans
 * Added an extensive debugging facility.
 *
@@ -183,6 +202,11 @@ struct    cc_ary
    short	cc_TWO;
 };

+typedef struct DmaStuffStruct
+{
+	struct	cc_ary cc_array;
+	char	cc_byte;
+}DmaStuffStruct;
 /******************************************************************************
 *
 * This structure is used to hold the hardware-specific information for a
@@ -197,8 +221,12 @@ struct	niLink {
  WDOG_ID	watchDogId;	/* watchdog for timeouts */
  struct	ibregs	*ibregs;/* pointer to board registers */

+#if 0
  char		cc_byte;
  struct	cc_ary	cc_array;
+#else
+  DmaStuffStruct *DmaStuff;
+#endif

  char		r_isr1;
  char		r_isr2;
@@ -218,7 +246,7 @@ STATIC	int	pollInhibit[NIGPIB_NUM_LINKS][IBAPERLINK];
 /******************************************************************************
 *
 * This structure is used to hold the hardware-specific information for a
- * single Bit Bus GPIB link. They are dynamically allocated (and an ibLinkTask
+ * single BitBus GPIB link. They are dynamically allocated (and an ibLinkTask
 * started for it) when an IOCTL command requests it.
 *
 * The IOCTL requests to initiate a BBGPIB_IO link comes from the device support
@@ -372,9 +400,9 @@ initGpib(void)
      if (ibDebug)
 	logMsg("GPIB card found at address 0x%08.8X\n", pibregs);

-      if ((pNiLink[i] = (struct niLink *) devLibA24Malloc(sizeof(struct niLink))) == NULL)
+      if ((pNiLink[i] = (struct niLink *)malloc(sizeof(struct niLink))) == NULL)
      { /* This better never happen! */
-	logMsg("initGpib(): Can't malloc memory for NI-link data structures!");
+	logMsg("initGpib(): Can't malloc memory for NI-link data structures!\n");
        return(ERROR);
      }

@@ -402,10 +430,15 @@ initGpib(void)
      pNiLink[i]->cmdSpins = 0;
      pNiLink[i]->maxSpins = 0;

-      pNiLink[i]->cc_array.cc_ccb = 0;	/* DMAC array chained structure */
-      pNiLink[i]->cc_array.cc_ONE = 1;
-      pNiLink[i]->cc_array.cc_n_1addr = 0;
-      pNiLink[i]->cc_array.cc_TWO = 2;
+      if ((pNiLink[i]->DmaStuff = (DmaStuffStruct *)devLibA24Malloc(sizeof(DmaStuffStruct))) == NULL)
+      { /* This better never happen! */
+	logMsg("initGpib(): Can't malloc A24 memory for DMAC control structures!\n");
+        return(ERROR);
+      }
+      pNiLink[i]->DmaStuff->cc_array.cc_ccb = 0; /* DMAC chaining structure */
+      pNiLink[i]->DmaStuff->cc_array.cc_ONE = 1;
+      pNiLink[i]->DmaStuff->cc_array.cc_n_1addr = 0;
+      pNiLink[i]->DmaStuff->cc_array.cc_TWO = 2;

      pNiLink[i]->first_read = 1;	/* used in physIo() */
    }
@@ -970,9 +1003,9 @@ int	time;		/* time to wait on the DMA operation */
    b->auxmr = AUXRA | HR_HLDE;		/* hold off on end */
    
    if (cnt != 1)
-      pNiLink[link]->cc_byte = AUXRA | HR_HLDA;	/* (cc) holdoff on all */
+      pNiLink[link]->DmaStuff->cc_byte = AUXRA | HR_HLDA; /* (cc) holdoff on all */
    else
-      pNiLink[link]->cc_byte = b->auxmr = AUXRA | HR_HLDA; /* last byte, do now */
+      pNiLink[link]->DmaStuff->cc_byte = b->auxmr = AUXRA | HR_HLDA; /* last byte, do now */
    b->ch0.ocr = D_DTM | D_XRQ;
    /* make sure I only alter the 1014D port-specific fields here! */
    b->cfg1 = D_ECC | D_IN | (NIGPIB_IRQ_LEVEL << 5) | D_BRG3 | D_DBM;
@@ -989,7 +1022,7 @@ int	time;		/* time to wait on the DMA operation */
    memcpy(pNiLink[link]->A24BounceBuffer, buffer, length);

    if (cnt != 1)
-      pNiLink[link]->cc_byte = AUX_SEOI;	/* send EOI with last byte */
+      pNiLink[link]->DmaStuff->cc_byte = AUX_SEOI; /* send EOI with last byte */
    else
      b->auxmr = AUX_SEOI;			/* last byte, do it now */

@@ -1006,28 +1039,28 @@ int	time;		/* time to wait on the DMA operation */
  /* setup channel 1 (carry cycle) */

  if(ibDebug > 5)
-    logMsg("PhysIO: readying to xlate cc pointers at %8.8X and %8.8X\n", &(pNiLink[link]->cc_byte), &pNiLink[link]->A24BounceBuffer[cnt - 1]);
+    logMsg("PhysIO: readying to xlate cc pointers at %8.8X and %8.8X\n", &(pNiLink[link]->DmaStuff->cc_byte), &pNiLink[link]->A24BounceBuffer[cnt - 1]);

 #ifdef USE_OLD_XLATION
-  pNiLink[link]->cc_array.cc_ccb = &(pNiLink[link]->cc_byte) + (long) ram_base;
-  pNiLink[link]->cc_array.cc_n_1addr = &(pNiLink[link]->A24BounceBuffer[cnt - 1]) + (long)ram_base;
+  pNiLink[link]->DmaStuff->cc_array.cc_ccb = &(pNiLink[link]->DmaStuff->cc_byte) + (long) ram_base;
+  pNiLink[link]->DmaStuff->cc_array.cc_n_1addr = &(pNiLink[link]->A24BounceBuffer[cnt - 1]) + (long)ram_base;
 #else

-  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->cc_byte), &(pNiLink[link]->cc_array.cc_ccb)) == ERROR)
+  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->DmaStuff->cc_byte), &(pNiLink[link]->DmaStuff->cc_array.cc_ccb)) == ERROR)
    return(ERROR);

-  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->A24BounceBuffer[cnt - 1]), &(pNiLink[link]->cc_array.cc_n_1addr)) == ERROR)
+  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->A24BounceBuffer[cnt - 1]), &(pNiLink[link]->DmaStuff->cc_array.cc_n_1addr)) == ERROR)
    return(ERROR);

 #endif
  if(ibDebug > 5)
-    logMsg("PhysIO: &cc_byte=%8.8X, &pNiLink[link]->A24BounceBuffer[cnt-1]=%8.8X, ", pNiLink[link]->cc_array.cc_ccb, pNiLink[link]->cc_array.cc_n_1addr);
+    logMsg("PhysIO: &cc_byte=%8.8X, &pNiLink[link]->A24BounceBuffer[cnt-1]=%8.8X, ", pNiLink[link]->DmaStuff->cc_array.cc_ccb, pNiLink[link]->DmaStuff->cc_array.cc_n_1addr);

  cnt--;
 #ifdef USE_OLD_XLATION
-  temp_addr = (long) (&(pNiLink[link]->cc_array)) + (long)ram_base;
+  temp_addr = (long) (&(pNiLink[link]->DmaStuff->cc_array)) + (long)ram_base;
 #else
-  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->cc_array), &temp_addr) == ERROR)
+  if (sysLocalToBusAdrs(VME_AM_STD_SUP_DATA, &(pNiLink[link]->DmaStuff->cc_array), &temp_addr) == ERROR)
    return(ERROR);
 #endif
  if(ibDebug > 5)
@@ -1079,7 +1112,7 @@ int	time;		/* time to wait on the DMA operation */
  if (ibDmaTimingError > ibDmaMaxError)
    ibDmaMaxError = ibDmaTimingError;
  if (ibDmaDebug)
-    printf("DMA timing: error = %d, total = %d, max = %d\n",
+    logMsg("DMA timing: error = %d, total = %d, max = %d\n",
        ibDmaTimingError, ibDmaTimingErrorTotal, ibDmaMaxError);
  /***************************************************************************/

@@ -1095,7 +1128,7 @@ int	time;		/* time to wait on the DMA operation */
  if (ibDmaTimingError > ibDmaMaxError)
    ibDmaMaxError = ibDmaTimingError;
  if (ibDmaDebug)
-    printf("DMA timing: error = %d, total = %d, max = %d\n",
+    logMsg("DMA timing: error = %d, total = %d, max = %d\n",
        ibDmaTimingError, ibDmaTimingErrorTotal, ibDmaMaxError);
  /***************************************************************************/

@@ -2008,6 +2041,102 @@ int     length; 	/* number of bytes to write out from the data buffer */
  return(ERROR);
 }

+#ifdef INCLUDE_HIDEOS_INTERFACE
+/******************************************************************************
+ *
+ * Interface functions for HiDEOS access.
+ *
+ ******************************************************************************/
+/******************************************************************************
+ *
+ * Read up to <length> bytes into <*buffer>.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibRead(struct ibLink *pibLink, int device, char *buffer, int length, int time)
+{
+	logMsg("HideosGpibRead() entered\n");
+	return(bytes read | error);
+}
+/******************************************************************************
+ *
+ * Write <length> bytes from <*buffer> in data mode.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibWrite(struct ibLink *pibLink, int device, char *buffer, int length, int time)
+{
+	logMsg("HideosGpibWrite() entered\n");
+	return(bytes sent | error);
+}
+/******************************************************************************
+ *
+ * Write <length> bytes from <*buffer> in command mode.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibCmd(struct ibLink *pibLink, char *buffer, int length)
+{
+	logMsg("HideosGpibCmd() entered\n");
+	return(bytes sent | error);
+}
+/******************************************************************************
+ *
+ * Verify that the given GPIB port exists.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibCheckLink(int link, int bug)
+{
+	logMsg("HideosGpibCheckLink() entered\n");
+	return(OK | ERROR);
+}
+/******************************************************************************
+ *
+ * Prevent SRQs from being polled on a given GPIB port.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibSrqPollInhibit(int link, int bug, int gpibAddr)
+{
+	logMsg("HideosGpibSrqPollInhibit() entered -- NOT SUPPORTED YET\n");
+	return(ERROR);
+}
+/******************************************************************************
+ *
+ * Generate a GPIB link for a HiDEOS port.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibGenLink(int link, int bug)
+{
+	logMsg("HideosGpibGenLink() entered\n");
+	return(ibLinkStart() | ERROR);
+}
+/******************************************************************************
+ *
+ * Handle a GPIB IOCTL call.
+ *
+ ******************************************************************************/
+STATIC int
+HideosGpibIoctl(int link, int bug, int cmd, int v, caddr_t p)
+{
+	logMsg("HideosGpibIoctl() entered\n");
+	return(OK | ERROR);
+}
+/******************************************************************************
+ *
+ * Given the port information, return a link structure.
+ *
+ ******************************************************************************/
+struct	bbIbLink *
+HideosGpibFindLink(int link, int bug)
+{
+	logMsg("HideosGpibFindLink() entered\n");
+	return(bbIbLink* | NULL);
+}
+#endif
+
 /******************************************************************************
 *
 * These are the BitBus architecture specific functions.
@@ -2524,13 +2653,13 @@ IBHistDump(int type, int link, int bug)
  {
    if (pibLink->linkType == GPIB_IO)
    {
-      printf("%d GPIB-L%d-D%d: %s\n", pibLink->History.Hist[i].Time,
+      logMsg("%d GPIB-L%d-D%d: %s\n", pibLink->History.Hist[i].Time,
    	pibLink->linkId, pibLink->History.Hist[i].DevAddr, 
 	pibLink->History.Hist[i].Msg);
    }
    else if (pibLink->linkType == BBGPIB_IO)
    {
-      printf("%d BBIB-l%d-B%d-D%d: %s\n", pibLink->History.Hist[i].Time,
+      logMsg("%d BBIB-l%d-B%d-D%d: %s\n", pibLink->History.Hist[i].Time,
 	pibLink->linkId, pibLink->bug, pibLink->History.Hist[i].DevAddr,
 	pibLink->History.Hist[i].Msg);
    }
@@ -2544,3 +2673,12 @@ IBHistDump(int type, int link, int bug)
  return(0);
 }
 #endif
+
+#if 1
+/* A way to stop the CPU when idle... run from shell at prio 250 */
+BigFFT()
+{
+  while (1)
+  	asm(" stop #0x3000");
+}
+#endif
--- a/src/iocCore/Makefile.Vx
+++ b/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)
--- a/src/rec/recBi.c
+++ b/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;
--- a/src/rec/recBo.c
+++ b/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;
--- a/src/rec/recScan.c
+++ b/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);
+    }
+
+}
+
+
--- a/src/vxWorks/db/devLib.c
+++ b/src/vxWorks/db/devLib.c
@@ -1270,13 +1270,15 @@ void *devLibA24Malloc(size_t size)
  void		*ret;

  if (devLibA24Debug)
-    printf("devLibA24Malloc(%d) entered\n", size);
+    logMsg("devLibA24Malloc(%d) entered\n", size, 0,0,0,0,0);

  if (A24MallocFunc == NULL)
  {
    /* See if the sysA24Malloc() function is present. */
    if(symFindByName(sysSymTbl,"_sysA24Malloc", (char**)&A24MallocFunc,&stype)==ERROR)
    { /* Could not find sysA24Malloc... use the malloc one and hope we are OK */
+      if (devLibA24Debug)
+	logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
      A24MallocFunc = malloc;
      A24FreeFunc   = free;
    }
@@ -1284,6 +1286,8 @@ void *devLibA24Malloc(size_t size)
    {
      if(symFindByName(sysSymTbl,"_sysA24Free", (char**)&A24FreeFunc, &stype) == ERROR)
      { /* That's strange... we have malloc, but no free! */
+        if (devLibA24Debug)
+	  logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
        A24MallocFunc = malloc;
        A24FreeFunc   = free;
      }
@@ -1301,5 +1305,8 @@ void *devLibA24Malloc(size_t size)

 void devLibA24Free(void *pBlock)
 {
+  if (devLibA24Debug)
+    logMsg("devLibA24Free(%p) entered\n", (unsigned long)pBlock,0,0,0,0,0);
+
  A24FreeFunc(pBlock);
 }
--- a/src/vxWorks/db/drvTS.c
+++ b/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;
 }

--- a/src/vxWorks/devOpt/devGpibInteract.c
+++ b/src/vxWorks/devOpt/devGpibInteract.c
@@ -139,8 +139,10 @@ int GI(void)
   for (cnt=0; cnt < LIST_SIZE; cnt++)
   {   /* init the elements of the command table */

+#if 0
 	gpibIntCmds[cnt].head.header.list.list1 = NULL;
 	gpibIntCmds[cnt].head.header.list.list2 = NULL;
+#endif
 	gpibIntCmds[cnt].head.workStart = gpibWork;
 	gpibIntCmds[cnt].head.link = 0;
 	gpibIntCmds[cnt].head.device = 0;
@@ -155,7 +157,7 @@ int GI(void)
  }

  ans = 0;                /* set loop not to exit */
-  printf("\n\n");
+  logMsg("\n\n");

  while ((ans != 'q') && (ans != 'Q'))
  {
@@ -380,6 +382,8 @@ static int sendMsg(void)

  if (replyIsBack)
  {
+    if (ibDebug)
+	taskDelay(60);		/* Allow debug printing to complete */
    showGpibMsg(msgNum);
  }
  else
@@ -438,7 +442,7 @@ static int gpibWork(struct gpibIntCmd *pCmd)
      }
      else if (status > (MAX_MSG_LENGTH - 1)) /* check length of resp */
      {
-        printf("GPIB Response length equaled allocated space !!!\n");
+        logMsg("GPIB Response length equaled allocated space !!!\n");
        pCmd->resp[(MAX_MSG_LENGTH)] = '\0';    /* place \0 at end */
      }
      else
--- a/src/vxWorks/devOpt/devXxDc5009Gpib.c
+++ b/src/vxWorks/devOpt/devXxDc5009Gpib.c
@@ -391,8 +391,8 @@ 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;
+      ((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
--- a/src/vxWorks/devOpt/devXxSkeletonGpib.c
+++ b/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
    {
--- a/src/vxWorks/devOpt/devXxSr620Gpib.c
+++ b/src/vxWorks/devOpt/devXxSr620Gpib.c
@@ -282,8 +282,8 @@ STATIC int srqHandler(struct hwpvt *phwpvt, int srqStatus)
      logMsg("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;
+      ((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
Author	SHA1	Message	Date
John Winans	e7e77e415f	Added analog input support for temperature	1995-01-09 20:52:02 +00:00
Marty Kraimer	8bbe24525b	Must flush for dbhcr	1995-01-09 20:41:59 +00:00
John Winans	33074d31f4	Added AI support for temperature input	1995-01-09 20:28:42 +00:00
Marty Kraimer	16c09ec67c	dbCalloc for papPeriodic previously allocated too much storage.	1995-01-09 19:39:25 +00:00
Marty Kraimer	a79e478a32	init_record always returns status=2 so that conversion is not performed	1995-01-09 19:36:46 +00:00
John Winans	3941fb3ead	Added some ifdef'd out test code to see if the end of the sequence program 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.	1995-01-06 17:03:43 +00:00
John Winans	1eb71e24b6	Added the log parameter to the doc	1995-01-06 16:55:52 +00:00
John Winans	dacd2a6cc5	Added a line of DOC	1995-01-06 16:55:18 +00:00
John Winans	e5dae1d675	enabled irq services and rearranged the parm names and meanings.	1995-01-06 16:55:04 +00:00
cvs2svn	5f24768671	This commit was manufactured by cvs2svn to create tag 'R3.12.0-beta5'.	1994-12-21 16:03:12 +00:00
Janet B. Anderson	d4f720482b	Added $(RM) line and removed chmod line in vxWorks rules	1994-12-21 16:03:11 +00:00
Marty Kraimer	8f3b1cce16	get_enum_strs has no_strs=2 if no strings defined so CA clients work	1994-12-21 14:58:01 +00:00
Marty Kraimer	a94db92c29	get_enum_strs MUST set no_strs=2 if no strings defined	1994-12-21 14:19:44 +00:00
Marty Kraimer	b6a46820e9	If calink has MS or PP then issue error message only in errVerbose=TRUE	1994-12-21 14:16:59 +00:00
John Winans	cf7307f399	Added the devXxSkeletonGpib.c file to the build list. This is to insure that it is a buildable module.	1994-12-20 15:31:45 +00:00
Marty Kraimer	fb0a164de1	Added FFO option	1994-12-19 18:25:51 +00:00
Marty Kraimer	8d9d7a126a	In init_record mask is shifted not set equal to	1994-12-19 18:25:16 +00:00
cvs2svn	67378ebaa1	This commit was manufactured by cvs2svn to create tag 'R3.12.0-beta4'.	1994-12-16 16:11:27 +00:00
John Winans	0859173047	Added debug flag guards to ALL printing. The default debug level is set to 1 -- this provides the same output as the old version.	1994-12-16 16:11:26 +00:00
John Winans	0f1c9c357a	Changed error message in the event system error handler & added a conditional based on a debug flag to print it... defaults to off. (Per request from MRK.)	1994-12-16 15:51:21 +00:00
Janet B. Anderson	a4cfb43ba1	Now installs individual objects and devLibOpt	1994-12-15 19:44:44 +00:00
cvs2svn	6c620894f5	This commit was manufactured by cvs2svn to create tag 'R3.12.0-beta3'.	1994-12-15 16:12:45 +00:00
Marty Kraimer	b7451c7a5d	Allow iocInit to continue even if getResources fails	1994-12-15 16:12:44 +00:00
John Winans	a2331c9d0e	Changed a printf to logMsg and added a printing delay to use when the ibDebug flag is set so things come out closer to the proper order.	1994-12-14 22:43:48 +00:00
John Winans	f44ce3dbb0	Changed printf to logMsg in the A24Malloc code and added a few more debug statements.	1994-12-14 22:41:06 +00:00
John Winans	d9066673ef	Removed DMAC command chaining structure(s) from the ibLink structure so they can be malloc'd seperately. This keeps the usage of A24 space restricted to ONLY those structures that have to be there.	1994-12-14 22:29:14 +00:00
Janet B. Anderson	82867f0684	Now installs individual objects instead of devLibOpt	1994-12-14 15:00:16 +00:00
John Winans	6fb928ea9d	Updated the GPIB request header.	1994-12-12 19:59:45 +00:00
John Winans	ad41921414	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.	1994-12-12 16:03:00 +00:00
cvs2svn	17c54db7f7	This commit was manufactured by cvs2svn to create tag 'R3.12.0-beta2'.	1994-12-07 15:11:14 +00:00