Merge branch 'drm-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied...
[linux-2.6] / drivers / staging / comedi / drivers / das08.c
1 /*
2     comedi/drivers/das08.c
3     DAS08 driver
4
5     COMEDI - Linux Control and Measurement Device Interface
6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7     Copyright (C) 2001,2002,2003 Frank Mori Hess <fmhess@users.sourceforge.net>
8     Copyright (C) 2004 Salvador E. Tropea <set@users.sf.net> <set@ieee.org>
9
10     This program is free software; you can redistribute it and/or modify
11     it under the terms of the GNU General Public License as published by
12     the Free Software Foundation; either version 2 of the License, or
13     (at your option) any later version.
14
15     This program is distributed in the hope that it will be useful,
16     but WITHOUT ANY WARRANTY; without even the implied warranty of
17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18     GNU General Public License for more details.
19
20     You should have received a copy of the GNU General Public License
21     along with this program; if not, write to the Free Software
22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23
24 *****************************************************************
25
26 */
27 /*
28 Driver: das08
29 Description: DAS-08 compatible boards
30 Author: Warren Jasper, ds, Frank Hess
31 Devices: [Keithley Metrabyte] DAS08 (isa-das08), [ComputerBoards] DAS08 (isa-das08),
32   DAS08-PGM (das08-pgm),
33   DAS08-PGH (das08-pgh), DAS08-PGL (das08-pgl), DAS08-AOH (das08-aoh),
34   DAS08-AOL (das08-aol), DAS08-AOM (das08-aom), DAS08/JR-AO (das08/jr-ao),
35   DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (das08),
36   PC104-DAS08 (pc104-das08), DAS08/JR/16 (das08jr/16)
37 Status: works
38
39 This is a rewrite of the das08 and das08jr drivers.
40
41 Options (for ISA cards):
42         [0] - base io address
43
44 Options (for pci-das08):
45         [0] - bus  (optional)
46         [1] = slot (optional)
47
48 The das08 driver doesn't support asynchronous commands, since
49 the cheap das08 hardware doesn't really support them.  The
50 comedi_rt_timer driver can be used to emulate commands for this
51 driver.
52 */
53
54 #include "../comedidev.h"
55
56 #include <linux/delay.h>
57
58 #include "comedi_pci.h"
59 #include "8255.h"
60 #include "das08.h"
61
62 #define DRV_NAME "das08"
63
64 #define PCI_VENDOR_ID_COMPUTERBOARDS 0x1307
65 #define PCI_DEVICE_ID_PCIDAS08 0x29
66 #define PCIDAS08_SIZE 0x54
67
68 // pci configuration registers
69 #define INTCSR               0x4c
70 #define   INTR1_ENABLE         0x1
71 #define   INTR1_HIGH_POLARITY  0x2
72 #define   PCI_INTR_ENABLE      0x40
73 #define   INTR1_EDGE_TRIG      0x100    // requires high polarity
74 #define CNTRL                0x50
75 #define   CNTRL_DIR            0x2
76 #define   CNTRL_INTR           0x4
77
78 /*
79     cio-das08.pdf
80
81   "isa-das08"
82
83   0     a/d bits 0-3            start 8 bit
84   1     a/d bits 4-11           start 12 bit
85   2     eoc, ip1-3, irq, mux    op1-4, inte, mux
86   3     unused                  unused
87   4567  8254
88   89ab  8255
89
90   requires hard-wiring for async ai
91
92 */
93
94 #define DAS08_LSB               0
95 #define DAS08_MSB               1
96 #define DAS08_TRIG_12BIT        1
97 #define DAS08_STATUS            2
98 #define   DAS08_EOC                     (1<<7)
99 #define   DAS08_IRQ                     (1<<3)
100 #define   DAS08_IP(x)                   (((x)>>4)&0x7)
101 #define DAS08_CONTROL           2
102 #define   DAS08_MUX_MASK        0x7
103 #define   DAS08_MUX(x)          ((x) & DAS08_MUX_MASK)
104 #define   DAS08_INTE                    (1<<3)
105 #define   DAS08_DO_MASK         0xf0
106 #define   DAS08_OP(x)           (((x) << 4) & DAS08_DO_MASK)
107
108 /*
109     cio-das08jr.pdf
110
111   "das08/jr-ao"
112
113   0     a/d bits 0-3            unused
114   1     a/d bits 4-11           start 12 bit
115   2     eoc, mux                mux
116   3     di                      do
117   4     unused                  ao0_lsb
118   5     unused                  ao0_msb
119   6     unused                  ao1_lsb
120   7     unused                  ao1_msb
121
122 */
123
124 #define DAS08JR_DIO             3
125 #define DAS08JR_AO_LSB(x)       ((x)?6:4)
126 #define DAS08JR_AO_MSB(x)       ((x)?7:5)
127
128 /*
129     cio-das08_aox.pdf
130
131   "das08-aoh"
132   "das08-aol"
133   "das08-aom"
134
135   0     a/d bits 0-3            start 8 bit
136   1     a/d bits 4-11           start 12 bit
137   2     eoc, ip1-3, irq, mux    op1-4, inte, mux
138   3     mux, gain status        gain control
139   4567  8254
140   8     unused                  ao0_lsb
141   9     unused                  ao0_msb
142   a     unused                  ao1_lsb
143   b     unused                  ao1_msb
144   89ab
145   cdef  8255
146 */
147
148 #define DAS08AO_GAIN_CONTROL    3
149 #define DAS08AO_GAIN_STATUS     3
150
151 #define DAS08AO_AO_LSB(x)       ((x)?0xa:8)
152 #define DAS08AO_AO_MSB(x)       ((x)?0xb:9)
153 #define DAS08AO_AO_UPDATE       8
154
155 /* gainlist same as _pgx_ below */
156
157 static int das08_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
158         struct comedi_insn * insn, unsigned int * data);
159 static int das08_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
160         struct comedi_insn * insn, unsigned int * data);
161 static int das08_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
162         struct comedi_insn * insn, unsigned int * data);
163 static int das08jr_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
164         struct comedi_insn * insn, unsigned int * data);
165 static int das08jr_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
166         struct comedi_insn * insn, unsigned int * data);
167 static int das08jr_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
168         struct comedi_insn * insn, unsigned int * data);
169 static int das08ao_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
170         struct comedi_insn * insn, unsigned int * data);
171 static void i8254_set_mode_low(unsigned int base, int channel,
172         unsigned int mode);
173
174 static const struct comedi_lrange range_das08_pgl = { 9, {
175                         BIP_RANGE(10),
176                         BIP_RANGE(5),
177                         BIP_RANGE(2.5),
178                         BIP_RANGE(1.25),
179                         BIP_RANGE(0.625),
180                         UNI_RANGE(10),
181                         UNI_RANGE(5),
182                         UNI_RANGE(2.5),
183                         UNI_RANGE(1.25)
184         }
185 };
186 static const struct comedi_lrange range_das08_pgh = { 12, {
187                         BIP_RANGE(10),
188                         BIP_RANGE(5),
189                         BIP_RANGE(1),
190                         BIP_RANGE(0.5),
191                         BIP_RANGE(0.1),
192                         BIP_RANGE(0.05),
193                         BIP_RANGE(0.01),
194                         BIP_RANGE(0.005),
195                         UNI_RANGE(10),
196                         UNI_RANGE(1),
197                         UNI_RANGE(0.1),
198                         UNI_RANGE(0.01),
199         }
200 };
201 static const struct comedi_lrange range_das08_pgm = { 9, {
202                         BIP_RANGE(10),
203                         BIP_RANGE(5),
204                         BIP_RANGE(0.5),
205                         BIP_RANGE(0.05),
206                         BIP_RANGE(0.01),
207                         UNI_RANGE(10),
208                         UNI_RANGE(1),
209                         UNI_RANGE(0.1),
210                         UNI_RANGE(0.01)
211         }
212 };                              /*
213                                    cio-das08jr.pdf
214
215                                    "das08/jr-ao"
216
217                                    0 a/d bits 0-3            unused
218                                    1 a/d bits 4-11           start 12 bit
219                                    2 eoc, mux                mux
220                                    3 di                      do
221                                    4 unused                  ao0_lsb
222                                    5 unused                  ao0_msb
223                                    6 unused                  ao1_lsb
224                                    7 unused                  ao1_msb
225
226                                  */
227
228 static const struct comedi_lrange *const das08_ai_lranges[] = {
229         &range_unknown,
230         &range_bipolar5,
231         &range_das08_pgh,
232         &range_das08_pgl,
233         &range_das08_pgm,
234 };
235
236 static const int das08_pgh_gainlist[] =
237         { 8, 0, 10, 2, 12, 4, 14, 6, 1, 3, 5, 7 };
238 static const int das08_pgl_gainlist[] = { 8, 0, 2, 4, 6, 1, 3, 5, 7 };
239 static const int das08_pgm_gainlist[] = { 8, 0, 10, 12, 14, 9, 11, 13, 15 };
240
241 static const int *const das08_gainlists[] = {
242         NULL,
243         NULL,
244         das08_pgh_gainlist,
245         das08_pgl_gainlist,
246         das08_pgm_gainlist,
247 };
248
249 static const struct das08_board_struct das08_boards[] = {
250         {
251               name:     "isa-das08",    // cio-das08.pdf
252               bustype:  isa,
253               ai:       das08_ai_rinsn,
254               ai_nbits:12,
255               ai_pg:    das08_pg_none,
256               ai_encoding:das08_encode12,
257               ao:       NULL,
258               ao_nbits:12,
259               di:       das08_di_rbits,
260               do_:      das08_do_wbits,
261               do_nchan:4,
262               i8255_offset:8,
263               i8254_offset:4,
264               iosize:   16,     // unchecked
265                 },
266         {
267               name:     "das08-pgm",    // cio-das08pgx.pdf
268               bustype:  isa,
269               ai:       das08_ai_rinsn,
270               ai_nbits:12,
271               ai_pg:    das08_pgm,
272               ai_encoding:das08_encode12,
273               ao:       NULL,
274               di:       das08_di_rbits,
275               do_:      das08_do_wbits,
276               do_nchan:4,
277               i8255_offset:0,
278               i8254_offset:0x04,
279               iosize:   16,     // unchecked
280                 },
281         {
282               name:     "das08-pgh",    // cio-das08pgx.pdf
283               bustype:  isa,
284               ai:       das08_ai_rinsn,
285               ai_nbits:12,
286               ai_pg:    das08_pgh,
287               ai_encoding:das08_encode12,
288               ao:       NULL,
289               di:       das08_di_rbits,
290               do_:      das08_do_wbits,
291               do_nchan:4,
292               i8255_offset:0,
293               i8254_offset:0x04,
294               iosize:   16,     // unchecked
295                 },
296         {
297               name:     "das08-pgl",    // cio-das08pgx.pdf
298               bustype:  isa,
299               ai:       das08_ai_rinsn,
300               ai_nbits:12,
301               ai_pg:    das08_pgl,
302               ai_encoding:das08_encode12,
303               ao:       NULL,
304               di:       das08_di_rbits,
305               do_:      das08_do_wbits,
306               do_nchan:4,
307               i8255_offset:0,
308               i8254_offset:0x04,
309               iosize:   16,     // unchecked
310                 },
311         {
312               name:     "das08-aoh",    // cio-das08_aox.pdf
313               bustype:  isa,
314               ai:       das08_ai_rinsn,
315               ai_nbits:12,
316               ai_pg:    das08_pgh,
317               ai_encoding:das08_encode12,
318               ao:       das08ao_ao_winsn,       // 8
319               ao_nbits:12,
320               di:       das08_di_rbits,
321               do_:      das08_do_wbits,
322               do_nchan:4,
323               i8255_offset:0x0c,
324               i8254_offset:0x04,
325               iosize:   16,     // unchecked
326                 },
327         {
328               name:     "das08-aol",    // cio-das08_aox.pdf
329               bustype:  isa,
330               ai:       das08_ai_rinsn,
331               ai_nbits:12,
332               ai_pg:    das08_pgl,
333               ai_encoding:das08_encode12,
334               ao:       das08ao_ao_winsn,       // 8
335               ao_nbits:12,
336               di:       das08_di_rbits,
337               do_:      das08_do_wbits,
338               do_nchan:4,
339               i8255_offset:0x0c,
340               i8254_offset:0x04,
341               iosize:   16,     // unchecked
342                 },
343         {
344               name:     "das08-aom",    // cio-das08_aox.pdf
345               bustype:  isa,
346               ai:       das08_ai_rinsn,
347               ai_nbits:12,
348               ai_pg:    das08_pgm,
349               ai_encoding:das08_encode12,
350               ao:       das08ao_ao_winsn,       // 8
351               ao_nbits:12,
352               di:       das08_di_rbits,
353               do_:      das08_do_wbits,
354               do_nchan:4,
355               i8255_offset:0x0c,
356               i8254_offset:0x04,
357               iosize:   16,     // unchecked
358                 },
359         {
360               name:     "das08/jr-ao",  // cio-das08-jr-ao.pdf
361               bustype:  isa,
362               ai:       das08_ai_rinsn,
363               ai_nbits:12,
364               ai_pg:    das08_pg_none,
365               ai_encoding:das08_encode12,
366               ao:       das08jr_ao_winsn,
367               ao_nbits:12,
368               di:       das08jr_di_rbits,
369               do_:      das08jr_do_wbits,
370               do_nchan:8,
371               i8255_offset:0,
372               i8254_offset:0,
373               iosize:   16,     // unchecked
374                 },
375         {
376               name:     "das08jr-16-ao",        // cio-das08jr-16-ao.pdf
377               bustype:  isa,
378               ai:       das08_ai_rinsn,
379               ai_nbits:16,
380               ai_pg:    das08_pg_none,
381               ai_encoding:das08_encode12,
382               ao:       das08jr_ao_winsn,
383               ao_nbits:16,
384               di:       das08jr_di_rbits,
385               do_:      das08jr_do_wbits,
386               do_nchan:8,
387               i8255_offset:0,
388               i8254_offset:0x04,
389               iosize:   16,     // unchecked
390                 },
391 #ifdef CONFIG_COMEDI_PCI
392         {
393               name:     "das08",        // pci-das08
394               id:       PCI_DEVICE_ID_PCIDAS08,
395               bustype:  pci,
396               ai:       das08_ai_rinsn,
397               ai_nbits:12,
398               ai_pg:    das08_bipolar5,
399               ai_encoding:das08_encode12,
400               ao:       NULL,
401               ao_nbits:0,
402               di:       das08_di_rbits,
403               do_:      das08_do_wbits,
404               do_nchan:4,
405               i8255_offset:0,
406               i8254_offset:4,
407               iosize:   8,
408                 },
409 #endif
410         {
411               name:     "pc104-das08",
412               bustype:  pc104,
413               ai:       das08_ai_rinsn,
414               ai_nbits:12,
415               ai_pg:    das08_pg_none,
416               ai_encoding:das08_encode12,
417               ao:       NULL,
418               ao_nbits:0,
419               di:       das08_di_rbits,
420               do_:      das08_do_wbits,
421               do_nchan:4,
422               i8255_offset:0,
423               i8254_offset:4,
424               iosize:   16,     // unchecked
425                 },
426 #if 0
427         {
428               name:     "das08/f",
429                 },
430         {
431               name:     "das08jr",
432                 },
433 #endif
434         {
435               name:     "das08jr/16",
436               bustype:  isa,
437               ai:       das08_ai_rinsn,
438               ai_nbits:16,
439               ai_pg:    das08_pg_none,
440               ai_encoding:das08_encode16,
441               ao:       NULL,
442               ao_nbits:0,
443               di:       das08jr_di_rbits,
444               do_:      das08jr_do_wbits,
445               do_nchan:8,
446               i8255_offset:0,
447               i8254_offset:0,
448               iosize:   16,     // unchecked
449                 },
450 #if 0
451         {
452               name:     "das48-pga",    // cio-das48-pga.pdf
453                 },
454         {
455               name:     "das08-pga-g2", // a KM board
456                 },
457 #endif
458 };
459
460 #ifdef CONFIG_COMEDI_PCMCIA
461 struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = {
462         {
463               name:     "pcm-das08",
464               id:       0x0,    // XXX
465               bustype:  pcmcia,
466               ai:       das08_ai_rinsn,
467               ai_nbits:12,
468               ai_pg:    das08_bipolar5,
469               ai_encoding:das08_pcm_encode12,
470               ao:       NULL,
471               ao_nbits:0,
472               di:       das08_di_rbits,
473               do_:      das08_do_wbits,
474               do_nchan:3,
475               i8255_offset:0,
476               i8254_offset:0,
477               iosize:   16,
478                 },
479         // duplicate so driver name can be used also
480         {
481               name:     "das08_cs",
482               id:       0x0,    // XXX
483               bustype:  pcmcia,
484               ai:       das08_ai_rinsn,
485               ai_nbits:12,
486               ai_pg:    das08_bipolar5,
487               ai_encoding:das08_pcm_encode12,
488               ao:       NULL,
489               ao_nbits:0,
490               di:       das08_di_rbits,
491               do_:      das08_do_wbits,
492               do_nchan:3,
493               i8255_offset:0,
494               i8254_offset:0,
495               iosize:   16,
496                 },
497 };
498 #endif
499
500 #ifdef CONFIG_COMEDI_PCI
501 static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = {
502         {PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08, PCI_ANY_ID,
503                 PCI_ANY_ID, 0, 0, 0},
504         {0}
505 };
506
507 MODULE_DEVICE_TABLE(pci, das08_pci_table);
508 #endif
509
510 #define devpriv ((struct das08_private_struct *)dev->private)
511 #define thisboard ((const struct das08_board_struct *)dev->board_ptr)
512
513 #define TIMEOUT 100000
514
515 static int das08_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
516         struct comedi_insn * insn, unsigned int * data)
517 {
518         int i, n;
519         int chan;
520         int range;
521         int lsb, msb;
522
523         chan = CR_CHAN(insn->chanspec);
524         range = CR_RANGE(insn->chanspec);
525
526         /* clear crap */
527         inb(dev->iobase + DAS08_LSB);
528         inb(dev->iobase + DAS08_MSB);
529
530         /* set multiplexer */
531         spin_lock(&dev->spinlock);      // lock to prevent race with digital output
532         devpriv->do_mux_bits &= ~DAS08_MUX_MASK;
533         devpriv->do_mux_bits |= DAS08_MUX(chan);
534         outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
535         spin_unlock(&dev->spinlock);
536
537         if (s->range_table->length > 1) {
538                 /* set gain/range */
539                 range = CR_RANGE(insn->chanspec);
540                 outb(devpriv->pg_gainlist[range],
541                         dev->iobase + DAS08AO_GAIN_CONTROL);
542         }
543
544         for (n = 0; n < insn->n; n++) {
545                 /* clear over-range bits for 16-bit boards */
546                 if (thisboard->ai_nbits == 16)
547                         if (inb(dev->iobase + DAS08_MSB) & 0x80)
548                                 rt_printk("das08: over-range\n");
549
550                 /* trigger conversion */
551                 outb_p(0, dev->iobase + DAS08_TRIG_12BIT);
552
553                 for (i = 0; i < TIMEOUT; i++) {
554                         if (!(inb(dev->iobase + DAS08_STATUS) & DAS08_EOC))
555                                 break;
556                 }
557                 if (i == TIMEOUT) {
558                         rt_printk("das08: timeout\n");
559                         return -ETIME;
560                 }
561                 msb = inb(dev->iobase + DAS08_MSB);
562                 lsb = inb(dev->iobase + DAS08_LSB);
563                 if (thisboard->ai_encoding == das08_encode12) {
564                         data[n] = (lsb >> 4) | (msb << 4);
565                 } else if (thisboard->ai_encoding == das08_pcm_encode12) {
566                         data[n] = (msb << 8) + lsb;
567                 } else if (thisboard->ai_encoding == das08_encode16) {
568                         /* FPOS 16-bit boards are sign-magnitude */
569                         if (msb & 0x80)
570                                 data[n] = (1 << 15) | lsb | ((msb & 0x7f) << 8);
571                         else
572                                 data[n] = (1 << 15) - (lsb | (msb & 0x7f) << 8);
573                 } else {
574                         comedi_error(dev, "bug! unknown ai encoding");
575                         return -1;
576                 }
577         }
578
579         return n;
580 }
581
582 static int das08_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
583         struct comedi_insn * insn, unsigned int * data)
584 {
585         data[0] = 0;
586         data[1] = DAS08_IP(inb(dev->iobase + DAS08_STATUS));
587
588         return 2;
589 }
590
591 static int das08_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
592         struct comedi_insn * insn, unsigned int * data)
593 {
594         int wbits;
595
596         // get current settings of digital output lines
597         wbits = (devpriv->do_mux_bits >> 4) & 0xf;
598         // null bits we are going to set
599         wbits &= ~data[0];
600         // set new bit values
601         wbits |= data[0] & data[1];
602         // remember digital output bits
603         spin_lock(&dev->spinlock);      // prevent race with setting of analog input mux
604         devpriv->do_mux_bits &= ~DAS08_DO_MASK;
605         devpriv->do_mux_bits |= DAS08_OP(wbits);
606         outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
607         spin_unlock(&dev->spinlock);
608
609         data[1] = wbits;
610
611         return 2;
612 }
613
614 static int das08jr_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
615         struct comedi_insn * insn, unsigned int * data)
616 {
617         data[0] = 0;
618         data[1] = inb(dev->iobase + DAS08JR_DIO);
619
620         return 2;
621 }
622
623 static int das08jr_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
624         struct comedi_insn * insn, unsigned int * data)
625 {
626         // null bits we are going to set
627         devpriv->do_bits &= ~data[0];
628         // set new bit values
629         devpriv->do_bits |= data[0] & data[1];
630         outb(devpriv->do_bits, dev->iobase + DAS08JR_DIO);
631
632         data[1] = devpriv->do_bits;
633
634         return 2;
635 }
636
637 static int das08jr_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
638         struct comedi_insn * insn, unsigned int * data)
639 {
640         int n;
641         int lsb, msb;
642         int chan;
643
644         lsb = data[0] & 0xff;
645         msb = (data[0] >> 8) & 0xf;
646
647         chan = CR_CHAN(insn->chanspec);
648
649         for (n = 0; n < insn->n; n++) {
650 #if 0
651                 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
652                 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
653 #else
654                 outb(lsb, dev->iobase + DAS08JR_AO_LSB(chan));
655                 outb(msb, dev->iobase + DAS08JR_AO_MSB(chan));
656 #endif
657
658                 /* load DACs */
659                 inb(dev->iobase + DAS08JR_DIO);
660         }
661
662         return n;
663 }
664
665 /*
666  *
667  * The -aox boards have the DACs at a different offset and use
668  * a different method to force an update.
669  *
670  */
671 static int das08ao_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
672         struct comedi_insn * insn, unsigned int * data)
673 {
674         int n;
675         int lsb, msb;
676         int chan;
677
678         lsb = data[0] & 0xff;
679         msb = (data[0] >> 8) & 0xf;
680
681         chan = CR_CHAN(insn->chanspec);
682
683         for (n = 0; n < insn->n; n++) {
684 #if 0
685                 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
686                 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
687 #else
688                 outb(lsb, dev->iobase + DAS08AO_AO_LSB(chan));
689                 outb(msb, dev->iobase + DAS08AO_AO_MSB(chan));
690 #endif
691
692                 /* load DACs */
693                 inb(dev->iobase + DAS08AO_AO_UPDATE);
694         }
695
696         return n;
697 }
698
699 static unsigned int i8254_read_channel_low(unsigned int base, int chan)
700 {
701         unsigned int msb, lsb;
702
703         /* The following instructions must be in order.
704            We must avoid other process reading the counter's value in the
705            middle.
706            The spin_lock isn't needed since ioctl calls grab the big kernel
707            lock automatically */
708         /*spin_lock(sp); */
709         outb(chan << 6, base + I8254_CTRL);
710         base += chan;
711         lsb = inb(base);
712         msb = inb(base);
713         /*spin_unlock(sp); */
714
715         return lsb | (msb << 8);
716 }
717
718 static void i8254_write_channel_low(unsigned int base, int chan,
719         unsigned int value)
720 {
721         unsigned int msb, lsb;
722
723         lsb = value & 0xFF;
724         msb = value >> 8;
725
726         /* write lsb, then msb */
727         base += chan;
728         /* See comments in i8254_read_channel_low */
729         /*spin_lock(sp); */
730         outb(lsb, base);
731         outb(msb, base);
732         /*spin_unlock(sp); */
733 }
734
735 static unsigned int i8254_read_channel(struct i8254_struct *st, int channel)
736 {
737         int chan = st->logic2phys[channel];
738
739         return i8254_read_channel_low(st->iobase, chan);
740 }
741
742 static void i8254_write_channel(struct i8254_struct *st, int channel,
743         unsigned int value)
744 {
745         int chan = st->logic2phys[channel];
746
747         i8254_write_channel_low(st->iobase, chan, value);
748 }
749
750 static void i8254_initialize(struct i8254_struct *st)
751 {
752         int i;
753         for (i = 0; i < 3; ++i)
754                 i8254_set_mode_low(st->iobase, i, st->mode[i]);
755 }
756
757 static void i8254_set_mode_low(unsigned int base, int channel,
758         unsigned int mode)
759 {
760         outb((channel << 6) | 0x30 | (mode & 0x0F), base + I8254_CTRL);
761 }
762
763 static void i8254_set_mode(struct i8254_struct *st, int channel,
764         unsigned int mode)
765 {
766         int chan = st->logic2phys[channel];
767
768         st->mode[chan] = mode;
769         return i8254_set_mode_low(st->iobase, chan, mode);
770 }
771
772 static unsigned int i8254_read_status_low(unsigned int base, int channel)
773 {
774         outb(0xE0 | (2 << channel), base + I8254_CTRL);
775         return inb(base + channel);
776 }
777
778 static unsigned int i8254_read_status(struct i8254_struct *st, int channel)
779 {
780         int chan = st->logic2phys[channel];
781
782         return i8254_read_status_low(st->iobase, chan);
783 }
784
785 static int das08_counter_read(struct comedi_device * dev, struct comedi_subdevice * s,
786         struct comedi_insn * insn, unsigned int * data)
787 {
788         int chan = insn->chanspec;
789
790         //printk("Reading counter channel %d ",chan);
791         data[0] = i8254_read_channel(&devpriv->i8254, chan);
792         //printk("=> 0x%08X\n",data[0]);
793
794         return 1;
795 }
796
797 static int das08_counter_write(struct comedi_device * dev, struct comedi_subdevice * s,
798         struct comedi_insn * insn, unsigned int * data)
799 {
800         int chan = insn->chanspec;
801
802         //printk("Writing counter channel %d with 0x%04X\n",chan,data[0]);
803         i8254_write_channel(&devpriv->i8254, chan, data[0]);
804
805         return 1;
806 }
807
808 static int das08_counter_config(struct comedi_device * dev, struct comedi_subdevice * s,
809         struct comedi_insn * insn, unsigned int * data)
810 {
811         int chan = insn->chanspec;
812
813         if (insn->n != 2)
814                 return -EINVAL;
815
816         switch (data[0]) {
817         case INSN_CONFIG_SET_COUNTER_MODE:
818                 i8254_set_mode(&devpriv->i8254, chan, data[1]);
819                 break;
820         case INSN_CONFIG_8254_READ_STATUS:
821                 data[1] = i8254_read_status(&devpriv->i8254, chan);
822                 break;
823         default:
824                 return -EINVAL;
825                 break;
826         }
827         return 2;
828 }
829
830 static int das08_attach(struct comedi_device * dev, struct comedi_devconfig * it);
831
832 static struct comedi_driver driver_das08 = {
833       driver_name: DRV_NAME,
834       module:THIS_MODULE,
835       attach:das08_attach,
836       detach:das08_common_detach,
837       board_name:&das08_boards[0].name,
838       num_names:sizeof(das08_boards) /
839                 sizeof(struct das08_board_struct),
840       offset:sizeof(struct das08_board_struct),
841 };
842
843 int das08_common_attach(struct comedi_device * dev, unsigned long iobase)
844 {
845         struct comedi_subdevice *s;
846         int ret;
847
848         // allocate ioports for non-pcmcia, non-pci boards
849         if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
850                 printk(" iobase 0x%lx\n", iobase);
851                 if (!request_region(iobase, thisboard->iosize, DRV_NAME)) {
852                         printk(" I/O port conflict\n");
853                         return -EIO;
854                 }
855         }
856         dev->iobase = iobase;
857
858         dev->board_name = thisboard->name;
859
860         if ((ret = alloc_subdevices(dev, 6)) < 0)
861                 return ret;
862
863         s = dev->subdevices + 0;
864         /* ai */
865         if (thisboard->ai) {
866                 s->type = COMEDI_SUBD_AI;
867                 /* XXX some boards actually have differential inputs instead of single ended.
868                  *  The driver does nothing with arefs though, so it's no big deal. */
869                 s->subdev_flags = SDF_READABLE | SDF_GROUND;
870                 s->n_chan = 8;
871                 s->maxdata = (1 << thisboard->ai_nbits) - 1;
872                 s->range_table = das08_ai_lranges[thisboard->ai_pg];
873                 s->insn_read = thisboard->ai;
874                 devpriv->pg_gainlist = das08_gainlists[thisboard->ai_pg];
875         } else {
876                 s->type = COMEDI_SUBD_UNUSED;
877         }
878
879         s = dev->subdevices + 1;
880         /* ao */
881         if (thisboard->ao) {
882                 s->type = COMEDI_SUBD_AO;
883 // XXX lacks read-back insn
884                 s->subdev_flags = SDF_WRITABLE;
885                 s->n_chan = 2;
886                 s->maxdata = (1 << thisboard->ao_nbits) - 1;
887                 s->range_table = &range_bipolar5;
888                 s->insn_write = thisboard->ao;
889         } else {
890                 s->type = COMEDI_SUBD_UNUSED;
891         }
892
893         s = dev->subdevices + 2;
894         /* di */
895         if (thisboard->di) {
896                 s->type = COMEDI_SUBD_DI;
897                 s->subdev_flags = SDF_READABLE;
898                 s->n_chan = (thisboard->di == das08_di_rbits) ? 3 : 8;
899                 s->maxdata = 1;
900                 s->range_table = &range_digital;
901                 s->insn_bits = thisboard->di;
902         } else {
903                 s->type = COMEDI_SUBD_UNUSED;
904         }
905
906         s = dev->subdevices + 3;
907         /* do */
908         if (thisboard->do_) {
909                 s->type = COMEDI_SUBD_DO;
910                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
911                 s->n_chan = thisboard->do_nchan;
912                 s->maxdata = 1;
913                 s->range_table = &range_digital;
914                 s->insn_bits = thisboard->do_;
915         } else {
916                 s->type = COMEDI_SUBD_UNUSED;
917         }
918
919         s = dev->subdevices + 4;
920         /* 8255 */
921         if (thisboard->i8255_offset != 0) {
922                 subdev_8255_init(dev, s, NULL, (unsigned long)(dev->iobase +
923                                 thisboard->i8255_offset));
924         } else {
925                 s->type = COMEDI_SUBD_UNUSED;
926         }
927
928         s = dev->subdevices + 5;
929         /* 8254 */
930         if (thisboard->i8254_offset != 0) {
931                 s->type = COMEDI_SUBD_COUNTER;
932                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
933                 s->n_chan = 3;
934                 s->maxdata = 0xFFFF;
935                 s->insn_read = das08_counter_read;
936                 s->insn_write = das08_counter_write;
937                 s->insn_config = das08_counter_config;
938                 /* Set-up the 8254 structure */
939                 devpriv->i8254.channels = 3;
940                 devpriv->i8254.logic2phys[0] = 0;
941                 devpriv->i8254.logic2phys[1] = 1;
942                 devpriv->i8254.logic2phys[2] = 2;
943                 devpriv->i8254.iobase = iobase + thisboard->i8254_offset;
944                 devpriv->i8254.mode[0] =
945                         devpriv->i8254.mode[1] =
946                         devpriv->i8254.mode[2] = I8254_MODE0 | I8254_BINARY;
947                 i8254_initialize(&devpriv->i8254);
948         } else {
949                 s->type = COMEDI_SUBD_UNUSED;
950         }
951
952         return 0;
953 }
954
955 static int das08_attach(struct comedi_device * dev, struct comedi_devconfig * it)
956 {
957         int ret;
958         unsigned long iobase;
959 #ifdef CONFIG_COMEDI_PCI
960         unsigned long pci_iobase = 0;
961         struct pci_dev *pdev;
962 #endif
963
964         if ((ret = alloc_private(dev, sizeof(struct das08_private_struct))) < 0)
965                 return ret;
966
967         printk("comedi%d: das08: ", dev->minor);
968         // deal with a pci board
969         if (thisboard->bustype == pci) {
970 #ifdef CONFIG_COMEDI_PCI
971                 if (it->options[0] || it->options[1]) {
972                         printk("bus %i slot %i ",
973                                 it->options[0], it->options[1]);
974                 }
975                 printk("\n");
976                 // find card
977                 for (pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
978                         pdev != NULL;
979                         pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) {
980                         if (pdev->vendor == PCI_VENDOR_ID_COMPUTERBOARDS
981                                 && pdev->device == PCI_DEVICE_ID_PCIDAS08) {
982                                 if (it->options[0] || it->options[1]) {
983                                         if (pdev->bus->number == it->options[0]
984                                                 && PCI_SLOT(pdev->devfn) ==
985                                                 it->options[1]) {
986                                                 break;
987                                         }
988                                 } else {
989                                         break;
990                                 }
991                         }
992                 }
993                 if (!pdev) {
994                         printk("No pci das08 cards found\n");
995                         return -EIO;
996                 }
997                 devpriv->pdev = pdev;
998                 // enable PCI device and reserve I/O spaces
999                 if (comedi_pci_enable(pdev, DRV_NAME)) {
1000                         printk(" Error enabling PCI device and requesting regions\n");
1001                         return -EIO;
1002                 }
1003                 // read base addresses
1004                 pci_iobase = pci_resource_start(pdev, 1);
1005                 iobase = pci_resource_start(pdev, 2);
1006                 printk("pcibase 0x%lx  iobase 0x%lx\n", pci_iobase, iobase);
1007                 devpriv->pci_iobase = pci_iobase;
1008 #if 0
1009 /* We could enable to pci-das08's interrupt here to make it possible
1010  * to do timed input in this driver, but there is little point since
1011  * conversions would have to be started by the interrupt handler
1012  * so you might as well use comedi_rt_timer to emulate commands
1013  */
1014                 /* set source of interrupt trigger to counter2 output */
1015                 outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL);
1016                 /* Enable local interrupt 1 and pci interrupt */
1017                 outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR);
1018 #endif
1019 #else   /* CONFIG_COMEDI_PCI */
1020                 printk("this driver has not been built with PCI support.\n");
1021                 return -EINVAL;
1022 #endif  /* CONFIG_COMEDI_PCI */
1023         } else {
1024                 iobase = it->options[0];
1025         }
1026         printk("\n");
1027
1028         return das08_common_attach(dev, iobase);
1029 }
1030
1031 int das08_common_detach(struct comedi_device * dev)
1032 {
1033         printk(KERN_INFO "comedi%d: das08: remove\n", dev->minor);
1034
1035         if (dev->subdevices)
1036                 subdev_8255_cleanup(dev, dev->subdevices + 4);
1037
1038         // deallocate ioports for non-pcmcia, non-pci boards
1039         if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
1040                 if (dev->iobase)
1041                         release_region(dev->iobase, thisboard->iosize);
1042         }
1043
1044 #ifdef CONFIG_COMEDI_PCI
1045         if (devpriv) {
1046                 if (devpriv->pdev) {
1047                         if (devpriv->pci_iobase) {
1048                                 comedi_pci_disable(devpriv->pdev);
1049                         }
1050                         pci_dev_put(devpriv->pdev);
1051                 }
1052         }
1053 #endif
1054
1055         return 0;
1056 }
1057
1058 #ifdef CONFIG_COMEDI_PCI
1059 COMEDI_PCI_INITCLEANUP(driver_das08, das08_pci_table);
1060 #else
1061 COMEDI_INITCLEANUP(driver_das08);
1062 #endif
1063
1064 EXPORT_SYMBOL_GPL(das08_common_attach);
1065 EXPORT_SYMBOL_GPL(das08_common_detach);
1066 #ifdef CONFIG_COMEDI_PCMCIA
1067 EXPORT_SYMBOL_GPL(das08_cs_boards);
1068 #endif