070e49ef8ae533b76c1759b92fa952250be91199
[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.23 2008/08/02 01:14:42 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 bio_actf        bio_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/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 bio start_queue; /* Start queue */
128         struct bio *last;       /* End of start queue */
129         int count;
130         u_char *data;
131         u_char *data_end;
132         long tmo;                       /* Timeout in Hertz */
133         long min_tmo;           /* Timeout in Hertz */
134         int cleared_intr;
135
136         int gains[8];
137
138         cdev_t dev;                     /* Copy of device */
139
140         void (*starter)(struct ctlr *ctlr, long count);
141         void (*stop)(struct ctlr *ctlr);
142         void (*intr)(struct ctlr *ctlr);
143
144         /* Digital I/O support.  Copy of Data Control Register for 8255:
145          */
146         u_char dcr_val, dcr_is;
147
148         /*
149          * Handle for canceling our timeout.
150          */
151         struct callout  ch;
152
153         /* Device configuration structure:
154          */
155 };
156
157 #ifdef LOUTB
158 /* loutb is a slow outb for debugging.  The overrun test may fail
159  * with this for some slower processors.
160  */
161 static void
162 loutb(int port, u_char val)
163 {
164         outb(port, val);
165         DELAY(1);
166 }
167 #else
168 #define loutb(port, val) outb(port, val)
169 #endif
170
171 static struct ctlr **labpcs;    /* XXX: Should be dynamic */
172
173 /* CR_EXPR: A macro that sets the shadow register in addition to
174  * sending out the data.
175  */
176 #define CR_EXPR(LABPC, CR, EXPR) do { \
177         (LABPC)->cr_image[CR - 1] EXPR ; \
178         loutb(((LABPC)->base + ( (CR == 4) ? (0x0F) : (CR - 1))), ((LABPC)->cr_image[(CR - 1)])); \
179 } while (0)
180
181 #define CR_CLR(LABPC, CR) CR_EXPR(LABPC, CR, &=0)
182 #define CR_REFRESH(LABPC, CR) CR_EXPR(LABPC, CR, &=0xff)
183 #define CR_SET(LABPC, CR, EXPR) CR_EXPR(LABPC, CR, = EXPR)
184
185 /* Configuration and Status Register Group.
186  */
187 #define     CR1(LABPC) ((LABPC)->base + 0x00)   /* Page 4-5 */
188         #define SCANEN    0x80
189         #define GAINMASK  0x70
190         #define GAIN(LABPC, SEL) do { \
191                 (LABPC)->cr_image[1 - 1] &= ~GAINMASK; \
192                 (LABPC)->cr_image[1 - 1] |= (SEL << 4); \
193                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
194                 } while (0)
195
196         #define TWOSCMP   0x08
197         #define MAMASK    0x07
198         #define MA(LABPC, SEL) do { \
199                 (LABPC)->cr_image[1 - 1] &= ~MAMASK; \
200                 (LABPC)->cr_image[1 - 1] |= SEL; \
201                 loutb((LABPC)->base + (1 - 1), (LABPC)->cr_image[(1 - 1)]); \
202                 } while (0)
203
204 #define  STATUS(LABPC) ((LABPC)->base + 0x00)   /* Page 4-7 */
205         #define LABPCPLUS 0x80
206         #define EXTGATA0  0x40
207         #define GATA0     0x20
208         #define DMATC     0x10
209         #define CNTINT    0x08
210         #define OVERFLOW  0x04
211         #define OVERRUN   0x02
212         #define DAVAIL    0x01
213
214 #define     CR2(LABPC) ((LABPC)->base + 0x01)   /* Page 4-9 */
215         #define LDAC1     0x80
216         #define LDAC0     0x40
217         #define _2SDAC1   0x20
218         #define _2SDAC0   0x10
219         #define TBSEL     0x08
220         #define SWTRIG    0x04
221         #define HWTRIG    0x02
222         #define PRETRIG   0x01
223         #define SWTRIGGERRED(LABPC) ((LABPC->cr_image[1]) & SWTRIG)
224
225 #define     CR3(LABPC) ((LABPC)->base + 0x02)   /* Page 4-11 */
226         #define FIFOINTEN 0x20
227         #define ERRINTEN  0x10
228         #define CNTINTEN  0x08
229         #define TCINTEN   0x04
230         #define DIOINTEN  0x02
231         #define DMAEN     0x01
232
233         #define ALLINTEN  0x3E
234         #define FIFOINTENABLED(LABPC) ((LABPC->cr_image[2]) & FIFOINTEN)
235
236 #define     CR4(LABPC) ((LABPC)->base + 0x0F)   /* Page 4-13 */
237         #define ECLKRCV   0x10
238         #define SE_D      0x08
239         #define ECKDRV    0x04
240         #define EOIRCV    0x02
241         #define INTSCAN   0x01
242
243 /* Analog Input Register Group
244  */
245 #define   ADFIFO(LABPC) ((LABPC)->base + 0x0A)  /* Page 4-16 */
246 #define  ADCLEAR(LABPC) ((LABPC)->base + 0x08)  /* Page 4-18 */
247 #define  ADSTART(LABPC) ((LABPC)->base + 0x03)  /* Page 4-19 */
248 #define DMATCICLR(LABPC) ((LABPC)->base + 0x0A) /* Page 4-20 */
249
250 /* Analog Output Register Group
251  */
252 #define    DAC0L(LABPC) ((LABPC)->base + 0x04)  /* Page 4-22 */
253 #define    DAC0H(LABPC) ((LABPC)->base + 0x05)  /* Page 4-22 */
254 #define    DAC1L(LABPC) ((LABPC)->base + 0x06)  /* Page 4-22 */
255 #define    DAC1H(LABPC) ((LABPC)->base + 0x07)  /* Page 4-22 */
256
257 /* 8253 registers:
258  */
259 #define A0DATA(LABPC) ((LABPC)->base + 0x14)
260 #define A1DATA(LABPC) ((LABPC)->base + 0x15)
261 #define A2DATA(LABPC) ((LABPC)->base + 0x16)
262 #define AMODE(LABPC) ((LABPC)->base + 0x17)
263
264 #define TICR(LABPC) ((LABPC)->base + 0x0c)
265
266 #define B0DATA(LABPC) ((LABPC)->base + 0x18)
267 #define B1DATA(LABPC) ((LABPC)->base + 0x19)
268 #define B2DATA(LABPC) ((LABPC)->base + 0x1A)
269 #define BMODE(LABPC) ((LABPC)->base + 0x1B)
270
271 /* 8255 registers:
272  */
273
274 #define PORTX(LABPC, X) ((LABPC)->base + 0x10 + X)
275
276 #define PORTA(LABPC) PORTX(LABPC, 0)
277 #define PORTB(LABPC) PORTX(LABPC, 1)
278 #define PORTC(LABPC) PORTX(LABPC, 2)
279
280 #define DCR(LABPC) ((LABPC)->base + 0x13)
281
282 static int labpcattach(struct isa_device *dev);
283 static int labpcprobe(struct isa_device *dev);
284 struct isa_driver labpcdriver =
285         { labpcprobe, labpcattach, "labpc", 0  };
286
287 static  d_open_t        labpcopen;
288 static  d_close_t       labpcclose;
289 static  d_ioctl_t       labpcioctl;
290 static  d_strategy_t    labpcstrategy;
291
292 #define CDEV_MAJOR 66
293 static struct dev_ops labpc_ops = {
294         { "labpc", CDEV_MAJOR, 0 },
295         .d_open =       labpcopen,
296         .d_close =      labpcclose,
297         .d_read =       physread,
298         .d_write =      physwrite,
299         .d_ioctl =      labpcioctl,
300         .d_strategy =   labpcstrategy,
301 };
302
303 static void labpcintr(void *);
304 static void start(struct ctlr *ctlr);
305
306 static void
307 bp_done(struct bio *bio, int err)
308 {
309         struct buf *bp = bio->bio_buf;
310
311         if (err || bp->b_resid)
312                 bp->b_flags |= B_ERROR;
313         biodone(bio);
314 }
315
316 static void tmo_stop(void *p);
317
318 static void
319 done_and_start_next(struct ctlr *ctlr, struct bio *bio, int err)
320 {
321         struct buf *bp = bio->bio_buf;
322
323         bp->b_resid = ctlr->data_end - ctlr->data;
324
325         ctlr->data = 0;
326
327         ctlr->start_queue.bio_actf = bio->bio_actf;
328         bp_done(bio, err);
329
330         callout_stop(&ctlr->ch);
331
332         start(ctlr);
333 }
334
335 static void
336 ad_clear(struct ctlr *ctlr)
337 {
338         int i;
339         loutb(ADCLEAR(ctlr), 0);
340         for (i = 0; i < 10000 && (inb(STATUS(ctlr)) & GATA0); i++)
341                 ;
342         (void)inb(ADFIFO(ctlr));
343         (void)inb(ADFIFO(ctlr));
344 }
345
346 /* reset: Reset the board following the sequence on page 5-1
347  */
348 static void
349 reset(struct ctlr *ctlr)
350 {
351         crit_enter();
352         CR_CLR(ctlr, 3);        /* Turn off interrupts first */
353         crit_exit();
354
355         CR_CLR(ctlr, 1);
356         CR_CLR(ctlr, 2);
357         CR_CLR(ctlr, 4);
358
359         loutb(AMODE(ctlr), 0x34);
360         loutb(A0DATA(ctlr),0x0A);
361         loutb(A0DATA(ctlr),0x00);
362
363         loutb(DMATCICLR(ctlr), 0x00);
364         loutb(TICR(ctlr), 0x00);
365
366         ad_clear(ctlr);
367
368         loutb(DAC0L(ctlr), 0);
369         loutb(DAC0H(ctlr), 0);
370         loutb(DAC1L(ctlr), 0);
371         loutb(DAC1H(ctlr), 0);
372
373         ad_clear(ctlr);
374 }
375
376 /* overrun: slam the start convert register and OVERRUN should get set:
377  */
378 static u_char
379 overrun(struct ctlr *ctlr)
380 {
381         int i;
382
383         u_char status = inb(STATUS(ctlr));
384         for (i = 0; ((status & OVERRUN) == 0) && i < 100; i++)
385         {
386                 loutb(ADSTART(ctlr), 1);
387                 status = inb(STATUS(ctlr));
388         }
389
390         return status;
391 }
392
393 static int
394 labpcinit(void)
395 {
396         if (NLABPC > MAX_UNITS)
397                 return 0;
398
399         labpcs = kmalloc(NLABPC * sizeof(struct ctlr *), M_DEVBUF, 
400                         M_WAITOK | M_ZERO);
401         return 1;
402 }
403
404 static int
405 labpcprobe(struct isa_device *dev)
406 {
407         static int unit;
408         struct ctlr scratch, *ctlr, *l;
409         u_char status;
410
411         if (!labpcs)
412         {
413                 if (labpcinit() == 0)
414                 {
415                         kprintf("labpcprobe: init failed\n");
416                         return 0;
417                 }
418         }
419
420         if (unit > NLABPC)
421         {
422                 kprintf("Too many LAB-PCs.  Reconfigure O/S.\n");
423                 return 0;
424         }
425         ctlr = &scratch;        /* Need somebody with the right base for the macros */
426         ctlr->base = dev->id_iobase;
427
428         /* XXX: There really isn't a perfect way to probe this board.
429          *      Here is my best attempt:
430          */
431         reset(ctlr);
432
433         /* After reset none of these bits should be set:
434          */
435         status = inb(STATUS(ctlr));
436         if (status & (GATA0 | OVERFLOW | DAVAIL | OVERRUN))
437                 return 0;
438
439         /* Now try to overrun the board FIFO and get the overrun bit set:
440          */
441         status = overrun(ctlr);
442
443         if ((status & OVERRUN) == 0)    /* No overrun bit set? */
444                 return 0;
445
446         /* Assume we have a board.
447          */
448         reset(ctlr);
449
450         l = kmalloc(sizeof(struct ctlr), M_DEVBUF, M_WAITOK | M_ZERO);
451         l->base = ctlr->base;
452         l->unit = unit;
453         labpcs[unit] = l;
454         dev->id_unit = l->unit;
455
456         unit++;
457         return 0x20;
458 }
459
460 /* attach: Set things in a normal state.
461  */
462 static int
463 labpcattach(struct isa_device *dev)
464 {
465         struct ctlr *ctlr = labpcs[dev->id_unit];
466
467         dev->id_intr = (inthand2_t *)labpcintr;
468         callout_init(&ctlr->ch);
469         ctlr->sample_us = (1000000.0 / (double)LABPC_DEFAULT_HERTZ) + .50;
470         reset(ctlr);
471
472         ctlr->min_tmo = LABPC_MIN_TMO;
473
474         ctlr->dcr_val = 0x80;
475         ctlr->dcr_is = 0x80;
476         loutb(DCR(ctlr), ctlr->dcr_val);
477
478         dev_ops_add(&labpc_ops, -1, dev->id_unit);
479         make_dev(&labpc_ops, dev->id_unit, 0, 0, 0600, 
480                 "labpc%d", dev->id_unit);
481         return 1;
482 }
483
484 /* Null handlers:
485  */
486 static void null_intr (struct ctlr *ctlr)             { }
487 static void null_start(struct ctlr *ctlr, long count) { }
488 static void null_stop (struct ctlr *ctlr)             { }
489
490 static void
491 trigger(struct ctlr *ctlr)
492 {
493         CR_EXPR(ctlr, 2, |= SWTRIG);
494 }
495
496 static void
497 ad_start(struct ctlr *ctlr, long count)
498 {
499         if (!SWTRIGGERRED(ctlr)) {
500                 int chan = CHAN(ctlr->dev);
501                 CR_EXPR(ctlr, 1, &= ~SCANEN);
502                 CR_EXPR(ctlr, 2, &= ~TBSEL);
503
504                 MA(ctlr, chan);
505                 GAIN(ctlr, ctlr->gains[chan]);
506
507                 if (SCAN(ctlr->dev))
508                         CR_EXPR(ctlr, 1, |= SCANEN);
509
510                 loutb(AMODE(ctlr), 0x34);
511                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
512                 loutb(A0DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
513                 loutb(AMODE(ctlr), 0x70);
514
515                 ad_clear(ctlr);
516                 trigger(ctlr);
517         }
518
519         ctlr->tmo = ((count + 16) * (long)ctlr->sample_us * hz) / 1000000 +
520                 ctlr->min_tmo;
521 }
522
523 static void
524 ad_interval_start(struct ctlr *ctlr, long count)
525 {
526         int chan = CHAN(ctlr->dev);
527         int n_frames = count / (chan + 1);
528
529         if (!SWTRIGGERRED(ctlr)) {
530                 CR_EXPR(ctlr, 1, &= ~SCANEN);
531                 CR_EXPR(ctlr, 2, &= ~TBSEL);
532
533                 MA(ctlr, chan);
534                 GAIN(ctlr, ctlr->gains[chan]);
535
536                 /* XXX: Is it really possible that you clear INTSCAN as
537                  * the documentation says?  That seems pretty unlikely.
538                  */
539                 CR_EXPR(ctlr, 4, &= ~INTSCAN);  /* XXX: Is this possible? */
540
541                 /* Program the sample interval counter to run as fast as
542                  * possible.
543                  */
544                 loutb(AMODE(ctlr), 0x34);
545                 loutb(A0DATA(ctlr), (u_char)(0x02));
546                 loutb(A0DATA(ctlr), (u_char)(0x00));
547                 loutb(AMODE(ctlr), 0x70);
548
549                 /* Program the interval scanning counter to run at the sample
550                  * frequency.
551                  */
552                 loutb(BMODE(ctlr), 0x74);
553                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us & 0xff)));
554                 loutb(B1DATA(ctlr), (u_char)((ctlr->sample_us >> 8)&0xff));
555                 CR_EXPR(ctlr, 1, |= SCANEN);
556
557                 ad_clear(ctlr);
558                 trigger(ctlr);
559         }
560
561         /* Each frame time takes two microseconds per channel times
562          * the number of channels being sampled plus the sample period.
563          */
564         ctlr->tmo = ((n_frames + 16) *
565         ((long)ctlr->sample_us + (chan + 1 ) * 2 ) * hz) / 1000000 +
566                 ctlr->min_tmo;
567 }
568
569 static void
570 all_stop(struct ctlr *ctlr)
571 {
572         reset(ctlr);
573 }
574
575 static void
576 tmo_stop(void *p)
577 {
578         struct ctlr *ctlr = (struct ctlr *)p;
579         struct bio *bio;
580
581         crit_enter();
582
583         if (ctlr == 0)
584         {
585                 kprintf("labpc?: Null ctlr struct?\n");
586                 crit_exit();
587                 return;
588         }
589
590         kprintf("labpc%d: timeout", ctlr->unit);
591
592         (*ctlr->stop)(ctlr);
593
594         bio = ctlr->start_queue.bio_actf;
595
596         if (bio == NULL) {
597                 kprintf(", Null bp.\n");
598                 crit_exit();
599                 return;
600         }
601
602         kprintf("\n");
603
604         done_and_start_next(ctlr, bio, ETIMEDOUT);
605
606         crit_exit();
607 }
608
609 static void ad_intr(struct ctlr *ctlr)
610 {
611         u_char status;
612
613         if (ctlr->cr_image[2] == 0)
614         {
615                 if (ctlr->cleared_intr)
616                 {
617                         ctlr->cleared_intr = 0;
618                         return;
619                 }
620
621                 kprintf("ad_intr (should not happen) interrupt with interrupts off\n");
622                 kprintf("status %x, cr3 %x\n", inb(STATUS(ctlr)), ctlr->cr_image[2]);
623                 return;
624         }
625
626         while ( (status = (inb(STATUS(ctlr)) & (DAVAIL|OVERRUN|OVERFLOW)) ) )
627         {
628                 if ((status & (OVERRUN|OVERFLOW)))
629                 {
630                         struct bio *bio = ctlr->start_queue.bio_actf;
631
632                         kprintf("ad_intr: error: bp %p, data %p, status %x",
633                             bio->bio_buf, ctlr->data, status);
634
635                         if (status & OVERRUN)
636                                 kprintf(" Conversion overrun (multiple A-D trigger)");
637
638                         if (status & OVERFLOW)
639                                 kprintf(" FIFO overflow");
640
641                         kprintf("\n");
642
643                         if (bio) {
644                                 done_and_start_next(ctlr, bio, EIO);
645                                 return;
646                         } else {
647                                 kprintf("ad_intr: (should not happen) error between records\n");
648                                 ctlr->err = status;     /* Set overrun condition */
649                                 return;
650                         }
651                 }
652                 else    /* FIFO interrupt */
653                 {
654                         struct bio *bio = ctlr->start_queue.bio_actf;
655
656                         if (ctlr->data) {
657                                 *ctlr->data++ = inb(ADFIFO(ctlr));
658                                 if (ctlr->data == ctlr->data_end) {
659                                         /* Normal completion */
660                                         done_and_start_next(ctlr, bio, 0);
661                                         return;
662                                 }
663                         } else {
664                                 /* Interrupt with no where to put the data.  */
665                                 kprintf("ad_intr: (should not happen) dropped input.\n");
666                                 (void)inb(ADFIFO(ctlr));
667
668                                 kprintf("bp %p, status %x, cr3 %x\n",
669                                     bio->bio_buf, status, ctlr->cr_image[2]);
670                                 ctlr->err = DROPPED_INPUT;
671                                 return;
672                         }
673                 }
674         }
675 }
676
677 static void
678 labpcintr(void *arg)
679 {
680         int unit = (int)arg;
681         struct ctlr *ctlr = labpcs[unit];
682         (*ctlr->intr)(ctlr);
683 }
684
685 /* lockout_multiple_opens: Return whether or not we can open again, or
686  * if the new mode is inconsistent with an already opened mode.
687  * We only permit multiple opens for digital I/O now.
688  */
689
690 static int
691 lockout_multiple_open(cdev_t current, cdev_t next)
692 {
693         return ! (DIGITAL(current) && DIGITAL(next));
694 }
695
696 static  int
697 labpcopen(struct dev_open_args *ap)
698 {
699         cdev_t dev = ap->a_head.a_dev;
700         u_short unit = UNIT(dev);
701
702         struct ctlr *ctlr;
703
704         if (unit >= MAX_UNITS)
705                 return ENXIO;
706
707         ctlr = labpcs[unit];
708
709         if (ctlr == 0)
710                 return ENXIO;
711
712         /* Don't allow another open if we have to change modes.
713          */
714
715         if ( (ctlr->flags & BUSY) == 0)
716         {
717                 ctlr->flags |= BUSY;
718
719                 reset(ctlr);
720
721                 ctlr->err = 0;
722                 ctlr->dev = dev;
723
724                 ctlr->intr = null_intr;
725                 ctlr->starter = null_start;
726                 ctlr->stop = null_stop;
727         }
728         else if (lockout_multiple_open(ctlr->dev, dev))
729                 return EBUSY;
730
731         return 0;
732 }
733
734 static  int
735 labpcclose(struct dev_close_args *ap)
736 {
737         cdev_t dev = ap->a_head.a_dev;
738         struct ctlr *ctlr = labpcs[UNIT(dev)];
739
740         (*ctlr->stop)(ctlr);
741
742         ctlr->flags &= ~BUSY;
743
744         return 0;
745 }
746
747 /*
748  * Start: Start a frame going in or out.
749  */
750 static void
751 start(struct ctlr *ctlr)
752 {
753         struct bio *bio;
754         struct buf *bp;
755
756         if ((bio = ctlr->start_queue.bio_actf) == NULL) {
757                 /* We must turn off FIFO interrupts when there is no
758                  * place to put the data.  We have to get back to
759                  * reading before the FIFO overflows.
760                  */
761                 CR_EXPR(ctlr, 3, &= ~(FIFOINTEN|ERRINTEN));
762                 ctlr->cleared_intr = 1;
763                 ctlr->count = 0;
764                 return;
765         }
766         bp = bio->bio_buf;
767
768         ctlr->data = (u_char *)bp->b_data;
769         ctlr->data_end = ctlr->data + bp->b_bcount;
770
771         if (ctlr->err)
772         {
773                 kprintf("labpc start: (should not happen) error between records.\n");
774                 done_and_start_next(ctlr, bio, EIO);
775                 return;
776         }
777
778         if (ctlr->data == 0)
779         {
780                 kprintf("labpc start: (should not happen) NULL data pointer.\n");
781                 done_and_start_next(ctlr, bio, EIO);
782                 return;
783         }
784
785         (*ctlr->starter)(ctlr, bp->b_bcount);
786
787         if (!FIFOINTENABLED(ctlr))      /* We can store the data again */
788         {
789                 CR_EXPR(ctlr, 3, |= (FIFOINTEN|ERRINTEN));
790
791                 /* Don't wait for the interrupts to fill things up.
792                  */
793                 (*ctlr->intr)(ctlr);
794         }
795
796         callout_reset(&ctlr->ch, ctlr->tmo, tmo_stop, ctlr);
797 }
798
799 static void
800 ad_strategy(struct bio *bio, struct ctlr *ctlr)
801 {
802         crit_enter();
803         bio->bio_actf = NULL;
804
805         if (ctlr->count) {
806                 ctlr->last->bio_actf = bio;
807                 ctlr->last = bio;
808         } else {
809                 ctlr->count = 1;
810                 ctlr->start_queue.bio_actf = bio;
811                 ctlr->last = bio;
812                 start(ctlr);
813         }
814         crit_exit();
815 }
816
817 /* da_strategy: Send data to the D-A.  The CHAN field should be
818  * 0: D-A port 0
819  * 1: D-A port 1
820  * 2: Alternate port 0 then port 1
821  *
822  * XXX:
823  *
824  * 1. There is no state for CHAN field 2:
825  * the first sample in each buffer goes to channel 0.
826  *
827  * 2. No interrupt support yet.
828  */
829 static void
830 da_strategy(struct bio *bio, struct ctlr *ctlr)
831 {
832         struct buf *bp = bio->bio_buf;
833         cdev_t dev = bio->bio_driver_info;
834         int len;
835         u_char *data;
836         int port;
837         int i;
838
839         switch(CHAN(dev))
840         {
841                 case 0:
842                         port = DAC0L(ctlr);
843                         break;
844
845                 case 1:
846                         port = DAC1L(ctlr);
847                         break;
848
849                 case 2: /* Device 2 handles both ports interleaved. */
850                         if (bp->b_bcount <= 2)
851                         {
852                                 port = DAC0L(ctlr);
853                                 break;
854                         }
855
856                         len = bp->b_bcount / 2;
857                         data = (u_char *)bp->b_data;
858
859                         for (i = 0; i < len; i++)
860                         {
861                                 loutb(DAC0H(ctlr), *data++);
862                                 loutb(DAC0L(ctlr), *data++);
863                                 loutb(DAC1H(ctlr), *data++);
864                                 loutb(DAC1L(ctlr), *data++);
865                         }
866
867                         bp->b_resid = bp->b_bcount & 3;
868                         bp_done(bio, 0);
869                         return;
870
871                 default:
872                         bp_done(bio, ENXIO);
873                         return;
874         }
875
876         /* Port 0 or 1 falls through to here.
877          */
878         if (bp->b_bcount & 1)   /* Odd transfers are illegal */
879                 bp_done(bio, EIO);
880
881         len = bp->b_bcount;
882         data = (u_char *)bp->b_data;
883
884         for (i = 0; i < len; i++)
885         {
886                 loutb(port + 1, *data++);
887                 loutb(port, *data++);
888         }
889
890         bp->b_resid = 0;
891
892         bp_done(bio, 0);
893 }
894
895 /* Input masks for MODE 0 of the ports treating PC as a single
896  * 8 bit port.  Set these bits to set the port to input.
897  */
898                             /* A     B    lowc  highc combined */
899 static u_char set_input[] = { 0x10, 0x02, 0x01,  0x08,  0x09 };
900
901 static void flush_dcr(struct ctlr *ctlr)
902 {
903         if (ctlr->dcr_is != ctlr->dcr_val)
904         {
905                 loutb(DCR(ctlr), ctlr->dcr_val);
906                 ctlr->dcr_is = ctlr->dcr_val;
907         }
908 }
909
910 /* do: Digital output
911  */
912 static void
913 digital_out_strategy(struct bio *bio, struct ctlr *ctlr)
914 {
915         struct buf *bp = bio->bio_buf;
916         cdev_t dev = bio->bio_driver_info;
917         int len;
918         u_char *data;
919         int port;
920         int i;
921         int chan = CHAN(dev);
922
923         ctlr->dcr_val &= ~set_input[chan];      /* Digital out: Clear bit */
924         flush_dcr(ctlr);
925
926         port = PORTX(ctlr, chan);
927
928         len = bp->b_bcount;
929         data = (u_char *)bp->b_data;
930
931         for (i = 0; i < len; i++)
932         {
933                 loutb(port, *data++);
934         }
935
936         bp->b_resid = 0;
937
938         bp_done(bio, 0);
939 }
940
941 /* digital_in_strategy: Digital input
942  */
943 static void
944 digital_in_strategy(struct bio *bio, struct ctlr *ctlr)
945 {
946         struct buf *bp = bio->bio_buf;
947         cdev_t dev = bio->bio_driver_info;
948         int len;
949         u_char *data;
950         int port;
951         int i;
952         int chan = CHAN(dev);
953
954         ctlr->dcr_val |= set_input[chan];       /* Digital in: Set bit */
955         flush_dcr(ctlr);
956         port = PORTX(ctlr, chan);
957
958         len = bp->b_bcount;
959         data = (u_char *)bp->b_data;
960
961         for (i = 0; i < len; i++)
962         {
963                 *data++ = inb(port);
964         }
965
966         bp->b_resid = 0;
967
968         bp_done(bio, 0);
969 }
970
971
972 static  int
973 labpcstrategy(struct dev_strategy_args *ap)
974 {
975         cdev_t dev = ap->a_head.a_dev;
976         struct bio *bio = ap->a_bio;
977         struct buf *bp = bio->bio_buf;
978         struct ctlr *ctlr = labpcs[UNIT(dev)];
979
980         bio->bio_driver_info = dev;
981
982         if (DIGITAL(dev)) {
983                 if (bp->b_cmd == BUF_CMD_READ) {
984                         ctlr->starter = null_start;
985                         ctlr->stop = all_stop;
986                         ctlr->intr = null_intr;
987                         digital_in_strategy(bio, ctlr);
988                 }
989                 else
990                 {
991                         ctlr->starter = null_start;
992                         ctlr->stop = all_stop;
993                         ctlr->intr = null_intr;
994                         digital_out_strategy(bio, ctlr);
995                 }
996         }
997         else {
998                 if (bp->b_cmd == BUF_CMD_READ) {
999
1000                         ctlr->starter = INTERVAL(ctlr->dev) ? ad_interval_start : ad_start;
1001                         ctlr->stop = all_stop;
1002                         ctlr->intr = ad_intr;
1003                         ad_strategy(bio, ctlr);
1004                 }
1005                 else
1006                 {
1007                         ctlr->starter = null_start;
1008                         ctlr->stop = all_stop;
1009                         ctlr->intr = null_intr;
1010                         da_strategy(bio, ctlr);
1011                 }
1012         }
1013         return(0);
1014 }
1015
1016 static  int
1017 labpcioctl(struct dev_ioctl_args *ap)
1018 {
1019         cdev_t dev = ap->a_head.a_dev;
1020         caddr_t arg = ap->a_data;
1021         struct ctlr *ctlr = labpcs[UNIT(dev)];
1022
1023         switch(ap->a_cmd)
1024         {
1025                 case AD_MICRO_PERIOD_SET:
1026                 {
1027                         /* XXX I'm only supporting what I have to, which is
1028                          * no slow periods.  You can't get any slower than 15 Hz
1029                          * with the current setup.  To go slower you'll need to
1030                          * support TCINTEN in CR3.
1031                          */
1032
1033                         long sample_us = *(long *)arg;
1034
1035                         if (sample_us > 65535)
1036                                 return EIO;
1037
1038                         ctlr->sample_us = sample_us;
1039                         return 0;
1040                 }
1041
1042                 case AD_MICRO_PERIOD_GET:
1043                         *(long *)arg = ctlr->sample_us;
1044                         return 0;
1045
1046                 case AD_NGAINS_GET:
1047                         *(int *)arg = 8;
1048                         return 0;
1049
1050                 case AD_NCHANS_GET:
1051                         *(int *)arg = 8;
1052                         return 0;
1053
1054                 case AD_SUPPORTED_GAINS:
1055                 {
1056                         static double gains[] = {1., 1.25, 2., 5., 10., 20., 50., 100.};
1057                         copyout(gains, *(caddr_t *)arg, sizeof(gains));
1058
1059                         return 0;
1060                 }
1061
1062                 case AD_GAINS_SET:
1063                 {
1064                         copyin(*(caddr_t *)arg, ctlr->gains, sizeof(ctlr->gains));
1065                         return 0;
1066                 }
1067
1068                 case AD_GAINS_GET:
1069                 {
1070                         copyout(ctlr->gains, *(caddr_t *)arg, sizeof(ctlr->gains));
1071                         return 0;
1072                 }
1073
1074                 default:
1075                         return ENOTTY;
1076         }
1077 }