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