1 /*======================================================================
3 comedi/drivers/quatech_daqp_cs.c
5 Quatech DAQP PCMCIA data capture cards COMEDI client driver
6 Copyright (C) 2000, 2003 Brent Baccala <baccala@freesoft.org>
7 The DAQP interface code in this file is released into the public domain.
9 COMEDI - Linux Control and Measurement Device Interface
10 Copyright (C) 1998 David A. Schleef <ds@schleef.org>
11 http://www.comedi.org/
13 quatech_daqp_cs.c 1.10
15 Documentation for the DAQP PCMCIA cards can be found on Quatech's site:
17 ftp://ftp.quatech.com/Manuals/daqp-208.pdf
19 This manual is for both the DAQP-208 and the DAQP-308.
26 - ground ref or differential
27 - single-shot and timed both supported
28 - D/A conversion, single-shot
33 - any kind of triggering - external or D/A channel 1
34 - the card's optional expansion board
35 - the card's timer (for anything other than A/D conversion)
36 - D/A update modes other than immediate (i.e, timed)
37 - fancier timing modes
38 - setting card's FIFO buffer thresholds to anything but default
40 ======================================================================*/
43 Driver: quatech_daqp_cs
44 Description: Quatech DAQP PCMCIA data capture cards
45 Author: Brent Baccala <baccala@freesoft.org>
47 Devices: [Quatech] DAQP-208 (daqp), DAQP-308
50 #include "../comedidev.h"
52 #include <pcmcia/cs_types.h>
53 #include <pcmcia/cs.h>
54 #include <pcmcia/cistpl.h>
55 #include <pcmcia/cisreg.h>
56 #include <pcmcia/ds.h>
59 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
60 you do not define PCMCIA_DEBUG at all, all the debug code will be
61 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
62 be present but disabled -- but it can then be enabled for specific
63 modules at load time with a 'pc_debug=#' option to insmod.
67 static int pc_debug
= PCMCIA_DEBUG
;
68 module_param(pc_debug
, int, 0644);
69 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
70 static char *version
= "quatech_daqp_cs.c 1.10 2003/04/21 (Brent Baccala)";
72 #define DEBUG(n, args...)
75 /* Maximum number of separate DAQP devices we'll allow */
78 typedef struct local_info_t
{
79 struct pcmcia_device
*link
;
85 enum { semaphore
, buffer
} interrupt_mode
;
89 struct comedi_device
*dev
;
90 struct comedi_subdevice
*s
;
94 /* A list of "instances" of the device. */
96 static local_info_t
*dev_table
[MAX_DEV
] = { NULL
, /* ... */ };
98 /* The DAQP communicates with the system through a 16 byte I/O window. */
100 #define DAQP_FIFO_SIZE 4096
103 #define DAQP_SCANLIST 1
104 #define DAQP_CONTROL 2
105 #define DAQP_STATUS 2
106 #define DAQP_DIGITAL_IO 3
107 #define DAQP_PACER_LOW 4
108 #define DAQP_PACER_MID 5
109 #define DAQP_PACER_HIGH 6
110 #define DAQP_COMMAND 7
112 #define DAQP_TIMER 10
115 #define DAQP_SCANLIST_DIFFERENTIAL 0x4000
116 #define DAQP_SCANLIST_GAIN(x) ((x)<<12)
117 #define DAQP_SCANLIST_CHANNEL(x) ((x)<<8)
118 #define DAQP_SCANLIST_START 0x0080
119 #define DAQP_SCANLIST_EXT_GAIN(x) ((x)<<4)
120 #define DAQP_SCANLIST_EXT_CHANNEL(x) (x)
122 #define DAQP_CONTROL_PACER_100kHz 0xc0
123 #define DAQP_CONTROL_PACER_1MHz 0x80
124 #define DAQP_CONTROL_PACER_5MHz 0x40
125 #define DAQP_CONTROL_PACER_EXTERNAL 0x00
126 #define DAQP_CONTORL_EXPANSION 0x20
127 #define DAQP_CONTROL_EOS_INT_ENABLE 0x10
128 #define DAQP_CONTROL_FIFO_INT_ENABLE 0x08
129 #define DAQP_CONTROL_TRIGGER_ONESHOT 0x00
130 #define DAQP_CONTROL_TRIGGER_CONTINUOUS 0x04
131 #define DAQP_CONTROL_TRIGGER_INTERNAL 0x00
132 #define DAQP_CONTROL_TRIGGER_EXTERNAL 0x02
133 #define DAQP_CONTROL_TRIGGER_RISING 0x00
134 #define DAQP_CONTROL_TRIGGER_FALLING 0x01
136 #define DAQP_STATUS_IDLE 0x80
137 #define DAQP_STATUS_RUNNING 0x40
138 #define DAQP_STATUS_EVENTS 0x38
139 #define DAQP_STATUS_DATA_LOST 0x20
140 #define DAQP_STATUS_END_OF_SCAN 0x10
141 #define DAQP_STATUS_FIFO_THRESHOLD 0x08
142 #define DAQP_STATUS_FIFO_FULL 0x04
143 #define DAQP_STATUS_FIFO_NEARFULL 0x02
144 #define DAQP_STATUS_FIFO_EMPTY 0x01
146 #define DAQP_COMMAND_ARM 0x80
147 #define DAQP_COMMAND_RSTF 0x40
148 #define DAQP_COMMAND_RSTQ 0x20
149 #define DAQP_COMMAND_STOP 0x10
150 #define DAQP_COMMAND_LATCH 0x08
151 #define DAQP_COMMAND_100kHz 0x00
152 #define DAQP_COMMAND_50kHz 0x02
153 #define DAQP_COMMAND_25kHz 0x04
154 #define DAQP_COMMAND_FIFO_DATA 0x01
155 #define DAQP_COMMAND_FIFO_PROGRAM 0x00
157 #define DAQP_AUX_TRIGGER_TTL 0x00
158 #define DAQP_AUX_TRIGGER_ANALOG 0x80
159 #define DAQP_AUX_TRIGGER_PRETRIGGER 0x40
160 #define DAQP_AUX_TIMER_INT_ENABLE 0x20
161 #define DAQP_AUX_TIMER_RELOAD 0x00
162 #define DAQP_AUX_TIMER_PAUSE 0x08
163 #define DAQP_AUX_TIMER_GO 0x10
164 #define DAQP_AUX_TIMER_GO_EXTERNAL 0x18
165 #define DAQP_AUX_TIMER_EXTERNAL_SRC 0x04
166 #define DAQP_AUX_TIMER_INTERNAL_SRC 0x00
167 #define DAQP_AUX_DA_DIRECT 0x00
168 #define DAQP_AUX_DA_OVERFLOW 0x01
169 #define DAQP_AUX_DA_EXTERNAL 0x02
170 #define DAQP_AUX_DA_PACER 0x03
172 #define DAQP_AUX_RUNNING 0x80
173 #define DAQP_AUX_TRIGGERED 0x40
174 #define DAQP_AUX_DA_BUFFER 0x20
175 #define DAQP_AUX_TIMER_OVERFLOW 0x10
176 #define DAQP_AUX_CONVERSION 0x08
177 #define DAQP_AUX_DATA_LOST 0x04
178 #define DAQP_AUX_FIFO_NEARFULL 0x02
179 #define DAQP_AUX_FIFO_EMPTY 0x01
181 /* These range structures tell COMEDI how the sample values map to
182 * voltages. The A/D converter has four ranges: +/- 10V through
183 * +/- 1.25V, and the D/A converter has only one: +/- 5V.
186 static const struct comedi_lrange range_daqp_ai
= { 4, {
194 static const struct comedi_lrange range_daqp_ao
= { 1, {BIP_RANGE(5)} };
196 /*====================================================================*/
198 /* comedi interface code */
200 static int daqp_attach(struct comedi_device
* dev
, comedi_devconfig
* it
);
201 static int daqp_detach(struct comedi_device
* dev
);
202 static struct comedi_driver driver_daqp
= {
203 driver_name
:"quatech_daqp_cs",
211 static void daqp_dump(struct comedi_device
* dev
)
213 printk("DAQP: status %02x; aux status %02x\n",
214 inb(dev
->iobase
+ DAQP_STATUS
), inb(dev
->iobase
+ DAQP_AUX
));
217 static void hex_dump(char *str
, void *ptr
, int len
)
219 unsigned char *cptr
= ptr
;
224 for (i
= 0; i
< len
; i
++) {
226 printk("\n0x%08x:", (unsigned int)cptr
);
228 printk(" %02x", *(cptr
++));
235 /* Cancel a running acquisition */
237 static int daqp_ai_cancel(struct comedi_device
* dev
, struct comedi_subdevice
* s
)
239 local_info_t
*local
= (local_info_t
*) s
->private;
245 outb(DAQP_COMMAND_STOP
, dev
->iobase
+ DAQP_COMMAND
);
247 /* flush any linguring data in FIFO - superfluous here */
248 /* outb(DAQP_COMMAND_RSTF, dev->iobase+DAQP_COMMAND); */
250 local
->interrupt_mode
= semaphore
;
257 * Operates in one of two modes. If local->interrupt_mode is
258 * 'semaphore', just signal the local->eos semaphore and return
259 * (one-shot mode). Otherwise (continuous mode), read data in from
260 * the card, transfer it to the buffer provided by the higher-level
261 * comedi kernel module, and signal various comedi callback routines,
262 * which run pretty quick.
265 static void daqp_interrupt(int irq
, void *dev_id PT_REGS_ARG
)
267 local_info_t
*local
= (local_info_t
*) dev_id
;
268 struct comedi_device
*dev
;
269 struct comedi_subdevice
*s
;
270 int loop_limit
= 10000;
275 "daqp_interrupt(): irq %d for unknown device.\n", irq
);
281 printk(KERN_WARNING
"daqp_interrupt(): NULL comedi_device.\n");
285 if (!dev
->attached
) {
287 "daqp_interrupt(): struct comedi_device not yet attached.\n");
294 "daqp_interrupt(): NULL comedi_subdevice.\n");
298 if ((local_info_t
*) s
->private != local
) {
300 "daqp_interrupt(): invalid comedi_subdevice.\n");
304 switch (local
->interrupt_mode
) {
313 while (!((status
= inb(dev
->iobase
+ DAQP_STATUS
))
314 & DAQP_STATUS_FIFO_EMPTY
)) {
318 if (status
& DAQP_STATUS_DATA_LOST
) {
320 COMEDI_CB_EOA
| COMEDI_CB_OVERFLOW
;
321 printk("daqp: data lost\n");
322 daqp_ai_cancel(dev
, s
);
326 data
= inb(dev
->iobase
+ DAQP_FIFO
);
327 data
|= inb(dev
->iobase
+ DAQP_FIFO
) << 8;
330 comedi_buf_put(s
->async
, data
);
332 /* If there's a limit, decrement it
333 * and stop conversion if zero
336 if (local
->count
> 0) {
338 if (local
->count
== 0) {
339 daqp_ai_cancel(dev
, s
);
340 s
->async
->events
|= COMEDI_CB_EOA
;
345 if ((loop_limit
--) <= 0)
349 if (loop_limit
<= 0) {
351 "loop_limit reached in daqp_interrupt()\n");
352 daqp_ai_cancel(dev
, s
);
353 s
->async
->events
|= COMEDI_CB_EOA
| COMEDI_CB_ERROR
;
356 s
->async
->events
|= COMEDI_CB_BLOCK
;
358 comedi_event(dev
, s
);
362 /* One-shot analog data acquisition routine */
364 static int daqp_ai_insn_read(struct comedi_device
* dev
, struct comedi_subdevice
* s
,
365 comedi_insn
* insn
, unsigned int * data
)
367 local_info_t
*local
= (local_info_t
*) s
->private;
376 /* Stop any running conversion */
377 daqp_ai_cancel(dev
, s
);
379 outb(0, dev
->iobase
+ DAQP_AUX
);
381 /* Reset scan list queue */
382 outb(DAQP_COMMAND_RSTQ
, dev
->iobase
+ DAQP_COMMAND
);
384 /* Program one scan list entry */
386 v
= DAQP_SCANLIST_CHANNEL(CR_CHAN(insn
->chanspec
))
387 | DAQP_SCANLIST_GAIN(CR_RANGE(insn
->chanspec
));
389 if (CR_AREF(insn
->chanspec
) == AREF_DIFF
) {
390 v
|= DAQP_SCANLIST_DIFFERENTIAL
;
393 v
|= DAQP_SCANLIST_START
;
395 outb(v
& 0xff, dev
->iobase
+ DAQP_SCANLIST
);
396 outb(v
>> 8, dev
->iobase
+ DAQP_SCANLIST
);
398 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
400 outb(DAQP_COMMAND_RSTF
, dev
->iobase
+ DAQP_COMMAND
);
404 v
= DAQP_CONTROL_TRIGGER_ONESHOT
| DAQP_CONTROL_TRIGGER_INTERNAL
405 | DAQP_CONTROL_PACER_100kHz
| DAQP_CONTROL_EOS_INT_ENABLE
;
407 outb(v
, dev
->iobase
+ DAQP_CONTROL
);
409 /* Reset any pending interrupts (my card has a tendancy to require
410 * require multiple reads on the status register to achieve this)
414 && (inb(dev
->iobase
+ DAQP_STATUS
) & DAQP_STATUS_EVENTS
)) ;
416 printk("daqp: couldn't clear interrupts in status register\n");
420 /* Make sure semaphore is blocked */
421 sema_init(&local
->eos
, 0);
422 local
->interrupt_mode
= semaphore
;
426 for (i
= 0; i
< insn
->n
; i
++) {
428 /* Start conversion */
429 outb(DAQP_COMMAND_ARM
| DAQP_COMMAND_FIFO_DATA
,
430 dev
->iobase
+ DAQP_COMMAND
);
432 /* Wait for interrupt service routine to unblock semaphore */
433 /* Maybe could use a timeout here, but it's interruptible */
434 if (down_interruptible(&local
->eos
))
437 data
[i
] = inb(dev
->iobase
+ DAQP_FIFO
);
438 data
[i
] |= inb(dev
->iobase
+ DAQP_FIFO
) << 8;
445 /* This function converts ns nanoseconds to a counter value suitable
446 * for programming the device. We always use the DAQP's 5 MHz clock,
447 * which with its 24-bit counter, allows values up to 84 seconds.
448 * Also, the function adjusts ns so that it cooresponds to the actual
449 * time that the device will use.
452 static int daqp_ns_to_timer(unsigned int *ns
, int round
)
462 /* cmdtest tests a particular command to see if it is valid.
463 * Using the cmdtest ioctl, a user can create a valid cmd
464 * and then have it executed by the cmd ioctl.
466 * cmdtest returns 1,2,3,4 or 0, depending on which tests
467 * the command passes.
470 static int daqp_ai_cmdtest(struct comedi_device
* dev
, struct comedi_subdevice
* s
,
476 /* step 1: make sure trigger sources are trivially valid */
478 tmp
= cmd
->start_src
;
479 cmd
->start_src
&= TRIG_NOW
;
480 if (!cmd
->start_src
|| tmp
!= cmd
->start_src
)
483 tmp
= cmd
->scan_begin_src
;
484 cmd
->scan_begin_src
&= TRIG_TIMER
| TRIG_FOLLOW
;
485 if (!cmd
->scan_begin_src
|| tmp
!= cmd
->scan_begin_src
)
488 tmp
= cmd
->convert_src
;
489 cmd
->convert_src
&= TRIG_TIMER
| TRIG_NOW
;
490 if (!cmd
->convert_src
|| tmp
!= cmd
->convert_src
)
493 tmp
= cmd
->scan_end_src
;
494 cmd
->scan_end_src
&= TRIG_COUNT
;
495 if (!cmd
->scan_end_src
|| tmp
!= cmd
->scan_end_src
)
499 cmd
->stop_src
&= TRIG_COUNT
| TRIG_NONE
;
500 if (!cmd
->stop_src
|| tmp
!= cmd
->stop_src
)
506 /* step 2: make sure trigger sources are unique and mutually compatible */
508 /* note that mutual compatiblity is not an issue here */
509 if (cmd
->scan_begin_src
!= TRIG_TIMER
&&
510 cmd
->scan_begin_src
!= TRIG_FOLLOW
)
512 if (cmd
->convert_src
!= TRIG_NOW
&& cmd
->convert_src
!= TRIG_TIMER
)
514 if (cmd
->scan_begin_src
== TRIG_FOLLOW
&& cmd
->convert_src
== TRIG_NOW
)
516 if (cmd
->stop_src
!= TRIG_COUNT
&& cmd
->stop_src
!= TRIG_NONE
)
522 /* step 3: make sure arguments are trivially compatible */
524 if (cmd
->start_arg
!= 0) {
528 #define MAX_SPEED 10000 /* 100 kHz - in nanoseconds */
530 if (cmd
->scan_begin_src
== TRIG_TIMER
531 && cmd
->scan_begin_arg
< MAX_SPEED
) {
532 cmd
->scan_begin_arg
= MAX_SPEED
;
536 /* If both scan_begin and convert are both timer values, the only
537 * way that can make sense is if the scan time is the number of
538 * conversions times the convert time
541 if (cmd
->scan_begin_src
== TRIG_TIMER
&& cmd
->convert_src
== TRIG_TIMER
542 && cmd
->scan_begin_arg
!=
543 cmd
->convert_arg
* cmd
->scan_end_arg
) {
547 if (cmd
->convert_src
== TRIG_TIMER
&& cmd
->convert_arg
< MAX_SPEED
) {
548 cmd
->convert_arg
= MAX_SPEED
;
552 if (cmd
->scan_end_arg
!= cmd
->chanlist_len
) {
553 cmd
->scan_end_arg
= cmd
->chanlist_len
;
556 if (cmd
->stop_src
== TRIG_COUNT
) {
557 if (cmd
->stop_arg
> 0x00ffffff) {
558 cmd
->stop_arg
= 0x00ffffff;
563 if (cmd
->stop_arg
!= 0) {
572 /* step 4: fix up any arguments */
574 if (cmd
->scan_begin_src
== TRIG_TIMER
) {
575 tmp
= cmd
->scan_begin_arg
;
576 daqp_ns_to_timer(&cmd
->scan_begin_arg
,
577 cmd
->flags
& TRIG_ROUND_MASK
);
578 if (tmp
!= cmd
->scan_begin_arg
)
582 if (cmd
->convert_src
== TRIG_TIMER
) {
583 tmp
= cmd
->convert_arg
;
584 daqp_ns_to_timer(&cmd
->convert_arg
,
585 cmd
->flags
& TRIG_ROUND_MASK
);
586 if (tmp
!= cmd
->convert_arg
)
596 static int daqp_ai_cmd(struct comedi_device
* dev
, struct comedi_subdevice
* s
)
598 local_info_t
*local
= (local_info_t
*) s
->private;
599 comedi_cmd
*cmd
= &s
->async
->cmd
;
601 int scanlist_start_on_every_entry
;
611 /* Stop any running conversion */
612 daqp_ai_cancel(dev
, s
);
614 outb(0, dev
->iobase
+ DAQP_AUX
);
616 /* Reset scan list queue */
617 outb(DAQP_COMMAND_RSTQ
, dev
->iobase
+ DAQP_COMMAND
);
619 /* Program pacer clock
621 * There's two modes we can operate in. If convert_src is
622 * TRIG_TIMER, then convert_arg specifies the time between
623 * each conversion, so we program the pacer clock to that
624 * frequency and set the SCANLIST_START bit on every scanlist
625 * entry. Otherwise, convert_src is TRIG_NOW, which means
626 * we want the fastest possible conversions, scan_begin_src
627 * is TRIG_TIMER, and scan_begin_arg specifies the time between
628 * each scan, so we program the pacer clock to this frequency
629 * and only set the SCANLIST_START bit on the first entry.
632 if (cmd
->convert_src
== TRIG_TIMER
) {
633 int counter
= daqp_ns_to_timer(&cmd
->convert_arg
,
634 cmd
->flags
& TRIG_ROUND_MASK
);
635 outb(counter
& 0xff, dev
->iobase
+ DAQP_PACER_LOW
);
636 outb((counter
>> 8) & 0xff, dev
->iobase
+ DAQP_PACER_MID
);
637 outb((counter
>> 16) & 0xff, dev
->iobase
+ DAQP_PACER_HIGH
);
638 scanlist_start_on_every_entry
= 1;
640 int counter
= daqp_ns_to_timer(&cmd
->scan_begin_arg
,
641 cmd
->flags
& TRIG_ROUND_MASK
);
642 outb(counter
& 0xff, dev
->iobase
+ DAQP_PACER_LOW
);
643 outb((counter
>> 8) & 0xff, dev
->iobase
+ DAQP_PACER_MID
);
644 outb((counter
>> 16) & 0xff, dev
->iobase
+ DAQP_PACER_HIGH
);
645 scanlist_start_on_every_entry
= 0;
648 /* Program scan list */
650 for (i
= 0; i
< cmd
->chanlist_len
; i
++) {
652 int chanspec
= cmd
->chanlist
[i
];
654 /* Program one scan list entry */
656 v
= DAQP_SCANLIST_CHANNEL(CR_CHAN(chanspec
))
657 | DAQP_SCANLIST_GAIN(CR_RANGE(chanspec
));
659 if (CR_AREF(chanspec
) == AREF_DIFF
) {
660 v
|= DAQP_SCANLIST_DIFFERENTIAL
;
663 if (i
== 0 || scanlist_start_on_every_entry
) {
664 v
|= DAQP_SCANLIST_START
;
667 outb(v
& 0xff, dev
->iobase
+ DAQP_SCANLIST
);
668 outb(v
>> 8, dev
->iobase
+ DAQP_SCANLIST
);
671 /* Now it's time to program the FIFO threshold, basically the
672 * number of samples the card will buffer before it interrupts
675 * If we don't have a stop count, then use half the size of
676 * the FIFO (the manufacturer's recommendation). Consider
677 * that the FIFO can hold 2K samples (4K bytes). With the
678 * threshold set at half the FIFO size, we have a margin of
679 * error of 1024 samples. At the chip's maximum sample rate
680 * of 100,000 Hz, the CPU would have to delay interrupt
681 * service for a full 10 milliseconds in order to lose data
682 * here (as opposed to higher up in the kernel). I've never
683 * seen it happen. However, for slow sample rates it may
684 * buffer too much data and introduce too much delay for the
687 * If we have a stop count, then things get more interesting.
688 * If the stop count is less than the FIFO size (actually
689 * three-quarters of the FIFO size - see below), we just use
690 * the stop count itself as the threshold, the card interrupts
691 * us when that many samples have been taken, and we kill the
692 * acquisition at that point and are done. If the stop count
693 * is larger than that, then we divide it by 2 until it's less
694 * than three quarters of the FIFO size (we always leave the
695 * top quarter of the FIFO as protection against sluggish CPU
696 * interrupt response) and use that as the threshold. So, if
697 * the stop count is 4000 samples, we divide by two twice to
698 * get 1000 samples, use that as the threshold, take four
699 * interrupts to get our 4000 samples and are done.
701 * The algorithm could be more clever. For example, if 81000
702 * samples are requested, we could set the threshold to 1500
703 * samples and take 54 interrupts to get 81000. But 54 isn't
704 * a power of two, so this algorithm won't find that option.
705 * Instead, it'll set the threshold at 1266 and take 64
706 * interrupts to get 81024 samples, of which the last 24 will
707 * be discarded... but we won't get the last interrupt until
708 * they've been collected. To find the first option, the
709 * computer could look at the prime decomposition of the
710 * sample count (81000 = 3^4 * 5^3 * 2^3) and factor it into a
711 * threshold (1500 = 3 * 5^3 * 2^2) and an interrupt count (54
712 * = 3^3 * 2). Hmmm... a one-line while loop or prime
713 * decomposition of integers... I'll leave it the way it is.
715 * I'll also note a mini-race condition before ignoring it in
716 * the code. Let's say we're taking 4000 samples, as before.
717 * After 1000 samples, we get an interrupt. But before that
718 * interrupt is completely serviced, another sample is taken
719 * and loaded into the FIFO. Since the interrupt handler
720 * empties the FIFO before returning, it will read 1001 samples.
721 * If that happens four times, we'll end up taking 4004 samples,
722 * not 4000. The interrupt handler will discard the extra four
723 * samples (by halting the acquisition with four samples still
724 * in the FIFO), but we will have to wait for them.
726 * In short, this code works pretty well, but for either of
727 * the two reasons noted, might end up waiting for a few more
728 * samples than actually requested. Shouldn't make too much
732 /* Save away the number of conversions we should perform, and
733 * compute the FIFO threshold (in bytes, not samples - that's
734 * why we multiple local->count by 2 = sizeof(sample))
737 if (cmd
->stop_src
== TRIG_COUNT
) {
738 local
->count
= cmd
->stop_arg
* cmd
->scan_end_arg
;
739 threshold
= 2 * local
->count
;
740 while (threshold
> DAQP_FIFO_SIZE
* 3 / 4)
744 threshold
= DAQP_FIFO_SIZE
/ 2;
747 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
749 outb(DAQP_COMMAND_RSTF
, dev
->iobase
+ DAQP_COMMAND
);
751 /* Set FIFO threshold. First two bytes are near-empty
752 * threshold, which is unused; next two bytes are near-full
753 * threshold. We computed the number of bytes we want in the
754 * FIFO when the interrupt is generated, what the card wants
755 * is actually the number of available bytes left in the FIFO
756 * when the interrupt is to happen.
759 outb(0x00, dev
->iobase
+ DAQP_FIFO
);
760 outb(0x00, dev
->iobase
+ DAQP_FIFO
);
762 outb((DAQP_FIFO_SIZE
- threshold
) & 0xff, dev
->iobase
+ DAQP_FIFO
);
763 outb((DAQP_FIFO_SIZE
- threshold
) >> 8, dev
->iobase
+ DAQP_FIFO
);
767 v
= DAQP_CONTROL_TRIGGER_CONTINUOUS
| DAQP_CONTROL_TRIGGER_INTERNAL
768 | DAQP_CONTROL_PACER_5MHz
| DAQP_CONTROL_FIFO_INT_ENABLE
;
770 outb(v
, dev
->iobase
+ DAQP_CONTROL
);
772 /* Reset any pending interrupts (my card has a tendancy to require
773 * require multiple reads on the status register to achieve this)
777 && (inb(dev
->iobase
+ DAQP_STATUS
) & DAQP_STATUS_EVENTS
)) ;
779 printk("daqp: couldn't clear interrupts in status register\n");
783 local
->interrupt_mode
= buffer
;
787 /* Start conversion */
788 outb(DAQP_COMMAND_ARM
| DAQP_COMMAND_FIFO_DATA
,
789 dev
->iobase
+ DAQP_COMMAND
);
794 /* Single-shot analog output routine */
796 static int daqp_ao_insn_write(struct comedi_device
* dev
, struct comedi_subdevice
* s
,
797 comedi_insn
* insn
, unsigned int * data
)
799 local_info_t
*local
= (local_info_t
*) s
->private;
807 chan
= CR_CHAN(insn
->chanspec
);
810 d
^= 0x0800; /* Flip the sign */
813 /* Make sure D/A update mode is direct update */
814 outb(0, dev
->iobase
+ DAQP_AUX
);
816 outw(d
, dev
->iobase
+ DAQP_DA
);
821 /* Digital input routine */
823 static int daqp_di_insn_read(struct comedi_device
* dev
, struct comedi_subdevice
* s
,
824 comedi_insn
* insn
, unsigned int * data
)
826 local_info_t
*local
= (local_info_t
*) s
->private;
832 data
[0] = inb(dev
->iobase
+ DAQP_DIGITAL_IO
);
837 /* Digital output routine */
839 static int daqp_do_insn_write(struct comedi_device
* dev
, struct comedi_subdevice
* s
,
840 comedi_insn
* insn
, unsigned int * data
)
842 local_info_t
*local
= (local_info_t
*) s
->private;
848 outw(data
[0] & 0xf, dev
->iobase
+ DAQP_DIGITAL_IO
);
853 /* daqp_attach is called via comedi_config to attach a comedi device
854 * to a /dev/comedi*. Note that this is different from daqp_cs_attach()
855 * which is called by the pcmcia subsystem to attach the PCMCIA card
856 * when it is inserted.
859 static int daqp_attach(struct comedi_device
* dev
, comedi_devconfig
* it
)
862 local_info_t
*local
= dev_table
[it
->options
[0]];
865 struct comedi_subdevice
*s
;
867 if (it
->options
[0] < 0 || it
->options
[0] >= MAX_DEV
|| !local
) {
868 printk("comedi%d: No such daqp device %d\n",
869 dev
->minor
, it
->options
[0]);
873 /* Typically brittle code that I don't completely understand,
874 * but "it works on my card". The intent is to pull the model
875 * number of the card out the PCMCIA CIS and stash it away as
876 * the COMEDI board_name. Looks like the third field in
877 * CISTPL_VERS_1 (offset 2) holds what we're looking for. If
878 * it doesn't work, who cares, just leave it as "DAQP".
881 strcpy(local
->board_name
, "DAQP");
882 dev
->board_name
= local
->board_name
;
884 tuple
.DesiredTuple
= CISTPL_VERS_1
;
885 if (pcmcia_get_first_tuple(local
->link
, &tuple
) == 0) {
888 buf
[0] = buf
[sizeof(buf
) - 1] = 0;
889 tuple
.TupleData
= buf
;
890 tuple
.TupleDataMax
= sizeof(buf
);
891 tuple
.TupleOffset
= 2;
892 if (pcmcia_get_tuple_data(local
->link
, &tuple
) == 0) {
894 for (i
= 0; i
< tuple
.TupleDataLen
- 4; i
++)
897 for (i
++; i
< tuple
.TupleDataLen
- 4; i
++)
901 if ((i
< tuple
.TupleDataLen
- 4)
902 && (strncmp(buf
+ i
, "DAQP", 4) == 0)) {
903 strncpy(local
->board_name
, buf
+ i
,
904 sizeof(local
->board_name
));
909 dev
->iobase
= local
->link
->io
.BasePort1
;
911 if ((ret
= alloc_subdevices(dev
, 4)) < 0)
914 printk("comedi%d: attaching daqp%d (io 0x%04lx)\n",
915 dev
->minor
, it
->options
[0], dev
->iobase
);
917 s
= dev
->subdevices
+ 0;
918 dev
->read_subdev
= s
;
920 s
->type
= COMEDI_SUBD_AI
;
921 s
->subdev_flags
= SDF_READABLE
| SDF_GROUND
| SDF_DIFF
| SDF_CMD_READ
;
923 s
->len_chanlist
= 2048;
925 s
->range_table
= &range_daqp_ai
;
926 s
->insn_read
= daqp_ai_insn_read
;
927 s
->do_cmdtest
= daqp_ai_cmdtest
;
928 s
->do_cmd
= daqp_ai_cmd
;
929 s
->cancel
= daqp_ai_cancel
;
931 s
= dev
->subdevices
+ 1;
932 dev
->write_subdev
= s
;
934 s
->type
= COMEDI_SUBD_AO
;
935 s
->subdev_flags
= SDF_WRITEABLE
;
939 s
->range_table
= &range_daqp_ao
;
940 s
->insn_write
= daqp_ao_insn_write
;
942 s
= dev
->subdevices
+ 2;
944 s
->type
= COMEDI_SUBD_DI
;
945 s
->subdev_flags
= SDF_READABLE
;
948 s
->insn_read
= daqp_di_insn_read
;
950 s
= dev
->subdevices
+ 3;
952 s
->type
= COMEDI_SUBD_DO
;
953 s
->subdev_flags
= SDF_WRITEABLE
;
956 s
->insn_write
= daqp_do_insn_write
;
961 /* daqp_detach (called from comedi_comdig) does nothing. If the PCMCIA
962 * card is removed, daqp_cs_detach() is called by the pcmcia subsystem.
965 static int daqp_detach(struct comedi_device
* dev
)
967 printk("comedi%d: detaching daqp\n", dev
->minor
);
972 /*====================================================================
974 PCMCIA interface code
976 The rest of the code in this file is based on dummy_cs.c v1.24
977 from the Linux pcmcia_cs distribution v3.1.8 and is subject
978 to the following license agreement.
980 The remaining contents of this file are subject to the Mozilla Public
981 License Version 1.1 (the "License"); you may not use this file
982 except in compliance with the License. You may obtain a copy of
983 the License at http://www.mozilla.org/MPL/
985 Software distributed under the License is distributed on an "AS
986 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
987 implied. See the License for the specific language governing
988 rights and limitations under the License.
990 The initial developer of the original code is David A. Hinds
991 <dhinds@pcmcia.sourceforge.org>. Portions created by David A. Hinds
992 are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
994 Alternatively, the contents of this file may be used under the
995 terms of the GNU Public License version 2 (the "GPL"), in which
996 case the provisions of the GPL are applicable instead of the
997 above. If you wish to allow the use of your version of this file
998 only under the terms of the GPL and not to allow others to use
999 your version of this file under the MPL, indicate your decision
1000 by deleting the provisions above and replace them with the notice
1001 and other provisions required by the GPL. If you do not delete
1002 the provisions above, a recipient may use your version of this
1003 file under either the MPL or the GPL.
1005 ======================================================================*/
1008 The event() function is this driver's Card Services event handler.
1009 It will be called by Card Services when an appropriate card status
1010 event is received. The config() and release() entry points are
1011 used to configure or release a socket, in response to card
1012 insertion and ejection events.
1014 Kernel version 2.6.16 upwards uses suspend() and resume() functions
1015 instead of an event() function.
1018 static void daqp_cs_config(struct pcmcia_device
*link
);
1019 static void daqp_cs_release(struct pcmcia_device
*link
);
1020 static int daqp_cs_suspend(struct pcmcia_device
*p_dev
);
1021 static int daqp_cs_resume(struct pcmcia_device
*p_dev
);
1024 The attach() and detach() entry points are used to create and destroy
1025 "instances" of the driver, where each instance represents everything
1026 needed to manage one actual PCMCIA card.
1029 static int daqp_cs_attach(struct pcmcia_device
*);
1030 static void daqp_cs_detach(struct pcmcia_device
*);
1033 The dev_info variable is the "key" that is used to match up this
1034 device driver with appropriate cards, through the card configuration
1038 static const dev_info_t dev_info
= "quatech_daqp_cs";
1040 /*======================================================================
1042 daqp_cs_attach() creates an "instance" of the driver, allocating
1043 local data structures for one device. The device is registered
1046 The dev_link structure is initialized, but we don't actually
1047 configure the card at this point -- we wait until we receive a
1048 card insertion event.
1050 ======================================================================*/
1052 static int daqp_cs_attach(struct pcmcia_device
*link
)
1054 local_info_t
*local
;
1057 DEBUG(0, "daqp_cs_attach()\n");
1059 for (i
= 0; i
< MAX_DEV
; i
++)
1060 if (dev_table
[i
] == NULL
)
1063 printk(KERN_NOTICE
"daqp_cs: no devices available\n");
1067 /* Allocate space for private device-specific data */
1068 local
= kzalloc(sizeof(local_info_t
), GFP_KERNEL
);
1072 local
->table_index
= i
;
1073 dev_table
[i
] = local
;
1077 /* Interrupt setup */
1078 link
->irq
.Attributes
= IRQ_TYPE_EXCLUSIVE
| IRQ_HANDLE_PRESENT
;
1079 link
->irq
.IRQInfo1
= IRQ_LEVEL_ID
;
1080 link
->irq
.Handler
= daqp_interrupt
;
1081 link
->irq
.Instance
= local
;
1084 General socket configuration defaults can go here. In this
1085 client, we assume very little, and rely on the CIS for almost
1086 everything. In most clients, many details (i.e., number, sizes,
1087 and attributes of IO windows) are fixed by the nature of the
1088 device, and can be hard-wired here.
1090 link
->conf
.Attributes
= 0;
1091 link
->conf
.IntType
= INT_MEMORY_AND_IO
;
1093 daqp_cs_config(link
);
1096 } /* daqp_cs_attach */
1098 /*======================================================================
1100 This deletes a driver "instance". The device is de-registered
1101 with Card Services. If it has been released, all local data
1102 structures are freed. Otherwise, the structures will be freed
1103 when the device is released.
1105 ======================================================================*/
1107 static void daqp_cs_detach(struct pcmcia_device
*link
)
1109 local_info_t
*dev
= link
->priv
;
1111 DEBUG(0, "daqp_cs_detach(0x%p)\n", link
);
1113 if (link
->dev_node
) {
1115 daqp_cs_release(link
);
1118 /* Unlink device structure, and free it */
1119 dev_table
[dev
->table_index
] = NULL
;
1123 } /* daqp_cs_detach */
1125 /*======================================================================
1127 daqp_cs_config() is scheduled to run after a CARD_INSERTION event
1128 is received, to configure the PCMCIA socket, and to make the
1129 device available to the system.
1131 ======================================================================*/
1133 static void daqp_cs_config(struct pcmcia_device
*link
)
1135 local_info_t
*dev
= link
->priv
;
1141 DEBUG(0, "daqp_cs_config(0x%p)\n", link
);
1144 This reads the card's CONFIG tuple to find its configuration
1147 tuple
.DesiredTuple
= CISTPL_CONFIG
;
1148 tuple
.Attributes
= 0;
1149 tuple
.TupleData
= buf
;
1150 tuple
.TupleDataMax
= sizeof(buf
);
1151 tuple
.TupleOffset
= 0;
1152 if ((last_ret
= pcmcia_get_first_tuple(link
, &tuple
))) {
1153 cs_error(link
, GetFirstTuple
, last_ret
);
1156 if ((last_ret
= pcmcia_get_tuple_data(link
, &tuple
))) {
1157 cs_error(link
, GetTupleData
, last_ret
);
1160 if ((last_ret
= pcmcia_parse_tuple(&tuple
, &parse
))) {
1161 cs_error(link
, ParseTuple
, last_ret
);
1164 link
->conf
.ConfigBase
= parse
.config
.base
;
1165 link
->conf
.Present
= parse
.config
.rmask
[0];
1168 In this loop, we scan the CIS for configuration table entries,
1169 each of which describes a valid card configuration, including
1170 voltage, IO window, memory window, and interrupt settings.
1172 We make no assumptions about the card to be configured: we use
1173 just the information available in the CIS. In an ideal world,
1174 this would work for any PCMCIA card, but it requires a complete
1175 and accurate CIS. In practice, a driver usually "knows" most of
1176 these things without consulting the CIS, and most client drivers
1177 will only use the CIS to fill in implementation-defined details.
1179 tuple
.DesiredTuple
= CISTPL_CFTABLE_ENTRY
;
1180 if ((last_ret
= pcmcia_get_first_tuple(link
, &tuple
))) {
1181 cs_error(link
, GetFirstTuple
, last_ret
);
1185 cistpl_cftable_entry_t dflt
= { 0 };
1186 cistpl_cftable_entry_t
*cfg
= &(parse
.cftable_entry
);
1187 if (pcmcia_get_tuple_data(link
, &tuple
))
1189 if (pcmcia_parse_tuple(&tuple
, &parse
))
1192 if (cfg
->flags
& CISTPL_CFTABLE_DEFAULT
)
1194 if (cfg
->index
== 0)
1196 link
->conf
.ConfigIndex
= cfg
->index
;
1198 /* Do we need to allocate an interrupt? */
1199 if (cfg
->irq
.IRQInfo1
|| dflt
.irq
.IRQInfo1
)
1200 link
->conf
.Attributes
|= CONF_ENABLE_IRQ
;
1202 /* IO window settings */
1203 link
->io
.NumPorts1
= link
->io
.NumPorts2
= 0;
1204 if ((cfg
->io
.nwin
> 0) || (dflt
.io
.nwin
> 0)) {
1205 cistpl_io_t
*io
= (cfg
->io
.nwin
) ? &cfg
->io
: &dflt
.io
;
1206 link
->io
.Attributes1
= IO_DATA_PATH_WIDTH_AUTO
;
1207 if (!(io
->flags
& CISTPL_IO_8BIT
))
1208 link
->io
.Attributes1
= IO_DATA_PATH_WIDTH_16
;
1209 if (!(io
->flags
& CISTPL_IO_16BIT
))
1210 link
->io
.Attributes1
= IO_DATA_PATH_WIDTH_8
;
1211 link
->io
.IOAddrLines
= io
->flags
& CISTPL_IO_LINES_MASK
;
1212 link
->io
.BasePort1
= io
->win
[0].base
;
1213 link
->io
.NumPorts1
= io
->win
[0].len
;
1215 link
->io
.Attributes2
= link
->io
.Attributes1
;
1216 link
->io
.BasePort2
= io
->win
[1].base
;
1217 link
->io
.NumPorts2
= io
->win
[1].len
;
1221 /* This reserves IO space but doesn't actually enable it */
1222 if (pcmcia_request_io(link
, &link
->io
))
1225 /* If we got this far, we're cool! */
1229 if ((last_ret
= pcmcia_get_next_tuple(link
, &tuple
))) {
1230 cs_error(link
, GetNextTuple
, last_ret
);
1236 Allocate an interrupt line. Note that this does not assign a
1237 handler to the interrupt, unless the 'Handler' member of the
1238 irq structure is initialized.
1240 if (link
->conf
.Attributes
& CONF_ENABLE_IRQ
)
1241 if ((last_ret
= pcmcia_request_irq(link
, &link
->irq
))) {
1242 cs_error(link
, RequestIRQ
, last_ret
);
1247 This actually configures the PCMCIA socket -- setting up
1248 the I/O windows and the interrupt mapping, and putting the
1249 card and host interface into "Memory and IO" mode.
1251 if ((last_ret
= pcmcia_request_configuration(link
, &link
->conf
))) {
1252 cs_error(link
, RequestConfiguration
, last_ret
);
1257 At this point, the dev_node_t structure(s) need to be
1258 initialized and arranged in a linked list at link->dev.
1260 /* Comedi's PCMCIA script uses this device name (extracted
1261 * from /var/lib/pcmcia/stab) to pass to comedi_config
1263 /* sprintf(dev->node.dev_name, "daqp%d", dev->table_index); */
1264 sprintf(dev
->node
.dev_name
, "quatech_daqp_cs");
1265 dev
->node
.major
= dev
->node
.minor
= 0;
1266 link
->dev_node
= &dev
->node
;
1268 /* Finally, report what we've done */
1269 printk(KERN_INFO
"%s: index 0x%02x",
1270 dev
->node
.dev_name
, link
->conf
.ConfigIndex
);
1271 if (link
->conf
.Attributes
& CONF_ENABLE_IRQ
)
1272 printk(", irq %u", link
->irq
.AssignedIRQ
);
1273 if (link
->io
.NumPorts1
)
1274 printk(", io 0x%04x-0x%04x", link
->io
.BasePort1
,
1275 link
->io
.BasePort1
+ link
->io
.NumPorts1
- 1);
1276 if (link
->io
.NumPorts2
)
1277 printk(" & 0x%04x-0x%04x", link
->io
.BasePort2
,
1278 link
->io
.BasePort2
+ link
->io
.NumPorts2
- 1);
1284 daqp_cs_release(link
);
1286 } /* daqp_cs_config */
1288 static void daqp_cs_release(struct pcmcia_device
*link
)
1290 DEBUG(0, "daqp_cs_release(0x%p)\n", link
);
1292 pcmcia_disable_device(link
);
1293 } /* daqp_cs_release */
1295 /*======================================================================
1297 The card status event handler. Mostly, this schedules other
1298 stuff to run after an event is received.
1300 When a CARD_REMOVAL event is received, we immediately set a
1301 private flag to block future accesses to this device. All the
1302 functions that actually access the device should check this flag
1303 to make sure the card is still present.
1305 ======================================================================*/
1307 static int daqp_cs_suspend(struct pcmcia_device
*link
)
1309 local_info_t
*local
= link
->priv
;
1311 /* Mark the device as stopped, to block IO until later */
1316 static int daqp_cs_resume(struct pcmcia_device
*link
)
1318 local_info_t
*local
= link
->priv
;
1325 /*====================================================================*/
1329 static struct pcmcia_device_id daqp_cs_id_table
[] = {
1330 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027),
1334 MODULE_DEVICE_TABLE(pcmcia
, daqp_cs_id_table
);
1336 struct pcmcia_driver daqp_cs_driver
= {
1337 .probe
= daqp_cs_attach
,
1338 .remove
= daqp_cs_detach
,
1339 .suspend
= daqp_cs_suspend
,
1340 .resume
= daqp_cs_resume
,
1341 .id_table
= daqp_cs_id_table
,
1342 .owner
= THIS_MODULE
,
1348 int __init
init_module(void)
1350 DEBUG(0, "%s\n", version
);
1351 pcmcia_register_driver(&daqp_cs_driver
);
1352 comedi_driver_register(&driver_daqp
);
1356 void __exit
cleanup_module(void)
1358 DEBUG(0, "daqp_cs: unloading\n");
1359 comedi_driver_unregister(&driver_daqp
);
1360 pcmcia_unregister_driver(&daqp_cs_driver
);