sys/dev/misc/gpib/gpib.c

   1
   2 /*
   3  * GPIB driver for FreeBSD.
   4  * Version 0.1 (No interrupts, no DMA)
   5  * Supports National Instruments AT-GPIB and AT-GPIB/TNT boards.
   6  * (AT-GPIB not tested, but it should work)
   7  *
   8  * Written by Fred Cawthorne (fcawth@delphi.umd.edu)
   9  * Some sections were based partly on the lpt driver.
  10  *  (some remnants may remain)
  11  *
  12  * This software is distributed with NO WARRANTIES, not even the implied
  13  * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  *
  15  * The author grants any other persons or organizations permission to use
  16  * or modify this software as long as this message is kept with the software,
  17  * all derivative works or modified versions.
  18  *
  19  * $FreeBSD: src/sys/i386/isa/gpib.c,v 1.29 2000/01/29 16:17:32 peter Exp $
  20  * $DragonFly: src/sys/dev/misc/gpib/gpib.c,v 1.9 2004/05/19 22:52:42 dillon Exp $
  21  *
  22  */
  23 /*Please read the README file for usage information*/
  24
  25 #include <sys/param.h>
  26 #include <sys/systm.h>
  27 #include <sys/conf.h>
  28 #include <sys/uio.h>
  29 #include <sys/malloc.h>
  30 #include "gpibreg.h"
  31 #include "gpib.h"
  32 #include <bus/isa/i386/isa_device.h>
  33
  34 #define GPIBPRI  PCATCH
  35 #define SLEEP_MAX 1000
  36 #define SLEEP_MIN 4
  37
  38
  39
  40 static int initgpib(void);
  41 static void closegpib(void);
  42 static int sendgpibfifo(unsigned char device,char *data,int count);
  43 static int sendrawgpibfifo(unsigned char device,char *data,int count);
  44 static int readgpibfifo(unsigned char device,char *data,int count);
  45 #if 0
  46 static void showregs(void);
  47 #endif
  48 static void enableremote(unsigned char device);
  49 static void gotolocal(unsigned char device);
  50 static void menableremote(unsigned char *device);
  51 static void mgotolocal(unsigned char *device);
  52 static void mtrigger(unsigned char *device);
  53 static void trigger(unsigned char device);
  54 static char spoll(unsigned char device);
  55
  56 static int gpprobe(struct isa_device *dvp);
  57 static int gpattach(struct isa_device *dvp);
  58
  59 struct   isa_driver gpdriver = {gpprobe, gpattach, "gp"};
  60
  61 static  d_open_t        gpopen;
  62 static  d_close_t       gpclose;
  63 static  d_write_t       gpwrite;
  64 static  d_ioctl_t       gpioctl;
  65
  66 #define CDEV_MAJOR 44
  67 static struct cdevsw gp_cdevsw = {
  68         /* name */      "gp",
  69         /* maj */       CDEV_MAJOR,
  70         /* flags */     0,
  71         /* port */      NULL,
  72         /* clone */     NULL,
  73
  74         /* open */      gpopen,
  75         /* close */     gpclose,
  76         /* read */      noread,
  77         /* write */     gpwrite,
  78         /* ioctl */     gpioctl,
  79         /* poll */      nopoll,
  80         /* mmap */      nommap,
  81         /* strategy */  nostrategy,
  82         /* dump */      nodump,
  83         /* psize */     nopsize
  84 };
  85
  86 #define   BUFSIZE      1024
  87 #define   ATTACHED     0x08
  88 #define   OPEN         0x04
  89 #define   INIT         0x02
  90
  91
  92 static struct gpib_softc {
  93         char    *sc_cp;         /* current data to send         */
  94         int     sc_count;       /* bytes queued in sc_inbuf     */
  95         int     sc_type;        /* Type of gpib controller      */
  96         u_char  sc_flags;       /* flags (open and internal)    */
  97         char    sc_unit;        /* gpib device number           */
  98         char    *sc_inbuf;      /* buffer for data              */
  99 } gpib_sc; /* only support one of these? */
 100 static int oldcount;
 101 static char oldbytes[2];
 102 /*Probe routine*/
 103 /*This needs to be changed to be a bit more robust*/
 104 static int
 105 gpprobe(struct isa_device *dvp)
 106 {
 107         int     status;
 108         struct gpib_softc *sc = &gpib_sc;
 109
 110         gpib_port = dvp->id_iobase;
 111         status=1;
 112         sc->sc_type=3;
 113 if ((inb(KSR)&0xF7)==0x34) sc->sc_type=3;
 114 else if ((inb(KSR)&0xF7)==0x24) sc->sc_type=2;
 115 else if ((inb(KSR)&0xF7)==0x14) sc->sc_type=1;
 116           else status=0;
 117
 118         return (status);
 119 }
 120
 121 /*
 122  * gpattach()
 123  *  Attach device and print the type of card to the screen.
 124  */
 125 static int
 126 gpattach(isdp)
 127         struct isa_device *isdp;
 128 {
 129         struct   gpib_softc   *sc = &gpib_sc;
 130
 131         sc->sc_unit = isdp->id_unit;
 132         if (sc->sc_type==3)
 133            printf ("gp%d: type AT-GPIB/TNT\n",sc->sc_unit);
 134         if (sc->sc_type==2)
 135            printf ("gp%d: type AT-GPIB chip NAT4882B\n",sc->sc_unit);
 136         if (sc->sc_type==1)
 137            printf ("gp%d: type AT-GPIB chip NAT4882A\n",sc->sc_unit);
 138         sc->sc_flags |=ATTACHED;
 139
 140         cdevsw_add(&gp_cdevsw, -1, sc->sc_unit);
 141         make_dev(&gp_cdevsw, sc->sc_unit, 0, 0, 0600, "gp");
 142         return (1);
 143 }
 144
 145 /*
 146  * gpopen()
 147  *      New open on device.
 148  *
 149  * More than 1 open is not allowed on the entire device.
 150  * i.e. even if gpib5 is open, we can't open another minor device
 151  */
 152 static  int
 153 gpopen(dev, flags, fmt, td)
 154         dev_t dev;
 155         int flags;
 156         int fmt;
 157         struct thread *td;
 158 {
 159         struct gpib_softc *sc = &gpib_sc;
 160         u_char unit;
 161         int status;
 162
 163        unit= minor(dev);
 164
 165         /* minor number out of limits ? */
 166         if (unit >= 32)
 167                 return (ENXIO);
 168
 169         /* Attached ? */
 170         if (!(sc->sc_flags&ATTACHED)) { /* not attached */
 171                 return(ENXIO);
 172         }
 173
 174         /* Already open  */
 175         if (sc->sc_flags&OPEN) { /* too late .. */
 176                 return(EBUSY);
 177         }
 178
 179         /* Have memory for buffer? */
 180         sc->sc_inbuf = malloc(BUFSIZE, M_DEVBUF, M_WAITOK);
 181         if (sc->sc_inbuf == 0)
 182                 return(ENOMEM);
 183
 184         if (initgpib()) return(EBUSY);
 185         sc->sc_flags |= OPEN;
 186         sc->sc_count = 0;
 187         oldcount=0;
 188 if (unit!=0) {  /*Someone is trying to access an actual device*/
 189                 /*So.. we'll address it to listen*/
 190 enableremote(unit);
 191  do {
 192  status=inb(ISR2);
 193  }
 194  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 195
 196  outb(CDOR,(unit&31)+32);/*address device to listen*/
 197
 198  do
 199  status=inb(ISR2);
 200  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 201  outb (CDOR,64); /*Address controller (me) to talk*/
 202  do status=inb(ISR2);
 203
 204  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 205  outb(AUXMR,gts); /*Set to Standby (Controller)*/
 206
 207
 208  do
 209  status=inb(ISR1);
 210  while (!(status&2)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 211 /*Set up the TURBO488 registers*/
 212  outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
 213  outb(CNT0,0);   /*NOTE this does not enable DMA to the host computer!!*/
 214  outb(CNT1,0);
 215  outb(CNT2,0);
 216  outb(CNT3,0);
 217  outb(CMDR,0x20);
 218  outb(CFG,0x47); /* 16 bit, write, fifo B first, TMOE TIM */
 219  outb(CMDR,0x10); /*RESET fifos*/
 220  outb(CMDR,0x04); /*Tell TURBO488 to GO*/
 221 }
 222         return(0);
 223 }
 224
 225
 226 /*
 227  * gpclose()
 228  *      Close gpib device.
 229  */
 230 static  int
 231 gpclose(dev, flags, fmt, td)
 232         dev_t dev;
 233         int flags;
 234         int fmt;
 235         struct thread *td;
 236 {
 237         struct gpib_softc *sc = &gpib_sc;
 238         unsigned char unit;
 239         unsigned char status;
 240
 241         unit=minor(dev);
 242 if (unit!=0) { /*Here we need to send the last character with EOS*/
 243                /*and unaddress the listening device*/
 244
 245
 246   status=EWOULDBLOCK;
 247
 248   /*Wait for fifo to become empty*/
 249   do {
 250   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 251    }
 252   while ((inb(ISR3)&0x04)&&status==EWOULDBLOCK); /*Fifo is not empty*/
 253
 254  outb(CMDR,0x08); /*Issue STOP to TURBO488*/
 255
 256   /*Wait for DONE and STOP*/
 257  if (status==EWOULDBLOCK) do {
 258    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 259    }
 260   while (!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*not done and stop*/
 261
 262 /*Shut down TURBO488 */
 263  outb(IMR2,0x00); /*DISABLE DMA to turbo488*/
 264  outb(CMDR,0x20); /*soft reset turbo488*/
 265  outb(CMDR,0x10); /*reset fifos*/
 266
 267
 268 /*Send last byte with EOI set*/
 269 /*Send second to last byte if there are 2 bytes left*/
 270 if (status==EWOULDBLOCK)  {
 271
 272 do
 273  if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
 274 while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
 275 if (oldcount==2){
 276  outb(CDOR,oldbytes[0]); /*Send second to last byte*/
 277  while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
 278   status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
 279  }
 280
 281    outb(AUXMR,seoi);  /*Set EOI for the last byte*/
 282    outb(AUXMR,0x5E); /*Clear SYNC*/
 283    if (oldcount==1)
 284    outb(CDOR,oldbytes[0]);
 285     else
 286    if (oldcount==2)
 287    outb(CDOR,oldbytes[1]);
 288    else {
 289    outb (CDOR,13); /*Send a CR.. we've got trouble*/
 290    printf("gpib: Warning: gpclose called with nothing left in buffer\n");
 291    }
 292 }
 293
 294 do
 295  if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
 296 while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
 297
 298
 299  if (!(inb(ISR1)&2)&&status==EWOULDBLOCK) do
 300    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 301  while (!(inb(ISR1)&2)&&status==EWOULDBLOCK);
 302
 303
 304  outb(AUXMR,tca); /* Regain full control of the bus*/
 305
 306
 307  do
 308   status=inb(ISR2);
 309  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 310  outb(CDOR,63); /*unlisten*/
 311  do
 312   status=inb(ISR2);
 313  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 314  outb(AUXMR,0x5E); /*Clear SYNC*/
 315  outb (CDOR,95);/*untalk*/
 316  do
 317   status=inb(ISR2);
 318  while (!(status&8)&&tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1)==EWOULDBLOCK);
 319 /*gotolocal(minor(dev));*/
 320 }
 321         closegpib();
 322         sc->sc_flags = ATTACHED;
 323         free(sc->sc_inbuf, M_DEVBUF);
 324         sc->sc_inbuf = 0;       /* Sanity */
 325         return(0);
 326 }
 327
 328 /*
 329  * gpwrite()
 330  *      Copy from user's buffer, then write to GPIB device referenced
 331  *    by minor(dev).
 332  */
 333 static  int
 334 gpwrite(dev, uio, ioflag)
 335         dev_t dev;
 336         struct uio *uio;
 337         int ioflag;
 338 {
 339         int err,count;
 340
 341         /* main loop */
 342         while ((gpib_sc.sc_count = MIN(BUFSIZE-1, uio->uio_resid)) > 0) {
 343                 /*  If there were >1 bytes left over, send them  */
 344                 if (oldcount==2)
 345                   sendrawgpibfifo(minor(dev),oldbytes,2);
 346
 347                 /*If there was 1 character left, put it at the beginning
 348                    of the new buffer*/
 349                 if (oldcount==1){
 350                    (gpib_sc.sc_inbuf)[0]=oldbytes[0];
 351                    gpib_sc.sc_cp = gpib_sc.sc_inbuf;
 352                 /*  get from user-space  */
 353                    uiomove(gpib_sc.sc_inbuf+1, gpib_sc.sc_count, uio);
 354                    gpib_sc.sc_count++;
 355                    }
 356                  else {
 357                 gpib_sc.sc_cp = gpib_sc.sc_inbuf;
 358                 /*  get from user-space  */
 359                 uiomove(gpib_sc.sc_inbuf, gpib_sc.sc_count, uio);
 360                     }
 361
 362 /*NOTE we always leave one byte in case this is the last write
 363   so close can send EOI with the last byte There may be 2 bytes
 364   since we are doing 16 bit transfers.(note the -1 in the count below)*/
 365       /*If count<=2 we'll either pick it up on the next write or on close*/
 366             if (gpib_sc.sc_count>2) {
 367                 count = sendrawgpibfifo(minor(dev),gpib_sc.sc_cp,gpib_sc.sc_count-1);
 368                 err=!count;
 369                 if (err)
 370                         return(1);
 371                 oldcount=gpib_sc.sc_count-count; /*Set # of remaining bytes*/
 372                 gpib_sc.sc_count-=count;
 373                 gpib_sc.sc_cp+=count; /*point char pointer to remaining bytes*/
 374               }
 375                 else oldcount=gpib_sc.sc_count;
 376                   oldbytes[0]=gpib_sc.sc_cp[0];
 377                 if (oldcount==2)
 378                   oldbytes[1]=gpib_sc.sc_cp[1];
 379         }
 380         return(0);
 381 }
 382 /* Here is how you would usually access a GPIB device
 383    An exception would be a plotter or printer that you can just
 384    write to using a minor device = its GPIB address */
 385
 386 static  int
 387 gpioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td)
 388 {
 389         struct gpibdata *gd = (struct gpibdata *)data;
 390         int     error,result;
 391         error = 0;
 392
 393         switch (cmd) {
 394         case GPIBWRITE:
 395                 sendgpibfifo(gd->address,gd->data,*(gd->count));
 396                 error=0;
 397                 break;
 398         case GPIBREAD:
 399                 result=readgpibfifo(gd->address,gd->data,*(gd->count));
 400                 *(gd->count)=result;
 401                 error=0;
 402                 break;
 403         case GPIBINIT:
 404                 initgpib();
 405                 error=0;
 406                 break;
 407         case GPIBTRIGGER:
 408                 trigger(gd->address);
 409                 error=0;
 410                 break;
 411         case GPIBREMOTE:
 412                 enableremote(gd->address);
 413                 error=0;
 414                 break;
 415         case GPIBLOCAL:
 416                 gotolocal(gd->address);
 417                 error=0;
 418                 break;
 419
 420         case GPIBMTRIGGER:
 421                 mtrigger(gd->data);
 422                 error=0;
 423                 break;
 424         case GPIBMREMOTE:
 425                 menableremote(gd->data);
 426                 error=0;
 427                 break;
 428         case GPIBMLOCAL:
 429                 mgotolocal(gd->data);
 430                 error=0;
 431                 break;
 432         case GPIBSPOLL:
 433                 *(gd->data)=spoll(gd->address);
 434                 error=0;
 435                 break;
 436         default:
 437                 error = ENODEV;
 438         }
 439
 440         return(error);
 441 }
 442
 443
 444
 445
 446 #if 0
 447 /*Just in case you want a dump of the registers...*/
 448
 449 static void showregs() {
 450  printf ("NAT4882:\n");
 451  printf ("ISR1=%X\t",inb(ISR1));
 452  printf ("ISR2=%X\t",inb(ISR2));
 453  printf ("SPSR=%X\t",inb(SPSR));
 454  printf ("KSR =%X\t",inb(KSR));
 455  printf ("ADSR=%X\t",inb(ADSR));
 456  printf ("CPTR=%X\t",inb(CPTR));
 457  printf ("SASR=%X\t",inb(SASR));
 458  printf ("ADR0=%X\t",inb(ADR0));
 459  printf ("ISR0=%X\t",inb(ISR0));
 460  printf ("ADR1=%X\t",inb(ADR1));
 461  printf ("BSR =%X\n",inb(BSR));
 462
 463  printf ("Turbo488\n");
 464  printf ("STS1=%X ",inb(STS1));
 465  printf ("STS2=%X ",inb(STS2));
 466  printf ("ISR3=%X ",inb(ISR3));
 467  printf ("CNT0=%X ",inb(CNT0));
 468  printf ("CNT1=%X ",inb(CNT1));
 469  printf ("CNT2=%X ",inb(CNT2));
 470  printf ("CNT3=%X ",inb(CNT3));
 471  printf ("IMR3=%X ",inb(IMR3));
 472  printf ("TIMER=%X\n",inb(TIMER));
 473
 474
 475  }
 476 #endif
 477 /*Set up the NAT4882 and TURBO488 registers */
 478 /*This will be nonsense to you unless you have a data sheet from
 479   National Instruments.  They should give you one if you call them*/
 480
 481 static int
 482 initgpib() {
 483   outb(CMDR,0x20);
 484   outb(CFG,0x16);
 485   outb(IMR3,0);
 486   outb(CMDR,0x10);
 487   outb(CNT0,0);
 488   outb(CNT1,0);
 489   outb(CNT2,0);
 490   outb(CNT3,0);
 491   outb(INTR,0); /* Put interrupt line in tri-state mode??*/
 492   outb(AUXMR,chip_reset);
 493
 494   outb(IMR1,0x10); /* send interrupt to TURBO488 when END received*/
 495   outb(IMR2,0);
 496   outb(IMR0,0x90); /* Do we want nba here too??? */
 497   outb(ADMR,1);
 498   outb(ADR,0);
 499   outb(ADR,128);
 500   outb(AUXMR,0xE9);
 501   outb(AUXMR,0x49);
 502   outb(AUXMR,0x70);
 503   outb(AUXMR,0xD0);
 504   outb(AUXMR,0xA0);
 505
 506   outb(EOSR,10); /*set EOS message to newline*/
 507                  /*should I make the default to interpret END as EOS?*/
 508                  /*It isn't now.  The following changes this*/
 509   outb(AUXMR,0x80);    /*No special EOS handling*/
 510  /*outb(AUXMR,0x88) */ /* Transmit END with EOS*/
 511  /*outb(AUXMR,0x84) */ /* Set END on EOS received*/
 512  /*outb(AUXMR,0x8C) */ /* Do both of the above*/
 513
 514
 515  /* outb(AUXMR,hldi); */ /*Perform RFD Holdoff for all data in*/
 516                          /*Not currently supported*/
 517
 518   outb(AUXMR,pon);
 519   outb(AUXMR,sic_rsc);
 520  tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 521
 522   outb(AUXMR,sic_rsc_off);
 523
 524 return(0);
 525
 526
 527    }
 528
 529 /*This is kind of Brute force..  But it works*/
 530
 531 static void
 532 closegpib()
 533 {
 534    outb(AUXMR,chip_reset);
 535 }
 536
 537 /*GPIB ROUTINES:
 538   These will also make little sense unless you have a data sheet.
 539   Note that the routines with an "m" in the beginning are for
 540   accessing multiple devices in one call*/
 541
 542
 543 /*This is one thing I could not figure out how to do correctly.
 544   I tried to use the auxilary  command to enable remote, but it
 545   never worked.  Here, I bypass everything and write to the BSR
 546   to enable the remote line.  NOTE that these lines are effectively
 547   "OR'ed" with the actual lines, so writing a 1 to the bit in the BSR
 548   forces the GPIB line true, no matter what the fancy circuitry of the
 549   NAT4882 wants to do with it*/
 550
 551 static void
 552 enableremote(unsigned char device)
 553 {
 554  int status;
 555
 556 status=EWOULDBLOCK;
 557   if (status==EWOULDBLOCK) do {
 558    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 559    }
 560   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 561
 562  outb(BSR,1);           /*Set REN bit on GPIB*/
 563   if (status==EWOULDBLOCK) do {
 564    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 565    }
 566   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 567  outb(CDOR,(device&31)+32); /*address device to listen*/
 568   if (status==EWOULDBLOCK) do {
 569    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 570    }
 571   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 572  outb (CDOR,63); /*Unaddress device*/
 573   if (status==EWOULDBLOCK) do {
 574    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 575    }
 576   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 577
 578  }
 579 /*This does not release the REM line on the gpib port, because if it did,
 580   all the remote devices would go to local mode.  This only sends the
 581   gotolocal message to one device.  Currently, REM is always held true
 582   after enableremote is called, and is reset only on a close of the
 583   gpib device */
 584
 585 static void
 586 gotolocal(unsigned char device)
 587 { int status;
 588   status=EWOULDBLOCK;
 589
 590   if (status==EWOULDBLOCK) do {
 591    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 592    }
 593   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 594
 595 outb(CDOR,(device&31)+32);
 596
 597   if (status==EWOULDBLOCK) do {
 598    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 599    }
 600   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 601
 602 outb(AUXMR,0x5E);  /*Clear SYNC*/
 603  outb (CDOR,1);
 604
 605   if (status==EWOULDBLOCK) do {
 606    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 607    }
 608   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 609
 610  outb(AUXMR,0x5E);
 611  outb (CDOR,63);/*unaddress device*/
 612
 613   if (status==EWOULDBLOCK) do {
 614    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 615    }
 616   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 617
 618  }
 619
 620
 621 static void
 622 menableremote(unsigned char *device)
 623 {
 624  int status, counter = 0;
 625
 626 status=EWOULDBLOCK;
 627   if (status==EWOULDBLOCK) do {
 628    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 629    }
 630   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 631
 632  outb(BSR,1);           /*Set REN bit on GPIB*/
 633  do
 634   {
 635   if (status==EWOULDBLOCK) do {
 636    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 637    }
 638   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 639  outb(CDOR,(device[counter]&31)+32); /*address device to listen*/
 640  counter++;
 641  }
 642  while (device[counter]<32);
 643
 644   if (status==EWOULDBLOCK) do {
 645    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 646    }
 647   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 648
 649  outb (CDOR,63); /*Unaddress device*/
 650   if (status==EWOULDBLOCK) do {
 651    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 652    }
 653   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 654
 655  }
 656
 657 static void
 658 mgotolocal(unsigned char *device)
 659 { int status;
 660   int counter=0;
 661 status=EWOULDBLOCK;
 662  if (device[counter]<32) do {
 663   if (status==EWOULDBLOCK) do {
 664    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 665    }
 666   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 667  outb(CDOR,(device[counter]&31)+32);
 668  counter++;
 669  } while (device[counter]<32);
 670   if (status==EWOULDBLOCK) do {
 671    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 672    }
 673   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 674
 675  outb(AUXMR,0x5E);  /*Clear SYNC*/
 676  outb (CDOR,1);
 677
 678
 679   if (status==EWOULDBLOCK) do {
 680    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 681    }
 682   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 683  outb(AUXMR,0x5E);
 684  outb (CDOR,63);/*unaddress device*/
 685   if (status==EWOULDBLOCK) do {
 686    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",2);
 687    }
 688   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 689
 690
 691  }
 692 /*Trigger a device.  What happens depends on how the device is
 693  configured.  */
 694
 695 static void
 696 trigger(unsigned char device)
 697 { int status;
 698
 699 status=EWOULDBLOCK;
 700  if (device<32)  {
 701   if (!(inb(ISR2)&0x08)) do {
 702    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 703    }
 704   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 705  outb(CDOR,(device&31)+32); /*address device to listen*/
 706   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 707    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 708    }
 709   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 710
 711  outb (CDOR,8);  /*send GET*/
 712
 713   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 714    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 715    }
 716   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 717  outb (AUXMR,0x5E);
 718  outb (CDOR,63);/*unaddress device*/
 719   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 720    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 721    }
 722   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 723
 724
 725  }
 726 }
 727
 728 /*Trigger multiple devices by addressing them all to listen, and then
 729   sending GET*/
 730
 731 static void
 732 mtrigger(unsigned char *device)
 733 { int status=EWOULDBLOCK;
 734   int counter=0;
 735  if(device[0]<32){
 736  do {
 737  if (device[counter]<32)
 738   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 739    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 740    }
 741   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 742  outb(CDOR,(device[counter]&31)+32); /*address device to listen*/
 743  counter++;
 744    }
 745  while (device[counter]<32);
 746   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 747    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 748    }
 749   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 750  outb (CDOR,8);  /*send GET*/
 751
 752   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 753    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 754    }
 755   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 756  outb (AUXMR,0x5E);
 757  outb (CDOR,63);/*unaddress device*/
 758   if (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK) do {
 759    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 760    }
 761   while (!(inb(ISR2)&0x08)&&status==EWOULDBLOCK); /*Wait to send next cmd*/
 762
 763
 764  }
 765 }
 766
 767 /*This is not used now, but it should work with NI's 8 bit gpib board
 768   since it does not use the TURBO488 registers at all */
 769
 770
 771 /*Send data through the TURBO488 FIFOS to a device that is already
 772  addressed to listen.  This is used by the write call when someone is
 773  writing to a printer or plotter, etc... */
 774 /*The last byte of each write is held off until either the next
 775  write or close, so it can be sent with EOI set*/
 776
 777 static int
 778 sendrawgpibfifo(unsigned char device,char *data,int count)
 779  {
 780  int status;
 781  int counter;
 782  int fifopos;
 783  int sleeptime;
 784
 785
 786  sleeptime=SLEEP_MIN;
 787  counter=0;
 788
 789
 790  fifopos=0;
 791
 792 status=EWOULDBLOCK;
 793  do {
 794   /*Wait for fifo to become not full if it is full */
 795   sleeptime=SLEEP_MIN;
 796   if (!(inb(ISR3)&0x08)) do {
 797    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",sleeptime);
 798    if (sleeptime<SLEEP_MAX) sleeptime=sleeptime*2;
 799    }
 800   while (!(inb(ISR3)&0x08)&&(status==EWOULDBLOCK)); /*Fifo is full*/
 801
 802    if((count>1)&&(inb(ISR3)&0x08)){
 803    outw(FIFOB,*(unsigned*)(data+counter));
 804  /*  printf ("gpib: sent:%c,%c\n",data[counter],data[counter+1]);*/
 805
 806   counter+=2;
 807   count-=2;
 808    }
 809   }
 810  while ((count>1)&&(status==EWOULDBLOCK));
 811 /*The write routine and close routine must check if there is 1
 812   byte left and handle it accordingly*/
 813
 814
 815 /*Return the number of bytes written to the device*/
 816  return(counter);
 817
 818
 819
 820 }
 821
 822 static int
 823 sendgpibfifo(unsigned char device,char *data,int count)
 824  {
 825  int status;
 826  int counter;
 827  int fifopos;
 828  int sleeptime;
 829
 830 outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
 831  outb(CNT0,0);
 832  outb(CNT1,0);
 833  outb(CNT2,0);
 834  outb(CNT3,0);
 835 status=EWOULDBLOCK;
 836  if (!(inb(ISR2)&8)) do
 837    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 838  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 839
 840  outb(CDOR,(device&31)+32);/*address device to listen*/
 841
 842  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
 843    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 844  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 845  outb (CDOR,64); /*Address controller (me) to talk*/
 846
 847  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
 848    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 849  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 850
 851  outb(AUXMR,gts); /*Set to Standby (Controller)*/
 852  fifopos=0;
 853
 854  sleeptime=SLEEP_MIN;
 855  counter=0;
 856
 857
 858  fifopos=0;
 859
 860  outb(CMDR,0x20);
 861  outb(CFG,0x47); /* 16 bit, write, fifo B first, TMOE TIM */
 862  outb(CMDR,0x10); /*RESET fifos*/
 863  outb(CCRG,seoi); /*program to send EOI at end*/
 864  outb(CMDR,0x04); /*Tell TURBO488 to GO*/
 865 status=EWOULDBLOCK;
 866  do {
 867   /*Wait for fifo to become not full if it is full */
 868   sleeptime=SLEEP_MIN;
 869   if (!(inb(ISR3)&0x08)) do {
 870    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",sleeptime);
 871    if (sleeptime<SLEEP_MAX) sleeptime=sleeptime*2;
 872    }
 873   while (!(inb(ISR3)&0x08)&&(status==EWOULDBLOCK)); /*Fifo is full*/
 874
 875    if((count>1)&&(inb(ISR3)&0x08)){
 876    /*if(count==2) outb(CFG,15+0x40); *//*send eoi when done*/
 877    outw(FIFOB,*(unsigned*)(data+counter));
 878
 879   counter+=2;
 880   count-=2;
 881    }
 882   }
 883  while ((count>2)&&(status==EWOULDBLOCK));
 884
 885  if (count==2&&status==EWOULDBLOCK) {
 886   /*Wait for fifo to become not full*/
 887   if(status==EWOULDBLOCK&&!(inb(ISR3)&0x08)) do {
 888    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",SLEEP_MIN);
 889    }
 890   while (!(inb(ISR3)&0x08)&&status==EWOULDBLOCK); /*Fifo is full*/
 891   /*outb(CFG,0x40+15);*//*send eoi when done*/
 892   outb(FIFOB,data[counter]);
 893   counter++;
 894   count--;
 895   }
 896
 897
 898  /*outb(CMDR,0x04);*/
 899
 900   /*Wait for fifo to become empty*/
 901   if (status==EWOULDBLOCK) do {
 902   status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 903    }
 904   while ((inb(ISR3)&0x04)&&status==EWOULDBLOCK); /*Fifo is not empty*/
 905
 906  outb(CMDR,0x08); /*Issue STOP to TURBO488*/
 907
 908   /*Wait for DONE and STOP*/
 909  if (status==EWOULDBLOCK) do {
 910    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 911    }
 912   while (!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*not done and stop*/
 913
 914  outb(IMR2,0x00); /*we have to enable DMA (0x30) for turbo488 to work*/
 915  outb(CMDR,0x20); /*soft reset turbo488*/
 916  outb(CMDR,0x10); /*reset fifos*/
 917
 918
 919 /*Send last byte with EOI set*/
 920 /*Here EOI is handled correctly since the string to be sent */
 921 /*is actually all sent during the ioctl.  (See above)*/
 922
 923 if (count==1&&status==EWOULDBLOCK)  {  /*Count should always=1 here*/
 924
 925 do
 926  if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
 927 while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
 928
 929    outb(AUXMR,seoi);  /*Set EOI for the last byte*/
 930    outb(AUXMR,0x5E); /*Clear SYNC*/
 931    outb(CDOR,data[counter]);
 932  counter++;
 933  count--;
 934 }
 935
 936 do
 937  if (!(inb(ISR1)&2)) status=tsleep((caddr_t)&gpib_sc, GPIBPRI,"gpibpoll",1);
 938 while (!(inb(ISR1)&2)&&(status==EWOULDBLOCK));
 939
 940
 941  if (!(inb(ISR1)&2)&&status==EWOULDBLOCK) do
 942    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 943  while (!(inb(ISR1)&2)&&status==EWOULDBLOCK);
 944  outb(AUXMR,tca); /* Regain full control of the bus*/
 945
 946
 947  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
 948    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 949    while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 950
 951    outb(CDOR,63); /*unlisten*/
 952
 953
 954  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
 955    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 956  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 957
 958
 959 outb(AUXMR,0x5E); /*Clear SYNC*/
 960  outb (CDOR,95);/*untalk*/
 961  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
 962    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 963  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 964
 965
 966  return(counter);
 967
 968
 969
 970 }
 971
 972 static int
 973 readgpibfifo(unsigned char device,char *data,int count)
 974 {
 975  int status;
 976  int status2 = 0;
 977  int status1;
 978  int counter;
 979  int fifopos;
 980  unsigned inword;
 981
 982  outb(IMR2,0x30); /*we have to enable DMA (0x30) for turbo488 to work*/
 983  /*outb(IMR3,0x1F);
 984  outb(INTR,1); */
 985  outb(CMDR,0x20);
 986
 987  outb(CFG,14+0x60+1); /* Halt on int,read, fifo B first, CCEN TMOE TIM */
 988  outb(CMDR,0x10); /*RESET fifos*/
 989  outb(CCRG,tcs); /*program to tcs at end*/
 990  outb(CMDR,0x08);/*STOP??*/
 991
 992
 993
 994 status=EWOULDBLOCK;
 995 do
 996    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
 997  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
 998
 999  outb (CDOR,32); /*Address controller (me) to listen*/
1000
1001   do
1002    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1003  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1004
1005  outb(CDOR,(device&31)+64);/*address device to talk*/
1006
1007
1008   do
1009    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1010  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1011
1012  outb(AUXMR,gts); /*Set to Standby (Controller)*/
1013
1014  counter=0;
1015  fifopos=0;
1016
1017   outb(CMDR,0x04); /*Tell TURBO488 to GO*/
1018
1019
1020  do {
1021    status1=inb(ISR3);
1022    if (!(status1&0x01)&&(status1&0x04)){
1023    status2=inb(STS2);
1024    inword=inw(FIFOB);
1025    *(unsigned*)(data+counter)=inword;
1026   /* printf ("Read:%c,%c\n",data[counter],data[counter+1]);*/
1027   counter+=2;
1028   }
1029  else {
1030    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",4);
1031   }
1032  }
1033  while (!(status1&0x01)&&status==EWOULDBLOCK);
1034  if(!(status2 & 0x04)){ /*Only 1 byte came in on last 16 bit transfer*/
1035   data[counter-1]=0;
1036   counter--; }
1037   else
1038     data[counter]=0;
1039  outb(CMDR,0x08); /*send STOP*/
1040
1041  do{
1042    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1043    }
1044  while(!(inb(ISR3)&0x11)&&status==EWOULDBLOCK); /*wait for DONE and STOP*/
1045  outb(AUXMR,0x55);
1046
1047  outb(IMR2,0x00); /*we have to enable DMA (0x30) for turbo488 to work*/
1048  outb(CMDR,0x20); /*soft reset turbo488*/
1049  outb(CMDR,0x10); /*reset fifos*/
1050
1051 /* do
1052    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1053  while (!(inb(ISR1)&2));*/
1054  outb(AUXMR,tca); /* Regain full control of the bus*/
1055
1056
1057  do
1058    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1059  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1060  outb(CDOR,63); /*unlisten*/
1061
1062  do
1063    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1064  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1065
1066 outb(AUXMR,0x5E); /*Clear SYNC*/
1067  outb (CDOR,95);/*untalk*/
1068  do
1069    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1070  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1071
1072  return(counter);
1073
1074
1075 }
1076
1077
1078 /* Return the status byte from device */
1079 static char
1080 spoll(unsigned char device)
1081  {
1082  int status=EWOULDBLOCK;
1083  unsigned int statusbyte;
1084
1085  if (!(inb(ISR2)&8)) do
1086    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1087  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1088
1089  outb(CDOR,(device&31)+64);/*address device to talk*/
1090
1091  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1092    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1093  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1094
1095  outb (CDOR,32); /*Address controller (me) to listen*/
1096
1097  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1098    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1099  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1100  outb(AUXMR,0x5E);
1101  outb (CDOR,0x18); /*Send SPE (serial poll enable)*/
1102  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1103    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1104  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1105
1106   /*wait for bus to be synced*/
1107  if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
1108    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1109  while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
1110
1111  outb(AUXMR,gts); /*Set to Standby (Controller)*/
1112
1113  if (!(inb(ISR1)&1)&&status==EWOULDBLOCK) do
1114    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1115  while (!(inb(ISR1)&1)&&status==EWOULDBLOCK);
1116  outb(AUXMR,0x5E);
1117  outb(AUXMR,tcs); /* Take control after next read*/
1118  statusbyte=inb(DIR);
1119
1120  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1121    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1122  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1123
1124  outb(CDOR,0x19); /*SPD (serial poll disable)*/
1125
1126   /*wait for bus to be synced*/
1127  if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
1128    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1129  while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
1130
1131
1132  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1133    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1134  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1135
1136 outb(CDOR,95); /*untalk*/
1137
1138  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1139    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1140  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1141  outb(AUXMR,0x5E);
1142  outb (CDOR,63);/*unlisten*/
1143  if (!(inb(ISR2)&8)&&status==EWOULDBLOCK) do
1144    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1145  while (!(inb(ISR2)&8)&&status==EWOULDBLOCK);
1146
1147   /*wait for bus to be synced*/
1148  if (!(inb(ISR0)&1)&&status==EWOULDBLOCK) do
1149    status=tsleep((caddr_t)&gpib_sc,GPIBPRI,"gpibpoll",1);
1150  while (!(inb(ISR0)&1)&&status==EWOULDBLOCK);
1151
1152
1153  return(statusbyte);
1154
1155
1156 }