I am not sure if it is a good idea or not to have my id in the cvs log

for this file, but here goes nothing.  This was my first attempt at
tidying up this file.  Unfortunately, it just exposes many more horrors
in the code itself that had been masked by the eyesore that was there
before.  I think this just needs to be put out of its misery.

1 files changed, 797 insertions, 824 deletions

diff --git a/sys/i386/isa/gpib.c b/sys/i386/isa/gpib.c
index 8225877..ce4824e 100644
--- a/sys/i386/isa/gpib.c
+++ b/sys/i386/isa/gpib.c
@@ -1,5 +1,4 @@
-
-/*
+/* 
  * GPIB driver for FreeBSD.
  * Version 0.1 (No interrupts, no DMA)
  * Supports National Instruments AT-GPIB and AT-GPIB/TNT boards.
@@ -17,9 +16,9 @@
  * all derivative works or modified versions.
  *
  * $FreeBSD$
- *
  */
-/*Please read the README file for usage information*/
+
+/* Please read the README file for usage information */
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -36,19 +35,17 @@
 #error "The gpib device requires the old isa compatibility shims"
 #endif
 
-#define MIN(a,b) ((a < b) ? a : b)
+#define MIN(a, b) ((a < b) ? a : b)
 
-#define GPIBPRI  (PZERO+8)|PCATCH
+#define GPIBPRI  (PZERO + 8) | PCATCH
 #define SLEEP_MAX 1000
 #define SLEEP_MIN 4
 
-
-
 static int initgpib(void);
 static void closegpib(void);
-static int sendgpibfifo(unsigned char device,char *data,int count);
-static int sendrawgpibfifo(unsigned char device,char *data,int count);
-static int readgpibfifo(unsigned char device,char *data,int count);
+static int sendgpibfifo(unsigned char device, char *data, int count);
+static int sendrawgpibfifo(unsigned char device, char *data, int count);
+static int readgpibfifo(unsigned char device, char *data, int count);
 #if 0
 static void showregs(void);
 #endif
@@ -93,11 +90,10 @@ static struct cdevsw gp_cdevsw = {
 	/* flags */	0,
 };
 
-#define   BUFSIZE      1024
-#define   ATTACHED     0x08
-#define   OPEN         0x04
-#define   INIT	       0x02
-
+#define	BUFSIZE		1024
+#define	ATTACHED	0x08
+#define	OPEN		0x04
+#define	INIT		0x02
 
 static struct gpib_softc {
 	char	*sc_cp;		/* current data to send		*/
@@ -106,11 +102,15 @@ static struct gpib_softc {
 	u_char	sc_flags;	/* flags (open and internal)	*/
         char	sc_unit;	/* gpib device number		*/
         char	*sc_inbuf;	/* buffer for data		*/
-} gpib_sc; /* only support one of these? */
+} gpib_sc;	/* only support one of these? */
+
 static int oldcount;
 static char oldbytes[2];
-/*Probe routine*/
-/*This needs to be changed to be a bit more robust*/
+
+/*
+ * Probe routine
+ * This needs to be changed to be a bit more robust
+ */
 static int
 gpprobe(struct isa_device *dvp)
 {
@@ -118,17 +118,20 @@ gpprobe(struct isa_device *dvp)
         struct gpib_softc *sc = &gpib_sc;
 
 	gpib_port = dvp->id_iobase;
-        status=1;
-        sc->sc_type=3;
-if ((inb(KSR)&0xF7)==0x34) sc->sc_type=3;
-else if ((inb(KSR)&0xF7)==0x24) sc->sc_type=2;
-else if ((inb(KSR)&0xF7)==0x14) sc->sc_type=1;
-          else status=0;
-
+        status = 1;
+        sc->sc_type = 3;
+	if ((inb(KSR) & 0xF7) == 0x34)
+		sc->sc_type = 3;
+	else if ((inb(KSR) & 0xF7) == 0x24)
+		sc->sc_type = 2;
+	else if ((inb(KSR) & 0xF7) == 0x14)
+		sc->sc_type = 1;
+	else
+		status = 0;
         return (status);
 }
 
-/*
+/* 
  * gpattach()
  *  Attach device and print the type of card to the screen.
  */
@@ -139,19 +142,18 @@ gpattach(isdp)
 	struct   gpib_softc   *sc = &gpib_sc;
 
 	sc->sc_unit = isdp->id_unit;
-        if (sc->sc_type==3)
-           printf ("gp%d: type AT-GPIB/TNT\n",sc->sc_unit);
-        if (sc->sc_type==2)
-           printf ("gp%d: type AT-GPIB chip NAT4882B\n",sc->sc_unit);
-        if (sc->sc_type==1)
-           printf ("gp%d: type AT-GPIB chip NAT4882A\n",sc->sc_unit);
-        sc->sc_flags |=ATTACHED;
-
+        if (sc->sc_type == 3)
+		printf ("gp%d: type AT-GPIB/TNT\n", sc->sc_unit);
+        if (sc->sc_type == 2)
+		printf ("gp%d: type AT-GPIB chip NAT4882B\n", sc->sc_unit);
+        if (sc->sc_type == 1)
+		printf ("gp%d: type AT-GPIB chip NAT4882A\n", sc->sc_unit);
+        sc->sc_flags |= ATTACHED;
 	make_dev(&gp_cdevsw, 0, 0, 0, 0600, "gp");
         return (1);
 }
 
-/*
+/* 
  * gpopen()
  *	New open on device.
  *
@@ -169,70 +171,72 @@ gpopen(dev, flags, fmt, td)
 	u_char unit;
 	int status;
 
-       unit= minor(dev);
+	unit = minor(dev);
 
 	/* minor number out of limits ? */
 	if (unit >= 32)
 		return (ENXIO);
 
 	/* Attached ? */
-	if (!(sc->sc_flags&ATTACHED)) { /* not attached */
-		return(ENXIO);
-	}
+	if (!(sc->sc_flags&ATTACHED))	/* not attached */
+		return (ENXIO);
 
-	/* Already open  */
-	if (sc->sc_flags&OPEN) { /* too late .. */
-		return(EBUSY);
-	}
+	/* Already open */
+	if (sc->sc_flags&OPEN)	/* too late .. */
+		return (EBUSY);
 
 	/* Have memory for buffer? */
 	sc->sc_inbuf = malloc(BUFSIZE, M_DEVBUF, M_WAITOK);
 	if (sc->sc_inbuf == 0)
-		return(ENOMEM);
+		return (ENOMEM);
 
-        if (initgpib()) return(EBUSY);
+        if (initgpib()) return (EBUSY);
         sc->sc_flags |= OPEN;
 	sc->sc_count = 0;
