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>
58 /* Maximum number of separate DAQP devices we'll allow */
62 struct pcmcia_device *link;
67 enum { semaphore, buffer } interrupt_mode;
71 struct comedi_device *dev;
72 struct comedi_subdevice *s;
76 /* A list of "instances" of the device. */
78 static struct local_info_t *dev_table[MAX_DEV] = { NULL, /* ... */ };
80 /* The DAQP communicates with the system through a 16 byte I/O window. */
82 #define DAQP_FIFO_SIZE 4096
85 #define DAQP_SCANLIST 1
86 #define DAQP_CONTROL 2
88 #define DAQP_DIGITAL_IO 3
89 #define DAQP_PACER_LOW 4
90 #define DAQP_PACER_MID 5
91 #define DAQP_PACER_HIGH 6
92 #define DAQP_COMMAND 7
97 #define DAQP_SCANLIST_DIFFERENTIAL 0x4000
98 #define DAQP_SCANLIST_GAIN(x) ((x)<<12)
99 #define DAQP_SCANLIST_CHANNEL(x) ((x)<<8)
100 #define DAQP_SCANLIST_START 0x0080
101 #define DAQP_SCANLIST_EXT_GAIN(x) ((x)<<4)
102 #define DAQP_SCANLIST_EXT_CHANNEL(x) (x)
104 #define DAQP_CONTROL_PACER_100kHz 0xc0
105 #define DAQP_CONTROL_PACER_1MHz 0x80
106 #define DAQP_CONTROL_PACER_5MHz 0x40
107 #define DAQP_CONTROL_PACER_EXTERNAL 0x00
108 #define DAQP_CONTORL_EXPANSION 0x20
109 #define DAQP_CONTROL_EOS_INT_ENABLE 0x10
110 #define DAQP_CONTROL_FIFO_INT_ENABLE 0x08
111 #define DAQP_CONTROL_TRIGGER_ONESHOT 0x00
112 #define DAQP_CONTROL_TRIGGER_CONTINUOUS 0x04
113 #define DAQP_CONTROL_TRIGGER_INTERNAL 0x00
114 #define DAQP_CONTROL_TRIGGER_EXTERNAL 0x02
115 #define DAQP_CONTROL_TRIGGER_RISING 0x00
116 #define DAQP_CONTROL_TRIGGER_FALLING 0x01
118 #define DAQP_STATUS_IDLE 0x80
119 #define DAQP_STATUS_RUNNING 0x40
120 #define DAQP_STATUS_EVENTS 0x38
121 #define DAQP_STATUS_DATA_LOST 0x20
122 #define DAQP_STATUS_END_OF_SCAN 0x10
123 #define DAQP_STATUS_FIFO_THRESHOLD 0x08
124 #define DAQP_STATUS_FIFO_FULL 0x04
125 #define DAQP_STATUS_FIFO_NEARFULL 0x02
126 #define DAQP_STATUS_FIFO_EMPTY 0x01
128 #define DAQP_COMMAND_ARM 0x80
129 #define DAQP_COMMAND_RSTF 0x40
130 #define DAQP_COMMAND_RSTQ 0x20
131 #define DAQP_COMMAND_STOP 0x10
132 #define DAQP_COMMAND_LATCH 0x08
133 #define DAQP_COMMAND_100kHz 0x00
134 #define DAQP_COMMAND_50kHz 0x02
135 #define DAQP_COMMAND_25kHz 0x04
136 #define DAQP_COMMAND_FIFO_DATA 0x01
137 #define DAQP_COMMAND_FIFO_PROGRAM 0x00
139 #define DAQP_AUX_TRIGGER_TTL 0x00
140 #define DAQP_AUX_TRIGGER_ANALOG 0x80
141 #define DAQP_AUX_TRIGGER_PRETRIGGER 0x40
142 #define DAQP_AUX_TIMER_INT_ENABLE 0x20
143 #define DAQP_AUX_TIMER_RELOAD 0x00
144 #define DAQP_AUX_TIMER_PAUSE 0x08
145 #define DAQP_AUX_TIMER_GO 0x10
146 #define DAQP_AUX_TIMER_GO_EXTERNAL 0x18
147 #define DAQP_AUX_TIMER_EXTERNAL_SRC 0x04
148 #define DAQP_AUX_TIMER_INTERNAL_SRC 0x00
149 #define DAQP_AUX_DA_DIRECT 0x00
150 #define DAQP_AUX_DA_OVERFLOW 0x01
151 #define DAQP_AUX_DA_EXTERNAL 0x02
152 #define DAQP_AUX_DA_PACER 0x03
154 #define DAQP_AUX_RUNNING 0x80
155 #define DAQP_AUX_TRIGGERED 0x40
156 #define DAQP_AUX_DA_BUFFER 0x20
157 #define DAQP_AUX_TIMER_OVERFLOW 0x10
158 #define DAQP_AUX_CONVERSION 0x08
159 #define DAQP_AUX_DATA_LOST 0x04
160 #define DAQP_AUX_FIFO_NEARFULL 0x02
161 #define DAQP_AUX_FIFO_EMPTY 0x01
163 /* These range structures tell COMEDI how the sample values map to
164 * voltages. The A/D converter has four .ranges = +/- 10V through
165 * +/- 1.25V, and the D/A converter has only .one = +/- 5V.
168 static const struct comedi_lrange range_daqp_ai = { 4, {
176 static const struct comedi_lrange range_daqp_ao = { 1, {BIP_RANGE(5)} };
178 /*====================================================================*/
180 /* comedi interface code */
182 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it);
183 static int daqp_detach(struct comedi_device *dev);
184 static struct comedi_driver driver_daqp = {
185 .driver_name = "quatech_daqp_cs",
186 .module = THIS_MODULE,
187 .attach = daqp_attach,
188 .detach = daqp_detach,
193 static void daqp_dump(struct comedi_device *dev)
195 printk("DAQP: status %02x; aux status %02x\n",
196 inb(dev->iobase + DAQP_STATUS), inb(dev->iobase + DAQP_AUX));
199 static void hex_dump(char *str, void *ptr, int len)
201 unsigned char *cptr = ptr;
206 for (i = 0; i < len; i++) {
208 printk("\n0x%08x:", (unsigned int)cptr);
210 printk(" %02x", *(cptr++));
217 /* Cancel a running acquisition */
219 static int daqp_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
221 struct local_info_t *local = (struct local_info_t *)s->private;
227 outb(DAQP_COMMAND_STOP, dev->iobase + DAQP_COMMAND);
229 /* flush any linguring data in FIFO - superfluous here */
230 /* outb(DAQP_COMMAND_RSTF, dev->iobase+DAQP_COMMAND); */
232 local->interrupt_mode = semaphore;
239 * Operates in one of two modes. If local->interrupt_mode is
240 * 'semaphore', just signal the local->eos semaphore and return
241 * (one-shot mode). Otherwise (continuous mode), read data in from
242 * the card, transfer it to the buffer provided by the higher-level
243 * comedi kernel module, and signal various comedi callback routines,
244 * which run pretty quick.
247 static void daqp_interrupt(int irq, void *dev_id)
249 struct local_info_t *local = (struct local_info_t *)dev_id;
250 struct comedi_device *dev;
251 struct comedi_subdevice *s;
252 int loop_limit = 10000;
257 "daqp_interrupt(): irq %d for unknown device.\n", irq);
263 printk(KERN_WARNING "daqp_interrupt(): NULL comedi_device.\n");
267 if (!dev->attached) {
269 "daqp_interrupt(): struct comedi_device not yet attached.\n");
276 "daqp_interrupt(): NULL comedi_subdevice.\n");
280 if ((struct local_info_t *)s->private != local) {
282 "daqp_interrupt(): invalid comedi_subdevice.\n");
286 switch (local->interrupt_mode) {
295 while (!((status = inb(dev->iobase + DAQP_STATUS))
296 & DAQP_STATUS_FIFO_EMPTY)) {
300 if (status & DAQP_STATUS_DATA_LOST) {
302 COMEDI_CB_EOA | COMEDI_CB_OVERFLOW;
303 printk("daqp: data lost\n");
304 daqp_ai_cancel(dev, s);
308 data = inb(dev->iobase + DAQP_FIFO);
309 data |= inb(dev->iobase + DAQP_FIFO) << 8;
312 comedi_buf_put(s->async, data);
314 /* If there's a limit, decrement it
315 * and stop conversion if zero
318 if (local->count > 0) {
320 if (local->count == 0) {
321 daqp_ai_cancel(dev, s);
322 s->async->events |= COMEDI_CB_EOA;
327 if ((loop_limit--) <= 0)
331 if (loop_limit <= 0) {
333 "loop_limit reached in daqp_interrupt()\n");
334 daqp_ai_cancel(dev, s);
335 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
338 s->async->events |= COMEDI_CB_BLOCK;
340 comedi_event(dev, s);
344 /* One-shot analog data acquisition routine */
346 static int daqp_ai_insn_read(struct comedi_device *dev,
347 struct comedi_subdevice *s,
348 struct comedi_insn *insn, unsigned int *data)
350 struct local_info_t *local = (struct local_info_t *)s->private;
359 /* Stop any running conversion */
360 daqp_ai_cancel(dev, s);
362 outb(0, dev->iobase + DAQP_AUX);
364 /* Reset scan list queue */
365 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
367 /* Program one scan list entry */
369 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(insn->chanspec))
370 | DAQP_SCANLIST_GAIN(CR_RANGE(insn->chanspec));
372 if (CR_AREF(insn->chanspec) == AREF_DIFF) {
373 v |= DAQP_SCANLIST_DIFFERENTIAL;
376 v |= DAQP_SCANLIST_START;
378 outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
379 outb(v >> 8, dev->iobase + DAQP_SCANLIST);
381 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
383 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
387 v = DAQP_CONTROL_TRIGGER_ONESHOT | DAQP_CONTROL_TRIGGER_INTERNAL
388 | DAQP_CONTROL_PACER_100kHz | DAQP_CONTROL_EOS_INT_ENABLE;
390 outb(v, dev->iobase + DAQP_CONTROL);
392 /* Reset any pending interrupts (my card has a tendancy to require
393 * require multiple reads on the status register to achieve this)
397 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
399 printk("daqp: couldn't clear interrupts in status register\n");
403 /* Make sure semaphore is blocked */
404 sema_init(&local->eos, 0);
405 local->interrupt_mode = semaphore;
409 for (i = 0; i < insn->n; i++) {
411 /* Start conversion */
412 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
413 dev->iobase + DAQP_COMMAND);
415 /* Wait for interrupt service routine to unblock semaphore */
416 /* Maybe could use a timeout here, but it's interruptible */
417 if (down_interruptible(&local->eos))
420 data[i] = inb(dev->iobase + DAQP_FIFO);
421 data[i] |= inb(dev->iobase + DAQP_FIFO) << 8;
428 /* This function converts ns nanoseconds to a counter value suitable
429 * for programming the device. We always use the DAQP's 5 MHz clock,
430 * which with its 24-bit counter, allows values up to 84 seconds.
431 * Also, the function adjusts ns so that it cooresponds to the actual
432 * time that the device will use.
435 static int daqp_ns_to_timer(unsigned int *ns, int round)
445 /* cmdtest tests a particular command to see if it is valid.
446 * Using the cmdtest ioctl, a user can create a valid cmd
447 * and then have it executed by the cmd ioctl.
449 * cmdtest returns 1,2,3,4 or 0, depending on which tests
450 * the command passes.
453 static int daqp_ai_cmdtest(struct comedi_device *dev,
454 struct comedi_subdevice *s, struct comedi_cmd *cmd)
459 /* step 1: make sure trigger sources are trivially valid */
461 tmp = cmd->start_src;
462 cmd->start_src &= TRIG_NOW;
463 if (!cmd->start_src || tmp != cmd->start_src)
466 tmp = cmd->scan_begin_src;
467 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW;
468 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
471 tmp = cmd->convert_src;
472 cmd->convert_src &= TRIG_TIMER | TRIG_NOW;
473 if (!cmd->convert_src || tmp != cmd->convert_src)
476 tmp = cmd->scan_end_src;
477 cmd->scan_end_src &= TRIG_COUNT;
478 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
482 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
483 if (!cmd->stop_src || tmp != cmd->stop_src)
489 /* step 2: make sure trigger sources are unique and mutually compatible */
491 /* note that mutual compatibility is not an issue here */
492 if (cmd->scan_begin_src != TRIG_TIMER &&
493 cmd->scan_begin_src != TRIG_FOLLOW)
495 if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER)
497 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
499 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
505 /* step 3: make sure arguments are trivially compatible */
507 if (cmd->start_arg != 0) {
511 #define MAX_SPEED 10000 /* 100 kHz - in nanoseconds */
513 if (cmd->scan_begin_src == TRIG_TIMER
514 && cmd->scan_begin_arg < MAX_SPEED) {
515 cmd->scan_begin_arg = MAX_SPEED;
519 /* If both scan_begin and convert are both timer values, the only
520 * way that can make sense is if the scan time is the number of
521 * conversions times the convert time
524 if (cmd->scan_begin_src == TRIG_TIMER && cmd->convert_src == TRIG_TIMER
525 && cmd->scan_begin_arg != cmd->convert_arg * cmd->scan_end_arg) {
529 if (cmd->convert_src == TRIG_TIMER && cmd->convert_arg < MAX_SPEED) {
530 cmd->convert_arg = MAX_SPEED;
534 if (cmd->scan_end_arg != cmd->chanlist_len) {
535 cmd->scan_end_arg = cmd->chanlist_len;
538 if (cmd->stop_src == TRIG_COUNT) {
539 if (cmd->stop_arg > 0x00ffffff) {
540 cmd->stop_arg = 0x00ffffff;
545 if (cmd->stop_arg != 0) {
554 /* step 4: fix up any arguments */
556 if (cmd->scan_begin_src == TRIG_TIMER) {
557 tmp = cmd->scan_begin_arg;
558 daqp_ns_to_timer(&cmd->scan_begin_arg,
559 cmd->flags & TRIG_ROUND_MASK);
560 if (tmp != cmd->scan_begin_arg)
564 if (cmd->convert_src == TRIG_TIMER) {
565 tmp = cmd->convert_arg;
566 daqp_ns_to_timer(&cmd->convert_arg,
567 cmd->flags & TRIG_ROUND_MASK);
568 if (tmp != cmd->convert_arg)
578 static int daqp_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
580 struct local_info_t *local = (struct local_info_t *)s->private;
581 struct comedi_cmd *cmd = &s->async->cmd;
583 int scanlist_start_on_every_entry;
593 /* Stop any running conversion */
594 daqp_ai_cancel(dev, s);
596 outb(0, dev->iobase + DAQP_AUX);
598 /* Reset scan list queue */
599 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
601 /* Program pacer clock
603 * There's two modes we can operate in. If convert_src is
604 * TRIG_TIMER, then convert_arg specifies the time between
605 * each conversion, so we program the pacer clock to that
606 * frequency and set the SCANLIST_START bit on every scanlist
607 * entry. Otherwise, convert_src is TRIG_NOW, which means
608 * we want the fastest possible conversions, scan_begin_src
609 * is TRIG_TIMER, and scan_begin_arg specifies the time between
610 * each scan, so we program the pacer clock to this frequency
611 * and only set the SCANLIST_START bit on the first entry.
614 if (cmd->convert_src == TRIG_TIMER) {
615 int counter = daqp_ns_to_timer(&cmd->convert_arg,
616 cmd->flags & TRIG_ROUND_MASK);
617 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
618 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
619 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
620 scanlist_start_on_every_entry = 1;
622 int counter = daqp_ns_to_timer(&cmd->scan_begin_arg,
623 cmd->flags & TRIG_ROUND_MASK);
624 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
625 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
626 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
627 scanlist_start_on_every_entry = 0;
630 /* Program scan list */
632 for (i = 0; i < cmd->chanlist_len; i++) {
634 int chanspec = cmd->chanlist[i];
636 /* Program one scan list entry */
638 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(chanspec))
639 | DAQP_SCANLIST_GAIN(CR_RANGE(chanspec));
641 if (CR_AREF(chanspec) == AREF_DIFF) {
642 v |= DAQP_SCANLIST_DIFFERENTIAL;
645 if (i == 0 || scanlist_start_on_every_entry) {
646 v |= DAQP_SCANLIST_START;
649 outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
650 outb(v >> 8, dev->iobase + DAQP_SCANLIST);
653 /* Now it's time to program the FIFO threshold, basically the
654 * number of samples the card will buffer before it interrupts
657 * If we don't have a stop count, then use half the size of
658 * the FIFO (the manufacturer's recommendation). Consider
659 * that the FIFO can hold 2K samples (4K bytes). With the
660 * threshold set at half the FIFO size, we have a margin of
661 * error of 1024 samples. At the chip's maximum sample rate
662 * of 100,000 Hz, the CPU would have to delay interrupt
663 * service for a full 10 milliseconds in order to lose data
664 * here (as opposed to higher up in the kernel). I've never
665 * seen it happen. However, for slow sample rates it may
666 * buffer too much data and introduce too much delay for the
669 * If we have a stop count, then things get more interesting.
670 * If the stop count is less than the FIFO size (actually
671 * three-quarters of the FIFO size - see below), we just use
672 * the stop count itself as the threshold, the card interrupts
673 * us when that many samples have been taken, and we kill the
674 * acquisition at that point and are done. If the stop count
675 * is larger than that, then we divide it by 2 until it's less
676 * than three quarters of the FIFO size (we always leave the
677 * top quarter of the FIFO as protection against sluggish CPU
678 * interrupt response) and use that as the threshold. So, if
679 * the stop count is 4000 samples, we divide by two twice to
680 * get 1000 samples, use that as the threshold, take four
681 * interrupts to get our 4000 samples and are done.
683 * The algorithm could be more clever. For example, if 81000
684 * samples are requested, we could set the threshold to 1500
685 * samples and take 54 interrupts to get 81000. But 54 isn't
686 * a power of two, so this algorithm won't find that option.
687 * Instead, it'll set the threshold at 1266 and take 64
688 * interrupts to get 81024 samples, of which the last 24 will
689 * be discarded... but we won't get the last interrupt until
690 * they've been collected. To find the first option, the
691 * computer could look at the prime decomposition of the
692 * sample count (81000 = 3^4 * 5^3 * 2^3) and factor it into a
693 * threshold (1500 = 3 * 5^3 * 2^2) and an interrupt count (54
694 * = 3^3 * 2). Hmmm... a one-line while loop or prime
695 * decomposition of integers... I'll leave it the way it is.
697 * I'll also note a mini-race condition before ignoring it in
698 * the code. Let's say we're taking 4000 samples, as before.
699 * After 1000 samples, we get an interrupt. But before that
700 * interrupt is completely serviced, another sample is taken
701 * and loaded into the FIFO. Since the interrupt handler
702 * empties the FIFO before returning, it will read 1001 samples.
703 * If that happens four times, we'll end up taking 4004 samples,
704 * not 4000. The interrupt handler will discard the extra four
705 * samples (by halting the acquisition with four samples still
706 * in the FIFO), but we will have to wait for them.
708 * In short, this code works pretty well, but for either of
709 * the two reasons noted, might end up waiting for a few more
710 * samples than actually requested. Shouldn't make too much
714 /* Save away the number of conversions we should perform, and
715 * compute the FIFO threshold (in bytes, not samples - that's
716 * why we multiple local->count by 2 = sizeof(sample))
719 if (cmd->stop_src == TRIG_COUNT) {
720 local->count = cmd->stop_arg * cmd->scan_end_arg;
721 threshold = 2 * local->count;
722 while (threshold > DAQP_FIFO_SIZE * 3 / 4)
726 threshold = DAQP_FIFO_SIZE / 2;
729 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
731 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
733 /* Set FIFO threshold. First two bytes are near-empty
734 * threshold, which is unused; next two bytes are near-full
735 * threshold. We computed the number of bytes we want in the
736 * FIFO when the interrupt is generated, what the card wants
737 * is actually the number of available bytes left in the FIFO
738 * when the interrupt is to happen.
741 outb(0x00, dev->iobase + DAQP_FIFO);
742 outb(0x00, dev->iobase + DAQP_FIFO);
744 outb((DAQP_FIFO_SIZE - threshold) & 0xff, dev->iobase + DAQP_FIFO);
745 outb((DAQP_FIFO_SIZE - threshold) >> 8, dev->iobase + DAQP_FIFO);
749 v = DAQP_CONTROL_TRIGGER_CONTINUOUS | DAQP_CONTROL_TRIGGER_INTERNAL
750 | DAQP_CONTROL_PACER_5MHz | DAQP_CONTROL_FIFO_INT_ENABLE;
752 outb(v, dev->iobase + DAQP_CONTROL);
754 /* Reset any pending interrupts (my card has a tendancy to require
755 * require multiple reads on the status register to achieve this)
759 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
761 printk("daqp: couldn't clear interrupts in status register\n");
765 local->interrupt_mode = buffer;
769 /* Start conversion */
770 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
771 dev->iobase + DAQP_COMMAND);
776 /* Single-shot analog output routine */
778 static int daqp_ao_insn_write(struct comedi_device *dev,
779 struct comedi_subdevice *s,
780 struct comedi_insn *insn, unsigned int *data)
782 struct local_info_t *local = (struct local_info_t *)s->private;
790 chan = CR_CHAN(insn->chanspec);
793 d ^= 0x0800; /* Flip the sign */
796 /* Make sure D/A update mode is direct update */
797 outb(0, dev->iobase + DAQP_AUX);
799 outw(d, dev->iobase + DAQP_DA);
804 /* Digital input routine */
806 static int daqp_di_insn_read(struct comedi_device *dev,
807 struct comedi_subdevice *s,
808 struct comedi_insn *insn, unsigned int *data)
810 struct local_info_t *local = (struct local_info_t *)s->private;
816 data[0] = inb(dev->iobase + DAQP_DIGITAL_IO);
821 /* Digital output routine */
823 static int daqp_do_insn_write(struct comedi_device *dev,
824 struct comedi_subdevice *s,
825 struct comedi_insn *insn, unsigned int *data)
827 struct local_info_t *local = (struct local_info_t *)s->private;
833 outw(data[0] & 0xf, dev->iobase + DAQP_DIGITAL_IO);
838 /* daqp_attach is called via comedi_config to attach a comedi device
839 * to a /dev/comedi*. Note that this is different from daqp_cs_attach()
840 * which is called by the pcmcia subsystem to attach the PCMCIA card
841 * when it is inserted.
844 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
847 struct local_info_t *local = dev_table[it->options[0]];
848 struct comedi_subdevice *s;
850 if (it->options[0] < 0 || it->options[0] >= MAX_DEV || !local) {
851 printk("comedi%d: No such daqp device %d\n",
852 dev->minor, it->options[0]);
856 /* Typically brittle code that I don't completely understand,
857 * but "it works on my card". The intent is to pull the model
858 * number of the card out the PCMCIA CIS and stash it away as
859 * the COMEDI board_name. Looks like the third field in
860 * CISTPL_VERS_1 (offset 2) holds what we're looking for. If
861 * it doesn't work, who cares, just leave it as "DAQP".
864 strcpy(local->board_name, "DAQP");
865 dev->board_name = local->board_name;
866 if (local->link->prod_id[2]) {
867 if (strncmp(local->link->prod_id[2], "DAQP", 4) == 0) {
868 strncpy(local->board_name, local->link->prod_id[2],
869 sizeof(local->board_name));
873 dev->iobase = local->link->io.BasePort1;
875 ret = alloc_subdevices(dev, 4);
879 printk("comedi%d: attaching daqp%d (io 0x%04lx)\n",
880 dev->minor, it->options[0], dev->iobase);
882 s = dev->subdevices + 0;
883 dev->read_subdev = s;
885 s->type = COMEDI_SUBD_AI;
886 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
888 s->len_chanlist = 2048;
890 s->range_table = &range_daqp_ai;
891 s->insn_read = daqp_ai_insn_read;
892 s->do_cmdtest = daqp_ai_cmdtest;
893 s->do_cmd = daqp_ai_cmd;
894 s->cancel = daqp_ai_cancel;
896 s = dev->subdevices + 1;
897 dev->write_subdev = s;
899 s->type = COMEDI_SUBD_AO;
900 s->subdev_flags = SDF_WRITEABLE;
904 s->range_table = &range_daqp_ao;
905 s->insn_write = daqp_ao_insn_write;
907 s = dev->subdevices + 2;
909 s->type = COMEDI_SUBD_DI;
910 s->subdev_flags = SDF_READABLE;
913 s->insn_read = daqp_di_insn_read;
915 s = dev->subdevices + 3;
917 s->type = COMEDI_SUBD_DO;
918 s->subdev_flags = SDF_WRITEABLE;
921 s->insn_write = daqp_do_insn_write;
926 /* daqp_detach (called from comedi_comdig) does nothing. If the PCMCIA
927 * card is removed, daqp_cs_detach() is called by the pcmcia subsystem.
930 static int daqp_detach(struct comedi_device *dev)
932 printk("comedi%d: detaching daqp\n", dev->minor);
937 /*====================================================================
939 PCMCIA interface code
941 The rest of the code in this file is based on dummy_cs.c v1.24
942 from the Linux pcmcia_cs distribution v3.1.8 and is subject
943 to the following license agreement.
945 The remaining contents of this file are subject to the Mozilla Public
946 License Version 1.1 (the "License"); you may not use this file
947 except in compliance with the License. You may obtain a copy of
948 the License at http://www.mozilla.org/MPL/
950 Software distributed under the License is distributed on an "AS
951 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
952 implied. See the License for the specific language governing
953 rights and limitations under the License.
955 The initial developer of the original code is David A. Hinds
956 <dhinds@pcmcia.sourceforge.org>. Portions created by David A. Hinds
957 are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
959 Alternatively, the contents of this file may be used under the
960 terms of the GNU Public License version 2 (the "GPL"), in which
961 case the provisions of the GPL are applicable instead of the
962 above. If you wish to allow the use of your version of this file
963 only under the terms of the GPL and not to allow others to use
964 your version of this file under the MPL, indicate your decision
965 by deleting the provisions above and replace them with the notice
966 and other provisions required by the GPL. If you do not delete
967 the provisions above, a recipient may use your version of this
968 file under either the MPL or the GPL.
970 ======================================================================*/
973 The event() function is this driver's Card Services event handler.
974 It will be called by Card Services when an appropriate card status
975 event is received. The config() and release() entry points are
976 used to configure or release a socket, in response to card
977 insertion and ejection events.
979 Kernel version 2.6.16 upwards uses suspend() and resume() functions
980 instead of an event() function.
983 static void daqp_cs_config(struct pcmcia_device *link);
984 static void daqp_cs_release(struct pcmcia_device *link);
985 static int daqp_cs_suspend(struct pcmcia_device *p_dev);
986 static int daqp_cs_resume(struct pcmcia_device *p_dev);
989 The attach() and detach() entry points are used to create and destroy
990 "instances" of the driver, where each instance represents everything
991 needed to manage one actual PCMCIA card.
994 static int daqp_cs_attach(struct pcmcia_device *);
995 static void daqp_cs_detach(struct pcmcia_device *);
998 The dev_info variable is the "key" that is used to match up this
999 device driver with appropriate cards, through the card configuration
1003 static const dev_info_t dev_info = "quatech_daqp_cs";
1005 /*======================================================================
1007 daqp_cs_attach() creates an "instance" of the driver, allocating
1008 local data structures for one device. The device is registered
1011 The dev_link structure is initialized, but we don't actually
1012 configure the card at this point -- we wait until we receive a
1013 card insertion event.
1015 ======================================================================*/
1017 static int daqp_cs_attach(struct pcmcia_device *link)
1019 struct local_info_t *local;
1022 dev_dbg(&link->dev, "daqp_cs_attach()\n");
1024 for (i = 0; i < MAX_DEV; i++)
1025 if (dev_table[i] == NULL)
1028 printk(KERN_NOTICE "daqp_cs: no devices available\n");
1032 /* Allocate space for private device-specific data */
1033 local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
1037 local->table_index = i;
1038 dev_table[i] = local;
1043 General socket configuration defaults can go here. In this
1044 client, we assume very little, and rely on the CIS for almost
1045 everything. In most clients, many details (i.e., number, sizes,
1046 and attributes of IO windows) are fixed by the nature of the
1047 device, and can be hard-wired here.
1049 link->conf.Attributes = 0;
1050 link->conf.IntType = INT_MEMORY_AND_IO;
1052 daqp_cs_config(link);
1055 } /* daqp_cs_attach */
1057 /*======================================================================
1059 This deletes a driver "instance". The device is de-registered
1060 with Card Services. If it has been released, all local data
1061 structures are freed. Otherwise, the structures will be freed
1062 when the device is released.
1064 ======================================================================*/
1066 static void daqp_cs_detach(struct pcmcia_device *link)
1068 struct local_info_t *dev = link->priv;
1070 dev_dbg(&link->dev, "daqp_cs_detach\n");
1073 daqp_cs_release(link);
1075 /* Unlink device structure, and free it */
1076 dev_table[dev->table_index] = NULL;
1080 } /* daqp_cs_detach */
1082 /*======================================================================
1084 daqp_cs_config() is scheduled to run after a CARD_INSERTION event
1085 is received, to configure the PCMCIA socket, and to make the
1086 device available to the system.
1088 ======================================================================*/
1091 static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev,
1092 cistpl_cftable_entry_t *cfg,
1093 cistpl_cftable_entry_t *dflt,
1097 if (cfg->index == 0)
1100 /* Do we need to allocate an interrupt? */
1101 p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
1103 /* IO window settings */
1104 p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
1105 if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
1106 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
1107 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1108 if (!(io->flags & CISTPL_IO_8BIT))
1109 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
1110 if (!(io->flags & CISTPL_IO_16BIT))
1111 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
1112 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
1113 p_dev->io.BasePort1 = io->win[0].base;
1114 p_dev->io.NumPorts1 = io->win[0].len;
1116 p_dev->io.Attributes2 = p_dev->io.Attributes1;
1117 p_dev->io.BasePort2 = io->win[1].base;
1118 p_dev->io.NumPorts2 = io->win[1].len;
1122 /* This reserves IO space but doesn't actually enable it */
1123 return pcmcia_request_io(p_dev, &p_dev->io);
1126 static void daqp_cs_config(struct pcmcia_device *link)
1130 dev_dbg(&link->dev, "daqp_cs_config\n");
1132 ret = pcmcia_loop_config(link, daqp_pcmcia_config_loop, NULL);
1134 dev_warn(&link->dev, "no configuration found\n");
1138 ret = pcmcia_request_irq(link, daqp_interrupt);
1143 This actually configures the PCMCIA socket -- setting up
1144 the I/O windows and the interrupt mapping, and putting the
1145 card and host interface into "Memory and IO" mode.
1147 ret = pcmcia_request_configuration(link, &link->conf);
1151 /* Finally, report what we've done */
1152 dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
1153 if (link->conf.Attributes & CONF_ENABLE_IRQ)
1154 printk(", irq %u", link->irq);
1155 if (link->io.NumPorts1)
1156 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
1157 link->io.BasePort1 + link->io.NumPorts1 - 1);
1158 if (link->io.NumPorts2)
1159 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
1160 link->io.BasePort2 + link->io.NumPorts2 - 1);
1166 daqp_cs_release(link);
1168 } /* daqp_cs_config */
1170 static void daqp_cs_release(struct pcmcia_device *link)
1172 dev_dbg(&link->dev, "daqp_cs_release\n");
1174 pcmcia_disable_device(link);
1175 } /* daqp_cs_release */
1177 /*======================================================================
1179 The card status event handler. Mostly, this schedules other
1180 stuff to run after an event is received.
1182 When a CARD_REMOVAL event is received, we immediately set a
1183 private flag to block future accesses to this device. All the
1184 functions that actually access the device should check this flag
1185 to make sure the card is still present.
1187 ======================================================================*/
1189 static int daqp_cs_suspend(struct pcmcia_device *link)
1191 struct local_info_t *local = link->priv;
1193 /* Mark the device as stopped, to block IO until later */
1198 static int daqp_cs_resume(struct pcmcia_device *link)
1200 struct local_info_t *local = link->priv;
1207 /*====================================================================*/
1211 static struct pcmcia_device_id daqp_cs_id_table[] = {
1212 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027),
1216 MODULE_DEVICE_TABLE(pcmcia, daqp_cs_id_table);
1218 struct pcmcia_driver daqp_cs_driver = {
1219 .probe = daqp_cs_attach,
1220 .remove = daqp_cs_detach,
1221 .suspend = daqp_cs_suspend,
1222 .resume = daqp_cs_resume,
1223 .id_table = daqp_cs_id_table,
1224 .owner = THIS_MODULE,
1230 int __init init_module(void)
1232 pcmcia_register_driver(&daqp_cs_driver);
1233 comedi_driver_register(&driver_daqp);
1237 void __exit cleanup_module(void)
1239 comedi_driver_unregister(&driver_daqp);
1240 pcmcia_unregister_driver(&daqp_cs_driver);