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