-        oldcount=0;
-if (unit!=0) {  /*Someone is trying to access an actual device*/
-                /*So.. we'll address it to listen*/
-enableremote(unit);
- do {
- status=inb(ISR2);
- }
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
-
- outb(CDOR,(unit&31)+32);/*address device to listen*/
-
- do
- status=inb(ISR2);
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
- outb (CDOR,64); /*Address controller (me) to talk*/
- do status=inb(ISR2);
-
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
- outb(AUXMR,gts); /*Set to Standby (Controller)*/
-
-
- do
- status=inb(ISR1);
- while (!(status&2)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
-/*Set up the TURBO488 registers*/
- outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
- outb(CNT0,0);   /*NOTE this does not enable DMA to the host computer!!*/
- outb(CNT1,0);
- outb(CNT2,0);
- outb(CNT3,0);
- outb(CMDR,0x20);
- outb(CFG,0x47); /* 16 bit, write, fifo B first, TMOE TIM */
- outb(CMDR,0x10); /*RESET fifos*/
- outb(CMDR,0x04); /*Tell TURBO488 to GO*/
-}
-	return(0);
+        oldcount = 0;
+	if (unit != 0) {	/* Someone is trying to access an actual device */
+		/* So.. we'll address it to listen */
+		enableremote(unit);
+		do {
+			status = inb(ISR2);
+		} while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+
+		outb(CDOR, (unit & 31) + 32);	/* address device to listen */
+
+		do
+			status = inb(ISR2);
+		while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			   "gpibpoll", 1) == EWOULDBLOCK);
+		outb(CDOR, 64);		/* Address controller (me) to talk */
+		do {
+			status = inb(ISR2);
+		} while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+		outb(AUXMR, gts);	/* Set to Standby (Controller) */
+
+
+		do {
+			status = inb(ISR1);
+		} while (!(status & 2) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+
+		/* Set up the TURBO488 registers */
+		outb(IMR2, 0x30);	/* we have to enable DMA (0x30) for turbo488 to work */
+		outb(CNT0, 0);		/* NOTE this does not enable DMA to the host computer!! */
+		outb(CNT1, 0);
+		outb(CNT2, 0);
+		outb(CNT3, 0);
+		outb(CMDR, 0x20);
+		outb(CFG, 0x47);	/* 16 bit, write, fifo B first, TMOE TIM */
+		outb(CMDR, 0x10);	/* RESET fifos */
+		outb(CMDR, 0x04);	/* Tell TURBO488 to GO */
+	}
+	return (0);
 }
 
 
-/*
+/* 
  * gpclose()
  *	Close gpib device.
  */
@@ -247,94 +251,93 @@ gpclose(dev, flags, fmt, td)
         unsigned char unit;
         unsigned char status;
 
-        unit=minor(dev);
-if (unit!=0) { /*Here we need to send the last character with EOS*/
-               /*and unaddress the listening device*/
-
-
-  status=EWOULDBLOCK;
-
-  /*Wait for fifo to become empty*/
-  do {
-  status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while ((inb(ISR3)&0x04)&&status==EWOULDBLOCK); /*Fifo is not empty*/
-
- outb(CMDR,0x08); /*Issue STOP to TURBO488*/
-
-  /*Wait for DONE and STOP*/
- if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*not done and stop*/
-
-/*Shut down TURBO488 */
- outb(IMR2,0x00); /*DISABLE DMA to turbo488*/
- outb(CMDR,0x20); /*soft reset turbo488*/
- outb(CMDR,0x10); /*reset fifos*/
-
-
-/*Send last byte with EOI set*/
-/*Send second to last byte if there are 2 bytes left*/
-if (status==EWOULDBLOCK)  {
-
-do
- if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
-while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
-if (oldcount==2){
- outb(CDOR,oldbytes[0]); /*Send second to last byte*/
- while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
-  status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
- }
-
-   outb(AUXMR,seoi);  /*Set EOI for the last byte*/
-   outb(AUXMR,0x5E); /*Clear SYNC*/
-   if (oldcount==1)
-   outb(CDOR,oldbytes[0]);
-    else
-   if (oldcount==2)
-   outb(CDOR,oldbytes[1]);
-   else {
-   outb (CDOR,13); /*Send a CR.. we've got trouble*/
-   printf("gpib: Warning: gpclose called with nothing left in buffer\n");
-   }
-}
-
-do
- if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
-while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
-
-
- if (!(inb(ISR1)&2)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR1)&2)&&status==EWOULDBLOCK);
-
-
- outb(AUXMR,tca); /* Regain full control of the bus*/
-
-
- do
-  status=inb(ISR2);
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
- outb(CDOR,63); /*unlisten*/
- do
-  status=inb(ISR2);
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
- outb(AUXMR,0x5E); /*Clear SYNC*/
- outb (CDOR,95);/*untalk*/
- do
-  status=inb(ISR2);
- while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
-/*gotolocal(minor(dev));*/
-}
+        unit = minor(dev);
+	if (unit != 0) {	/* Here we need to send the last character with EOS */
+		/* and unaddress the listening device */
+
+		status = EWOULDBLOCK;
+
+		/* Wait for fifo to become empty */
+		do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while ((inb(ISR3) & 0x04) && status == EWOULDBLOCK);	/* Fifo is not empty */
+
+		outb(CMDR, 0x08);	/* Issue STOP to TURBO488 */
+
+		/* Wait for DONE and STOP */
+		if (status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR3) & 0x11) && status == EWOULDBLOCK);	/* not done and stop */
+
+		/* Shut down TURBO488 */
+		outb(IMR2, 0x00);	/* DISABLE DMA to turbo488 */
+		outb(CMDR, 0x20);	/* soft reset turbo488 */
+		outb(CMDR, 0x10);	/* reset fifos */
+
+		/* Send last byte with EOI set */
+		/* Send second to last byte if there are 2 bytes left */
+		if (status == EWOULDBLOCK)  {
+			do {
+				if (!(inb(ISR1) & 2)) status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+			} while (!(inb(ISR1) & 2) && (status == EWOULDBLOCK));
+			if (oldcount == 2) {
+				outb(CDOR, oldbytes[0]);	/* Send second to last byte */
+				while (!(inb(ISR1) & 2) && (status == EWOULDBLOCK));
+				status = tsleep((caddr_t)&gpib_sc, GPIBPRI,
+				    "gpibpoll", 1);
+			}
+
+			outb(AUXMR, seoi);	/* Set EOI for the last byte */
+			outb(AUXMR, 0x5E);	/* Clear SYNC */
+			if (oldcount == 1)
+				outb(CDOR, oldbytes[0]);
+			else
+				if (oldcount == 2)
+					outb(CDOR, oldbytes[1]);
+				else {
+					outb(CDOR, 13);	/* Send a CR.. we've got trouble */
+					printf("gpib: Warning: gpclose called with nothing left in buffer\n");
+				}
+		}
+
+		do {
+			if (!(inb(ISR1) & 2)) status = tsleep((caddr_t)&gpib_sc,
+			    GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR1) & 2) && (status == EWOULDBLOCK));
+
+		if (!(inb(ISR1) & 2) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR1) & 2) && status == EWOULDBLOCK);
+
+		outb(AUXMR, tca); /* Regain full control of the bus */
+
+		do {
+			status = inb(ISR2);
+		} while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+		outb(CDOR, 63);	/* unlisten */
+		do {
+			status = inb(ISR2);
+		} while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+		outb(AUXMR, 0x5E);	/* Clear SYNC */
+		outb(CDOR, 95);	/* untalk */
+		do {
+			status = inb(ISR2);
+		} while (!(status & 8) && tsleep((caddr_t)&gpib_sc, GPIBPRI,
+			     "gpibpoll", 1) == EWOULDBLOCK);
+#if 0
+		gotolocal(minor(dev));
+#endif
+	}
 	closegpib();
 	sc->sc_flags = ATTACHED;
 	free(sc->sc_inbuf, M_DEVBUF);
 	sc->sc_inbuf = 0;	/* Sanity */
