Staging: comedi: Remove comedi_krange typedef
[linux-2.6] / drivers / staging / comedi / drivers / das16.c
1 /*
2     comedi/drivers/das16.c
3     DAS16 driver
4
5     COMEDI - Linux Control and Measurement Device Interface
6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7     Copyright (C) 2000 Chris R. Baugher <baugher@enteract.com>
8     Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net>
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 Driver: das16
28 Description: DAS16 compatible boards
29 Author: Sam Moore, Warren Jasper, ds, Chris Baugher, Frank Hess, Roman Fietze
30 Devices: [Keithley Metrabyte] DAS-16 (das-16), DAS-16G (das-16g),
31   DAS-16F (das-16f), DAS-1201 (das-1201), DAS-1202 (das-1202),
32   DAS-1401 (das-1401), DAS-1402 (das-1402), DAS-1601 (das-1601),
33   DAS-1602 (das-1602),
34   [ComputerBoards] PC104-DAS16/JR (pc104-das16jr),
35   PC104-DAS16JR/16 (pc104-das16jr/16),
36   CIO-DAS16JR/16 (cio-das16jr/16),
37   CIO-DAS16/JR (cio-das16/jr), CIO-DAS1401/12 (cio-das1401/12),
38   CIO-DAS1402/12 (cio-das1402/12), CIO-DAS1402/16 (cio-das1402/16),
39   CIO-DAS1601/12 (cio-das1601/12), CIO-DAS1602/12 (cio-das1602/12),
40   CIO-DAS1602/16 (cio-das1602/16), CIO-DAS16/330 (cio-das16/330)
41 Status: works
42 Updated: 2003-10-12
43
44 A rewrite of the das16 and das1600 drivers.
45 Options:
46         [0] - base io address
47         [1] - irq (does nothing, irq is not used anymore)
48         [2] - dma (optional, required for comedi_command support)
49         [3] - master clock speed in MHz (optional, 1 or 10, ignored if
50                 board can probe clock, defaults to 1)
51         [4] - analog input range lowest voltage in microvolts (optional,
52                 only useful if your board does not have software
53                 programmable gain)
54         [5] - analog input range highest voltage in microvolts (optional,
55                 only useful if board does not have software programmable
56                 gain)
57         [6] - analog output range lowest voltage in microvolts (optional)
58         [7] - analog output range highest voltage in microvolts (optional)
59         [8] - use timer mode for DMA.  Timer mode is needed e.g. for
60                 buggy DMA controllers in NS CS5530A (Geode Companion), and for
61                 'jr' cards that lack a hardware fifo.  This option is no
62                 longer needed, since timer mode is _always_ used.
63
64 Passing a zero for an option is the same as leaving it unspecified.
65
66 */
67 /*
68
69 Testing and debugging help provided by Daniel Koch.
70
71 Keithley Manuals:
72         2309.PDF (das16)
73         4919.PDF (das1400, 1600)
74         4922.PDF (das-1400)
75         4923.PDF (das1200, 1400, 1600)
76
77 Computer boards manuals also available from their website www.measurementcomputing.com
78
79 */
80
81 #include <linux/pci.h>
82 #include <asm/dma.h>
83 #include "../comedidev.h"
84
85 #include "8253.h"
86 #include "8255.h"
87 #include "comedi_fc.h"
88
89 #undef DEBUG
90 //#define DEBUG
91
92 #ifdef DEBUG
93 #define DEBUG_PRINT(format, args...) rt_printk("das16: " format, ## args)
94 #else
95 #define DEBUG_PRINT(format, args...)
96 #endif
97
98 #define DAS16_SIZE 20           // number of ioports
99 #define DAS16_DMA_SIZE 0xff00   // size in bytes of allocated dma buffer
100
101 /*
102     cio-das16.pdf
103
104     "das16"
105     "das16/f"
106
107   0     a/d bits 0-3            start 12 bit
108   1     a/d bits 4-11           unused
109   2     mux read                mux set
110   3     di 4 bit                do 4 bit
111   4     unused                  ao0_lsb
112   5     unused                  ao0_msb
113   6     unused                  ao1_lsb
114   7     unused                  ao1_msb
115   8     status eoc uni/bip      interrupt reset
116   9     dma, int, trig ctrl     set dma, int
117   a     pacer control           unused
118   b     reserved                reserved
119   cdef  8254
120   0123  8255
121
122 */
123
124 /*
125     cio-das16jr.pdf
126
127     "das16jr"
128
129   0     a/d bits 0-3            start 12 bit
130   1     a/d bits 4-11           unused
131   2     mux read                mux set
132   3     di 4 bit                do 4 bit
133   4567  unused                  unused
134   8     status eoc uni/bip      interrupt reset
135   9     dma, int, trig ctrl     set dma, int
136   a     pacer control           unused
137   b     gain status             gain control
138   cdef  8254
139
140 */
141
142 /*
143     cio-das16jr_16.pdf
144
145     "das16jr_16"
146
147   0     a/d bits 0-7            start 16 bit
148   1     a/d bits 8-15           unused
149   2     mux read                mux set
150   3     di 4 bit                do 4 bit
151   4567  unused                  unused
152   8     status eoc uni/bip      interrupt reset
153   9     dma, int, trig ctrl     set dma, int
154   a     pacer control           unused
155   b     gain status             gain control
156   cdef  8254
157
158 */
159 /*
160     cio-das160x-1x.pdf
161
162     "das1601/12"
163     "das1602/12"
164     "das1602/16"
165
166   0     a/d bits 0-3            start 12 bit
167   1     a/d bits 4-11           unused
168   2     mux read                mux set
169   3     di 4 bit                do 4 bit
170   4     unused                  ao0_lsb
171   5     unused                  ao0_msb
172   6     unused                  ao1_lsb
173   7     unused                  ao1_msb
174   8     status eoc uni/bip      interrupt reset
175   9     dma, int, trig ctrl     set dma, int
176   a     pacer control           unused
177   b     gain status             gain control
178   cdef  8254
179   400   8255
180   404   unused                  conversion enable
181   405   unused                  burst enable
182   406   unused                  das1600 enable
183   407   status
184
185 */
186
187 static const int sample_size = 2;       // size in bytes of a sample from board
188
189 #define DAS16_TRIG              0
190 #define DAS16_AI_LSB            0
191 #define DAS16_AI_MSB            1
192 #define DAS16_MUX               2
193 #define DAS16_DIO               3
194 #define DAS16_AO_LSB(x) ((x)?6:4)
195 #define DAS16_AO_MSB(x) ((x)?7:5)
196 #define DAS16_STATUS            8
197 #define   BUSY                  (1<<7)
198 #define   UNIPOLAR                      (1<<6)
199 #define   DAS16_MUXBIT                  (1<<5)
200 #define   DAS16_INT                     (1<<4)
201 #define DAS16_CONTROL           9
202 #define   DAS16_INTE                    (1<<7)
203 #define   DAS16_IRQ(x)                  (((x) & 0x7) << 4)
204 #define   DMA_ENABLE                    (1<<2)
205 #define   PACING_MASK   0x3
206 #define   INT_PACER             0x03
207 #define   EXT_PACER                     0x02
208 #define   DAS16_SOFT            0x00
209 #define DAS16_PACER             0x0A
210 #define   DAS16_CTR0                    (1<<1)
211 #define   DAS16_TRIG0                   (1<<0)
212 #define   BURST_LEN_BITS(x)                     (((x) & 0xf) << 4)
213 #define DAS16_GAIN              0x0B
214 #define DAS16_CNTR0_DATA                0x0C
215 #define DAS16_CNTR1_DATA                0x0D
216 #define DAS16_CNTR2_DATA                0x0E
217 #define DAS16_CNTR_CONTROL      0x0F
218 #define   DAS16_TERM_CNT        0x00
219 #define   DAS16_ONE_SHOT        0x02
220 #define   DAS16_RATE_GEN        0x04
221 #define   DAS16_CNTR_LSB_MSB    0x30
222 #define   DAS16_CNTR0           0x00
223 #define   DAS16_CNTR1           0x40
224 #define   DAS16_CNTR2           0x80
225
226 #define DAS1600_CONV            0x404
227 #define   DAS1600_CONV_DISABLE          0x40
228 #define DAS1600_BURST           0x405
229 #define   DAS1600_BURST_VAL             0x40
230 #define DAS1600_ENABLE          0x406
231 #define   DAS1600_ENABLE_VAL            0x40
232 #define DAS1600_STATUS_B        0x407
233 #define   DAS1600_BME           0x40
234 #define   DAS1600_ME            0x20
235 #define   DAS1600_CD                    0x10
236 #define   DAS1600_WS                    0x02
237 #define   DAS1600_CLK_10MHZ             0x01
238
239 static const struct comedi_lrange range_das1x01_bip = { 4, {
240                         BIP_RANGE(10),
241                         BIP_RANGE(1),
242                         BIP_RANGE(0.1),
243                         BIP_RANGE(0.01),
244         }
245 };
246 static const struct comedi_lrange range_das1x01_unip = { 4, {
247                         UNI_RANGE(10),
248                         UNI_RANGE(1),
249                         UNI_RANGE(0.1),
250                         UNI_RANGE(0.01),
251         }
252 };
253 static const struct comedi_lrange range_das1x02_bip = { 4, {
254                         BIP_RANGE(10),
255                         BIP_RANGE(5),
256                         BIP_RANGE(2.5),
257                         BIP_RANGE(1.25),
258         }
259 };
260 static const struct comedi_lrange range_das1x02_unip = { 4, {
261                         UNI_RANGE(10),
262                         UNI_RANGE(5),
263                         UNI_RANGE(2.5),
264                         UNI_RANGE(1.25),
265         }
266 };
267 static const struct comedi_lrange range_das16jr = { 9, {
268                         // also used by 16/330
269                         BIP_RANGE(10),
270                         BIP_RANGE(5),
271                         BIP_RANGE(2.5),
272                         BIP_RANGE(1.25),
273                         BIP_RANGE(0.625),
274                         UNI_RANGE(10),
275                         UNI_RANGE(5),
276                         UNI_RANGE(2.5),
277                         UNI_RANGE(1.25),
278         }
279 };
280 static const struct comedi_lrange range_das16jr_16 = { 8, {
281                         BIP_RANGE(10),
282                         BIP_RANGE(5),
283                         BIP_RANGE(2.5),
284                         BIP_RANGE(1.25),
285                         UNI_RANGE(10),
286                         UNI_RANGE(5),
287                         UNI_RANGE(2.5),
288                         UNI_RANGE(1.25),
289         }
290 };
291
292 static const int das16jr_gainlist[] = { 8, 0, 1, 2, 3, 4, 5, 6, 7 };
293 static const int das16jr_16_gainlist[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
294 static const int das1600_gainlist[] = { 0, 1, 2, 3 };
295 enum {
296         das16_pg_none = 0,
297         das16_pg_16jr,
298         das16_pg_16jr_16,
299         das16_pg_1601,
300         das16_pg_1602,
301 };
302 static const int *const das16_gainlists[] = {
303         NULL,
304         das16jr_gainlist,
305         das16jr_16_gainlist,
306         das1600_gainlist,
307         das1600_gainlist,
308 };
309 static const struct comedi_lrange *const das16_ai_uni_lranges[] = {
310         &range_unknown,
311         &range_das16jr,
312         &range_das16jr_16,
313         &range_das1x01_unip,
314         &range_das1x02_unip,
315 };
316 static const struct comedi_lrange *const das16_ai_bip_lranges[] = {
317         &range_unknown,
318         &range_das16jr,
319         &range_das16jr_16,
320         &range_das1x01_bip,
321         &range_das1x02_bip,
322 };
323
324 struct munge_info {
325         uint8_t byte;
326         unsigned have_byte:1;
327 };
328
329 static int das16_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
330         struct comedi_insn * insn, unsigned int * data);
331 static int das16_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
332         struct comedi_insn * insn, unsigned int * data);
333 static int das16_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
334         struct comedi_insn * insn, unsigned int * data);
335 static int das16_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
336         struct comedi_insn * insn, unsigned int * data);
337
338 static int das16_cmd_test(struct comedi_device * dev, struct comedi_subdevice * s,
339         struct comedi_cmd * cmd);
340 static int das16_cmd_exec(struct comedi_device * dev, struct comedi_subdevice * s);
341 static int das16_cancel(struct comedi_device * dev, struct comedi_subdevice * s);
342 static void das16_ai_munge(struct comedi_device * dev, struct comedi_subdevice * s,
343         void *array, unsigned int num_bytes, unsigned int start_chan_index);
344
345 static void das16_reset(struct comedi_device * dev);
346 static irqreturn_t das16_dma_interrupt(int irq, void *d PT_REGS_ARG);
347 static void das16_timer_interrupt(unsigned long arg);
348 static void das16_interrupt(struct comedi_device * dev);
349
350 static unsigned int das16_set_pacer(struct comedi_device * dev, unsigned int ns,
351         int flags);
352 static int das1600_mode_detect(struct comedi_device * dev);
353 static unsigned int das16_suggest_transfer_size(struct comedi_device * dev,
354         struct comedi_cmd cmd);
355
356 static void reg_dump(struct comedi_device * dev);
357
358 typedef struct das16_board_struct {
359         const char *name;
360         void *ai;
361         unsigned int ai_nbits;
362         unsigned int ai_speed;  // max conversion speed in nanosec
363         unsigned int ai_pg;
364         void *ao;
365         unsigned int ao_nbits;
366         void *di;
367         void *do_;
368
369         unsigned int i8255_offset;
370         unsigned int i8254_offset;
371
372         unsigned int size;
373         unsigned int id;
374 } das16_board;
375
376 static const struct das16_board_struct das16_boards[] = {
377         {
378               name:     "das-16",
379               ai:       das16_ai_rinsn,
380               ai_nbits:12,
381               ai_speed:15000,
382               ai_pg:    das16_pg_none,
383               ao:       das16_ao_winsn,
384               ao_nbits:12,
385               di:       das16_di_rbits,
386               do_:      das16_do_wbits,
387               i8255_offset:0x10,
388               i8254_offset:0x0c,
389               size:     0x14,
390               id:       0x00,
391                 },
392         {
393               name:     "das-16g",
394               ai:       das16_ai_rinsn,
395               ai_nbits:12,
396               ai_speed:15000,
397               ai_pg:    das16_pg_none,
398               ao:       das16_ao_winsn,
399               ao_nbits:12,
400               di:       das16_di_rbits,
401               do_:      das16_do_wbits,
402               i8255_offset:0x10,
403               i8254_offset:0x0c,
404               size:     0x14,
405               id:       0x00,
406                 },
407         {
408               name:     "das-16f",
409               ai:       das16_ai_rinsn,
410               ai_nbits:12,
411               ai_speed:8500,
412               ai_pg:    das16_pg_none,
413               ao:       das16_ao_winsn,
414               ao_nbits:12,
415               di:       das16_di_rbits,
416               do_:      das16_do_wbits,
417               i8255_offset:0x10,
418               i8254_offset:0x0c,
419               size:     0x14,
420               id:       0x00,
421                 },
422         {
423               name:     "cio-das16",    // cio-das16.pdf
424               ai:       das16_ai_rinsn,
425               ai_nbits:12,
426               ai_speed:20000,
427               ai_pg:    das16_pg_none,
428               ao:       das16_ao_winsn,
429               ao_nbits:12,
430               di:       das16_di_rbits,
431               do_:      das16_do_wbits,
432               i8255_offset:0x10,
433               i8254_offset:0x0c,
434               size:     0x14,
435               id:       0x80,
436                 },
437         {
438               name:     "cio-das16/f",  // das16.pdf
439               ai:       das16_ai_rinsn,
440               ai_nbits:12,
441               ai_speed:10000,
442               ai_pg:    das16_pg_none,
443               ao:       das16_ao_winsn,
444               ao_nbits:12,
445               di:       das16_di_rbits,
446               do_:      das16_do_wbits,
447               i8255_offset:0x10,
448               i8254_offset:0x0c,
449               size:     0x14,
450               id:       0x80,
451                 },
452         {
453               name:     "cio-das16/jr", // cio-das16jr.pdf
454               ai:       das16_ai_rinsn,
455               ai_nbits:12,
456               ai_speed:7692,
457               ai_pg:    das16_pg_16jr,
458               ao:       NULL,
459               di:       das16_di_rbits,
460               do_:      das16_do_wbits,
461               i8255_offset:0,
462               i8254_offset:0x0c,
463               size:     0x10,
464               id:       0x00,
465                 },
466         {
467               name:     "pc104-das16jr",        // pc104-das16jr_xx.pdf
468               ai:       das16_ai_rinsn,
469               ai_nbits:12,
470               ai_speed:3300,
471               ai_pg:    das16_pg_16jr,
472               ao:       NULL,
473               di:       das16_di_rbits,
474               do_:      das16_do_wbits,
475               i8255_offset:0,
476               i8254_offset:0x0c,
477               size:     0x10,
478               id:       0x00,
479                 },
480         {
481               name:     "cio-das16jr/16",       // cio-das16jr_16.pdf
482               ai:       das16_ai_rinsn,
483               ai_nbits:16,
484               ai_speed:10000,
485               ai_pg:    das16_pg_16jr_16,
486               ao:       NULL,
487               di:       das16_di_rbits,
488               do_:      das16_do_wbits,
489               i8255_offset:0,
490               i8254_offset:0x0c,
491               size:     0x10,
492               id:       0x00,
493                 },
494         {
495               name:     "pc104-das16jr/16",     // pc104-das16jr_xx.pdf
496               ai:       das16_ai_rinsn,
497               ai_nbits:16,
498               ai_speed:10000,
499               ai_pg:    das16_pg_16jr_16,
500               ao:       NULL,
501               di:       das16_di_rbits,
502               do_:      das16_do_wbits,
503               i8255_offset:0,
504               i8254_offset:0x0c,
505               size:     0x10,
506               id:       0x00,
507                 },
508         {
509               name:     "das-1201",     // 4924.pdf (keithley user's manual)
510               ai:       das16_ai_rinsn,
511               ai_nbits:12,
512               ai_speed:20000,
513               ai_pg:    das16_pg_none,
514               ao:       NULL,
515               di:       das16_di_rbits,
516               do_:      das16_do_wbits,
517               i8255_offset:0x400,
518               i8254_offset:0x0c,
519               size:     0x408,
520               id:       0x20,
521                 },
522         {
523               name:     "das-1202",     // 4924.pdf (keithley user's manual)
524               ai:       das16_ai_rinsn,
525               ai_nbits:12,
526               ai_speed:10000,
527               ai_pg:    das16_pg_none,
528               ao:       NULL,
529               di:       das16_di_rbits,
530               do_:      das16_do_wbits,
531               i8255_offset:0x400,
532               i8254_offset:0x0c,
533               size:     0x408,
534               id:       0x20,
535                 },
536         {
537               name:     "das-1401",     // 4919.pdf and 4922.pdf (keithley user's manual)
538               ai:       das16_ai_rinsn,
539               ai_nbits:12,
540               ai_speed:10000,
541               ai_pg:    das16_pg_1601,
542               ao:       NULL,
543               di:       das16_di_rbits,
544               do_:      das16_do_wbits,
545               i8255_offset:0x0,
546               i8254_offset:0x0c,
547               size:     0x408,
548               id:       0xc0    // 4919.pdf says id bits are 0xe0, 4922.pdf says 0xc0
549                 },
550         {
551               name:     "das-1402",     // 4919.pdf and 4922.pdf (keithley user's manual)
552               ai:       das16_ai_rinsn,
553               ai_nbits:12,
554               ai_speed:10000,
555               ai_pg:    das16_pg_1602,
556               ao:       NULL,
557               di:       das16_di_rbits,
558               do_:      das16_do_wbits,
559               i8255_offset:0x0,
560               i8254_offset:0x0c,
561               size:     0x408,
562               id:       0xc0    // 4919.pdf says id bits are 0xe0, 4922.pdf says 0xc0
563                 },
564         {
565               name:     "das-1601",     // 4919.pdf
566               ai:       das16_ai_rinsn,
567               ai_nbits:12,
568               ai_speed:10000,
569               ai_pg:    das16_pg_1601,
570               ao:       das16_ao_winsn,
571               ao_nbits:12,
572               di:       das16_di_rbits,
573               do_:      das16_do_wbits,
574               i8255_offset:0x400,
575               i8254_offset:0x0c,
576               size:     0x408,
577       id:       0xc0},
578         {
579               name:     "das-1602",     // 4919.pdf
580               ai:       das16_ai_rinsn,
581               ai_nbits:12,
582               ai_speed:10000,
583               ai_pg:    das16_pg_1602,
584               ao:       das16_ao_winsn,
585               ao_nbits:12,
586               di:       das16_di_rbits,
587               do_:      das16_do_wbits,
588               i8255_offset:0x400,
589               i8254_offset:0x0c,
590               size:     0x408,
591       id:       0xc0},
592         {
593               name:     "cio-das1401/12",       // cio-das1400_series.pdf
594               ai:       das16_ai_rinsn,
595               ai_nbits:12,
596               ai_speed:6250,
597               ai_pg:    das16_pg_1601,
598               ao:       NULL,
599               di:       das16_di_rbits,
600               do_:      das16_do_wbits,
601               i8255_offset:0,
602               i8254_offset:0x0c,
603               size:     0x408,
604       id:       0xc0},
605         {
606               name:     "cio-das1402/12",       // cio-das1400_series.pdf
607               ai:       das16_ai_rinsn,
608               ai_nbits:12,
609               ai_speed:6250,
610               ai_pg:    das16_pg_1602,
611               ao:       NULL,
612               di:       das16_di_rbits,
613               do_:      das16_do_wbits,
614               i8255_offset:0,
615               i8254_offset:0x0c,
616               size:     0x408,
617       id:       0xc0},
618         {
619               name:     "cio-das1402/16",       // cio-das1400_series.pdf
620               ai:       das16_ai_rinsn,
621               ai_nbits:16,
622               ai_speed:10000,
623               ai_pg:    das16_pg_1602,
624               ao:       NULL,
625               di:       das16_di_rbits,
626               do_:      das16_do_wbits,
627               i8255_offset:0,
628               i8254_offset:0x0c,
629               size:     0x408,
630       id:       0xc0},
631         {
632               name:     "cio-das1601/12",       // cio-das160x-1x.pdf
633               ai:       das16_ai_rinsn,
634               ai_nbits:12,
635               ai_speed:6250,
636               ai_pg:    das16_pg_1601,
637               ao:       das16_ao_winsn,
638               ao_nbits:12,
639               di:       das16_di_rbits,
640               do_:      das16_do_wbits,
641               i8255_offset:0x400,
642               i8254_offset:0x0c,
643               size:     0x408,
644       id:       0xc0},
645         {
646               name:     "cio-das1602/12",       // cio-das160x-1x.pdf
647               ai:       das16_ai_rinsn,
648               ai_nbits:12,
649               ai_speed:10000,
650               ai_pg:    das16_pg_1602,
651               ao:       das16_ao_winsn,
652               ao_nbits:12,
653               di:       das16_di_rbits,
654               do_:      das16_do_wbits,
655               i8255_offset:0x400,
656               i8254_offset:0x0c,
657               size:     0x408,
658       id:       0xc0},
659         {
660               name:     "cio-das1602/16",       // cio-das160x-1x.pdf
661               ai:       das16_ai_rinsn,
662               ai_nbits:16,
663               ai_speed:10000,
664               ai_pg:    das16_pg_1602,
665               ao:       das16_ao_winsn,
666               ao_nbits:12,
667               di:       das16_di_rbits,
668               do_:      das16_do_wbits,
669               i8255_offset:0x400,
670               i8254_offset:0x0c,
671               size:     0x408,
672       id:       0xc0},
673         {
674               name:     "cio-das16/330",        // ?
675               ai:       das16_ai_rinsn,
676               ai_nbits:12,
677               ai_speed:3030,
678               ai_pg:    das16_pg_16jr,
679               ao:       NULL,
680               di:       das16_di_rbits,
681               do_:      das16_do_wbits,
682               i8255_offset:0,
683               i8254_offset:0x0c,
684               size:     0x14,
685       id:       0xf0},
686 #if 0
687         {
688               name:     "das16/330i",   // ?
689                 },
690         {
691               name:     "das16/jr/ctr5",        // ?
692                 },
693         {
694               name:     "cio-das16/m1/16",      // cio-das16_m1_16.pdf, this board is a bit quirky, no dma
695                 },
696 #endif
697 };
698
699 #define n_das16_boards ((sizeof(das16_boards))/(sizeof(das16_board)))
700
701 static int das16_attach(struct comedi_device * dev, struct comedi_devconfig * it);
702 static int das16_detach(struct comedi_device * dev);
703 static struct comedi_driver driver_das16 = {
704       driver_name:"das16",
705       module:THIS_MODULE,
706       attach:das16_attach,
707       detach:das16_detach,
708       board_name:&das16_boards[0].name,
709       num_names:n_das16_boards,
710       offset:sizeof(das16_boards[0]),
711 };
712
713 #define DAS16_TIMEOUT 1000
714
715 /* Period for timer interrupt in jiffies.  It's a function
716  * to deal with possibility of dynamic HZ patches  */
717 static inline int timer_period(void)
718 {
719         return HZ / 20;
720 }
721 struct das16_private_struct {
722         unsigned int ai_unipolar;       // unipolar flag
723         unsigned int ai_singleended;    // single ended flag
724         unsigned int clockbase; // master clock speed in ns
725         volatile unsigned int control_state;    // dma, interrupt and trigger control bits
726         volatile unsigned long adc_byte_count;  // number of bytes remaining
727         unsigned int divisor1;  // divisor dividing master clock to get conversion frequency
728         unsigned int divisor2;  // divisor dividing master clock to get conversion frequency
729         unsigned int dma_chan;  // dma channel
730         uint16_t *dma_buffer[2];
731         dma_addr_t dma_buffer_addr[2];
732         unsigned int current_buffer;
733         volatile unsigned int dma_transfer_size;        // target number of bytes to transfer per dma shot
734         // user-defined analog input and output ranges defined from config options
735         struct comedi_lrange *user_ai_range_table;
736         struct comedi_lrange *user_ao_range_table;
737
738         struct timer_list timer;        // for timed interrupt
739         volatile short timer_running;
740         volatile short timer_mode;      // true if using timer mode
741 };
742 #define devpriv ((struct das16_private_struct *)(dev->private))
743 #define thisboard ((struct das16_board_struct *)(dev->board_ptr))
744
745 static int das16_cmd_test(struct comedi_device * dev, struct comedi_subdevice * s,
746         struct comedi_cmd * cmd)
747 {
748         int err = 0, tmp;
749         int gain, start_chan, i;
750         int mask;
751
752         /* make sure triggers are valid */
753         tmp = cmd->start_src;
754         cmd->start_src &= TRIG_NOW;
755         if (!cmd->start_src || tmp != cmd->start_src)
756                 err++;
757
758         tmp = cmd->scan_begin_src;
759         mask = TRIG_FOLLOW;
760         // if board supports burst mode
761         if (thisboard->size > 0x400)
762                 mask |= TRIG_TIMER | TRIG_EXT;
763         cmd->scan_begin_src &= mask;
764         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
765                 err++;
766
767         tmp = cmd->convert_src;
768         mask = TRIG_TIMER | TRIG_EXT;
769         // if board supports burst mode
770         if (thisboard->size > 0x400)
771                 mask |= TRIG_NOW;
772         cmd->convert_src &= mask;
773         if (!cmd->convert_src || tmp != cmd->convert_src)
774                 err++;
775
776         tmp = cmd->scan_end_src;
777         cmd->scan_end_src &= TRIG_COUNT;
778         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
779                 err++;
780
781         tmp = cmd->stop_src;
782         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
783         if (!cmd->stop_src || tmp != cmd->stop_src)
784                 err++;
785
786         if (err)
787                 return 1;
788
789         /* step 2: make sure trigger sources are unique and mutually compatible */
790         if (cmd->scan_begin_src != TRIG_TIMER &&
791                 cmd->scan_begin_src != TRIG_EXT &&
792                 cmd->scan_begin_src != TRIG_FOLLOW)
793                 err++;
794         if (cmd->convert_src != TRIG_TIMER &&
795                 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
796                 err++;
797         if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
798                 err++;
799
800         // make sure scan_begin_src and convert_src dont conflict
801         if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
802                 err++;
803         if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
804                 err++;
805
806         if (err)
807                 return 2;
808
809         /* step 3: make sure arguments are trivially compatible */
810         if (cmd->start_arg != 0) {
811                 cmd->start_arg = 0;
812                 err++;
813         }
814
815         if (cmd->scan_begin_src == TRIG_FOLLOW) {
816                 /* internal trigger */
817                 if (cmd->scan_begin_arg != 0) {
818                         cmd->scan_begin_arg = 0;
819                         err++;
820                 }
821         }
822
823         if (cmd->scan_end_arg != cmd->chanlist_len) {
824                 cmd->scan_end_arg = cmd->chanlist_len;
825                 err++;
826         }
827         // check against maximum frequency
828         if (cmd->scan_begin_src == TRIG_TIMER) {
829                 if (cmd->scan_begin_arg <
830                         thisboard->ai_speed * cmd->chanlist_len) {
831                         cmd->scan_begin_arg =
832                                 thisboard->ai_speed * cmd->chanlist_len;
833                         err++;
834                 }
835         }
836         if (cmd->convert_src == TRIG_TIMER) {
837                 if (cmd->convert_arg < thisboard->ai_speed) {
838                         cmd->convert_arg = thisboard->ai_speed;
839                         err++;
840                 }
841         }
842
843         if (cmd->stop_src == TRIG_NONE) {
844                 if (cmd->stop_arg != 0) {
845                         cmd->stop_arg = 0;
846                         err++;
847                 }
848         }
849         if (err)
850                 return 3;
851
852         // step 4: fix up arguments
853         if (cmd->scan_begin_src == TRIG_TIMER) {
854                 unsigned int tmp = cmd->scan_begin_arg;
855                 // set divisors, correct timing arguments
856                 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
857                         &(devpriv->divisor1), &(devpriv->divisor2),
858                         &(cmd->scan_begin_arg), cmd->flags & TRIG_ROUND_MASK);
859                 err += (tmp != cmd->scan_begin_arg);
860         }
861         if (cmd->convert_src == TRIG_TIMER) {
862                 unsigned int tmp = cmd->convert_arg;
863                 // set divisors, correct timing arguments
864                 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
865                         &(devpriv->divisor1), &(devpriv->divisor2),
866                         &(cmd->convert_arg), cmd->flags & TRIG_ROUND_MASK);
867                 err += (tmp != cmd->convert_arg);
868         }
869         if (err)
870                 return 4;
871
872         // check channel/gain list against card's limitations
873         if (cmd->chanlist) {
874                 gain = CR_RANGE(cmd->chanlist[0]);
875                 start_chan = CR_CHAN(cmd->chanlist[0]);
876                 for (i = 1; i < cmd->chanlist_len; i++) {
877                         if (CR_CHAN(cmd->chanlist[i]) !=
878                                 (start_chan + i) % s->n_chan) {
879                                 comedi_error(dev,
880                                         "entries in chanlist must be consecutive channels, counting upwards\n");
881                                 err++;
882                         }
883                         if (CR_RANGE(cmd->chanlist[i]) != gain) {
884                                 comedi_error(dev,
885                                         "entries in chanlist must all have the same gain\n");
886                                 err++;
887                         }
888                 }
889         }
890         if (err)
891                 return 5;
892
893         return 0;
894 }
895
896 static int das16_cmd_exec(struct comedi_device * dev, struct comedi_subdevice * s)
897 {
898         struct comedi_async *async = s->async;
899         struct comedi_cmd *cmd = &async->cmd;
900         unsigned int byte;
901         unsigned long flags;
902         int range;
903
904         if (devpriv->dma_chan == 0 || (dev->irq == 0
905                         && devpriv->timer_mode == 0)) {
906                 comedi_error(dev,
907                         "irq (or use of 'timer mode') dma required to execute comedi_cmd");
908                 return -1;
909         }
910         if (cmd->flags & TRIG_RT) {
911                 comedi_error(dev,
912                         "isa dma transfers cannot be performed with TRIG_RT, aborting");
913                 return -1;
914         }
915
916         devpriv->adc_byte_count =
917                 cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t);
918
919         // disable conversions for das1600 mode
920         if (thisboard->size > 0x400) {
921                 outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV);
922         }
923         // set scan limits
924         byte = CR_CHAN(cmd->chanlist[0]);
925         byte |= CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1]) << 4;
926         outb(byte, dev->iobase + DAS16_MUX);
927
928         /* set gain (this is also burst rate register but according to
929          * computer boards manual, burst rate does nothing, even on keithley cards) */
930         if (thisboard->ai_pg != das16_pg_none) {
931                 range = CR_RANGE(cmd->chanlist[0]);
932                 outb((das16_gainlists[thisboard->ai_pg])[range],
933                         dev->iobase + DAS16_GAIN);
934         }
935
936         /* set counter mode and counts */
937         cmd->convert_arg =
938                 das16_set_pacer(dev, cmd->convert_arg,
939                 cmd->flags & TRIG_ROUND_MASK);
940         DEBUG_PRINT("pacer period: %d ns\n", cmd->convert_arg);
941
942         /* enable counters */
943         byte = 0;
944         /* Enable burst mode if appropriate. */
945         if (thisboard->size > 0x400) {
946                 if (cmd->convert_src == TRIG_NOW) {
947                         outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST);
948                         // set burst length
949                         byte |= BURST_LEN_BITS(cmd->chanlist_len - 1);
950                 } else {
951                         outb(0, dev->iobase + DAS1600_BURST);
952                 }
953         }
954         outb(byte, dev->iobase + DAS16_PACER);
955
956         // set up dma transfer
957         flags = claim_dma_lock();
958         disable_dma(devpriv->dma_chan);
959         /* clear flip-flop to make sure 2-byte registers for
960          * count and address get set correctly */
961         clear_dma_ff(devpriv->dma_chan);
962         devpriv->current_buffer = 0;
963         set_dma_addr(devpriv->dma_chan,
964                 devpriv->dma_buffer_addr[devpriv->current_buffer]);
965         // set appropriate size of transfer
966         devpriv->dma_transfer_size = das16_suggest_transfer_size(dev, *cmd);
967         set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
968         enable_dma(devpriv->dma_chan);
969         release_dma_lock(flags);
970
971         // set up interrupt
972         if (devpriv->timer_mode) {
973                 devpriv->timer_running = 1;
974                 devpriv->timer.expires = jiffies + timer_period();
975                 add_timer(&devpriv->timer);
976                 devpriv->control_state &= ~DAS16_INTE;
977         } else {
978                 /* clear interrupt bit */
979                 outb(0x00, dev->iobase + DAS16_STATUS);
980                 /* enable interrupts */
981                 devpriv->control_state |= DAS16_INTE;
982         }
983         devpriv->control_state |= DMA_ENABLE;
984         devpriv->control_state &= ~PACING_MASK;
985         if (cmd->convert_src == TRIG_EXT)
986                 devpriv->control_state |= EXT_PACER;
987         else
988                 devpriv->control_state |= INT_PACER;
989         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
990
991         /* Enable conversions if using das1600 mode */
992         if (thisboard->size > 0x400) {
993                 outb(0, dev->iobase + DAS1600_CONV);
994         }
995
996         return 0;
997 }
998
999 static int das16_cancel(struct comedi_device * dev, struct comedi_subdevice * s)
1000 {
1001         unsigned long flags;
1002
1003         comedi_spin_lock_irqsave(&dev->spinlock, flags);
1004         /* disable interrupts, dma and pacer clocked conversions */
1005         devpriv->control_state &= ~DAS16_INTE & ~PACING_MASK & ~DMA_ENABLE;
1006         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
1007         if (devpriv->dma_chan)
1008                 disable_dma(devpriv->dma_chan);
1009
1010         // disable SW timer
1011         if (devpriv->timer_mode && devpriv->timer_running) {
1012                 devpriv->timer_running = 0;
1013                 del_timer(&devpriv->timer);
1014         }
1015
1016         /* disable burst mode */
1017         if (thisboard->size > 0x400) {
1018                 outb(0, dev->iobase + DAS1600_BURST);
1019         }
1020
1021         comedi_spin_unlock_irqrestore(&dev->spinlock, flags);
1022
1023         return 0;
1024 }
1025
1026 static void das16_reset(struct comedi_device * dev)
1027 {
1028         outb(0, dev->iobase + DAS16_STATUS);
1029         outb(0, dev->iobase + DAS16_CONTROL);
1030         outb(0, dev->iobase + DAS16_PACER);
1031         outb(0, dev->iobase + DAS16_CNTR_CONTROL);
1032 }
1033
1034 static int das16_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
1035         struct comedi_insn * insn, unsigned int * data)
1036 {
1037         int i, n;
1038         int range;
1039         int chan;
1040         int msb, lsb;
1041
1042         // disable interrupts and pacing
1043         devpriv->control_state &= ~DAS16_INTE & ~DMA_ENABLE & ~PACING_MASK;
1044         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
1045
1046         /* set multiplexer */
1047         chan = CR_CHAN(insn->chanspec);
1048         chan |= CR_CHAN(insn->chanspec) << 4;
1049         outb(chan, dev->iobase + DAS16_MUX);
1050
1051         /* set gain */
1052         if (thisboard->ai_pg != das16_pg_none) {
1053                 range = CR_RANGE(insn->chanspec);
1054                 outb((das16_gainlists[thisboard->ai_pg])[range],
1055                         dev->iobase + DAS16_GAIN);
1056         }
1057
1058         for (n = 0; n < insn->n; n++) {
1059                 /* trigger conversion */
1060                 outb_p(0, dev->iobase + DAS16_TRIG);
1061
1062                 for (i = 0; i < DAS16_TIMEOUT; i++) {
1063                         if (!(inb(dev->iobase + DAS16_STATUS) & BUSY))
1064                                 break;
1065                 }
1066                 if (i == DAS16_TIMEOUT) {
1067                         rt_printk("das16: timeout\n");
1068                         return -ETIME;
1069                 }
1070                 msb = inb(dev->iobase + DAS16_AI_MSB);
1071                 lsb = inb(dev->iobase + DAS16_AI_LSB);
1072                 if (thisboard->ai_nbits == 12) {
1073                         data[n] = ((lsb >> 4) & 0xf) | (msb << 4);
1074                 } else {
1075                         data[n] = lsb | (msb << 8);
1076                 }
1077         }
1078
1079         return n;
1080 }
1081
1082 static int das16_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
1083         struct comedi_insn * insn, unsigned int * data)
1084 {
1085         unsigned int bits;
1086
1087         bits = inb(dev->iobase + DAS16_DIO) & 0xf;
1088         data[1] = bits;
1089         data[0] = 0;
1090
1091         return 2;
1092 }
1093
1094 static int das16_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
1095         struct comedi_insn * insn, unsigned int * data)
1096 {
1097         unsigned int wbits;
1098
1099         // only set bits that have been masked
1100         data[0] &= 0xf;
1101         wbits = s->state;
1102         // zero bits that have been masked
1103         wbits &= ~data[0];
1104         // set masked bits
1105         wbits |= data[0] & data[1];
1106         s->state = wbits;
1107         data[1] = wbits;
1108
1109         outb(s->state, dev->iobase + DAS16_DIO);
1110
1111         return 2;
1112 }
1113
1114 static int das16_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
1115         struct comedi_insn * insn, unsigned int * data)
1116 {
1117         int i;
1118         int lsb, msb;
1119         int chan;
1120
1121         chan = CR_CHAN(insn->chanspec);
1122
1123         for (i = 0; i < insn->n; i++) {
1124                 if (thisboard->ao_nbits == 12) {
1125                         lsb = (data[i] << 4) & 0xff;
1126                         msb = (data[i] >> 4) & 0xff;
1127                 } else {
1128                         lsb = data[i] & 0xff;
1129                         msb = (data[i] >> 8) & 0xff;
1130                 }
1131                 outb(lsb, dev->iobase + DAS16_AO_LSB(chan));
1132                 outb(msb, dev->iobase + DAS16_AO_MSB(chan));
1133         }
1134
1135         return i;
1136 }
1137
1138 static irqreturn_t das16_dma_interrupt(int irq, void *d PT_REGS_ARG)
1139 {
1140         int status;
1141         struct comedi_device *dev = d;
1142
1143         status = inb(dev->iobase + DAS16_STATUS);
1144
1145         if ((status & DAS16_INT) == 0) {
1146                 DEBUG_PRINT("spurious interrupt\n");
1147                 return IRQ_NONE;
1148         }
1149
1150         /* clear interrupt */
1151         outb(0x00, dev->iobase + DAS16_STATUS);
1152         das16_interrupt(dev);
1153         return IRQ_HANDLED;
1154 }
1155
1156 static void das16_timer_interrupt(unsigned long arg)
1157 {
1158         struct comedi_device *dev = (struct comedi_device *) arg;
1159
1160         das16_interrupt(dev);
1161
1162         if (devpriv->timer_running)
1163                 mod_timer(&devpriv->timer, jiffies + timer_period());
1164 }
1165
1166 /* the pc104-das16jr (at least) has problems if the dma
1167         transfer is interrupted in the middle of transferring
1168         a 16 bit sample, so this function takes care to get
1169         an even transfer count after disabling dma
1170         channel.
1171 */
1172 static int disable_dma_on_even(struct comedi_device * dev)
1173 {
1174         int residue;
1175         int i;
1176         static const int disable_limit = 100;
1177         static const int enable_timeout = 100;
1178         disable_dma(devpriv->dma_chan);
1179         residue = get_dma_residue(devpriv->dma_chan);
1180         for (i = 0; i < disable_limit && (residue % 2); ++i) {
1181                 int j;
1182                 enable_dma(devpriv->dma_chan);
1183                 for (j = 0; j < enable_timeout; ++j) {
1184                         int new_residue;
1185                         comedi_udelay(2);
1186                         new_residue = get_dma_residue(devpriv->dma_chan);
1187                         if (new_residue != residue)
1188                                 break;
1189                 }
1190                 disable_dma(devpriv->dma_chan);
1191                 residue = get_dma_residue(devpriv->dma_chan);
1192         }
1193         if (i == disable_limit) {
1194                 comedi_error(dev,
1195                         "failed to get an even dma transfer, could be trouble.");
1196         }
1197         return residue;
1198 }
1199
1200 static void das16_interrupt(struct comedi_device * dev)
1201 {
1202         unsigned long dma_flags, spin_flags;
1203         struct comedi_subdevice *s = dev->read_subdev;
1204         struct comedi_async *async;
1205         struct comedi_cmd *cmd;
1206         int num_bytes, residue;
1207         int buffer_index;
1208
1209         if (dev->attached == 0) {
1210                 comedi_error(dev, "premature interrupt");
1211                 return;
1212         }
1213         // initialize async here to make sure it is not NULL
1214         async = s->async;
1215         cmd = &async->cmd;
1216
1217         if (devpriv->dma_chan == 0) {
1218                 comedi_error(dev, "interrupt with no dma channel?");
1219                 return;
1220         }
1221
1222         comedi_spin_lock_irqsave(&dev->spinlock, spin_flags);
1223         if ((devpriv->control_state & DMA_ENABLE) == 0) {
1224                 comedi_spin_unlock_irqrestore(&dev->spinlock, spin_flags);
1225                 DEBUG_PRINT("interrupt while dma disabled?\n");
1226                 return;
1227         }
1228
1229         dma_flags = claim_dma_lock();
1230         clear_dma_ff(devpriv->dma_chan);
1231         residue = disable_dma_on_even(dev);
1232
1233         // figure out how many points to read
1234         if (residue > devpriv->dma_transfer_size) {
1235                 comedi_error(dev, "residue > transfer size!\n");
1236                 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1237                 num_bytes = 0;
1238         } else
1239                 num_bytes = devpriv->dma_transfer_size - residue;
1240
1241         if (cmd->stop_src == TRIG_COUNT && num_bytes >= devpriv->adc_byte_count) {
1242                 num_bytes = devpriv->adc_byte_count;
1243                 async->events |= COMEDI_CB_EOA;
1244         }
1245
1246         buffer_index = devpriv->current_buffer;
1247         devpriv->current_buffer = (devpriv->current_buffer + 1) % 2;
1248         devpriv->adc_byte_count -= num_bytes;
1249
1250         // figure out how many bytes for next transfer
1251         if (cmd->stop_src == TRIG_COUNT && devpriv->timer_mode == 0 &&
1252                 devpriv->dma_transfer_size > devpriv->adc_byte_count)
1253                 devpriv->dma_transfer_size = devpriv->adc_byte_count;
1254
1255         // re-enable  dma
1256         if ((async->events & COMEDI_CB_EOA) == 0) {
1257                 set_dma_addr(devpriv->dma_chan,
1258                         devpriv->dma_buffer_addr[devpriv->current_buffer]);
1259                 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
1260                 enable_dma(devpriv->dma_chan);
1261                 /* reenable conversions for das1600 mode, (stupid hardware) */
1262                 if (thisboard->size > 0x400 && devpriv->timer_mode == 0) {
1263                         outb(0x00, dev->iobase + DAS1600_CONV);
1264                 }
1265         }
1266         release_dma_lock(dma_flags);
1267
1268         comedi_spin_unlock_irqrestore(&dev->spinlock, spin_flags);
1269
1270         cfc_write_array_to_buffer(s,
1271                 devpriv->dma_buffer[buffer_index], num_bytes);
1272
1273         cfc_handle_events(dev, s);
1274 }
1275
1276 static unsigned int das16_set_pacer(struct comedi_device * dev, unsigned int ns,
1277         int rounding_flags)
1278 {
1279         i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &(devpriv->divisor1),
1280                 &(devpriv->divisor2), &ns, rounding_flags & TRIG_ROUND_MASK);
1281
1282         /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
1283         i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 1, devpriv->divisor1, 2);
1284         i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 2, devpriv->divisor2, 2);
1285
1286         return ns;
1287 }
1288
1289 static void reg_dump(struct comedi_device * dev)
1290 {
1291         DEBUG_PRINT("********DAS1600 REGISTER DUMP********\n");
1292         DEBUG_PRINT("DAS16_MUX: %x\n", inb(dev->iobase + DAS16_MUX));
1293         DEBUG_PRINT("DAS16_DIO: %x\n", inb(dev->iobase + DAS16_DIO));
1294         DEBUG_PRINT("DAS16_STATUS: %x\n", inb(dev->iobase + DAS16_STATUS));
1295         DEBUG_PRINT("DAS16_CONTROL: %x\n", inb(dev->iobase + DAS16_CONTROL));
1296         DEBUG_PRINT("DAS16_PACER: %x\n", inb(dev->iobase + DAS16_PACER));
1297         DEBUG_PRINT("DAS16_GAIN: %x\n", inb(dev->iobase + DAS16_GAIN));
1298         DEBUG_PRINT("DAS16_CNTR_CONTROL: %x\n",
1299                 inb(dev->iobase + DAS16_CNTR_CONTROL));
1300         DEBUG_PRINT("DAS1600_CONV: %x\n", inb(dev->iobase + DAS1600_CONV));
1301         DEBUG_PRINT("DAS1600_BURST: %x\n", inb(dev->iobase + DAS1600_BURST));
1302         DEBUG_PRINT("DAS1600_ENABLE: %x\n", inb(dev->iobase + DAS1600_ENABLE));
1303         DEBUG_PRINT("DAS1600_STATUS_B: %x\n",
1304                 inb(dev->iobase + DAS1600_STATUS_B));
1305 }
1306
1307 static int das16_probe(struct comedi_device * dev, struct comedi_devconfig * it)
1308 {
1309         int status;
1310         int diobits;
1311
1312         /* status is available on all boards */
1313
1314         status = inb(dev->iobase + DAS16_STATUS);
1315
1316         if ((status & UNIPOLAR)) {
1317                 devpriv->ai_unipolar = 1;
1318         } else {
1319                 devpriv->ai_unipolar = 0;
1320         }
1321
1322         if ((status & DAS16_MUXBIT)) {
1323                 devpriv->ai_singleended = 1;
1324         } else {
1325                 devpriv->ai_singleended = 0;
1326         }
1327
1328         /* diobits indicates boards */
1329
1330         diobits = inb(dev->iobase + DAS16_DIO) & 0xf0;
1331
1332         printk(" id bits are 0x%02x\n", diobits);
1333         if (thisboard->id != diobits) {
1334                 printk(" requested board's id bits are 0x%x (ignore)\n",
1335                         thisboard->id);
1336         }
1337
1338         return 0;
1339 }
1340
1341 static int das1600_mode_detect(struct comedi_device * dev)
1342 {
1343         int status = 0;
1344
1345         status = inb(dev->iobase + DAS1600_STATUS_B);
1346
1347         if (status & DAS1600_CLK_10MHZ) {
1348                 devpriv->clockbase = 100;
1349                 printk(" 10MHz pacer clock\n");
1350         } else {
1351                 devpriv->clockbase = 1000;
1352                 printk(" 1MHz pacer clock\n");
1353         }
1354
1355         reg_dump(dev);
1356
1357         return 0;
1358 }
1359
1360 /*
1361  *
1362  * Options list:
1363  *   0  I/O base
1364  *   1  IRQ
1365  *   2  DMA
1366  *   3  Clock speed (in MHz)
1367  */
1368
1369 static int das16_attach(struct comedi_device * dev, struct comedi_devconfig * it)
1370 {
1371         struct comedi_subdevice *s;
1372         int ret;
1373         unsigned int irq;
1374         unsigned long iobase;
1375         unsigned int dma_chan;
1376         int timer_mode;
1377         unsigned long flags;
1378         struct comedi_krange *user_ai_range, *user_ao_range;
1379
1380         iobase = it->options[0];
1381 #if 0
1382         irq = it->options[1];
1383         timer_mode = it->options[8];
1384 #endif
1385         /* always use time_mode since using irq can drop samples while
1386          * waiting for dma done interrupt (due to hardware limitations) */
1387         irq = 0;
1388         timer_mode = 1;
1389         if (timer_mode)
1390                 irq = 0;
1391
1392         printk("comedi%d: das16:", dev->minor);
1393
1394         // check that clock setting is valid
1395         if (it->options[3]) {
1396                 if (it->options[3] != 0 &&
1397                         it->options[3] != 1 && it->options[3] != 10) {
1398                         printk("\n Invalid option.  Master clock must be set to 1 or 10 (MHz)\n");
1399                         return -EINVAL;
1400                 }
1401         }
1402
1403         if ((ret = alloc_private(dev, sizeof(struct das16_private_struct))) < 0)
1404                 return ret;
1405
1406         if (thisboard->size < 0x400) {
1407                 printk(" 0x%04lx-0x%04lx\n", iobase, iobase + thisboard->size);
1408                 if (!request_region(iobase, thisboard->size, "das16")) {
1409                         printk(" I/O port conflict\n");
1410                         return -EIO;
1411                 }
1412         } else {
1413                 printk(" 0x%04lx-0x%04lx 0x%04lx-0x%04lx\n",
1414                         iobase, iobase + 0x0f,
1415                         iobase + 0x400,
1416                         iobase + 0x400 + (thisboard->size & 0x3ff));
1417                 if (!request_region(iobase, 0x10, "das16")) {
1418                         printk(" I/O port conflict:  0x%04lx-0x%04lx\n",
1419                                 iobase, iobase + 0x0f);
1420                         return -EIO;
1421                 }
1422                 if (!request_region(iobase + 0x400, thisboard->size & 0x3ff,
1423                                 "das16")) {
1424                         release_region(iobase, 0x10);
1425                         printk(" I/O port conflict:  0x%04lx-0x%04lx\n",
1426                                 iobase + 0x400,
1427                                 iobase + 0x400 + (thisboard->size & 0x3ff));
1428                         return -EIO;
1429                 }
1430         }
1431
1432         dev->iobase = iobase;
1433
1434         // probe id bits to make sure they are consistent
1435         if (das16_probe(dev, it)) {
1436                 printk(" id bits do not match selected board, aborting\n");
1437                 return -EINVAL;
1438         }
1439         dev->board_name = thisboard->name;
1440
1441         // get master clock speed
1442         if (thisboard->size < 0x400) {
1443                 if (it->options[3])
1444                         devpriv->clockbase = 1000 / it->options[3];
1445                 else
1446                         devpriv->clockbase = 1000;      // 1 MHz default
1447         } else {
1448                 das1600_mode_detect(dev);
1449         }
1450
1451         /* now for the irq */
1452         if (irq > 1 && irq < 8) {
1453                 if ((ret = comedi_request_irq(irq, das16_dma_interrupt, 0,
1454                                         "das16", dev)) < 0)
1455                         return ret;
1456                 dev->irq = irq;
1457                 printk(" ( irq = %u )", irq);
1458         } else if (irq == 0) {
1459                 printk(" ( no irq )");
1460         } else {
1461                 printk(" invalid irq\n");
1462                 return -EINVAL;
1463         }
1464
1465         // initialize dma
1466         dma_chan = it->options[2];
1467         if (dma_chan == 1 || dma_chan == 3) {
1468                 // allocate dma buffers
1469                 int i;
1470                 for (i = 0; i < 2; i++) {
1471                         devpriv->dma_buffer[i] = pci_alloc_consistent(NULL,
1472                                 DAS16_DMA_SIZE, &devpriv->dma_buffer_addr[i]);
1473                         if (devpriv->dma_buffer[i] == NULL)
1474                                 return -ENOMEM;
1475                 }
1476                 if (request_dma(dma_chan, "das16")) {
1477                         printk(" failed to allocate dma channel %i\n",
1478                                 dma_chan);
1479                         return -EINVAL;
1480                 }
1481                 devpriv->dma_chan = dma_chan;
1482                 flags = claim_dma_lock();
1483                 disable_dma(devpriv->dma_chan);
1484                 set_dma_mode(devpriv->dma_chan, DMA_MODE_READ);
1485                 release_dma_lock(flags);
1486                 printk(" ( dma = %u)\n", dma_chan);
1487         } else if (dma_chan == 0) {
1488                 printk(" ( no dma )\n");
1489         } else {
1490                 printk(" invalid dma channel\n");
1491                 return -EINVAL;
1492         }
1493
1494         // get any user-defined input range
1495         if (thisboard->ai_pg == das16_pg_none &&
1496                 (it->options[4] || it->options[5])) {
1497                 // allocate single-range range table
1498                 devpriv->user_ai_range_table =
1499                         kmalloc(sizeof(struct comedi_lrange) + sizeof(struct comedi_krange),
1500                         GFP_KERNEL);
1501                 // initialize ai range
1502                 devpriv->user_ai_range_table->length = 1;
1503                 user_ai_range = devpriv->user_ai_range_table->range;
1504                 user_ai_range->min = it->options[4];
1505                 user_ai_range->max = it->options[5];
1506                 user_ai_range->flags = UNIT_volt;
1507         }
1508         // get any user-defined output range
1509         if (it->options[6] || it->options[7]) {
1510                 // allocate single-range range table
1511                 devpriv->user_ao_range_table =
1512                         kmalloc(sizeof(struct comedi_lrange) + sizeof(struct comedi_krange),
1513                         GFP_KERNEL);
1514                 // initialize ao range
1515                 devpriv->user_ao_range_table->length = 1;
1516                 user_ao_range = devpriv->user_ao_range_table->range;
1517                 user_ao_range->min = it->options[6];
1518                 user_ao_range->max = it->options[7];
1519                 user_ao_range->flags = UNIT_volt;
1520         }
1521
1522         if (timer_mode) {
1523                 init_timer(&(devpriv->timer));
1524                 devpriv->timer.function = das16_timer_interrupt;
1525                 devpriv->timer.data = (unsigned long)dev;
1526         }
1527         devpriv->timer_mode = timer_mode ? 1 : 0;
1528
1529         if ((ret = alloc_subdevices(dev, 5)) < 0)
1530                 return ret;
1531
1532         s = dev->subdevices + 0;
1533         dev->read_subdev = s;
1534         /* ai */
1535         if (thisboard->ai) {
1536                 s->type = COMEDI_SUBD_AI;
1537                 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1538                 if (devpriv->ai_singleended) {
1539                         s->n_chan = 16;
1540                         s->len_chanlist = 16;
1541                         s->subdev_flags |= SDF_GROUND;
1542                 } else {
1543                         s->n_chan = 8;
1544                         s->len_chanlist = 8;
1545                         s->subdev_flags |= SDF_DIFF;
1546                 }
1547                 s->maxdata = (1 << thisboard->ai_nbits) - 1;
1548                 if (devpriv->user_ai_range_table) {     // user defined ai range
1549                         s->range_table = devpriv->user_ai_range_table;
1550                 } else if (devpriv->ai_unipolar) {
1551                         s->range_table = das16_ai_uni_lranges[thisboard->ai_pg];
1552                 } else {
1553                         s->range_table = das16_ai_bip_lranges[thisboard->ai_pg];
1554                 }
1555                 s->insn_read = thisboard->ai;
1556                 s->do_cmdtest = das16_cmd_test;
1557                 s->do_cmd = das16_cmd_exec;
1558                 s->cancel = das16_cancel;
1559                 s->munge = das16_ai_munge;
1560         } else {
1561                 s->type = COMEDI_SUBD_UNUSED;
1562         }
1563
1564         s = dev->subdevices + 1;
1565         /* ao */
1566         if (thisboard->ao) {
1567                 s->type = COMEDI_SUBD_AO;
1568                 s->subdev_flags = SDF_WRITABLE;
1569                 s->n_chan = 2;
1570                 s->maxdata = (1 << thisboard->ao_nbits) - 1;
1571                 if (devpriv->user_ao_range_table) {     // user defined ao range
1572                         s->range_table = devpriv->user_ao_range_table;
1573                 } else {
1574                         s->range_table = &range_unknown;
1575                 }
1576                 s->insn_write = thisboard->ao;
1577         } else {
1578                 s->type = COMEDI_SUBD_UNUSED;
1579         }
1580
1581         s = dev->subdevices + 2;
1582         /* di */
1583         if (thisboard->di) {
1584                 s->type = COMEDI_SUBD_DI;
1585                 s->subdev_flags = SDF_READABLE;
1586                 s->n_chan = 4;
1587                 s->maxdata = 1;
1588                 s->range_table = &range_digital;
1589                 s->insn_bits = thisboard->di;
1590         } else {
1591                 s->type = COMEDI_SUBD_UNUSED;
1592         }
1593
1594         s = dev->subdevices + 3;
1595         /* do */
1596         if (thisboard->do_) {
1597                 s->type = COMEDI_SUBD_DO;
1598                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1599                 s->n_chan = 4;
1600                 s->maxdata = 1;
1601                 s->range_table = &range_digital;
1602                 s->insn_bits = thisboard->do_;
1603                 // initialize digital output lines
1604                 outb(s->state, dev->iobase + DAS16_DIO);
1605         } else {
1606                 s->type = COMEDI_SUBD_UNUSED;
1607         }
1608
1609         s = dev->subdevices + 4;
1610         /* 8255 */
1611         if (thisboard->i8255_offset != 0) {
1612                 subdev_8255_init(dev, s, NULL, (dev->iobase +
1613                                 thisboard->i8255_offset));
1614         } else {
1615                 s->type = COMEDI_SUBD_UNUSED;
1616         }
1617
1618         das16_reset(dev);
1619         /* set the interrupt level */
1620         devpriv->control_state = DAS16_IRQ(dev->irq);
1621         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
1622
1623         // turn on das1600 mode if available
1624         if (thisboard->size > 0x400) {
1625                 outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE);
1626                 outb(0, dev->iobase + DAS1600_CONV);
1627                 outb(0, dev->iobase + DAS1600_BURST);
1628         }
1629
1630         return 0;
1631 }
1632
1633 static int das16_detach(struct comedi_device * dev)
1634 {
1635         printk("comedi%d: das16: remove\n", dev->minor);
1636
1637         das16_reset(dev);
1638
1639         if (dev->subdevices)
1640                 subdev_8255_cleanup(dev, dev->subdevices + 4);
1641
1642         if (devpriv) {
1643                 int i;
1644                 for (i = 0; i < 2; i++) {
1645                         if (devpriv->dma_buffer[i])
1646                                 pci_free_consistent(NULL, DAS16_DMA_SIZE,
1647                                         devpriv->dma_buffer[i],
1648                                         devpriv->dma_buffer_addr[i]);
1649                 }
1650                 if (devpriv->dma_chan)
1651                         free_dma(devpriv->dma_chan);
1652                 if (devpriv->user_ai_range_table)
1653                         kfree(devpriv->user_ai_range_table);
1654                 if (devpriv->user_ao_range_table)
1655                         kfree(devpriv->user_ao_range_table);
1656         }
1657
1658         if (dev->irq)
1659                 comedi_free_irq(dev->irq, dev);
1660
1661         if (dev->iobase) {
1662                 if (thisboard->size < 0x400) {
1663                         release_region(dev->iobase, thisboard->size);
1664                 } else {
1665                         release_region(dev->iobase, 0x10);
1666                         release_region(dev->iobase + 0x400,
1667                                 thisboard->size & 0x3ff);
1668                 }
1669         }
1670
1671         return 0;
1672 }
1673
1674 COMEDI_INITCLEANUP(driver_das16);
1675
1676 // utility function that suggests a dma transfer size in bytes
1677 static unsigned int das16_suggest_transfer_size(struct comedi_device * dev,
1678         struct comedi_cmd cmd)
1679 {
1680         unsigned int size;
1681         unsigned int freq;
1682
1683         /* if we are using timer interrupt, we don't care how long it
1684          * will take to complete transfer since it will be interrupted
1685          * by timer interrupt */
1686         if (devpriv->timer_mode)
1687                 return DAS16_DMA_SIZE;
1688
1689         /* otherwise, we are relying on dma terminal count interrupt,
1690          * so pick a reasonable size */
1691         if (cmd.convert_src == TRIG_TIMER)
1692                 freq = 1000000000 / cmd.convert_arg;
1693         else if (cmd.scan_begin_src == TRIG_TIMER)
1694                 freq = (1000000000 / cmd.scan_begin_arg) * cmd.chanlist_len;
1695         // return some default value
1696         else
1697                 freq = 0xffffffff;
1698
1699         if (cmd.flags & TRIG_WAKE_EOS) {
1700                 size = sample_size * cmd.chanlist_len;
1701         } else {
1702                 // make buffer fill in no more than 1/3 second
1703                 size = (freq / 3) * sample_size;
1704         }
1705
1706         // set a minimum and maximum size allowed
1707         if (size > DAS16_DMA_SIZE)
1708                 size = DAS16_DMA_SIZE - DAS16_DMA_SIZE % sample_size;
1709         else if (size < sample_size)
1710                 size = sample_size;
1711
1712         if (cmd.stop_src == TRIG_COUNT && size > devpriv->adc_byte_count)
1713                 size = devpriv->adc_byte_count;
1714
1715         return size;
1716 }
1717
1718 static void das16_ai_munge(struct comedi_device * dev, struct comedi_subdevice * s,
1719         void *array, unsigned int num_bytes, unsigned int start_chan_index)
1720 {
1721         unsigned int i, num_samples = num_bytes / sizeof(short);
1722         short *data = array;
1723
1724         for (i = 0; i < num_samples; i++) {
1725                 data[i] = le16_to_cpu(data[i]);
1726                 if (thisboard->ai_nbits == 12) {
1727                         data[i] = (data[i] >> 4) & 0xfff;
1728                 }
1729         }
1730 }