Style(9) cleanup to src/sys/vfs, stage 20/21: umapfs.
[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.7 2004/05/13 23:49:16 dillon 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
59 #ifdef LOUTB
60 #include <machine/clock.h>
61 #endif
62
63 #include <bus/isa/i386/isa_device.h>
64
65
66
67 /* Miniumum timeout:
68  */
69 #ifndef LABPC_MIN_TMO
70 #define LABPC_MIN_TMO (hz)
71 #endif
72
73 #ifndef LABPC_DEFAULT_HERZ
74 #define LABPC_DEFAULT_HERZ 500
75 #endif
76
77 /* Minor number:
78  * UUSIDCCC
79  * UU: Board unit.
80  * S: SCAN bit for scan enable.
81  * I: INTERVAL for interval support
82  * D: 1: Digital I/O, 0: Analog I/O
83  * CCC: Channel.
84  *  Analog (D==0):
85  *  input: channel must be 0 to 7.
86  *  output: channel must be 0 to 2
87  *          0: D-A 0
88  *          1: D-A 1
89  *          2: Alternate channel 0 then 1
90  *
91  *  Digital (D==1):
92  *  input: Channel must be 0 to 2.
93  *  output: Channel must be 0 to 2.
94  */
95
96 /* Up to four boards:
97  */
98 #define MAX_UNITS 4
99 #define UNIT(dev) (((minor(dev) & 0xB0) >> 6) & 0x3)
100
101 #define SCAN(dev)     ((minor(dev) & 0x20) >> 5)
102 #define INTERVAL(dev) ((minor(dev) & 0x10) >> 4)
103 #define DIGITAL(dev)  ((minor(dev) & 0x08) >> 3)
104
105 /* Eight channels:
106  */
107
108 #define CHAN(dev) (minor(dev) & 0x7)
109
110 /* History: Derived from "dt2811.c" March 1995
111  */
112
113 struct ctlr
114 {
115         int err;
116 #define DROPPED_INPUT 0x100
117         int base;
118         int unit;
119         unsigned long flags;
120 #define BUSY 0x00000001
121
122         u_char cr_image[4];
123
124         u_short sample_us;
125
126         struct buf start_queue; /* Start queue */
127         struct buf *last;       /* End of start queue */
128         u_char *data;
129         u_char *data_end;
130         long tmo;                       /* Timeout in Herz */
131         long min_tmo;           /* Timeout in Herz */
132         int cleared_intr;
133
134         int gains[8];
135
136         dev_t dev;                      /* Copy of device */
137
138         void (*starter)(struct ctlr *ctlr, long count);
139         void (*stop)(struct ctlr *ctlr);
140         void (*intr)(struct ctlr *ctlr);
141
142         /* Digital I/O support.  Copy of Data Control Register for 8255:
143          */
144         u_char dcr_val, dcr_is;
145
146         /*
147          * Handle for canceling our timeout.
148          */
149         struct callout_handle ch;
150
151         /* Device configuration structure:
152          */
153 };
154
155 #ifdef LOUTB
156 /* loutb is a slow outb for debugging.  The overrun test may fail
157  * with this for some slower processors.
158  */
159 static __inline void loutb(int port, u_char val)
160 {
161         outb(port, val);
162         DELAY(1);
163 }
164 #else
165 #define loutb(port, val) outb(port, val)
166 #endif
167
168 static struct ctlr **labpcs;    /* XXX: Should be dynamic */
169
170 /* CR_EXPR: A macro that sets the shadow register in addition to
171  * sending out the data.
172  */
173 #define CR_EXPR(LABPC, CR, EXPR) do { \
174         (LABPC)->cr_image[CR - 1] EXPR ; \
175         loutb(((LABPC)->base + ( (CR == 4) ? (0x0F) : (CR - 1))), ((LABPC)->cr_image[(CR - 1)])); \
176 } while (0)
177
178 #define CR_CLR(LABPC, CR) CR_EXPR(LABPC, CR, &=0)
179 #define CR_REFRESH(LABPC, CR) CR_EXPR(LABPC, CR, &=0xff)
180 #define CR_SET(LABPC, CR, EXPR) CR_EXPR(LABPC, CR, = EXPR)
181
182 /* Configuration and Status Register Group.
183  */
184 #define     CR1(LABPC) ((LABPC)->base + 0x00)   /* Page 4-5 */
185         #define SCANEN    0x80
186         #define GAINMASK  0x70
187         #define GAIN(LABPC, SEL) do { \
188                 (LABPC)->cr_image[1 - 1] &= ~GAINMASK; \
189                 (LABPC)->cr_image[1 - 1] |= (SEL << 4); \
190                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
191                 } while (0)
192
193         #define TWOSCMP   0x08
194         #define MAMASK    0x07
195         #define MA(LABPC, SEL) do { \
196                 (LABPC)->cr_image[1 - 1] &= ~MAMASK; \
197                 (LABPC)->cr_image[1 - 1] |= SEL; \
198                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
199                 } while (0)
200
201 #define  STATUS(LABPC) ((LABPC)->base + 0x00)   /* Page 4-7 */
202         #define LABPCPLUS 0x80
203         #define EXTGATA0  0x40
204         #define GATA0     0x20
205         #define DMATC     0x10
206         #define CNTINT    0x08
207         #define OVERFLOW  0x04
208         #define OVERRUN   0x02
209         #define DAVAIL    0x01
210
211 #define     CR2(LABPC) ((LABPC)->base + 0x01)   /* Page 4-9 */
212         #define LDAC1     0x80
213         #define LDAC0     0x40
214         #define _2SDAC1   0x20
215         #define _2SDAC0   0x10
216         #define TBSEL     0x08
217         #define SWTRIG    0x04
218         #define HWTRIG    0x02
219         #define PRETRIG   0x01
220         #define SWTRIGGERRED(LABPC) ((LABPC->cr_image[1]) & SWTRIG)
221
222 #define     CR3(LABPC) ((LABPC)->base + 0x02)   /* Page 4-11 */
223         #define FIFOINTEN 0x20
224         #define ERRINTEN  0x10
225         #define CNTINTEN  0x08
226         #define TCINTEN   0x04
227         #define DIOINTEN  0x02
228         #define DMAEN     0x01
229
230         #define ALLINTEN  0x3E
231         #define FIFOINTENABLED(LABPC) ((LABPC->cr_image[2]) & FIFOINTEN)
232
233 #define     CR4(LABPC) ((LABPC)->base + 0x0F)   /* Page 4-13 */
234         #define ECLKRCV   0x10
235         #define SE_D      0x08
236         #define ECKDRV    0x04
237         #define EOIRCV    0x02
238         #define INTSCAN   0x01
239
240 /* Analog Input Register Group
241  */
242 #define   ADFIFO(LABPC) ((LABPC)->base + 0x0A)  /* Page 4-16 */
243 #define  ADCLEAR(LABPC) ((LABPC)->base + 0x08)  /* Page 4-18 */
244 #define  ADSTART(LABPC) ((LABPC)->base + 0x03)  /* Page 4-19 */
245 #define DMATCICLR(LABPC) ((LABPC)->base + 0x0A) /* Page 4-20 */
246
247 /* Analog Output Register Group
248  */
249 #define    DAC0L(LABPC) ((LABPC)->base + 0x04)  /* Page 4-22 */
250 #define    DAC0H(LABPC) ((LABPC)->base + 0x05)  /* Page 4-22 */
251 #define    DAC1L(LABPC) ((LABPC)->base + 0x06)  /* Page 4-22 */
252 #define    DAC1H(LABPC) ((LABPC)->base + 0x07)  /* Page 4-22 */
253
254 /* 8253 registers:
255  */
256 #define A0DATA(LABPC) ((LABPC)->base + 0x14)
257 #define A1DATA(LABPC) ((LABPC)->base + 0x15)
258 #define A2DATA(LABPC) ((LABPC)->base + 0x16)
259 #define AMODE(LABPC) ((LABPC)->base + 0x17)
260
261 #define TICR(LABPC) ((LABPC)->base + 0x0c)
262
263 #define B0DATA(LABPC) ((LABPC)->base + 0x18)
264 #define B1DATA(LABPC) ((LABPC)->base + 0x19)
265 #define B2DATA(LABPC) ((LABPC)->base + 0x1A)
266 #define BMODE(LABPC) ((LABPC)->base + 0x1B)
267
268 /* 8255 registers:
269  */
270
271 #define PORTX(LABPC, X) ((LABPC)->base + 0x10 + X)
272
273 #define PORTA(LABPC) PORTX(LABPC, 0)
274 #define PORTB(LABPC) PORTX(LABPC, 1)
275 #define PORTC(LABPC) PORTX(LABPC, 2)
276
277 #define DCR(LABPC) ((LABPC)->base + 0x13)
278
279 static int labpcattach(struct isa_device *dev);
280 static int labpcprobe(struct isa_device *dev);
281 struct isa_driver labpcdriver =
282         { labpcprobe, labpcattach, "labpc", 0  };
283
284 static  d_open_t        labpcopen;
285 static  d_close_t       labpcclose;
286 static  d_ioctl_t       labpcioctl;
287 static  d_strategy_t    labpcstrategy;
288
289 #define CDEV_MAJOR 66
290 static struct cdevsw labpc_cdevsw = {
291         /* name */      "labpc",
292         /* maj */       CDEV_MAJOR,
293         /* flags */     0,
294         /* port */      NULL,
295         /* clone */     NULL,
296
297         /* open */      labpcopen,
298         /* close */     labpcclose,
299         /* read */      physread,
300         /* write */     physwrite,
301         /* ioctl */     labpcioctl,
302         /* poll */      nopoll,
303         /* mmap */      nommap,
304         /* strategy */  labpcstrategy,
305         /* dump */      nodump,
306         /* psize */     nopsize
307 };
308
309 static ointhand2_t labpcintr;
310 static void start(struct ctlr *ctlr);
311
312 static void
313 bp_done(struct buf *bp, int err)
314 {
315         bp->b_error = err;
316
317         if (err || bp->b_resid)
318         {
319                 bp->b_flags |= B_ERROR;
320         }
321
322         biodone(bp);
323 }
324
325 static void tmo_stop(void *p);
326
327 static void
328 done_and_start_next(struct ctlr *ctlr, struct buf *bp, int err)
329 {
330         bp->b_resid = ctlr->data_end - ctlr->data;
331
332         ctlr->data = 0;
333
334         ctlr->start_queue.b_actf = bp->b_actf;
335         bp_done(bp, err);
336
337         untimeout(tmo_stop, ctlr, ctlr->ch);
338
339         start(ctlr);
340 }
341
342 static __inline void
343 ad_clear(struct ctlr *ctlr)
344 {
345         int i;
346         loutb(ADCLEAR(ctlr), 0);
347         for (i = 0; i < 10000 && (inb(STATUS(ctlr)) & GATA0); i++)
348                 ;
349         (void)inb(ADFIFO(ctlr));
350         (void)inb(ADFIFO(ctlr));
351 }
352
353 /* reset: Reset the board following the sequence on page 5-1
354  */
355 static __inline void
356 reset(struct ctlr *ctlr)
357 {
358         int s = splhigh();
359
360         CR_CLR(ctlr, 3);        /* Turn off interrupts first */
361         splx(s);
362
363         CR_CLR(ctlr, 1);
364         CR_CLR(ctlr, 2);
365         CR_CLR(ctlr, 4);
366
367         loutb(AMODE(ctlr), 0x34);
368         loutb(A0DATA(ctlr),0x0A);
369         loutb(A0DATA(ctlr),0x00);
370
371         loutb(DMATCICLR(ctlr), 0x00);
372         loutb(TICR(ctlr), 0x00);
373
374         ad_clear(ctlr);
375
376         loutb(DAC0L(ctlr), 0);
377         loutb(DAC0H(ctlr), 0);
378         loutb(DAC1L(ctlr), 0);
379         loutb(DAC1H(ctlr), 0);
380
381         ad_clear(ctlr);
382 }
383
384 /* overrun: slam the start convert register and OVERRUN should get set:
385  */
386 static u_char
387 overrun(struct ctlr *ctlr)
388 {
389         int i;
390
391         u_char status = inb(STATUS(ctlr));
392         for (i = 0; ((status & OVERRUN) == 0) && i < 100; i++)
393         {
394                 loutb(ADSTART(ctlr), 1);
395                 status = inb(STATUS(ctlr));
396         }
397
398         return status;
399 }
400
401 static int
402 labpcinit(void)
403 {
404         if (NLABPC > MAX_UNITS)
405                 return 0;
406
407         labpcs = malloc(NLABPC * sizeof(struct ctlr *), M_DEVBUF, 
408                         M_WAITOK | M_ZERO);
409         /*
410          * XXX this is really odd code, adding the device only if
411          * the allocation fails?  it could be broken.
412          */
413         if (labpcs) {
414                 return 1;
415         }
416         cdevsw_add(&labpc_cdevsw);
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_handle_init(&ctlr->ch);
485         ctlr->sample_us = (1000000.0 / (double)LABPC_DEFAULT_HERZ) + .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         make_dev(&labpc_cdevsw, 0, 0, 0, 0600, "labpc%d", dev->id_unit);
495         return 1;
496 }
497
498 /* Null handlers:
499  */
500 static void null_intr (struct ctlr *ctlr)             { }
501 static void null_start(struct ctlr *ctlr, long count) { }
502 static void null_stop (struct ctlr *ctlr)             { }
503
504 static __inline void
505 trigger(struct ctlr *ctlr)
506 {
507         CR_EXPR(ctlr, 2, |= SWTRIG);
508 }
509
510 static void
511 ad_start(struct ctlr *ctlr, long count)
512 {
513         if (!SWTRIGGERRED(ctlr)) {
514                 int chan = CHAN(ctlr->dev);
515                 CR_EXPR(ctlr, 1, &= ~SCANEN);
516                 CR_EXPR(ctlr, 2, &= ~TBSEL);
517
518                 MA(ctlr, chan);
519                 GAIN(ctlr, ctlr->gains[chan]);
520
521                 if (SCAN(ctlr->dev))
522                         CR_EXPR(ctlr, 1, |= SCANEN);
523
524                 loutb(AMODE(ctlr), 0x34);
525                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
526                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
527                 loutb(AMODE(ctlr), 0x70);
528
529                 ad_clear(ctlr);
530                 trigger(ctlr);
531         }
532
533         ctlr->tmo = ((count + 16) * (long)ctlr->sample_us * hz) / 1000000 +
534                 ctlr->min_tmo;
535 }
536
537 static void
538 ad_interval_start(struct ctlr *ctlr, long count)
539 {
540         int chan = CHAN(ctlr->dev);
541         int n_frames = count / (chan + 1);
542
543         if (!SWTRIGGERRED(ctlr)) {
544                 CR_EXPR(ctlr, 1, &= ~SCANEN);
545                 CR_EXPR(ctlr, 2, &= ~TBSEL);
546
547                 MA(ctlr, chan);
548                 GAIN(ctlr, ctlr->gains[chan]);
549
550                 /* XXX: Is it really possible that you clear INTSCAN as
551                  * the documentation says?  That seems pretty unlikely.
552                  */
553                 CR_EXPR(ctlr, 4, &= ~INTSCAN);  /* XXX: Is this possible? */
554
555                 /* Program the sample interval counter to run as fast as
556                  * possible.
557                  */
558                 loutb(AMODE(ctlr), 0x34);
559                 loutb(A0DATA(ctlr), (u_char)(0x02));
560                 loutb(A0DATA(ctlr), (u_char)(0x00));
561                 loutb(AMODE(ctlr), 0x70);
562
563                 /* Program the interval scanning counter to run at the sample
564                  * frequency.
565                  */
566                 loutb(BMODE(ctlr), 0x74);
567                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
568                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
569                 CR_EXPR(ctlr, 1, |= SCANEN);
570
571                 ad_clear(ctlr);
572                 trigger(ctlr);
573         }
574
575         /* Each frame time takes two microseconds per channel times
576          * the number of channels being sampled plus the sample period.
577          */
578         ctlr->tmo = ((n_frames + 16) *
579         ((long)ctlr->sample_us + (chan + 1 ) * 2 ) * hz) / 1000000 +
580                 ctlr->min_tmo;
581 }
582
583 static void
584 all_stop(struct ctlr *ctlr)
585 {
586         reset(ctlr);
587 }
588
589 static void
590 tmo_stop(void *p)
591 {
592         struct ctlr *ctlr = (struct ctlr *)p;
593         struct buf *bp;
594
595         int s = spltty();
596
597         if (ctlr == 0)
598         {
599                 printf("labpc?: Null ctlr struct?\n");
600                 splx(s);
601                 return;
602         }
603
604         printf("labpc%d: timeout", ctlr->unit);
605
606         (*ctlr->stop)(ctlr);
607
608         bp = ctlr->start_queue.b_actf;
609
610         if (bp == 0) {
611                 printf(", Null bp.\n");
612                 splx(s);
613                 return;
614         }
615
616         printf("\n");
617
618         done_and_start_next(ctlr, bp, ETIMEDOUT);
619
620         splx(s);
621 }
622
623 static void ad_intr(struct ctlr *ctlr)
624 {
625         u_char status;
626
627         if (ctlr->cr_image[2] == 0)
628         {
629                 if (ctlr->cleared_intr)
630                 {
631                         ctlr->cleared_intr = 0;
632                         return;
633                 }
634
635                 printf("ad_intr (should not happen) interrupt with interrupts off\n");
636                 printf("status %x, cr3 %x\n", inb(STATUS(ctlr)), ctlr->cr_image[2]);
637                 return;
638         }
639
640         while ( (status = (inb(STATUS(ctlr)) & (DAVAIL|OVERRUN|OVERFLOW)) ) )
641         {
642                 if ((status & (OVERRUN|OVERFLOW)))
643                 {
644                         struct buf *bp = ctlr->start_queue.b_actf;
645
646                         printf("ad_intr: error: bp %p, data %p, status %x",
647                             (void *)bp, (void *)ctlr->data, status);
648
649                         if (status & OVERRUN)
650                                 printf(" Conversion overrun (multiple A-D trigger)");
651
652                         if (status & OVERFLOW)
653                                 printf(" FIFO overflow");
654
655                         printf("\n");
656
657                         if (bp)
658                         {
659                                 done_and_start_next(ctlr, bp, EIO);
660                                 return;
661                         }
662                         else
663                         {
664                                 printf("ad_intr: (should not happen) error between records\n");
665                                 ctlr->err = status;     /* Set overrun condition */
666                                 return;
667                         }
668                 }
669                 else    /* FIFO interrupt */
670                 {
671                         struct buf *bp = ctlr->start_queue.b_actf;
672
673                         if (ctlr->data)
674                         {
675                                 *ctlr->data++ = inb(ADFIFO(ctlr));
676                                 if (ctlr->data == ctlr->data_end)       /* Normal completion */
677                                 {
678                                         done_and_start_next(ctlr, bp, 0);
679                                         return;
680                                 }
681                         }
682                         else    /* Interrupt with no where to put the data.  */
683                         {
684                                 printf("ad_intr: (should not happen) dropped input.\n");
685                                 (void)inb(ADFIFO(ctlr));
686
687                                 printf("bp %p, status %x, cr3 %x\n",
688                                     (void *)bp, status, ctlr->cr_image[2]);
689
690                                 ctlr->err = DROPPED_INPUT;
691                                 return;
692                         }
693                 }
694         }
695 }
696
697 static void labpcintr(int unit)
698 {
699         struct ctlr *ctlr = labpcs[unit];
700         (*ctlr->intr)(ctlr);
701 }
702
703 /* lockout_multiple_opens: Return whether or not we can open again, or
704  * if the new mode is inconsistent with an already opened mode.
705  * We only permit multiple opens for digital I/O now.
706  */
707
708 static int
709 lockout_multiple_open(dev_t current, dev_t next)
710 {
711         return ! (DIGITAL(current) && DIGITAL(next));
712 }
713
714 static  int
715 labpcopen(dev_t dev, int flags, int fmt, struct thread *td)
716 {
717         u_short unit = UNIT(dev);
718
719         struct ctlr *ctlr;
720
721         if (unit >= MAX_UNITS)
722                 return ENXIO;
723
724         ctlr = labpcs[unit];
725
726         if (ctlr == 0)
727                 return ENXIO;
728
729         /* Don't allow another open if we have to change modes.
730          */
731
732         if ( (ctlr->flags & BUSY) == 0)
733         {
734                 ctlr->flags |= BUSY;
735
736                 reset(ctlr);
737
738                 ctlr->err = 0;
739                 ctlr->dev = dev;
740
741                 ctlr->intr = null_intr;
742                 ctlr->starter = null_start;
743                 ctlr->stop = null_stop;
744         }
745         else if (lockout_multiple_open(ctlr->dev, dev))
746                 return EBUSY;
747
748         return 0;
749 }
750
751 static  int
752 labpcclose(dev_t dev, int flags, int fmt, struct thread *td)
753 {
754         struct ctlr *ctlr = labpcs[UNIT(dev)];
755
756         (*ctlr->stop)(ctlr);
757
758         ctlr->flags &= ~BUSY;
759
760         return 0;
761 }
762
763 /*
764  * Start: Start a frame going in or out.
765  */
766 static void
767 start(struct ctlr *ctlr)
768 {
769         struct buf *bp;
770
771         if ((bp = ctlr->start_queue.b_actf) == 0)
772         {
773                 /* We must turn off FIFO interrupts when there is no
774                  * place to put the data.  We have to get back to
775                  * reading before the FIFO overflows.
776                  */
777                 CR_EXPR(ctlr, 3, &= ~(FIFOINTEN|ERRINTEN));
778                 ctlr->cleared_intr = 1;
779                 ctlr->start_queue.b_bcount = 0;
780                 return;
781         }
782
783         ctlr->data = (u_char *)bp->b_data;
784         ctlr->data_end = ctlr->data + bp->b_bcount;
785
786         if (ctlr->err)
787         {
788                 printf("labpc start: (should not happen) error between records.\n");
789                 done_and_start_next(ctlr, bp, EIO);
790                 return;
791         }
792
793         if (ctlr->data == 0)
794         {
795                 printf("labpc start: (should not happen) NULL data pointer.\n");
796                 done_and_start_next(ctlr, bp, EIO);
797                 return;
798         }
799
800
801         (*ctlr->starter)(ctlr, bp->b_bcount);
802
803         if (!FIFOINTENABLED(ctlr))      /* We can store the data again */
804         {
805                 CR_EXPR(ctlr, 3, |= (FIFOINTEN|ERRINTEN));
806
807                 /* Don't wait for the interrupts to fill things up.
808                  */
809                 (*ctlr->intr)(ctlr);
810         }
811
812         ctlr->ch = timeout(tmo_stop, ctlr, ctlr->tmo);
813 }
814
815 static void
816 ad_strategy(struct buf *bp, struct ctlr *ctlr)
817 {
818         int s;
819
820         s = spltty();
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         splx(s);
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 }