-	return(0);
+	return (0);
 }
 
-/*
+/* 
  * gpwrite()
  *	Copy from user's buffer, then write to GPIB device referenced
  *    by minor(dev).
@@ -345,821 +348,791 @@ gpwrite(dev, uio, ioflag)
 	struct uio *uio;
 	int ioflag;
 {
-	int err,count;
+	int err, count;
 
 	/* main loop */
 	while ((gpib_sc.sc_count = MIN(BUFSIZE-1, uio->uio_resid)) > 0) {
-		/*  If there were >1 bytes left over, send them  */
-                if (oldcount==2)
-                  sendrawgpibfifo(minor(dev),oldbytes,2);
-
-                /*If there was 1 character left, put it at the beginning
-                   of the new buffer*/
-                if (oldcount==1){
-                   (gpib_sc.sc_inbuf)[0]=oldbytes[0];
-	           gpib_sc.sc_cp = gpib_sc.sc_inbuf;
-		/*  get from user-space  */
-		   uiomove(gpib_sc.sc_inbuf+1, gpib_sc.sc_count, uio);
-                   gpib_sc.sc_count++;
-	           }
-                 else {
-                gpib_sc.sc_cp = gpib_sc.sc_inbuf;
-		/*  get from user-space  */
-		uiomove(gpib_sc.sc_inbuf, gpib_sc.sc_count, uio);
-                    }
-
-/*NOTE we always leave one byte in case this is the last write
-  so close can send EOI with the last byte There may be 2 bytes
-  since we are doing 16 bit transfers.(note the -1 in the count below)*/
-      /*If count<=2 we'll either pick it up on the next write or on close*/
-            if (gpib_sc.sc_count>2) {
- 		count = sendrawgpibfifo(minor(dev),gpib_sc.sc_cp,gpib_sc.sc_count-1);
-                err=!count;
-		if (err)
-			return(1);
-                oldcount=gpib_sc.sc_count-count; /*Set # of remaining bytes*/
-		gpib_sc.sc_count-=count;
-                gpib_sc.sc_cp+=count; /*point char pointer to remaining bytes*/
-              }
-                else oldcount=gpib_sc.sc_count;
-                  oldbytes[0]=gpib_sc.sc_cp[0];
-                if (oldcount==2)
-                  oldbytes[1]=gpib_sc.sc_cp[1];
+		/* If there were >1 bytes left over, send them */
+                if (oldcount == 2)
+			sendrawgpibfifo(minor(dev), oldbytes, 2);
+
+		/* If there was 1 character left, put it at the beginning
+		   of the new buffer */
+                if (oldcount == 1) {
+			(gpib_sc.sc_inbuf)[0] = oldbytes[0];
+			gpib_sc.sc_cp = gpib_sc.sc_inbuf;
+			/* get from user-space */
+			uiomove(gpib_sc.sc_inbuf + 1, gpib_sc.sc_count, uio);
+			gpib_sc.sc_count++;
+		} else {
+			gpib_sc.sc_cp = gpib_sc.sc_inbuf;
+			/* get from user-space */
+			uiomove(gpib_sc.sc_inbuf, gpib_sc.sc_count, uio);
+		}
+
+		/*
+		 * NOTE we always leave one byte in case this is the last write
+		 * so close can send EOI with the last byte There may be 2 bytes
+		 * since we are doing 16 bit transfers.(note the -1 in the count below)
+		 */
+
+		/* If count <= 2 we'll either pick it up on the next write or on close */
+		if (gpib_sc.sc_count>2) {
+			count = sendrawgpibfifo(minor(dev), gpib_sc.sc_cp, gpib_sc.sc_count-1);
+			err = !count;
+			if (err)
+				return (1);
+			oldcount = gpib_sc.sc_count-count;	/* Set # of remaining bytes */
+			gpib_sc.sc_count -= count;
+			gpib_sc.sc_cp += count;	/* point char pointer to remaining bytes */
+		}
+                else
+			oldcount = gpib_sc.sc_count;
+		oldbytes[0] = gpib_sc.sc_cp[0];
+                if (oldcount == 2)
+			oldbytes[1] = gpib_sc.sc_cp[1];
 	}
-	return(0);
+	return (0);
 }
-/* Here is how you would usually access a GPIB device
-   An exception would be a plotter or printer that you can just
-   write to using a minor device = its GPIB address */
+
+/*
+ * Here is how you would usually access a GPIB device
+ * An exception would be a plotter or printer that you can just
+ * write to using a minor device = its GPIB address
+ */
 
 static	int
 gpioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td)
 {
 	struct gpibdata *gd = (struct gpibdata *)data;
-	int	error,result;
+	int	error, result;
 	error = 0;
 
 	switch (cmd) {
 	case GPIBWRITE:
-		sendgpibfifo(gd->address,gd->data,*(gd->count));
-		error=0;
+		sendgpibfifo(gd->address, gd->data, *(gd->count));
+		error = 0;
 		break;
         case GPIBREAD:
-                result=readgpibfifo(gd->address,gd->data,*(gd->count));
-                *(gd->count)=result;
-                error=0;
+                result = readgpibfifo(gd->address, gd->data, *(gd->count));
+                *(gd->count) = result;
+                error = 0;
                 break;
         case GPIBINIT:
                 initgpib();
-                error=0;
+                error = 0;
                 break;
         case GPIBTRIGGER:
                 trigger(gd->address);
-                error=0;
+                error = 0;
                 break;
         case GPIBREMOTE:
                 enableremote(gd->address);
-                error=0;
+                error = 0;
                 break;
         case GPIBLOCAL:
                 gotolocal(gd->address);
-                error=0;
+                error = 0;
                 break;
-
         case GPIBMTRIGGER:
                 mtrigger(gd->data);
-                error=0;
+                error = 0;
                 break;
         case GPIBMREMOTE:
                 menableremote(gd->data);
-                error=0;
+                error = 0;
                 break;
         case GPIBMLOCAL:
                 mgotolocal(gd->data);
-                error=0;
+                error = 0;
                 break;
         case GPIBSPOLL:
-                *(gd->data)=spoll(gd->address);
-                error=0;
+                *(gd->data) = spoll(gd->address);
+                error = 0;
                 break;
         default:
 		error = ENODEV;
 	}
 
-	return(error);
+	return (error);
 }
 
