Let the compiler decide what code should be inlined and what not.
[dragonfly.git] / sys / dev / misc / labpc / labpc.c
1 /*
2  * Copyright (c) 1995 HD Associates, Inc.
3  * All rights reserved.
4  *
5  * HD Associates, Inc.
6  * PO Box 276
7  * Pepperell, MA 01463-0276
8  * dufault@hda.com
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by HD Associates, Inc.
21  * 4. The name of HD Associates, Inc.
22  *    may not be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  * Written by:
38  * Peter Dufault
39  * dufault@hda.com
40  *
41  * $FreeBSD: src/sys/i386/isa/labpc.c,v 1.35 1999/09/25 18:24:08 phk Exp $
42  * $DragonFly: src/sys/dev/misc/labpc/labpc.c,v 1.12 2005/06/16 16:04:28 joerg Exp $
43  *
44  */
45
46 #include "use_labpc.h"
47 #include "opt_debug_outb.h"
48 #include <sys/param.h>
49
50 #include <sys/systm.h>
51
52 #include <sys/kernel.h>
53 #include <sys/malloc.h>
54 #include <sys/buf.h>
55 #define b_actf  b_act.tqe_next
56 #include <sys/dataacq.h>
57 #include <sys/conf.h>
58 #include <sys/thread2.h>
59
60 #ifdef LOUTB
61 #include <machine/clock.h>
62 #endif
63
64 #include <bus/isa/i386/isa_device.h>
65
66
67
68 /* Miniumum timeout:
69  */
70 #ifndef LABPC_MIN_TMO
71 #define LABPC_MIN_TMO (hz)
72 #endif
73
74 #ifndef LABPC_DEFAULT_HERTZ
75 #define LABPC_DEFAULT_HERTZ 500
76 #endif
77
78 /* Minor number:
79  * UUSIDCCC
80  * UU: Board unit.
81  * S: SCAN bit for scan enable.
82  * I: INTERVAL for interval support
83  * D: 1: Digital I/O, 0: Analog I/O
84  * CCC: Channel.
85  *  Analog (D==0):
86  *  input: channel must be 0 to 7.
87  *  output: channel must be 0 to 2
88  *          0: D-A 0
89  *          1: D-A 1
90  *          2: Alternate channel 0 then 1
91  *
92  *  Digital (D==1):
93  *  input: Channel must be 0 to 2.
94  *  output: Channel must be 0 to 2.
95  */
96
97 /* Up to four boards:
98  */
99 #define MAX_UNITS 4
100 #define UNIT(dev) (((minor(dev) & 0xB0) >> 6) & 0x3)
101
102 #define SCAN(dev)     ((minor(dev) & 0x20) >> 5)
103 #define INTERVAL(dev) ((minor(dev) & 0x10) >> 4)
104 #define DIGITAL(dev)  ((minor(dev) & 0x08) >> 3)
105
106 /* Eight channels:
107  */
108
109 #define CHAN(dev) (minor(dev) & 0x7)
110
111 /* History: Derived from "dt2811.c" March 1995
112  */
113
114 struct ctlr
115 {
116         int err;
117 #define DROPPED_INPUT 0x100
118         int base;
119         int unit;
120         unsigned long flags;
121 #define BUSY 0x00000001
122
123         u_char cr_image[4];
124
125         u_short sample_us;
126
127         struct buf start_queue; /* Start queue */
128         struct buf *last;       /* End of start queue */
129         u_char *data;
130         u_char *data_end;
131         long tmo;                       /* Timeout in Hertz */
132         long min_tmo;           /* Timeout in Hertz */
133         int cleared_intr;
134
135         int gains[8];
136
137         dev_t dev;                      /* Copy of device */
138
139         void (*starter)(struct ctlr *ctlr, long count);
140         void (*stop)(struct ctlr *ctlr);
141         void (*intr)(struct ctlr *ctlr);
142
143         /* Digital I/O support.  Copy of Data Control Register for 8255:
144          */
145         u_char dcr_val, dcr_is;
146
147         /*
148          * Handle for canceling our timeout.
149          */
150         struct callout  ch;
151
152         /* Device configuration structure:
153          */
154 };
155
156 #ifdef LOUTB
157 /* loutb is a slow outb for debugging.  The overrun test may fail
158  * with this for some slower processors.
159  */
160 static void
161 loutb(int port, u_char val)
162 {
163         outb(port, val);
164         DELAY(1);
165 }
166 #else
167 #define loutb(port, val) outb(port, val)
168 #endif
169
170 static struct ctlr **labpcs;    /* XXX: Should be dynamic */
171
172 /* CR_EXPR: A macro that sets the shadow register in addition to
173  * sending out the data.
174  */
175 #define CR_EXPR(LABPC, CR, EXPR) do { \
176         (LABPC)->cr_image[CR - 1] EXPR ; \
177         loutb(((LABPC)->base + ( (CR == 4) ? (0x0F) : (CR - 1))), ((LABPC)->cr_image[(CR - 1)])); \
178 } while (0)
179
180 #define CR_CLR(LABPC, CR) CR_EXPR(LABPC, CR, &=0)
181 #define CR_REFRESH(LABPC, CR) CR_EXPR(LABPC, CR, &=0xff)
182 #define CR_SET(LABPC, CR, EXPR) CR_EXPR(LABPC, CR, = EXPR)
183
184 /* Configuration and Status Register Group.
185  */
186 #define     CR1(LABPC) ((LABPC)->base + 0x00)   /* Page 4-5 */
187         #define SCANEN    0x80
188         #define GAINMASK  0x70
189         #define GAIN(LABPC, SEL) do { \
190                 (LABPC)->cr_image[1 - 1] &= ~GAINMASK; \
191                 (LABPC)->cr_image[1 - 1] |= (SEL << 4); \
192                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
193                 } while (0)
194
195         #define TWOSCMP   0x08
196         #define MAMASK    0x07
197         #define MA(LABPC, SEL) do { \
198                 (LABPC)->cr_image[1 - 1] &= ~MAMASK; \
199                 (LABPC)->cr_image[1 - 1] |= SEL; \
200                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
201                 } while (0)
202
203 #define  STATUS(LABPC) ((LABPC)->base + 0x00)   /* Page 4-7 */
204         #define LABPCPLUS 0x80
205         #define EXTGATA0  0x40
206         #define GATA0     0x20
207         #define DMATC     0x10
208         #define CNTINT    0x08
209         #define OVERFLOW  0x04
210         #define OVERRUN   0x02
211         #define DAVAIL    0x01
212
213 #define     CR2(LABPC) ((LABPC)->base + 0x01)   /* Page 4-9 */
214         #define LDAC1     0x80
215         #define LDAC0     0x40
216         #define _2SDAC1   0x20
217         #define _2SDAC0   0x10
218         #define TBSEL     0x08
219         #define SWTRIG    0x04
220         #define HWTRIG    0x02
221         #define PRETRIG   0x01
222         #define SWTRIGGERRED(LABPC) ((LABPC->cr_image[1]) & SWTRIG)
223
224 #define     CR3(LABPC) ((LABPC)->base + 0x02)   /* Page 4-11 */
225         #define FIFOINTEN 0x20
226         #define ERRINTEN  0x10
227         #define CNTINTEN  0x08
228         #define TCINTEN   0x04
229         #define DIOINTEN  0x02
230         #define DMAEN     0x01
231
232         #define ALLINTEN  0x3E
233         #define FIFOINTENABLED(LABPC) ((LABPC->cr_image[2]) & FIFOINTEN)
234
235 #define     CR4(LABPC) ((LABPC)->base + 0x0F)   /* Page 4-13 */
236         #define ECLKRCV   0x10
237         #define SE_D      0x08
238         #define ECKDRV    0x04
239         #define EOIRCV    0x02
240         #define INTSCAN   0x01
241
242 /* Analog Input Register Group
243  */
244 #define   ADFIFO(LABPC) ((LABPC)->base + 0x0A)  /* Page 4-16 */
245 #define  ADCLEAR(LABPC) ((LABPC)->base + 0x08)  /* Page 4-18 */
246 #define  ADSTART(LABPC) ((LABPC)->base + 0x03)  /* Page 4-19 */
247 #define DMATCICLR(LABPC) ((LABPC)->base + 0x0A) /* Page 4-20 */
248
249 /* Analog Output Register Group
250  */
251 #define    DAC0L(LABPC) ((LABPC)->base + 0x04)  /* Page 4-22 */
252 #define    DAC0H(LABPC) ((LABPC)->base + 0x05)  /* Page 4-22 */
253 #define    DAC1L(LABPC) ((LABPC)->base + 0x06)  /* Page 4-22 */
254 #define    DAC1H(LABPC) ((LABPC)->base + 0x07)  /* Page 4-22 */
255
256 /* 8253 registers:
257  */
258 #define A0DATA(LABPC) ((LABPC)->base + 0x14)
259 #define A1DATA(LABPC) ((LABPC)->base + 0x15)
260 #define A2DATA(LABPC) ((LABPC)->base + 0x16)
261 #define AMODE(LABPC) ((LABPC)->base + 0x17)
262
263 #define TICR(LABPC) ((LABPC)->base + 0x0c)
264
265 #define B0DATA(LABPC) ((LABPC)->base + 0x18)
266 #define B1DATA(LABPC) ((LABPC)->base + 0x19)
267 #define B2DATA(LABPC) ((LABPC)->base + 0x1A)
268 #define BMODE(LABPC) ((LABPC)->base + 0x1B)
269
270 /* 8255 registers:
271  */
272
273 #define PORTX(LABPC, X) ((LABPC)->base + 0x10 + X)
274
275 #define PORTA(LABPC) PORTX(LABPC, 0)
276 #define PORTB(LABPC) PORTX(LABPC, 1)
277 #define PORTC(LABPC) PORTX(LABPC, 2)
278
279 #define DCR(LABPC) ((LABPC)->base + 0x13)
280
281 static int labpcattach(struct isa_device *dev);
282 static int labpcprobe(struct isa_device *dev);
283 struct isa_driver labpcdriver =
284         { labpcprobe, labpcattach, "labpc", 0  };
285
286 static  d_open_t        labpcopen;
287 static  d_close_t       labpcclose;
288 static  d_ioctl_t       labpcioctl;
289 static  d_strategy_t    labpcstrategy;
290
291 #define CDEV_MAJOR 66
292 static struct cdevsw labpc_cdevsw = {
293         /* name */      "labpc",
294         /* maj */       CDEV_MAJOR,
295         /* flags */     0,
296         /* port */      NULL,
297         /* clone */     NULL,
298
299         /* open */      labpcopen,
300         /* close */     labpcclose,
301         /* read */      physread,
302         /* write */     physwrite,
303         /* ioctl */     labpcioctl,
304         /* poll */      nopoll,
305         /* mmap */      nommap,
306         /* strategy */  labpcstrategy,
307         /* dump */      nodump,
308         /* psize */     nopsize
309 };
310
311 static ointhand2_t labpcintr;
312 static void start(struct ctlr *ctlr);
313
314 static void
315 bp_done(struct buf *bp, int err)
316 {
317         bp->b_error = err;
318
319         if (err || bp->b_resid)
320         {
321                 bp->b_flags |= B_ERROR;
322         }
323
324         biodone(bp);
325 }
326
327 static void tmo_stop(void *p);
328
329 static void
330 done_and_start_next(struct ctlr *ctlr, struct buf *bp, int err)
331 {
332         bp->b_resid = ctlr->data_end - ctlr->data;
333
334         ctlr->data = 0;
335
336         ctlr->start_queue.b_actf = bp->b_actf;
337         bp_done(bp, err);
338
339         callout_stop(&ctlr->ch);
340
341         start(ctlr);
342 }
343
344 static void
345 ad_clear(struct ctlr *ctlr)
346 {
347         int i;
348         loutb(ADCLEAR(ctlr), 0);
349         for (i = 0; i < 10000 && (inb(STATUS(ctlr)) & GATA0); i++)
350                 ;
351         (void)inb(ADFIFO(ctlr));
352         (void)inb(ADFIFO(ctlr));
353 }
354
355 /* reset: Reset the board following the sequence on page 5-1
356  */
357 static void
358 reset(struct ctlr *ctlr)
359 {
360         crit_enter();
361         CR_CLR(ctlr, 3);        /* Turn off interrupts first */
362         crit_exit();
363
364         CR_CLR(ctlr, 1);
365         CR_CLR(ctlr, 2);
366         CR_CLR(ctlr, 4);
367
368         loutb(AMODE(ctlr), 0x34);
369         loutb(A0DATA(ctlr),0x0A);
370         loutb(A0DATA(ctlr),0x00);
371
372         loutb(DMATCICLR(ctlr), 0x00);
373         loutb(TICR(ctlr), 0x00);
374
375         ad_clear(ctlr);
376
377         loutb(DAC0L(ctlr), 0);
378         loutb(DAC0H(ctlr), 0);
379         loutb(DAC1L(ctlr), 0);
380         loutb(DAC1H(ctlr), 0);
381
382         ad_clear(ctlr);
383 }
384
385 /* overrun: slam the start convert register and OVERRUN should get set:
386  */
387 static u_char
388 overrun(struct ctlr *ctlr)
389 {
390         int i;
391
392         u_char status = inb(STATUS(ctlr));
393         for (i = 0; ((status & OVERRUN) == 0) && i < 100; i++)
394         {
395                 loutb(ADSTART(ctlr), 1);
396                 status = inb(STATUS(ctlr));
397         }
398
399         return status;
400 }
401
402 static int
403 labpcinit(void)
404 {
405         if (NLABPC > MAX_UNITS)
406                 return 0;
407
408         labpcs = malloc(NLABPC * sizeof(struct ctlr *), M_DEVBUF, 
409                         M_WAITOK | M_ZERO);
410         /*
411          * XXX this is really odd code, adding the device only if
412          * the allocation fails?  it could be broken.
413          */
414         if (labpcs) {
415                 return 1;
416         }
417         return 0;
418 }
419
420 static int
421 labpcprobe(struct isa_device *dev)
422 {
423         static int unit;
424         struct ctlr scratch, *ctlr, *l;
425         u_char status;
426
427         if (!labpcs)
428         {
429                 if (labpcinit() == 0)
430                 {
431                         printf("labpcprobe: init failed\n");
432                         return 0;
433                 }
434         }
435
436         if (unit > NLABPC)
437         {
438                 printf("Too many LAB-PCs.  Reconfigure O/S.\n");
439                 return 0;
440         }
441         ctlr = &scratch;        /* Need somebody with the right base for the macros */
442         ctlr->base = dev->id_iobase;
443
444         /* XXX: There really isn't a perfect way to probe this board.
445          *      Here is my best attempt:
446          */
447         reset(ctlr);
448
449         /* After reset none of these bits should be set:
450          */
451         status = inb(STATUS(ctlr));
452         if (status & (GATA0 | OVERFLOW | DAVAIL | OVERRUN))
453                 return 0;
454
455         /* Now try to overrun the board FIFO and get the overrun bit set:
456          */
457         status = overrun(ctlr);
458
459         if ((status & OVERRUN) == 0)    /* No overrun bit set? */
460                 return 0;
461
462         /* Assume we have a board.
463          */
464         reset(ctlr);
465
466         l = malloc(sizeof(struct ctlr), M_DEVBUF, M_WAITOK | M_ZERO);
467         l->base = ctlr->base;
468         l->unit = unit;
469         labpcs[unit] = l;
470         dev->id_unit = l->unit;
471
472         unit++;
473         return 0x20;
474 }
475
476 /* attach: Set things in a normal state.
477  */
478 static int
479 labpcattach(struct isa_device *dev)
480 {
481         struct ctlr *ctlr = labpcs[dev->id_unit];
482
483         dev->id_ointr = labpcintr;
484         callout_init(&ctlr->ch);
485         ctlr->sample_us = (1000000.0 / (double)LABPC_DEFAULT_HERTZ) + .50;
486         reset(ctlr);
487
488         ctlr->min_tmo = LABPC_MIN_TMO;
489
490         ctlr->dcr_val = 0x80;
491         ctlr->dcr_is = 0x80;
492         loutb(DCR(ctlr), ctlr->dcr_val);
493
494         cdevsw_add(&labpc_cdevsw, -1, dev->id_unit);
495         make_dev(&labpc_cdevsw, dev->id_unit, 0, 0, 0600, 
496                 "labpc%d", dev->id_unit);
497         return 1;
498 }
499
500 /* Null handlers:
501  */
502 static void null_intr (struct ctlr *ctlr)             { }
503 static void null_start(struct ctlr *ctlr, long count) { }
504 static void null_stop (struct ctlr *ctlr)             { }
505
506 static void
507 trigger(struct ctlr *ctlr)
508 {
509         CR_EXPR(ctlr, 2, |= SWTRIG);
510 }
511
512 static void
513 ad_start(struct ctlr *ctlr, long count)
514 {
515         if (!SWTRIGGERRED(ctlr)) {
516                 int chan = CHAN(ctlr->dev);
517                 CR_EXPR(ctlr, 1, &= ~SCANEN);
518                 CR_EXPR(ctlr, 2, &= ~TBSEL);
519
520                 MA(ctlr, chan);
521                 GAIN(ctlr, ctlr->gains[chan]);
522
523                 if (SCAN(ctlr->dev))
524                         CR_EXPR(ctlr, 1, |= SCANEN);
525
526                 loutb(AMODE(ctlr), 0x34);
527                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
528                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
529                 loutb(AMODE(ctlr), 0x70);
530
531                 ad_clear(ctlr);
532                 trigger(ctlr);
533         }
534
535         ctlr->tmo = ((count + 16) * (long)ctlr->sample_us * hz) / 1000000 +
536                 ctlr->min_tmo;
537 }
538
539 static void
540 ad_interval_start(struct ctlr *ctlr, long count)
541 {
542         int chan = CHAN(ctlr->dev);
543         int n_frames = count / (chan + 1);
544
545         if (!SWTRIGGERRED(ctlr)) {
546                 CR_EXPR(ctlr, 1, &= ~SCANEN);
547                 CR_EXPR(ctlr, 2, &= ~TBSEL);
548
549                 MA(ctlr, chan);
550                 GAIN(ctlr, ctlr->gains[chan]);
551
552                 /* XXX: Is it really possible that you clear INTSCAN as
553                  * the documentation says?  That seems pretty unlikely.
554                  */
555                 CR_EXPR(ctlr, 4, &= ~INTSCAN);  /* XXX: Is this possible? */
556
557                 /* Program the sample interval counter to run as fast as
558                  * possible.
559                  */
560                 loutb(AMODE(ctlr), 0x34);
561                 loutb(A0DATA(ctlr), (u_char)(0x02));
562                 loutb(A0DATA(ctlr), (u_char)(0x00));
563                 loutb(AMODE(ctlr), 0x70);
564
565                 /* Program the interval scanning counter to run at the sample
566                  * frequency.
567                  */
568                 loutb(BMODE(ctlr), 0x74);
569                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
570                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
571                 CR_EXPR(ctlr, 1, |= SCANEN);
572
573                 ad_clear(ctlr);
574                 trigger(ctlr);
575         }
576
577         /* Each frame time takes two microseconds per channel times
578          * the number of channels being sampled plus the sample period.
579          */
580         ctlr->tmo = ((n_frames + 16) *
581         ((long)ctlr->sample_us + (chan + 1 ) * 2 ) * hz) / 1000000 +
582                 ctlr->min_tmo;
583 }
584
585 static void
586 all_stop(struct ctlr *ctlr)
587 {
588         reset(ctlr);
589 }
590
591 static void
592 tmo_stop(void *p)
593 {
594         struct ctlr *ctlr = (struct ctlr *)p;
595         struct buf *bp;
596
597         crit_enter();
598
599         if (ctlr == 0)
600         {
601                 printf("labpc?: Null ctlr struct?\n");
602                 crit_exit();
603                 return;
604         }
605
606         printf("labpc%d: timeout", ctlr->unit);
607
608         (*ctlr->stop)(ctlr);
609
610         bp = ctlr->start_queue.b_actf;
611
612         if (bp == 0) {
613                 printf(", Null bp.\n");
614                 crit_exit();
615                 return;
616         }
617
618         printf("\n");
619
620         done_and_start_next(ctlr, bp, ETIMEDOUT);
621
622         crit_exit();
623 }
624
625 static void ad_intr(struct ctlr *ctlr)
626 {
627         u_char status;
628
629         if (ctlr->cr_image[2] == 0)
630         {
631                 if (ctlr->cleared_intr)
632                 {
633                         ctlr->cleared_intr = 0;
634                         return;
635                 }
636
637                 printf("ad_intr (should not happen) interrupt with interrupts off\n");
638                 printf("status %x, cr3 %x\n", inb(STATUS(ctlr)), ctlr->cr_image[2]);
639                 return;
640         }
641
642         while ( (status = (inb(STATUS(ctlr)) & (DAVAIL|OVERRUN|OVERFLOW)) ) )
643         {
644                 if ((status & (OVERRUN|OVERFLOW)))
645                 {
646                         struct buf *bp = ctlr->start_queue.b_actf;
647
648                         printf("ad_intr: error: bp %p, data %p, status %x",
649                             (void *)bp, (void *)ctlr->data, status);
650
651                         if (status & OVERRUN)
652                                 printf(" Conversion overrun (multiple A-D trigger)");
653
654                         if (status & OVERFLOW)
655                                 printf(" FIFO overflow");
656
657                         printf("\n");
658
659                         if (bp)
660                         {
661                                 done_and_start_next(ctlr, bp, EIO);
662                                 return;
663                         }
664                         else
665                         {
666                                 printf("ad_intr: (should not happen) error between records\n");
667                                 ctlr->err = status;     /* Set overrun condition */
668                                 return;
669                         }
670                 }
671                 else    /* FIFO interrupt */
672                 {
673                         struct buf *bp = ctlr->start_queue.b_actf;
674
675                         if (ctlr->data)
676                         {
677                                 *ctlr->data++ = inb(ADFIFO(ctlr));
678                                 if (ctlr->data == ctlr->data_end)       /* Normal completion */
679                                 {
680                                         done_and_start_next(ctlr, bp, 0);
681                                         return;
682                                 }
683                         }
684                         else    /* Interrupt with no where to put the data.  */
685                         {
686                                 printf("ad_intr: (should not happen) dropped input.\n");
687                                 (void)inb(ADFIFO(ctlr));
688
689                                 printf("bp %p, status %x, cr3 %x\n",
690                                     (void *)bp, status, ctlr->cr_image[2]);
691
692                                 ctlr->err = DROPPED_INPUT;
693                                 return;
694                         }
695                 }
696         }
697 }
698
699 static void labpcintr(int unit)
700 {
701         struct ctlr *ctlr = labpcs[unit];
702         (*ctlr->intr)(ctlr);
703 }
704
705 /* lockout_multiple_opens: Return whether or not we can open again, or
706  * if the new mode is inconsistent with an already opened mode.
707  * We only permit multiple opens for digital I/O now.
708  */
709
710 static int
711 lockout_multiple_open(dev_t current, dev_t next)
712 {
713         return ! (DIGITAL(current) && DIGITAL(next));
714 }
715
716 static  int
717 labpcopen(dev_t dev, int flags, int fmt, struct thread *td)
718 {
719         u_short unit = UNIT(dev);
720
721         struct ctlr *ctlr;
722
723         if (unit >= MAX_UNITS)
724                 return ENXIO;
725
726         ctlr = labpcs[unit];
727
728         if (ctlr == 0)
729                 return ENXIO;
730
731         /* Don't allow another open if we have to change modes.
732          */
733
734         if ( (ctlr->flags & BUSY) == 0)
735         {
736                 ctlr->flags |= BUSY;
737
738                 reset(ctlr);
739
740                 ctlr->err = 0;
741                 ctlr->dev = dev;
742
743                 ctlr->intr = null_intr;
744                 ctlr->starter = null_start;
745                 ctlr->stop = null_stop;
746         }
747         else if (lockout_multiple_open(ctlr->dev, dev))
748                 return EBUSY;
749
750         return 0;
751 }
752
753 static  int
754 labpcclose(dev_t dev, int flags, int fmt, struct thread *td)
755 {
756         struct ctlr *ctlr = labpcs[UNIT(dev)];
757
758         (*ctlr->stop)(ctlr);
759
760         ctlr->flags &= ~BUSY;
761
762         return 0;
763 }
764
765 /*
766  * Start: Start a frame going in or out.
767  */
768 static void
769 start(struct ctlr *ctlr)
770 {
771         struct buf *bp;
772
773         if ((bp = ctlr->start_queue.b_actf) == 0)
774         {
775                 /* We must turn off FIFO interrupts when there is no
776                  * place to put the data.  We have to get back to
777                  * reading before the FIFO overflows.
778                  */
779                 CR_EXPR(ctlr, 3, &= ~(FIFOINTEN|ERRINTEN));
780                 ctlr->cleared_intr = 1;
781                 ctlr->start_queue.b_bcount = 0;
782                 return;
783         }
784
785         ctlr->data = (u_char *)bp->b_data;
786         ctlr->data_end = ctlr->data + bp->b_bcount;
787
788         if (ctlr->err)
789         {
790                 printf("labpc start: (should not happen) error between records.\n");
791                 done_and_start_next(ctlr, bp, EIO);
792                 return;
793         }
794
795         if (ctlr->data == 0)
796         {
797                 printf("labpc start: (should not happen) NULL data pointer.\n");
798                 done_and_start_next(ctlr, bp, EIO);
799                 return;
800         }
801
802
803         (*ctlr->starter)(ctlr, bp->b_bcount);
804
805         if (!FIFOINTENABLED(ctlr))      /* We can store the data again */
806         {
807                 CR_EXPR(ctlr, 3, |= (FIFOINTEN|ERRINTEN));
808
809                 /* Don't wait for the interrupts to fill things up.
810                  */
811                 (*ctlr->intr)(ctlr);
812         }
813
814         callout_reset(&ctlr->ch, ctlr->tmo, tmo_stop, ctlr);
815 }
816
817 static void
818 ad_strategy(struct buf *bp, struct ctlr *ctlr)
819 {
820         crit_enter();
821         bp->b_actf = NULL;
822
823         if (ctlr->start_queue.b_bcount)
824         {
825                 ctlr->last->b_actf = bp;
826                 ctlr->last = bp;
827         }
828         else
829         {
830                 ctlr->start_queue.b_bcount = 1;
831                 ctlr->start_queue.b_actf = bp;
832                 ctlr->last = bp;
833                 start(ctlr);
834         }
835         crit_exit();
836 }
837
838 /* da_strategy: Send data to the D-A.  The CHAN field should be
839  * 0: D-A port 0
840  * 1: D-A port 1
841  * 2: Alternate port 0 then port 1
842  *
843  * XXX:
844  *
845  * 1. There is no state for CHAN field 2:
846  * the first sample in each buffer goes to channel 0.
847  *
848  * 2. No interrupt support yet.
849  */
850 static void
851 da_strategy(struct buf *bp, struct ctlr *ctlr)
852 {
853         int len;
854         u_char *data;
855         int port;
856         int i;
857
858         switch(CHAN(bp->b_dev))
859         {
860                 case 0:
861                         port = DAC0L(ctlr);
862                         break;
863
864                 case 1:
865                         port = DAC1L(ctlr);
866                         break;
867
868                 case 2: /* Device 2 handles both ports interleaved. */
869                         if (bp->b_bcount <= 2)
870                         {
871                                 port = DAC0L(ctlr);
872                                 break;
873                         }
874
875                         len = bp->b_bcount / 2;
876                         data = (u_char *)bp->b_data;
877
878                         for (i = 0; i < len; i++)
879                         {
880                                 loutb(DAC0H(ctlr), *data++);
881                                 loutb(DAC0L(ctlr), *data++);
882                                 loutb(DAC1H(ctlr), *data++);
883                                 loutb(DAC1L(ctlr), *data++);
884                         }
885
886                         bp->b_resid = bp->b_bcount & 3;
887                         bp_done(bp, 0);
888                         return;
889
890                 default:
891                         bp_done(bp, ENXIO);
892                         return;
893         }
894
895         /* Port 0 or 1 falls through to here.
896          */
897         if (bp->b_bcount & 1)   /* Odd transfers are illegal */
898                 bp_done(bp, EIO);
899
900         len = bp->b_bcount;
901         data = (u_char *)bp->b_data;
902
903         for (i = 0; i < len; i++)
904         {
905                 loutb(port + 1, *data++);
906                 loutb(port, *data++);
907         }
908
909         bp->b_resid = 0;
910
911         bp_done(bp, 0);
912 }
913
914 /* Input masks for MODE 0 of the ports treating PC as a single
915  * 8 bit port.  Set these bits to set the port to input.
916  */
917                             /* A     B    lowc  highc combined */
918 static u_char set_input[] = { 0x10, 0x02, 0x01,  0x08,  0x09 };
919
920 static void flush_dcr(struct ctlr *ctlr)
921 {
922         if (ctlr->dcr_is != ctlr->dcr_val)
923         {
924                 loutb(DCR(ctlr), ctlr->dcr_val);
925                 ctlr->dcr_is = ctlr->dcr_val;
926         }
927 }
928
929 /* do: Digital output
930  */
931 static void
932 digital_out_strategy(struct buf *bp, struct ctlr *ctlr)
933 {
934         int len;
935         u_char *data;
936         int port;
937         int i;
938         int chan = CHAN(bp->b_dev);
939
940         ctlr->dcr_val &= ~set_input[chan];      /* Digital out: Clear bit */
941         flush_dcr(ctlr);
942
943         port = PORTX(ctlr, chan);
944
945         len = bp->b_bcount;
946         data = (u_char *)bp->b_data;
947
948         for (i = 0; i < len; i++)
949         {
950                 loutb(port, *data++);
951         }
952
953         bp->b_resid = 0;
954
955         bp_done(bp, 0);
956 }
957
958 /* digital_in_strategy: Digital input
959  */
960 static void
961 digital_in_strategy(struct buf *bp, struct ctlr *ctlr)
962 {
963         int len;
964         u_char *data;
965         int port;
966         int i;
967         int chan = CHAN(bp->b_dev);
968
969         ctlr->dcr_val |= set_input[chan];       /* Digital in: Set bit */
970         flush_dcr(ctlr);
971         port = PORTX(ctlr, chan);
972
973         len = bp->b_bcount;
974         data = (u_char *)bp->b_data;
975
976         for (i = 0; i < len; i++)
977         {
978                 *data++ = inb(port);
979         }
980
981         bp->b_resid = 0;
982
983         bp_done(bp, 0);
984 }
985
986
987 static  void
988 labpcstrategy(struct buf *bp)
989 {
990         struct ctlr *ctlr = labpcs[UNIT(bp->b_dev)];
991
992         if (DIGITAL(bp->b_dev)) {
993                 if (bp->b_flags & B_READ) {
994                         ctlr->starter = null_start;
995                         ctlr->stop = all_stop;
996                         ctlr->intr = null_intr;
997                         digital_in_strategy(bp, ctlr);
998                 }
999                 else
1000                 {
1001                         ctlr->starter = null_start;
1002                         ctlr->stop = all_stop;
1003                         ctlr->intr = null_intr;
1004                         digital_out_strategy(bp, ctlr);
1005                 }
1006         }
1007         else {
1008                 if (bp->b_flags & B_READ) {
1009
1010                         ctlr->starter = INTERVAL(ctlr->dev) ? ad_interval_start : ad_start;
1011                         ctlr->stop = all_stop;
1012                         ctlr->intr = ad_intr;
1013                         ad_strategy(bp, ctlr);
1014                 }
1015                 else
1016                 {
1017                         ctlr->starter = null_start;
1018                         ctlr->stop = all_stop;
1019                         ctlr->intr = null_intr;
1020                         da_strategy(bp, ctlr);
1021                 }
1022         }
1023 }
1024
1025 static  int
1026 labpcioctl(dev_t dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
1027 {
1028         struct ctlr *ctlr = labpcs[UNIT(dev)];
1029
1030         switch(cmd)
1031         {
1032                 case AD_MICRO_PERIOD_SET:
1033                 {
1034                         /* XXX I'm only supporting what I have to, which is
1035                          * no slow periods.  You can't get any slower than 15 Hz
1036                          * with the current setup.  To go slower you'll need to
1037                          * support TCINTEN in CR3.
1038                          */
1039
1040                         long sample_us = *(long *)arg;
1041
1042                         if (sample_us > 65535)
1043                                 return EIO;
1044
1045                         ctlr->sample_us = sample_us;
1046                         return 0;
1047                 }
1048
1049                 case AD_MICRO_PERIOD_GET:
1050                         *(long *)arg = ctlr->sample_us;
1051                         return 0;
1052
1053                 case AD_NGAINS_GET:
1054                         *(int *)arg = 8;
1055                         return 0;
1056
1057                 case AD_NCHANS_GET:
1058                         *(int *)arg = 8;
1059                         return 0;
1060
1061                 case AD_SUPPORTED_GAINS:
1062                 {
1063                         static double gains[] = {1., 1.25, 2., 5., 10., 20., 50., 100.};
1064                         copyout(gains, *(caddr_t *)arg, sizeof(gains));
1065
1066                         return 0;
1067                 }
1068
1069                 case AD_GAINS_SET:
1070                 {
1071                         copyin(*(caddr_t *)arg, ctlr->gains, sizeof(ctlr->gains));
1072                         return 0;
1073                 }
1074
1075                 case AD_GAINS_GET:
1076                 {
1077                         copyout(ctlr->gains, *(caddr_t *)arg, sizeof(ctlr->gains));
1078                         return 0;
1079                 }
1080
1081                 default:
1082                         return ENOTTY;
1083         }
1084 }