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