+#if 0
+/* Just in case you want a dump of the registers... */
 
+static void showregs() {
+	printf ("NAT4882:\n");
+	printf ("ISR1=%X\t", inb(ISR1));
+	printf ("ISR2=%X\t", inb(ISR2));
+	printf ("SPSR=%X\t", inb(SPSR));
+	printf ("KSR =%X\t", inb(KSR));
+	printf ("ADSR=%X\t", inb(ADSR));
+	printf ("CPTR=%X\t", inb(CPTR));
+	printf ("SASR=%X\t", inb(SASR));
+	printf ("ADR0=%X\t", inb(ADR0));
+	printf ("ISR0=%X\t", inb(ISR0));
+	printf ("ADR1=%X\t", inb(ADR1));
+	printf ("BSR =%X\n", inb(BSR));
+
+	printf ("Turbo488\n");
+	printf ("STS1=%X ", inb(STS1));
+	printf ("STS2=%X ", inb(STS2));
+	printf ("ISR3=%X ", inb(ISR3));
+	printf ("CNT0=%X ", inb(CNT0));
+	printf ("CNT1=%X ", inb(CNT1));
+	printf ("CNT2=%X ", inb(CNT2));
+	printf ("CNT3=%X ", inb(CNT3));
+	printf ("IMR3=%X ", inb(IMR3));
+	printf ("TIMER=%X\n", inb(TIMER));
+}
+#endif
 
+/*
+ * Set up the NAT4882 and TURBO488 registers
+ * This will be nonsense to you unless you have a data sheet from
+ * National Instruments.  They should give you one if you call them
+ */
 
+static int
+initgpib()
+{
+	outb(CMDR, 0x20);
+	outb(CFG, 0x16);
+	outb(IMR3, 0);
+	outb(CMDR, 0x10);
+	outb(CNT0, 0);
+	outb(CNT1, 0);
+	outb(CNT2, 0);
+	outb(CNT3, 0);
+	outb(INTR, 0);		/* Put interrupt line in tri-state mode?? */
+	outb(AUXMR, chip_reset);
+
+	outb(IMR1, 0x10);	/* send interrupt to TURBO488 when END received */
+	outb(IMR2, 0);
+	outb(IMR0, 0x90);	/* Do we want nba here too??? */
+	outb(ADMR, 1);
+	outb(ADR, 0);
+	outb(ADR, 128);
+	outb(AUXMR, 0xE9);
+	outb(AUXMR, 0x49);
+	outb(AUXMR, 0x70);
+	outb(AUXMR, 0xD0);
+	outb(AUXMR, 0xA0);
+
+	outb(EOSR, 10);	/* set EOS message to newline */
+	/* should I make the default to interpret END as EOS? */
+	/* It isn't now.  The following changes this */
+	outb(AUXMR, 0x80);	/* No special EOS handling */
 #if 0
-/*Just in case you want a dump of the registers...*/
+	outb(AUXMR, 0x88)	/* Transmit END with EOS */
+	outb(AUXMR, 0x84)	/* Set END on EOS received */
+	outb(AUXMR, 0x8C)	/* Do both of the above */
+#endif
 
-static void showregs() {
- printf ("NAT4882:\n");
- printf ("ISR1=%X\t",inb(ISR1));
- printf ("ISR2=%X\t",inb(ISR2));
- printf ("SPSR=%X\t",inb(SPSR));
- printf ("KSR =%X\t",inb(KSR));
- printf ("ADSR=%X\t",inb(ADSR));
- printf ("CPTR=%X\t",inb(CPTR));
- printf ("SASR=%X\t",inb(SASR));
- printf ("ADR0=%X\t",inb(ADR0));
- printf ("ISR0=%X\t",inb(ISR0));
- printf ("ADR1=%X\t",inb(ADR1));
- printf ("BSR =%X\n",inb(BSR));
-
- printf ("Turbo488\n");
- printf ("STS1=%X ",inb(STS1));
- printf ("STS2=%X ",inb(STS2));
- printf ("ISR3=%X ",inb(ISR3));
- printf ("CNT0=%X ",inb(CNT0));
- printf ("CNT1=%X ",inb(CNT1));
- printf ("CNT2=%X ",inb(CNT2));
- printf ("CNT3=%X ",inb(CNT3));
- printf ("IMR3=%X ",inb(IMR3));
- printf ("TIMER=%X\n",inb(TIMER));
-
-
- }
+#if 0
+	/* Not currently supported */
+	outb(AUXMR, hldi);	/* Perform RFD Holdoff for all data in */
 #endif
-/*Set up the NAT4882 and TURBO488 registers */
-/*This will be nonsense to you unless you have a data sheet from
-  National Instruments.  They should give you one if you call them*/
 
-static int
-initgpib() {
-  outb(CMDR,0x20);
-  outb(CFG,0x16);
-  outb(IMR3,0);
-  outb(CMDR,0x10);
-  outb(CNT0,0);
-  outb(CNT1,0);
-  outb(CNT2,0);
-  outb(CNT3,0);
-  outb(INTR,0); /* Put interrupt line in tri-state mode??*/
-  outb(AUXMR,chip_reset);
-
-  outb(IMR1,0x10); /* send interrupt to TURBO488 when END received*/
-  outb(IMR2,0);
-  outb(IMR0,0x90); /* Do we want nba here too??? */
-  outb(ADMR,1);
-  outb(ADR,0);
-  outb(ADR,128);
-  outb(AUXMR,0xE9);
-  outb(AUXMR,0x49);
-  outb(AUXMR,0x70);
-  outb(AUXMR,0xD0);
-  outb(AUXMR,0xA0);
-
-  outb(EOSR,10); /*set EOS message to newline*/
-                 /*should I make the default to interpret END as EOS?*/
-                 /*It isn't now.  The following changes this*/
-  outb(AUXMR,0x80);    /*No special EOS handling*/
- /*outb(AUXMR,0x88) */ /* Transmit END with EOS*/
- /*outb(AUXMR,0x84) */ /* Set END on EOS received*/
- /*outb(AUXMR,0x8C) */ /* Do both of the above*/
-
-
- /* outb(AUXMR,hldi); */ /*Perform RFD Holdoff for all data in*/
-                         /*Not currently supported*/
-
-  outb(AUXMR,pon);
-  outb(AUXMR,sic_rsc);
- tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-
-  outb(AUXMR,sic_rsc_off);
-
-return(0);
-
-
-   }
-
-/*This is kind of Brute force..  But it works*/
+	outb(AUXMR, pon);
+	outb(AUXMR, sic_rsc);
+	tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+
+	outb(AUXMR, sic_rsc_off);
+
+	return (0);
+}
+
+/* This is kind of Brute force..  But it works */
 
 static void 
 closegpib() 
 {
-   outb(AUXMR,chip_reset);
+	outb(AUXMR, chip_reset);
 }
 
-/*GPIB ROUTINES:
-  These will also make little sense unless you have a data sheet.
-  Note that the routines with an "m" in the beginning are for
-  accessing multiple devices in one call*/
-
+/*
+ * GPIB ROUTINES:
+ * These will also make little sense unless you have a data sheet.
+ * Note that the routines with an "m" in the beginning are for
+ * accessing multiple devices in one call
+ */
 
-/*This is one thing I could not figure out how to do correctly.
-  I tried to use the auxilary  command to enable remote, but it
-  never worked.  Here, I bypass everything and write to the BSR
-  to enable the remote line.  NOTE that these lines are effectively
-  "OR'ed" with the actual lines, so writing a 1 to the bit in the BSR
-  forces the GPIB line true, no matter what the fancy circuitry of the
-  NAT4882 wants to do with it*/
+/*
+ * This is one thing I could not figure out how to do correctly.
+ * I tried to use the auxilary  command to enable remote, but it
+ * never worked.  Here, I bypass everything and write to the BSR
+ * to enable the remote line.  NOTE that these lines are effectively
+ * "OR'ed" with the actual lines, so writing a 1 to the bit in the BSR
+ * forces the GPIB line true, no matter what the fancy circuitry of the
+ * NAT4882 wants to do with it
+ */
 
 static void
 enableremote(unsigned char device)
 {
- int status;
-
-status=EWOULDBLOCK;
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- outb(BSR,1);           /*Set REN bit on GPIB*/
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(CDOR,(device&31)+32); /*address device to listen*/
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb (CDOR,63); /*Unaddress device*/
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- }
-/*This does not release the REM line on the gpib port, because if it did,
-  all the remote devices would go to local mode.  This only sends the
-  gotolocal message to one device.  Currently, REM is always held true
-  after enableremote is called, and is reset only on a close of the
-  gpib device */
+	int status;
 
-static void
-gotolocal(unsigned char device)
-{ int status;
-  status=EWOULDBLOCK;
+	status = EWOULDBLOCK;
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+	outb(BSR, 1);	/* Set REN bit on GPIB */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+	outb(CDOR, (device & 31) + 32);	/* address device to listen */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+	outb(CDOR, 63);	/* Unaddress device */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+}
 
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
+/*
+ * This does not release the REM line on the gpib port, because if it did,
+ * all the remote devices would go to local mode.  This only sends the
+ * gotolocal message to one device.  Currently, REM is always held true
+ * after enableremote is called, and is reset only on a close of the
+ * gpib device
+ */
 
-outb(CDOR,(device&31)+32);
+static void
+gotolocal(unsigned char device)
+{
+	int status;
 
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
+	status = EWOULDBLOCK;
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
 
-outb(AUXMR,0x5E);  /*Clear SYNC*/
- outb (CDOR,1);
+	outb(CDOR, (device & 31) + 32);
 
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
 
- outb(AUXMR,0x5E);
- outb (CDOR,63);/*unaddress device*/
+	outb(AUXMR, 0x5E);	/* Clear SYNC */
+	outb(CDOR, 1);
 
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
 
- }
+	outb(AUXMR, 0x5E);
+	outb(CDOR, 63);	/* unaddress device */
 
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+}
 
 static void
 menableremote(unsigned char *device)
 {
- int status, counter = 0;
-
-status=EWOULDBLOCK;
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- outb(BSR,1);           /*Set REN bit on GPIB*/
- do
-  {
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(CDOR,(device[counter]&31)+32); /*address device to listen*/
- counter++;
- }
- while (device[counter]<32);
-
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- outb (CDOR,63); /*Unaddress device*/
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- }
+	int status, counter = 0;
+
+	status = EWOULDBLOCK;
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+	outb(BSR, 1);	/* Set REN bit on GPIB */
+	do {
+		if (status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(CDOR, (device[counter] & 31) + 32);	/* address device to listen */
+		counter++;
+	} while (device[counter] < 32);
+
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+	outb(CDOR, 63);	/* Unaddress device */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+}
 
 static void
 mgotolocal(unsigned char *device)
-{ int status;
-  int counter=0;
-status=EWOULDBLOCK;
- if (device[counter]<32) do {
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(CDOR,(device[counter]&31)+32);
- counter++;
- } while (device[counter]<32);
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- outb(AUXMR,0x5E);  /*Clear SYNC*/
- outb (CDOR,1);
-
-
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(AUXMR,0x5E);
- outb (CDOR,63);/*unaddress device*/
-  if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
-
- }
-/*Trigger a device.  What happens depends on how the device is
- configured.  */
+{
+	int status;
+	int counter = 0;
+
+	status = EWOULDBLOCK;
+	if (device[counter] < 32) do {
+		if (status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(CDOR, (device[counter] & 31) + 32);
+		counter++;
+	} while (device[counter] < 32);
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+	outb(AUXMR, 0x5E);	/* Clear SYNC */
+	outb(CDOR, 1);
+
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+	outb(AUXMR, 0x5E);
+	outb(CDOR, 63);		/* unaddress device */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 2);
+	} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+}
+
+/* Trigger a device.  What happens depends on how the device is configured. */
 
 static void 
 trigger(unsigned char device)
-{ int status;
-
-status=EWOULDBLOCK;
- if (device<32)  {
-  if (!(inb(ISR2)&0x08)) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(CDOR,(device&31)+32); /*address device to listen*/
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
- outb (CDOR,8);  /*send GET*/
-
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb (AUXMR,0x5E);
- outb (CDOR,63);/*unaddress device*/
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
-
- }
+{
+	int status;
+
+	status = EWOULDBLOCK;
+	if (device < 32)  {
+		if (!(inb(ISR2) & 0x08)) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(CDOR, (device & 31) + 32);	/* address device to listen */
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+
+		outb(CDOR, 8);	/* send GET */
+
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(AUXMR, 0x5E);
+		outb(CDOR, 63);	/* unaddress device */
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+	}
 }
 
-/*Trigger multiple devices by addressing them all to listen, and then
-  sending GET*/
+/*
+ * Trigger multiple devices by addressing them all to listen, and then
+ * sending GET
+ */
 
 static void
 mtrigger(unsigned char *device)
-{ int status=EWOULDBLOCK;
-  int counter=0;
- if(device[0]<32){
- do {
- if (device[counter]<32)
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb(CDOR,(device[counter]&31)+32); /*address device to listen*/
- counter++;
-   }
- while (device[counter]<32);
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb (CDOR,8);  /*send GET*/
-
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
- outb (AUXMR,0x5E);
- outb (CDOR,63);/*unaddress device*/
-  if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
-
-
- }
+{
+	int status = EWOULDBLOCK;
+	int counter = 0;
+	if (device[0] < 32) {
+		do {
+			if (device[counter] < 32)
+				if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+					status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+				} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+			outb(CDOR, (device[counter] & 31) + 32);	/* address device to listen */
+			counter++;
+		} while (device[counter] < 32);
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(CDOR, 8);	/* send GET */
+
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+		outb(AUXMR, 0x5E);
+		outb(CDOR, 63);	/* unaddress device */
+		if (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR2) & 0x08) && status == EWOULDBLOCK);	/* Wait to send next cmd */
+	}
 }
 
-/*This is not used now, but it should work with NI's 8 bit gpib board
-  since it does not use the TURBO488 registers at all */
-
+/*
+ * This is not used now, but it should work with NI's 8 bit gpib board
+ * since it does not use the TURBO488 registers at all
+ */
 
-/*Send data through the TURBO488 FIFOS to a device that is already
- addressed to listen.  This is used by the write call when someone is
- writing to a printer or plotter, etc... */
-/*The last byte of each write is held off until either the next
- write or close, so it can be sent with EOI set*/
+/*
+ * Send data through the TURBO488 FIFOS to a device that is already
+ * addressed to listen.  This is used by the write call when someone is
+ * writing to a printer or plotter, etc...
+ *
+ * The last byte of each write is held off until either the next
+ * write or close, so it can be sent with EOI set
+ */
 
 static int
-sendrawgpibfifo(unsigned char device,char *data,int count)
- {
- int status;
- int counter;
- int fifopos;
- int sleeptime;
-
-
- sleeptime=SLEEP_MIN;
- counter=0;
-
-
- fifopos=0;
-
-status=EWOULDBLOCK;
- do {
-  /*Wait for fifo to become not full if it is full */
-  sleeptime=SLEEP_MIN;
-  if (!(inb(ISR3)&0x08)) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",sleeptime);
-   if (sleeptime<SLEEP_MAX) sleeptime=sleeptime*2;
-   }
-  while (!(inb(ISR3)&0x08)&&(status==EWOULDBLOCK)); /*Fifo is full*/
-
-   if((count>1)&&(inb(ISR3)&0x08)){
-   outw(FIFOB,*(unsigned*)(data+counter));
- /*  printf ("gpib: sent:%c,%c\n",data[counter],data[counter+1]);*/
-
-  counter+=2;
-  count-=2;
-   }
-  }
- while ((count>1)&&(status==EWOULDBLOCK));
-/*The write routine and close routine must check if there is 1
-  byte left and handle it accordingly*/
+sendrawgpibfifo(unsigned char device, char *data, int count)
+{
+	int status;
+	int counter;
+	int fifopos;
+	int sleeptime;
+
+	sleeptime = SLEEP_MIN;
+	counter = 0;
+
+	fifopos = 0;
+
+	status = EWOULDBLOCK;
+	do {
+		/* Wait for fifo to become not full if it is full */
+		sleeptime = SLEEP_MIN;
+		if (!(inb(ISR3) & 0x08)) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", sleeptime);
+			if (sleeptime < SLEEP_MAX) sleeptime = sleeptime * 2;
+		} while (!(inb(ISR3) & 0x08) && (status == EWOULDBLOCK));	/* Fifo is full */
+
+		if ((count>1) && (inb(ISR3) & 0x08)) {
+			outw(FIFOB, *(unsigned *)(data + counter));
+#if 0
+			printf ("gpib: sent:%c, %c\n", data[counter], data[counter + 1]);
+#endif
+			counter += 2;
+			count -= 2;
+		}
+	}
+	while ((count>1) && (status == EWOULDBLOCK));
 
+	/*
+	 * The write routine and close routine must check if there is 1
+	 * byte left and handle it accordingly
+	 */
 
-/*Return the number of bytes written to the device*/
- return(counter);
+	/* Return the number of bytes written to the device */
+	return (counter);
+}
 
+static int
+sendgpibfifo(unsigned char device, char *data, int count)
+{
+	int status;
+	int counter;
+	int fifopos;
+	int sleeptime;
+
+	outb(IMR2, 0x30);	/* we have to enable DMA (0x30) for turbo488 to work */
+	outb(CNT0, 0);
+	outb(CNT1, 0);
+	outb(CNT2, 0);
+	outb(CNT3, 0);
+	status = EWOULDBLOCK;
+	if (!(inb(ISR2) & 8)) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+
+	outb(CDOR, (device & 31) + 32);	/* address device to listen */
+
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+	outb(CDOR, 64);		/* Address controller (me) to talk */
+
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+
+	outb(AUXMR, gts);	/* Set to Standby (Controller) */
+	fifopos = 0;
+
+	sleeptime = SLEEP_MIN;
+	counter = 0;
+
+	fifopos = 0;
+
+	outb(CMDR, 0x20);
+	outb(CFG, 0x47);	/* 16 bit, write, fifo B first, TMOE TIM */
+	outb(CMDR, 0x10);	/* RESET fifos */
+	outb(CCRG, seoi);	/* program to send EOI at end */
+	outb(CMDR, 0x04);	/* Tell TURBO488 to GO */
+	status = EWOULDBLOCK;
+	do {
+		/* Wait for fifo to become not full if it is full */
+		sleeptime = SLEEP_MIN;
+		if (!(inb(ISR3) & 0x08)) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", sleeptime);
+			if (sleeptime < SLEEP_MAX) sleeptime = sleeptime * 2;
+		} while (!(inb(ISR3) & 0x08) && (status == EWOULDBLOCK));	/* Fifo is full */
+
+		if ((count>1) && (inb(ISR3) & 0x08)) {
+#if 0
+			if (count == 2) outb(CFG, 15 + 0x40);	/* send eoi when done */
+#endif
+			outw(FIFOB, *(unsigned *)(data + counter));
+
+			counter += 2;
+			count -= 2;
+		}
+	} while ((count>2) && (status == EWOULDBLOCK));
+
+	if (count == 2 && status == EWOULDBLOCK) {
+		/* Wait for fifo to become not full */
+		if (status == EWOULDBLOCK && !(inb(ISR3) & 0x08)) do {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", SLEEP_MIN);
+		} while (!(inb(ISR3) & 0x08) && status == EWOULDBLOCK);	/* Fifo is full */
+#if 0
+		outb(CFG, 0x40 + 15);	/* send eoi when done */
+#endif
+		outb(FIFOB, data[counter]);
+		counter++;
+		count--;
+	}
 
+#if 0
+	outb(CMDR, 0x04);
+#endif
 
-}
+	/* Wait for fifo to become empty */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while ((inb(ISR3) & 0x04) && status == EWOULDBLOCK);	/* Fifo is not empty */
 
-static int
-sendgpibfifo(unsigned char device,char *data,int count)
- {
- int status;
- int counter;
- int fifopos;
- int sleeptime;
-
-outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
- outb(CNT0,0);
- outb(CNT1,0);
- outb(CNT2,0);
- outb(CNT3,0);
-status=EWOULDBLOCK;
- if (!(inb(ISR2)&8)) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
-
- outb(CDOR,(device&31)+32);/*address device to listen*/
-
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
- outb (CDOR,64); /*Address controller (me) to talk*/
-
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
-
- outb(AUXMR,gts); /*Set to Standby (Controller)*/
- fifopos=0;
-
- sleeptime=SLEEP_MIN;
- counter=0;
-
-
- fifopos=0;
-
- outb(CMDR,0x20);
- outb(CFG,0x47); /* 16 bit, write, fifo B first, TMOE TIM */
- outb(CMDR,0x10); /*RESET fifos*/
- outb(CCRG,seoi); /*program to send EOI at end*/
- outb(CMDR,0x04); /*Tell TURBO488 to GO*/
-status=EWOULDBLOCK;
- do {
-  /*Wait for fifo to become not full if it is full */
-  sleeptime=SLEEP_MIN;
-  if (!(inb(ISR3)&0x08)) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",sleeptime);
-   if (sleeptime<SLEEP_MAX) sleeptime=sleeptime*2;
-   }
-  while (!(inb(ISR3)&0x08)&&(status==EWOULDBLOCK)); /*Fifo is full*/
-
-   if((count>1)&&(inb(ISR3)&0x08)){
-   /*if(count==2) outb(CFG,15+0x40); *//*send eoi when done*/
-   outw(FIFOB,*(unsigned*)(data+counter));
-
-  counter+=2;
-  count-=2;
-   }
-  }
- while ((count>2)&&(status==EWOULDBLOCK));
-
- if (count==2&&status==EWOULDBLOCK) {
-  /*Wait for fifo to become not full*/
-  if(status==EWOULDBLOCK&&!(inb(ISR3)&0x08)) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",SLEEP_MIN);
-   }
-  while (!(inb(ISR3)&0x08)&&status==EWOULDBLOCK); /*Fifo is full*/
-  /*outb(CFG,0x40+15);*//*send eoi when done*/
-  outb(FIFOB,data[counter]);
-  counter++;
-  count--;
-  }
-
-
- /*outb(CMDR,0x04);*/
-
-  /*Wait for fifo to become empty*/
-  if (status==EWOULDBLOCK) do {
-  status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while ((inb(ISR3)&0x04)&&status==EWOULDBLOCK); /*Fifo is not empty*/
-
- outb(CMDR,0x08); /*Issue STOP to TURBO488*/
-
-  /*Wait for DONE and STOP*/
- if (status==EWOULDBLOCK) do {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
-  while (!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*not done and stop*/
-
- outb(IMR2,0x00); /*we have to enable DMA (0x30) for turbo488 to work*/
- outb(CMDR,0x20); /*soft reset turbo488*/
- outb(CMDR,0x10); /*reset fifos*/
-
-
-/*Send last byte with EOI set*/
-/*Here EOI is handled correctly since the string to be sent */
-/*is actually all sent during the ioctl.  (See above)*/
-
-if (count==1&&status==EWOULDBLOCK)  {  /*Count should always=1 here*/
-
-do
- if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
-while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
-
-   outb(AUXMR,seoi);  /*Set EOI for the last byte*/
-   outb(AUXMR,0x5E); /*Clear SYNC*/
-   outb(CDOR,data[counter]);
- counter++;
- count--;
-}
+	outb(CMDR, 0x08);	/* Issue STOP to TURBO488 */
 
-do
- if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
-while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
+	/* Wait for DONE and STOP */
+	if (status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR3) & 0x11) && status == EWOULDBLOCK);	/* not done and stop */
 
+	outb(IMR2, 0x00);	/* we have to enable DMA (0x30) for turbo488 to work */
+	outb(CMDR, 0x20);	/* soft reset turbo488 */
+	outb(CMDR, 0x10);	/* reset fifos */
 
- if (!(inb(ISR1)&2)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR1)&2)&&status==EWOULDBLOCK);
- outb(AUXMR,tca); /* Regain full control of the bus*/
 
+	/*
+	 * Send last byte with EOI set
+	 * Here EOI is handled correctly since the string to be sent
+	 * is actually all sent during the ioctl.  (See above)
+	 */
+	if (count == 1 && status == EWOULDBLOCK)  {	/* Count should always=1 here */
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+		do {
+			if (!(inb(ISR1) & 2)) status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+		} while (!(inb(ISR1) & 2) && (status == EWOULDBLOCK));
 
-   outb(CDOR,63); /*unlisten*/
+		outb(AUXMR, seoi);	/* Set EOI for the last byte */
+		outb(AUXMR, 0x5E);	/* Clear SYNC */
+		outb(CDOR, data[counter]);
+		counter++;
+		count--;
+	}
 
+	do {
+		if (!(inb(ISR1) & 2)) status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR1) & 2) && (status == EWOULDBLOCK));
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 
+	if (!(inb(ISR1) & 2) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR1) & 2) && status == EWOULDBLOCK);
+	outb(AUXMR, tca);	/* Regain full control of the bus */
 
-outb(AUXMR,0x5E); /*Clear SYNC*/
- outb (CDOR,95);/*untalk*/
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	outb(CDOR, 63);		/* unlisten */
 
- return(counter);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
 
+	outb(AUXMR, 0x5E);	/* Clear SYNC */
+	outb(CDOR, 95);		/* untalk */
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	return (counter);
 }
 
 static int
-readgpibfifo(unsigned char device,char *data,int count)
+readgpibfifo(unsigned char device, char *data, int count)
 {
- int status;
- int status2 = 0;
- int status1;
- int counter;
- int fifopos;
- unsigned inword;
-
- outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
- /*outb(IMR3,0x1F);
- outb(INTR,1); */
- outb(CMDR,0x20);
-
- outb(CFG,14+0x60+1); /* Halt on int,read, fifo B first, CCEN TMOE TIM */
- outb(CMDR,0x10); /*RESET fifos*/
- outb(CCRG,tcs); /*program to tcs at end*/
- outb(CMDR,0x08);/*STOP??*/
-
-
-
-status=EWOULDBLOCK;
-do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
-
- outb (CDOR,32); /*Address controller (me) to listen*/
-
-  do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
-
- outb(CDOR,(device&31)+64);/*address device to talk*/
-
+	int status;
+	int status2 = 0;
+	int status1;
+	int counter;
+	int fifopos;
+	unsigned inword;
 
-  do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	outb(IMR2, 0x30);	/* we have to enable DMA (0x30) for turbo488 to work */
+#if 0
+	outb(IMR3, 0x1F);
+	outb(INTR, 1);
+#endif
+	outb(CMDR, 0x20);
 
- outb(AUXMR,gts); /*Set to Standby (Controller)*/
+	outb(CFG, 14 + 0x60 + 1); /* Halt on int, read, fifo B first, CCEN TMOE TIM */
+	outb(CMDR, 0x10);	/* RESET fifos */
+	outb(CCRG, tcs);	/* program to tcs at end */
+	outb(CMDR, 0x08);	/* STOP?? */
 
- counter=0;
- fifopos=0;
+	status = EWOULDBLOCK;
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
-  outb(CMDR,0x04); /*Tell TURBO488 to GO*/
+	outb(CDOR, 32);		/* Address controller (me) to listen */
 
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- do {
-   status1=inb(ISR3);
-   if (!(status1&0x01)&&(status1&0x04)){
-   status2=inb(STS2);
-   inword=inw(FIFOB);
-   *(unsigned*)(data+counter)=inword;
-  /* printf ("Read:%c,%c\n",data[counter],data[counter+1]);*/
-  counter+=2;
-  }
- else {
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",4);
-  }
- }
- while (!(status1&0x01)&&status==EWOULDBLOCK);
- if(!(status2 & 0x04)){ /*Only 1 byte came in on last 16 bit transfer*/
-  data[counter-1]=0;
-  counter--; }
-  else
-    data[counter]=0;
- outb(CMDR,0x08); /*send STOP*/
+	outb(CDOR, (device & 31) + 64);	/* address device to talk */
 
- do{
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
-   }
- while(!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*wait for DONE and STOP*/
- outb(AUXMR,0x55);
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- outb(IMR2,0x00); /*we have to enable DMA (0x30) for turbo488 to work*/
- outb(CMDR,0x20); /*soft reset turbo488*/
- outb(CMDR,0x10); /*reset fifos*/
+	outb(AUXMR, gts);	/* Set to Standby (Controller) */
 
-/* do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR1)&2));*/
- outb(AUXMR,tca); /* Regain full control of the bus*/
+	counter = 0;
+	fifopos = 0;
 
+	outb(CMDR, 0x04);	/* Tell TURBO488 to GO */
 
- do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
- outb(CDOR,63); /*unlisten*/
+	do {
+		status1 = inb(ISR3);
+		if (!(status1 & 0x01) && (status1 & 0x04)) {
+			status2 = inb(STS2);
+			inword = inw(FIFOB);
+			*(unsigned *)(data + counter) = inword;
+#if 0
+			printf ("Read:%c, %c\n", data[counter], data[counter + 1]);
+#endif
+			counter += 2;
+		} else {
+			status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 4);
+		}
+	} while (!(status1 & 0x01) && status == EWOULDBLOCK);
+	if (!(status2 & 0x04)) {	/* Only 1 byte came in on last 16 bit transfer */
+		data[counter-1] = 0;
+		counter--;
+	} else
+		data[counter] = 0;
+	outb(CMDR, 0x08);	/* send STOP */
+
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR3) & 0x11) && status == EWOULDBLOCK);	/* wait for DONE and STOP */
+	outb(AUXMR, 0x55);
+
+	outb(IMR2, 0x00);	/* we have to enable DMA (0x30) for turbo488 to work */
+	outb(CMDR, 0x20);	/* soft reset turbo488 */
+	outb(CMDR, 0x10);	/* reset fifos */
 
- do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+#if 0
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR1) & 2));
+#endif
+	outb(AUXMR, tca);	/* Regain full control of the bus */
 
-outb(AUXMR,0x5E); /*Clear SYNC*/
- outb (CDOR,95);/*untalk*/
- do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+	outb(CDOR, 63);		/* unlisten */
 
- return(counter);
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	outb(AUXMR, 0x5E);	/* Clear SYNC */
+	outb(CDOR, 95);		/* untalk */
+	do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	return (counter);
 }
 
 
 /* Return the status byte from device */
 static char
 spoll(unsigned char device)
- {
- int status=EWOULDBLOCK;
- unsigned int statusbyte;
-
- if (!(inb(ISR2)&8)) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
-
- outb(CDOR,(device&31)+64);/*address device to talk*/
-
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+{
+	int status = EWOULDBLOCK;
+	unsigned int statusbyte;
 
- outb (CDOR,32); /*Address controller (me) to listen*/
+	if (!(inb(ISR2) & 8)) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
- outb(AUXMR,0x5E);
- outb (CDOR,0x18); /*Send SPE (serial poll enable)*/
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	outb(CDOR, (device & 31) + 64);	/* address device to talk */
 
-  /*wait for bus to be synced*/
- if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- outb(AUXMR,gts); /*Set to Standby (Controller)*/
+	outb(CDOR, 32);		/* Address controller (me) to listen */
 
- if (!(inb(ISR1)&1)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR1)&1)&&status==EWOULDBLOCK);
- outb(AUXMR,0x5E);
- outb(AUXMR,tcs); /* Take control after next read*/
- statusbyte=inb(DIR);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+	outb(AUXMR, 0x5E);
+	outb(CDOR, 0x18);	/* Send SPE (serial poll enable) */
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	/* wait for bus to be synced */
+	if (!(inb(ISR0) & 1) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR0) & 1) && status == EWOULDBLOCK);
 
- outb(CDOR,0x19); /*SPD (serial poll disable)*/
+	outb(AUXMR, gts);	/* Set to Standby (Controller) */
 
-  /*wait for bus to be synced*/
- if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
+	if (!(inb(ISR1) & 1) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR1) & 1) && status == EWOULDBLOCK);
+	outb(AUXMR, 0x5E);
+	outb(AUXMR, tcs);	/* Take control after next read */
+	statusbyte = inb(DIR);
 
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
+	outb(CDOR, 0x19);	/* SPD (serial poll disable) */
 
-outb(CDOR,95); /*untalk*/
+	/* wait for bus to be synced */
+	if (!(inb(ISR0) & 1) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR0) & 1) && status == EWOULDBLOCK);
 
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
- outb(AUXMR,0x5E);
- outb (CDOR,63);/*unlisten*/
- if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 
-  /*wait for bus to be synced*/
- if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
-   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
- while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	outb(CDOR, 95);		/* untalk */
 
- return(statusbyte);
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
+	outb(AUXMR, 0x5E);
+	outb(CDOR, 63);		/* unlisten */
+	if (!(inb(ISR2) & 8) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR2) & 8) && status == EWOULDBLOCK);
 
+	/* wait for bus to be synced */
+	if (!(inb(ISR0) & 1) && status == EWOULDBLOCK) do {
+		status = tsleep((caddr_t)&gpib_sc, GPIBPRI, "gpibpoll", 1);
+	} while (!(inb(ISR0) & 1) && status == EWOULDBLOCK);
 
+	return (statusbyte);
 }