2 comedi/drivers/amplc_pci224.c
3 Driver for Amplicon PCI224 and PCI234 AO boards.
5 Copyright (C) 2005 MEV Ltd. <http://www.mev.co.uk/>
7 COMEDI - Linux Control and Measurement Device Interface
8 Copyright (C) 1998,2000 David A. Schleef <ds@schleef.org>
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.
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.
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.
27 Description: Amplicon PCI224, PCI234
28 Author: Ian Abbott <abbotti@mev.co.uk>
29 Devices: [Amplicon] PCI224 (amplc_pci224 or pci224),
30 PCI234 (amplc_pci224 or pci234)
31 Updated: Wed, 22 Oct 2008 12:25:08 +0100
32 Status: works, but see caveats
37 - ao_do_cmd mode with the following sources:
39 - start_src TRIG_INT TRIG_EXT
40 - scan_begin_src TRIG_TIMER TRIG_EXT
41 - convert_src TRIG_NOW
42 - scan_end_src TRIG_COUNT
43 - stop_src TRIG_COUNT TRIG_EXT TRIG_NONE
45 The channel list must contain at least one channel with no repeated
46 channels. The scan end count must equal the number of channels in
49 There is only one external trigger source so only one of start_src,
50 scan_begin_src or stop_src may use TRIG_EXT.
52 Configuration options - PCI224:
53 [0] - PCI bus of device (optional).
54 [1] - PCI slot of device (optional).
55 If bus/slot is not specified, the first available PCI device
57 [2] - Select available ranges according to jumper LK1. All channels
58 are set to the same range:
59 0=Jumper position 1-2 (factory default), 4 software-selectable
60 internal voltage references, giving 4 bipolar and 4 unipolar
62 [-10V,+10V], [-5V,+5V], [-2.5V,+2.5V], [-1.25V,+1.25V],
63 [0,+10V], [0,+5V], [0,+2.5V], [0,1.25V].
64 1=Jumper position 2-3, 1 external voltage reference, giving
65 1 bipolar and 1 unipolar range:
66 [-Vext,+Vext], [0,+Vext].
68 Configuration options - PCI234:
69 [0] - PCI bus of device (optional).
70 [1] - PCI slot of device (optional).
71 If bus/slot is not specified, the first available PCI device
73 [2] - Select internal or external voltage reference according to
74 jumper LK1. This affects all channels:
75 0=Jumper position 1-2 (factory default), Vref=5V internal.
76 1=Jumper position 2-3, Vref=Vext external.
77 [3] - Select channel 0 range according to jumper LK2:
78 0=Jumper position 2-3 (factory default), range [-2*Vref,+2*Vref]
79 (10V bipolar when options[2]=0).
80 1=Jumper position 1-2, range [-Vref,+Vref]
81 (5V bipolar when options[2]=0).
82 [4] - Select channel 1 range according to jumper LK3: cf. options[3].
83 [5] - Select channel 2 range according to jumper LK4: cf. options[3].
84 [6] - Select channel 3 range according to jumper LK5: cf. options[3].
86 Passing a zero for an option is the same as leaving it unspecified.
90 1) All channels on the PCI224 share the same range. Any change to the
91 range as a result of insn_write or a streaming command will affect
92 the output voltages of all channels, including those not specified
93 by the instruction or command.
95 2) For the analog output command, the first scan may be triggered
96 falsely at the start of acquisition. This occurs when the DAC scan
97 trigger source is switched from 'none' to 'timer' (scan_begin_src =
98 TRIG_TIMER) or 'external' (scan_begin_src == TRIG_EXT) at the start
99 of acquisition and the trigger source is at logic level 1 at the
100 time of the switch. This is very likely for TRIG_TIMER. For
101 TRIG_EXT, it depends on the state of the external line and whether
102 the CR_INVERT flag has been set. The remaining scans are triggered
106 #include <linux/interrupt.h>
107 #include <linux/slab.h>
109 #include "../comedidev.h"
111 #include "comedi_fc.h"
114 #define DRIVER_NAME "amplc_pci224"
119 #define PCI_VENDOR_ID_AMPLICON 0x14dc
120 #define PCI_DEVICE_ID_AMPLICON_PCI224 0x0007
121 #define PCI_DEVICE_ID_AMPLICON_PCI234 0x0008
122 #define PCI_DEVICE_ID_INVALID 0xffff
125 * PCI224/234 i/o space 1 (PCIBAR2) registers.
127 #define PCI224_IO1_SIZE 0x20 /* Size of i/o space 1 (8-bit registers) */
128 #define PCI224_Z2_CT0 0x14 /* 82C54 counter/timer 0 */
129 #define PCI224_Z2_CT1 0x15 /* 82C54 counter/timer 1 */
130 #define PCI224_Z2_CT2 0x16 /* 82C54 counter/timer 2 */
131 #define PCI224_Z2_CTC 0x17 /* 82C54 counter/timer control word */
132 #define PCI224_ZCLK_SCE 0x1A /* Group Z Clock Configuration Register */
133 #define PCI224_ZGAT_SCE 0x1D /* Group Z Gate Configuration Register */
134 #define PCI224_INT_SCE 0x1E /* ISR Interrupt source mask register */
135 /* /Interrupt status */
138 * PCI224/234 i/o space 2 (PCIBAR3) 16-bit registers.
140 #define PCI224_IO2_SIZE 0x10 /* Size of i/o space 2 (16-bit registers). */
141 #define PCI224_DACDATA 0x00 /* (w-o) DAC FIFO data. */
142 #define PCI224_SOFTTRIG 0x00 /* (r-o) DAC software scan trigger. */
143 #define PCI224_DACCON 0x02 /* (r/w) DAC status/configuration. */
144 #define PCI224_FIFOSIZ 0x04 /* (w-o) FIFO size for wraparound mode. */
145 #define PCI224_DACCEN 0x06 /* (w-o) DAC channel enable register. */
150 /* (r/w) Scan trigger. */
151 #define PCI224_DACCON_TRIG_MASK (7 << 0)
152 #define PCI224_DACCON_TRIG_NONE (0 << 0) /* none */
153 #define PCI224_DACCON_TRIG_SW (1 << 0) /* software trig */
154 #define PCI224_DACCON_TRIG_EXTP (2 << 0) /* ext +ve edge */
155 #define PCI224_DACCON_TRIG_EXTN (3 << 0) /* ext -ve edge */
156 #define PCI224_DACCON_TRIG_Z2CT0 (4 << 0) /* Z2 CT0 out */
157 #define PCI224_DACCON_TRIG_Z2CT1 (5 << 0) /* Z2 CT1 out */
158 #define PCI224_DACCON_TRIG_Z2CT2 (6 << 0) /* Z2 CT2 out */
159 /* (r/w) Polarity (PCI224 only, PCI234 always bipolar!). */
160 #define PCI224_DACCON_POLAR_MASK (1 << 3)
161 #define PCI224_DACCON_POLAR_UNI (0 << 3) /* range [0,Vref] */
162 #define PCI224_DACCON_POLAR_BI (1 << 3) /* range [-Vref,Vref] */
163 /* (r/w) Internal Vref (PCI224 only, when LK1 in position 1-2). */
164 #define PCI224_DACCON_VREF_MASK (3 << 4)
165 #define PCI224_DACCON_VREF_1_25 (0 << 4) /* Vref = 1.25V */
166 #define PCI224_DACCON_VREF_2_5 (1 << 4) /* Vref = 2.5V */
167 #define PCI224_DACCON_VREF_5 (2 << 4) /* Vref = 5V */
168 #define PCI224_DACCON_VREF_10 (3 << 4) /* Vref = 10V */
169 /* (r/w) Wraparound mode enable (to play back stored waveform). */
170 #define PCI224_DACCON_FIFOWRAP (1 << 7)
171 /* (r/w) FIFO enable. It MUST be set! */
172 #define PCI224_DACCON_FIFOENAB (1 << 8)
173 /* (r/w) FIFO interrupt trigger level (most values are not very useful). */
174 #define PCI224_DACCON_FIFOINTR_MASK (7 << 9)
175 #define PCI224_DACCON_FIFOINTR_EMPTY (0 << 9) /* when empty */
176 #define PCI224_DACCON_FIFOINTR_NEMPTY (1 << 9) /* when not empty */
177 #define PCI224_DACCON_FIFOINTR_NHALF (2 << 9) /* when not half full */
178 #define PCI224_DACCON_FIFOINTR_HALF (3 << 9) /* when half full */
179 #define PCI224_DACCON_FIFOINTR_NFULL (4 << 9) /* when not full */
180 #define PCI224_DACCON_FIFOINTR_FULL (5 << 9) /* when full */
181 /* (r-o) FIFO fill level. */
182 #define PCI224_DACCON_FIFOFL_MASK (7 << 12)
183 #define PCI224_DACCON_FIFOFL_EMPTY (1 << 12) /* 0 */
184 #define PCI224_DACCON_FIFOFL_ONETOHALF (0 << 12) /* [1,2048] */
185 #define PCI224_DACCON_FIFOFL_HALFTOFULL (4 << 12) /* [2049,4095] */
186 #define PCI224_DACCON_FIFOFL_FULL (6 << 12) /* 4096 */
187 /* (r-o) DAC busy flag. */
188 #define PCI224_DACCON_BUSY (1 << 15)
189 /* (w-o) FIFO reset. */
190 #define PCI224_DACCON_FIFORESET (1 << 12)
191 /* (w-o) Global reset (not sure what it does). */
192 #define PCI224_DACCON_GLOBALRESET (1 << 13)
197 #define PCI224_FIFO_SIZE 4096
200 * DAC FIFO guaranteed minimum room available, depending on reported fill level.
201 * The maximum room available depends on the reported fill level and how much
204 #define PCI224_FIFO_ROOM_EMPTY PCI224_FIFO_SIZE
205 #define PCI224_FIFO_ROOM_ONETOHALF (PCI224_FIFO_SIZE / 2)
206 #define PCI224_FIFO_ROOM_HALFTOFULL 1
207 #define PCI224_FIFO_ROOM_FULL 0
210 * Counter/timer clock input configuration sources.
212 #define CLK_CLK 0 /* reserved (channel-specific clock) */
213 #define CLK_10MHZ 1 /* internal 10 MHz clock */
214 #define CLK_1MHZ 2 /* internal 1 MHz clock */
215 #define CLK_100KHZ 3 /* internal 100 kHz clock */
216 #define CLK_10KHZ 4 /* internal 10 kHz clock */
217 #define CLK_1KHZ 5 /* internal 1 kHz clock */
218 #define CLK_OUTNM1 6 /* output of channel-1 modulo total */
219 #define CLK_EXT 7 /* external clock */
220 /* Macro to construct clock input configuration register value. */
221 #define CLK_CONFIG(chan, src) ((((chan) & 3) << 3) | ((src) & 7))
222 /* Timebases in ns. */
223 #define TIMEBASE_10MHZ 100
224 #define TIMEBASE_1MHZ 1000
225 #define TIMEBASE_100KHZ 10000
226 #define TIMEBASE_10KHZ 100000
227 #define TIMEBASE_1KHZ 1000000
230 * Counter/timer gate input configuration sources.
232 #define GAT_VCC 0 /* VCC (i.e. enabled) */
233 #define GAT_GND 1 /* GND (i.e. disabled) */
234 #define GAT_EXT 2 /* reserved (external gate input) */
235 #define GAT_NOUTNM2 3 /* inverted output of channel-2 modulo total */
236 /* Macro to construct gate input configuration register value. */
237 #define GAT_CONFIG(chan, src) ((((chan) & 3) << 3) | ((src) & 7))
240 * Summary of CLK_OUTNM1 and GAT_NOUTNM2 connections for PCI224 and PCI234:
242 * Channel's Channel's
243 * clock input gate input
244 * Channel CLK_OUTNM1 GAT_NOUTNM2
245 * ------- ---------- -----------
246 * Z2-CT0 Z2-CT2-OUT /Z2-CT1-OUT
247 * Z2-CT1 Z2-CT0-OUT /Z2-CT2-OUT
248 * Z2-CT2 Z2-CT1-OUT /Z2-CT0-OUT
252 * Interrupt enable/status bits
254 #define PCI224_INTR_EXT 0x01 /* rising edge on external input */
255 #define PCI224_INTR_DAC 0x04 /* DAC (FIFO) interrupt */
256 #define PCI224_INTR_Z2CT1 0x20 /* rising edge on Z2-CT1 output */
258 #define PCI224_INTR_EDGE_BITS (PCI224_INTR_EXT | PCI224_INTR_Z2CT1)
259 #define PCI224_INTR_LEVEL_BITS PCI224_INTR_DACFIFO
265 /* Combine old and new bits. */
266 #define COMBINE(old, new, mask) (((old) & ~(mask)) | ((new) & (mask)))
268 /* Current CPU. XXX should this be hard_smp_processor_id()? */
269 #define THISCPU smp_processor_id()
271 /* State bits for use with atomic bit operations. */
272 #define AO_CMD_STARTED 0
278 /* The software selectable internal ranges for PCI224 (option[2] == 0). */
279 static const struct comedi_lrange range_pci224_internal = {
293 static const unsigned short hwrange_pci224_internal[8] = {
294 PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_10,
295 PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_5,
296 PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_2_5,
297 PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_1_25,
298 PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_10,
299 PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_5,
300 PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_2_5,
301 PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_1_25,
304 /* The software selectable external ranges for PCI224 (option[2] == 1). */
305 static const struct comedi_lrange range_pci224_external = {
308 RANGE_ext(-1, 1), /* bipolar [-Vref,+Vref] */
309 RANGE_ext(0, 1), /* unipolar [0,+Vref] */
313 static const unsigned short hwrange_pci224_external[2] = {
314 PCI224_DACCON_POLAR_BI,
315 PCI224_DACCON_POLAR_UNI,
318 /* The hardware selectable Vref*2 external range for PCI234
319 * (option[2] == 1, option[3+n] == 0). */
320 static const struct comedi_lrange range_pci234_ext2 = {
327 /* The hardware selectable Vref external range for PCI234
328 * (option[2] == 1, option[3+n] == 1). */
329 static const struct comedi_lrange range_pci234_ext = {
336 /* This serves for all the PCI234 ranges. */
337 static const unsigned short hwrange_pci234[1] = {
338 PCI224_DACCON_POLAR_BI, /* bipolar - hardware ignores it! */
342 * Board descriptions.
345 enum pci224_model { any_model, pci224_model, pci234_model };
347 struct pci224_board {
349 unsigned short devid;
350 enum pci224_model model;
351 unsigned int ao_chans;
352 unsigned int ao_bits;
355 static const struct pci224_board pci224_boards[] = {
358 .devid = PCI_DEVICE_ID_AMPLICON_PCI224,
359 .model = pci224_model,
365 .devid = PCI_DEVICE_ID_AMPLICON_PCI234,
366 .model = pci234_model,
372 .devid = PCI_DEVICE_ID_INVALID,
373 .model = any_model, /* wildcard */
377 /* this structure is for data unique to this hardware driver. If
378 several hardware drivers keep similar information in this structure,
379 feel free to suggest moving the variable to the struct comedi_device struct. */
380 struct pci224_private {
381 const unsigned short *hwrange;
382 unsigned long iobase1;
384 spinlock_t ao_spinlock;
385 unsigned int *ao_readback;
387 unsigned char *ao_scan_order;
390 unsigned short daccon;
391 unsigned int cached_div1;
392 unsigned int cached_div2;
393 unsigned int ao_stop_count;
394 short ao_stop_continuous;
395 unsigned short ao_enab; /* max 16 channels so 'short' will do */
396 unsigned char intsce;
400 * Called from the 'insn_write' function to perform a single write.
403 pci224_ao_set_data(struct comedi_device *dev, int chan, int range,
406 const struct pci224_board *thisboard = comedi_board(dev);
407 struct pci224_private *devpriv = dev->private;
408 unsigned short mangled;
410 /* Store unmangled data for readback. */
411 devpriv->ao_readback[chan] = data;
412 /* Enable the channel. */
413 outw(1 << chan, dev->iobase + PCI224_DACCEN);
414 /* Set range and reset FIFO. */
415 devpriv->daccon = COMBINE(devpriv->daccon, devpriv->hwrange[range],
416 (PCI224_DACCON_POLAR_MASK |
417 PCI224_DACCON_VREF_MASK));
418 outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
419 dev->iobase + PCI224_DACCON);
421 * Mangle the data. The hardware expects:
422 * - bipolar: 16-bit 2's complement
423 * - unipolar: 16-bit unsigned
425 mangled = (unsigned short)data << (16 - thisboard->ao_bits);
426 if ((devpriv->daccon & PCI224_DACCON_POLAR_MASK) ==
427 PCI224_DACCON_POLAR_BI) {
430 /* Write mangled data to the FIFO. */
431 outw(mangled, dev->iobase + PCI224_DACDATA);
432 /* Trigger the conversion. */
433 inw(dev->iobase + PCI224_SOFTTRIG);
437 * 'insn_write' function for AO subdevice.
440 pci224_ao_insn_write(struct comedi_device *dev, struct comedi_subdevice *s,
441 struct comedi_insn *insn, unsigned int *data)
446 /* Unpack channel and range. */
447 chan = CR_CHAN(insn->chanspec);
448 range = CR_RANGE(insn->chanspec);
450 /* Writing a list of values to an AO channel is probably not
451 * very useful, but that's how the interface is defined. */
452 for (i = 0; i < insn->n; i++)
453 pci224_ao_set_data(dev, chan, range, data[i]);
459 * 'insn_read' function for AO subdevice.
461 * N.B. The value read will not be valid if the DAC channel has
462 * never been written successfully since the device was attached
463 * or since the channel has been used by an AO streaming write
467 pci224_ao_insn_read(struct comedi_device *dev, struct comedi_subdevice *s,
468 struct comedi_insn *insn, unsigned int *data)
470 struct pci224_private *devpriv = dev->private;
474 chan = CR_CHAN(insn->chanspec);
476 for (i = 0; i < insn->n; i++)
477 data[i] = devpriv->ao_readback[chan];
484 * Just a wrapper for the inline function 'i8253_cascade_ns_to_timer'.
487 pci224_cascade_ns_to_timer(int osc_base, unsigned int *d1, unsigned int *d2,
488 unsigned int *nanosec, int round_mode)
490 i8253_cascade_ns_to_timer(osc_base, d1, d2, nanosec, round_mode);
494 * Kills a command running on the AO subdevice.
496 static void pci224_ao_stop(struct comedi_device *dev,
497 struct comedi_subdevice *s)
499 struct pci224_private *devpriv = dev->private;
502 if (!test_and_clear_bit(AO_CMD_STARTED, &devpriv->state))
506 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
507 /* Kill the interrupts. */
509 outb(0, devpriv->iobase1 + PCI224_INT_SCE);
511 * Interrupt routine may or may not be running. We may or may not
512 * have been called from the interrupt routine (directly or
513 * indirectly via a comedi_events() callback routine). It's highly
514 * unlikely that we've been called from some other interrupt routine
515 * but who knows what strange things coders get up to!
517 * If the interrupt routine is currently running, wait for it to
518 * finish, unless we appear to have been called via the interrupt
521 while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
522 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
523 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
525 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
526 /* Reconfigure DAC for insn_write usage. */
527 outw(0, dev->iobase + PCI224_DACCEN); /* Disable channels. */
528 devpriv->daccon = COMBINE(devpriv->daccon,
529 PCI224_DACCON_TRIG_SW |
530 PCI224_DACCON_FIFOINTR_EMPTY,
531 PCI224_DACCON_TRIG_MASK |
532 PCI224_DACCON_FIFOINTR_MASK);
533 outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
534 dev->iobase + PCI224_DACCON);
538 * Handles start of acquisition for the AO subdevice.
540 static void pci224_ao_start(struct comedi_device *dev,
541 struct comedi_subdevice *s)
543 struct pci224_private *devpriv = dev->private;
544 struct comedi_cmd *cmd = &s->async->cmd;
547 set_bit(AO_CMD_STARTED, &devpriv->state);
548 if (!devpriv->ao_stop_continuous && devpriv->ao_stop_count == 0) {
549 /* An empty acquisition! */
550 pci224_ao_stop(dev, s);
551 s->async->events |= COMEDI_CB_EOA;
552 comedi_event(dev, s);
554 /* Enable interrupts. */
555 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
556 if (cmd->stop_src == TRIG_EXT)
557 devpriv->intsce = PCI224_INTR_EXT | PCI224_INTR_DAC;
559 devpriv->intsce = PCI224_INTR_DAC;
561 outb(devpriv->intsce, devpriv->iobase1 + PCI224_INT_SCE);
562 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
567 * Handles interrupts from the DAC FIFO.
569 static void pci224_ao_handle_fifo(struct comedi_device *dev,
570 struct comedi_subdevice *s)
572 struct pci224_private *devpriv = dev->private;
573 struct comedi_cmd *cmd = &s->async->cmd;
574 unsigned int num_scans;
576 unsigned short dacstat;
578 unsigned int bytes_per_scan;
580 if (cmd->chanlist_len) {
581 bytes_per_scan = cmd->chanlist_len * sizeof(short);
583 /* Shouldn't get here! */
584 bytes_per_scan = sizeof(short);
586 /* Determine number of scans available in buffer. */
587 num_scans = comedi_buf_read_n_available(s->async) / bytes_per_scan;
588 if (!devpriv->ao_stop_continuous) {
589 /* Fixed number of scans. */
590 if (num_scans > devpriv->ao_stop_count)
591 num_scans = devpriv->ao_stop_count;
595 /* Determine how much room is in the FIFO (in samples). */
596 dacstat = inw(dev->iobase + PCI224_DACCON);
597 switch (dacstat & PCI224_DACCON_FIFOFL_MASK) {
598 case PCI224_DACCON_FIFOFL_EMPTY:
599 room = PCI224_FIFO_ROOM_EMPTY;
600 if (!devpriv->ao_stop_continuous && devpriv->ao_stop_count == 0) {
601 /* FIFO empty at end of counted acquisition. */
602 pci224_ao_stop(dev, s);
603 s->async->events |= COMEDI_CB_EOA;
604 comedi_event(dev, s);
608 case PCI224_DACCON_FIFOFL_ONETOHALF:
609 room = PCI224_FIFO_ROOM_ONETOHALF;
611 case PCI224_DACCON_FIFOFL_HALFTOFULL:
612 room = PCI224_FIFO_ROOM_HALFTOFULL;
615 room = PCI224_FIFO_ROOM_FULL;
618 if (room >= PCI224_FIFO_ROOM_ONETOHALF) {
619 /* FIFO is less than half-full. */
620 if (num_scans == 0) {
621 /* Nothing left to put in the FIFO. */
622 pci224_ao_stop(dev, s);
623 s->async->events |= COMEDI_CB_OVERFLOW;
624 dev_err(dev->class_dev, "AO buffer underrun\n");
627 /* Determine how many new scans can be put in the FIFO. */
628 if (cmd->chanlist_len)
629 room /= cmd->chanlist_len;
631 /* Determine how many scans to process. */
632 if (num_scans > room)
636 for (n = 0; n < num_scans; n++) {
637 cfc_read_array_from_buffer(s, &devpriv->ao_scan_vals[0],
639 for (i = 0; i < cmd->chanlist_len; i++) {
640 outw(devpriv->ao_scan_vals[devpriv->ao_scan_order[i]],
641 dev->iobase + PCI224_DACDATA);
644 if (!devpriv->ao_stop_continuous) {
645 devpriv->ao_stop_count -= num_scans;
646 if (devpriv->ao_stop_count == 0) {
648 * Change FIFO interrupt trigger level to wait
649 * until FIFO is empty.
651 devpriv->daccon = COMBINE(devpriv->daccon,
652 PCI224_DACCON_FIFOINTR_EMPTY,
653 PCI224_DACCON_FIFOINTR_MASK);
654 outw(devpriv->daccon, dev->iobase + PCI224_DACCON);
657 if ((devpriv->daccon & PCI224_DACCON_TRIG_MASK) ==
658 PCI224_DACCON_TRIG_NONE) {
662 * This is the initial DAC FIFO interrupt at the
663 * start of the acquisition. The DAC's scan trigger
664 * has been set to 'none' up until now.
666 * Now that data has been written to the FIFO, the
667 * DAC's scan trigger source can be set to the
670 * BUG: The first scan will be triggered immediately
671 * if the scan trigger source is at logic level 1.
673 if (cmd->scan_begin_src == TRIG_TIMER) {
674 trig = PCI224_DACCON_TRIG_Z2CT0;
676 /* cmd->scan_begin_src == TRIG_EXT */
677 if (cmd->scan_begin_arg & CR_INVERT)
678 trig = PCI224_DACCON_TRIG_EXTN;
680 trig = PCI224_DACCON_TRIG_EXTP;
683 devpriv->daccon = COMBINE(devpriv->daccon, trig,
684 PCI224_DACCON_TRIG_MASK);
685 outw(devpriv->daccon, dev->iobase + PCI224_DACCON);
687 if (s->async->events)
688 comedi_event(dev, s);
693 * Internal trigger function to start acquisition on AO subdevice.
696 pci224_ao_inttrig_start(struct comedi_device *dev, struct comedi_subdevice *s,
697 unsigned int trignum)
702 s->async->inttrig = NULL;
703 pci224_ao_start(dev, s);
708 #define MAX_SCAN_PERIOD 0xFFFFFFFFU
709 #define MIN_SCAN_PERIOD 2500
710 #define CONVERT_PERIOD 625
713 * 'do_cmdtest' function for AO subdevice.
716 pci224_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
717 struct comedi_cmd *cmd)
719 struct pci224_private *devpriv = dev->private;
723 /* Step 1: make sure trigger sources are trivially valid. */
725 tmp = cmd->start_src;
726 cmd->start_src &= TRIG_INT | TRIG_EXT;
727 if (!cmd->start_src || tmp != cmd->start_src)
730 tmp = cmd->scan_begin_src;
731 cmd->scan_begin_src &= TRIG_EXT | TRIG_TIMER;
732 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
735 tmp = cmd->convert_src;
736 cmd->convert_src &= TRIG_NOW;
737 if (!cmd->convert_src || tmp != cmd->convert_src)
740 tmp = cmd->scan_end_src;
741 cmd->scan_end_src &= TRIG_COUNT;
742 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
746 cmd->stop_src &= TRIG_COUNT | TRIG_EXT | TRIG_NONE;
747 if (!cmd->stop_src || tmp != cmd->stop_src)
753 /* Step 2: make sure trigger sources are unique and mutually
756 /* these tests are true if more than one _src bit is set */
757 if ((cmd->start_src & (cmd->start_src - 1)) != 0)
759 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0)
761 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
763 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
765 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
768 /* There's only one external trigger signal (which makes these
769 * tests easier). Only one thing can use it. */
771 if (cmd->start_src & TRIG_EXT)
773 if (cmd->scan_begin_src & TRIG_EXT)
775 if (cmd->stop_src & TRIG_EXT)
783 /* Step 3: make sure arguments are trivially compatible. */
785 switch (cmd->start_src) {
787 if (cmd->start_arg != 0) {
793 /* Force to external trigger 0. */
794 if ((cmd->start_arg & ~CR_FLAGS_MASK) != 0) {
795 cmd->start_arg = COMBINE(cmd->start_arg, 0,
799 /* The only flag allowed is CR_EDGE, which is ignored. */
800 if ((cmd->start_arg & CR_FLAGS_MASK & ~CR_EDGE) != 0) {
801 cmd->start_arg = COMBINE(cmd->start_arg, 0,
802 CR_FLAGS_MASK & ~CR_EDGE);
808 switch (cmd->scan_begin_src) {
810 if (cmd->scan_begin_arg > MAX_SCAN_PERIOD) {
811 cmd->scan_begin_arg = MAX_SCAN_PERIOD;
814 tmp = cmd->chanlist_len * CONVERT_PERIOD;
815 if (tmp < MIN_SCAN_PERIOD)
816 tmp = MIN_SCAN_PERIOD;
818 if (cmd->scan_begin_arg < tmp) {
819 cmd->scan_begin_arg = tmp;
824 /* Force to external trigger 0. */
825 if ((cmd->scan_begin_arg & ~CR_FLAGS_MASK) != 0) {
826 cmd->scan_begin_arg = COMBINE(cmd->scan_begin_arg, 0,
830 /* Only allow flags CR_EDGE and CR_INVERT. Ignore CR_EDGE. */
831 if ((cmd->scan_begin_arg & CR_FLAGS_MASK &
832 ~(CR_EDGE | CR_INVERT)) != 0) {
833 cmd->scan_begin_arg = COMBINE(cmd->scan_begin_arg, 0,
834 CR_FLAGS_MASK & ~(CR_EDGE
842 /* cmd->convert_src == TRIG_NOW */
843 if (cmd->convert_arg != 0) {
844 cmd->convert_arg = 0;
848 /* cmd->scan_end_arg == TRIG_COUNT */
849 if (cmd->scan_end_arg != cmd->chanlist_len) {
850 cmd->scan_end_arg = cmd->chanlist_len;
854 switch (cmd->stop_src) {
856 /* Any count allowed. */
859 /* Force to external trigger 0. */
860 if ((cmd->stop_arg & ~CR_FLAGS_MASK) != 0) {
861 cmd->stop_arg = COMBINE(cmd->stop_arg, 0,
865 /* The only flag allowed is CR_EDGE, which is ignored. */
866 if ((cmd->stop_arg & CR_FLAGS_MASK & ~CR_EDGE) != 0) {
867 cmd->stop_arg = COMBINE(cmd->stop_arg, 0,
868 CR_FLAGS_MASK & ~CR_EDGE);
872 if (cmd->stop_arg != 0) {
882 /* Step 4: fix up any arguments. */
884 if (cmd->scan_begin_src == TRIG_TIMER) {
885 unsigned int div1, div2, round;
886 int round_mode = cmd->flags & TRIG_ROUND_MASK;
888 tmp = cmd->scan_begin_arg;
889 /* Check whether to use a single timer. */
890 switch (round_mode) {
891 case TRIG_ROUND_NEAREST:
893 round = TIMEBASE_10MHZ / 2;
895 case TRIG_ROUND_DOWN:
899 round = TIMEBASE_10MHZ - 1;
902 /* Be careful to avoid overflow! */
903 div2 = cmd->scan_begin_arg / TIMEBASE_10MHZ;
904 div2 += (round + cmd->scan_begin_arg % TIMEBASE_10MHZ) /
906 if (div2 <= 0x10000) {
907 /* A single timer will suffice. */
910 cmd->scan_begin_arg = div2 * TIMEBASE_10MHZ;
911 if (cmd->scan_begin_arg < div2 ||
912 cmd->scan_begin_arg < TIMEBASE_10MHZ) {
914 cmd->scan_begin_arg = MAX_SCAN_PERIOD;
917 /* Use two timers. */
918 div1 = devpriv->cached_div1;
919 div2 = devpriv->cached_div2;
920 pci224_cascade_ns_to_timer(TIMEBASE_10MHZ, &div1, &div2,
921 &cmd->scan_begin_arg,
923 devpriv->cached_div1 = div1;
924 devpriv->cached_div2 = div2;
926 if (tmp != cmd->scan_begin_arg)
934 /* Step 5: check channel list. */
936 if (cmd->chanlist && (cmd->chanlist_len > 0)) {
938 enum { range_err = 1, dupchan_err = 2, };
944 * Check all channels have the same range index. Don't care
945 * about analogue reference, as we can't configure it.
947 * Check the list has no duplicate channels.
949 range = CR_RANGE(cmd->chanlist[0]);
952 for (n = 0; n < cmd->chanlist_len; n++) {
953 ch = CR_CHAN(cmd->chanlist[n]);
954 if (tmp & (1U << ch))
955 errors |= dupchan_err;
958 if (CR_RANGE(cmd->chanlist[n]) != range)
963 if (errors & dupchan_err) {
964 DPRINTK("comedi%d: " DRIVER_NAME
966 "entries in chanlist must contain no "
967 "duplicate channels\n", dev->minor);
969 if (errors & range_err) {
970 DPRINTK("comedi%d: " DRIVER_NAME
972 "entries in chanlist must all have "
973 "the same range index\n", dev->minor);
986 * 'do_cmd' function for AO subdevice.
988 static int pci224_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
990 struct pci224_private *devpriv = dev->private;
991 struct comedi_cmd *cmd = &s->async->cmd;
998 /* Cannot handle null/empty chanlist. */
999 if (cmd->chanlist == NULL || cmd->chanlist_len == 0)
1003 /* Determine which channels are enabled and their load order. */
1004 devpriv->ao_enab = 0;
1006 for (i = 0; i < cmd->chanlist_len; i++) {
1007 ch = CR_CHAN(cmd->chanlist[i]);
1008 devpriv->ao_enab |= 1U << ch;
1010 for (j = 0; j < cmd->chanlist_len; j++) {
1011 if (CR_CHAN(cmd->chanlist[j]) < ch)
1015 devpriv->ao_scan_order[rank] = i;
1018 /* Set enabled channels. */
1019 outw(devpriv->ao_enab, dev->iobase + PCI224_DACCEN);
1021 /* Determine range and polarity. All channels the same. */
1022 range = CR_RANGE(cmd->chanlist[0]);
1025 * Set DAC range and polarity.
1026 * Set DAC scan trigger source to 'none'.
1027 * Set DAC FIFO interrupt trigger level to 'not half full'.
1030 * N.B. DAC FIFO interrupts are currently disabled.
1032 devpriv->daccon = COMBINE(devpriv->daccon,
1034 hwrange[range] | PCI224_DACCON_TRIG_NONE |
1035 PCI224_DACCON_FIFOINTR_NHALF),
1036 (PCI224_DACCON_POLAR_MASK |
1037 PCI224_DACCON_VREF_MASK |
1038 PCI224_DACCON_TRIG_MASK |
1039 PCI224_DACCON_FIFOINTR_MASK));
1040 outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
1041 dev->iobase + PCI224_DACCON);
1043 if (cmd->scan_begin_src == TRIG_TIMER) {
1044 unsigned int div1, div2, round;
1045 unsigned int ns = cmd->scan_begin_arg;
1046 int round_mode = cmd->flags & TRIG_ROUND_MASK;
1048 /* Check whether to use a single timer. */
1049 switch (round_mode) {
1050 case TRIG_ROUND_NEAREST:
1052 round = TIMEBASE_10MHZ / 2;
1054 case TRIG_ROUND_DOWN:
1058 round = TIMEBASE_10MHZ - 1;
1061 /* Be careful to avoid overflow! */
1062 div2 = cmd->scan_begin_arg / TIMEBASE_10MHZ;
1063 div2 += (round + cmd->scan_begin_arg % TIMEBASE_10MHZ) /
1065 if (div2 <= 0x10000) {
1066 /* A single timer will suffice. */
1070 div1 = 1; /* Flag that single timer to be used. */
1072 /* Use two timers. */
1073 div1 = devpriv->cached_div1;
1074 div2 = devpriv->cached_div2;
1075 pci224_cascade_ns_to_timer(TIMEBASE_10MHZ, &div1, &div2,
1080 * The output of timer Z2-0 will be used as the scan trigger
1083 /* Make sure Z2-0 is gated on. */
1084 outb(GAT_CONFIG(0, GAT_VCC),
1085 devpriv->iobase1 + PCI224_ZGAT_SCE);
1087 /* Not cascading. Z2-0 needs 10 MHz clock. */
1088 outb(CLK_CONFIG(0, CLK_10MHZ),
1089 devpriv->iobase1 + PCI224_ZCLK_SCE);
1091 /* Cascading with Z2-2. */
1092 /* Make sure Z2-2 is gated on. */
1093 outb(GAT_CONFIG(2, GAT_VCC),
1094 devpriv->iobase1 + PCI224_ZGAT_SCE);
1095 /* Z2-2 needs 10 MHz clock. */
1096 outb(CLK_CONFIG(2, CLK_10MHZ),
1097 devpriv->iobase1 + PCI224_ZCLK_SCE);
1098 /* Load Z2-2 mode (2) and counter (div1). */
1099 i8254_load(devpriv->iobase1 + PCI224_Z2_CT0, 0,
1101 /* Z2-0 is clocked from Z2-2's output. */
1102 outb(CLK_CONFIG(0, CLK_OUTNM1),
1103 devpriv->iobase1 + PCI224_ZCLK_SCE);
1105 /* Load Z2-0 mode (2) and counter (div2). */
1106 i8254_load(devpriv->iobase1 + PCI224_Z2_CT0, 0, 0, div2, 2);
1110 * Sort out end of acquisition.
1112 switch (cmd->stop_src) {
1114 /* Fixed number of scans. */
1115 devpriv->ao_stop_continuous = 0;
1116 devpriv->ao_stop_count = cmd->stop_arg;
1119 /* Continuous scans. */
1120 devpriv->ao_stop_continuous = 1;
1121 devpriv->ao_stop_count = 0;
1126 * Sort out start of acquisition.
1128 switch (cmd->start_src) {
1130 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1131 s->async->inttrig = &pci224_ao_inttrig_start;
1132 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1135 /* Enable external interrupt trigger to start acquisition. */
1136 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1137 devpriv->intsce |= PCI224_INTR_EXT;
1138 outb(devpriv->intsce, devpriv->iobase1 + PCI224_INT_SCE);
1139 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1147 * 'cancel' function for AO subdevice.
1149 static int pci224_ao_cancel(struct comedi_device *dev,
1150 struct comedi_subdevice *s)
1152 pci224_ao_stop(dev, s);
1157 * 'munge' data for AO command.
1160 pci224_ao_munge(struct comedi_device *dev, struct comedi_subdevice *s,
1161 void *data, unsigned int num_bytes, unsigned int chan_index)
1163 const struct pci224_board *thisboard = comedi_board(dev);
1164 struct pci224_private *devpriv = dev->private;
1165 struct comedi_async *async = s->async;
1166 short *array = data;
1167 unsigned int length = num_bytes / sizeof(*array);
1168 unsigned int offset;
1172 /* The hardware expects 16-bit numbers. */
1173 shift = 16 - thisboard->ao_bits;
1174 /* Channels will be all bipolar or all unipolar. */
1175 if ((devpriv->hwrange[CR_RANGE(async->cmd.chanlist[0])] &
1176 PCI224_DACCON_POLAR_MASK) == PCI224_DACCON_POLAR_UNI) {
1183 /* Munge the data. */
1184 for (i = 0; i < length; i++)
1185 array[i] = (array[i] << shift) - offset;
1190 * Interrupt handler.
1192 static irqreturn_t pci224_interrupt(int irq, void *d)
1194 struct comedi_device *dev = d;
1195 struct pci224_private *devpriv = dev->private;
1196 struct comedi_subdevice *s = &dev->subdevices[0];
1197 struct comedi_cmd *cmd;
1198 unsigned char intstat, valid_intstat;
1199 unsigned char curenab;
1201 unsigned long flags;
1203 intstat = inb(devpriv->iobase1 + PCI224_INT_SCE) & 0x3F;
1206 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1207 valid_intstat = devpriv->intsce & intstat;
1208 /* Temporarily disable interrupt sources. */
1209 curenab = devpriv->intsce & ~intstat;
1210 outb(curenab, devpriv->iobase1 + PCI224_INT_SCE);
1211 devpriv->intr_running = 1;
1212 devpriv->intr_cpuid = THISCPU;
1213 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1214 if (valid_intstat != 0) {
1215 cmd = &s->async->cmd;
1216 if (valid_intstat & PCI224_INTR_EXT) {
1217 devpriv->intsce &= ~PCI224_INTR_EXT;
1218 if (cmd->start_src == TRIG_EXT)
1219 pci224_ao_start(dev, s);
1220 else if (cmd->stop_src == TRIG_EXT)
1221 pci224_ao_stop(dev, s);
1224 if (valid_intstat & PCI224_INTR_DAC)
1225 pci224_ao_handle_fifo(dev, s);
1228 /* Reenable interrupt sources. */
1229 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1230 if (curenab != devpriv->intsce) {
1231 outb(devpriv->intsce,
1232 devpriv->iobase1 + PCI224_INT_SCE);
1234 devpriv->intr_running = 0;
1235 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1237 return IRQ_RETVAL(retval);
1241 * This function looks for a board matching the supplied PCI device.
1243 static const struct pci224_board
1244 *pci224_find_pci_board(struct pci_dev *pci_dev)
1248 for (i = 0; i < ARRAY_SIZE(pci224_boards); i++)
1249 if (pci_dev->device == pci224_boards[i].devid)
1250 return &pci224_boards[i];
1255 * This function looks for a PCI device matching the requested board name,
1258 static struct pci_dev *pci224_find_pci_dev(struct comedi_device *dev,
1259 struct comedi_devconfig *it)
1261 const struct pci224_board *thisboard = comedi_board(dev);
1262 struct pci_dev *pci_dev = NULL;
1263 int bus = it->options[0];
1264 int slot = it->options[1];
1266 for_each_pci_dev(pci_dev) {
1268 if (bus != pci_dev->bus->number ||
1269 slot != PCI_SLOT(pci_dev->devfn))
1272 if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
1275 if (thisboard->model == any_model) {
1276 /* Match any supported model. */
1277 const struct pci224_board *board_ptr;
1279 board_ptr = pci224_find_pci_board(pci_dev);
1280 if (board_ptr == NULL)
1282 /* Change board_ptr to matched board. */
1283 dev->board_ptr = board_ptr;
1285 /* Match specific model name. */
1286 if (thisboard->devid != pci_dev->device)
1291 dev_err(dev->class_dev,
1292 "No supported board found! (req. bus %d, slot %d)\n",
1297 static void pci224_report_attach(struct comedi_device *dev, unsigned int irq)
1299 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1303 snprintf(tmpbuf, sizeof(tmpbuf), "irq %u%s", irq,
1304 (dev->irq ? "" : " UNAVAILABLE"));
1306 snprintf(tmpbuf, sizeof(tmpbuf), "no irq");
1307 dev_info(dev->class_dev, "%s (pci %s) (%s) attached\n",
1308 dev->board_name, pci_name(pcidev), tmpbuf);
1312 * Common part of attach and attach_pci.
1314 static int pci224_attach_common(struct comedi_device *dev,
1315 struct pci_dev *pci_dev, int *options)
1317 const struct pci224_board *thisboard = comedi_board(dev);
1318 struct pci224_private *devpriv = dev->private;
1319 struct comedi_subdevice *s;
1324 comedi_set_hw_dev(dev, &pci_dev->dev);
1326 ret = comedi_pci_enable(pci_dev, DRIVER_NAME);
1328 dev_err(dev->class_dev,
1329 "error! cannot enable PCI device and request regions!\n"
1333 spin_lock_init(&devpriv->ao_spinlock);
1335 devpriv->iobase1 = pci_resource_start(pci_dev, 2);
1336 dev->iobase = pci_resource_start(pci_dev, 3);
1339 /* Allocate readback buffer for AO channels. */
1340 devpriv->ao_readback = kmalloc(sizeof(devpriv->ao_readback[0]) *
1341 thisboard->ao_chans, GFP_KERNEL);
1342 if (!devpriv->ao_readback)
1346 /* Allocate buffer to hold values for AO channel scan. */
1347 devpriv->ao_scan_vals = kmalloc(sizeof(devpriv->ao_scan_vals[0]) *
1348 thisboard->ao_chans, GFP_KERNEL);
1349 if (!devpriv->ao_scan_vals)
1353 /* Allocate buffer to hold AO channel scan order. */
1354 devpriv->ao_scan_order = kmalloc(sizeof(devpriv->ao_scan_order[0]) *
1355 thisboard->ao_chans, GFP_KERNEL);
1356 if (!devpriv->ao_scan_order)
1360 /* Disable interrupt sources. */
1361 devpriv->intsce = 0;
1362 outb(0, devpriv->iobase1 + PCI224_INT_SCE);
1364 /* Initialize the DAC hardware. */
1365 outw(PCI224_DACCON_GLOBALRESET, dev->iobase + PCI224_DACCON);
1366 outw(0, dev->iobase + PCI224_DACCEN);
1367 outw(0, dev->iobase + PCI224_FIFOSIZ);
1368 devpriv->daccon = (PCI224_DACCON_TRIG_SW | PCI224_DACCON_POLAR_BI |
1369 PCI224_DACCON_FIFOENAB |
1370 PCI224_DACCON_FIFOINTR_EMPTY);
1371 outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
1372 dev->iobase + PCI224_DACCON);
1374 ret = comedi_alloc_subdevices(dev, 1);
1378 s = dev->subdevices + 0;
1379 /* Analog output subdevice. */
1380 s->type = COMEDI_SUBD_AO;
1381 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
1382 s->n_chan = thisboard->ao_chans;
1383 s->maxdata = (1 << thisboard->ao_bits) - 1;
1384 s->insn_write = &pci224_ao_insn_write;
1385 s->insn_read = &pci224_ao_insn_read;
1386 s->len_chanlist = s->n_chan;
1388 dev->write_subdev = s;
1389 s->do_cmd = &pci224_ao_cmd;
1390 s->do_cmdtest = &pci224_ao_cmdtest;
1391 s->cancel = &pci224_ao_cancel;
1392 s->munge = &pci224_ao_munge;
1394 /* Sort out channel range options. */
1395 if (thisboard->model == pci234_model) {
1396 /* PCI234 range options. */
1397 const struct comedi_lrange **range_table_list;
1399 s->range_table_list = range_table_list =
1400 kmalloc(sizeof(struct comedi_lrange *) * s->n_chan,
1402 if (!s->range_table_list)
1406 for (n = 2; n < 3 + s->n_chan; n++) {
1407 if (options[n] < 0 || options[n] > 1) {
1408 dev_warn(dev->class_dev, DRIVER_NAME
1409 ": warning! bad options[%u]=%d\n",
1414 for (n = 0; n < s->n_chan; n++) {
1415 if (n < COMEDI_NDEVCONFOPTS - 3 && options &&
1416 options[3 + n] == 1) {
1417 if (options[2] == 1)
1418 range_table_list[n] = &range_pci234_ext;
1420 range_table_list[n] = &range_bipolar5;
1423 if (options && options[2] == 1) {
1424 range_table_list[n] =
1427 range_table_list[n] = &range_bipolar10;
1431 devpriv->hwrange = hwrange_pci234;
1433 /* PCI224 range options. */
1434 if (options && options[2] == 1) {
1435 s->range_table = &range_pci224_external;
1436 devpriv->hwrange = hwrange_pci224_external;
1438 if (options && options[2] != 0) {
1439 dev_warn(dev->class_dev, DRIVER_NAME
1440 ": warning! bad options[2]=%d\n",
1443 s->range_table = &range_pci224_internal;
1444 devpriv->hwrange = hwrange_pci224_internal;
1448 dev->board_name = thisboard->name;
1451 ret = request_irq(irq, pci224_interrupt, IRQF_SHARED,
1454 dev_err(dev->class_dev,
1455 "error! unable to allocate irq %u\n", irq);
1462 pci224_report_attach(dev, irq);
1466 static int pci224_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1468 struct pci_dev *pci_dev;
1471 dev_info(dev->class_dev, DRIVER_NAME ": attach\n");
1473 ret = alloc_private(dev, sizeof(struct pci224_private));
1475 dev_err(dev->class_dev, "error! out of memory!\n");
1479 pci_dev = pci224_find_pci_dev(dev, it);
1483 return pci224_attach_common(dev, pci_dev, it->options);
1486 static int __devinit
1487 pci224_attach_pci(struct comedi_device *dev, struct pci_dev *pci_dev)
1491 dev_info(dev->class_dev, DRIVER_NAME ": attach_pci %s\n",
1494 ret = alloc_private(dev, sizeof(struct pci224_private));
1496 dev_err(dev->class_dev, "error! out of memory!\n");
1500 dev->board_ptr = pci224_find_pci_board(pci_dev);
1501 if (dev->board_ptr == NULL) {
1502 dev_err(dev->class_dev,
1503 DRIVER_NAME ": BUG! cannot determine board type!\n");
1506 return pci224_attach_common(dev, pci_dev, NULL);
1509 static void pci224_detach(struct comedi_device *dev)
1511 struct pci224_private *devpriv = dev->private;
1512 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1515 free_irq(dev->irq, dev);
1516 if (dev->subdevices) {
1517 struct comedi_subdevice *s;
1519 s = dev->subdevices + 0;
1521 kfree(s->range_table_list);
1524 kfree(devpriv->ao_readback);
1525 kfree(devpriv->ao_scan_vals);
1526 kfree(devpriv->ao_scan_order);
1530 comedi_pci_disable(pcidev);
1531 pci_dev_put(pcidev);
1535 static struct comedi_driver amplc_pci224_driver = {
1536 .driver_name = "amplc_pci224",
1537 .module = THIS_MODULE,
1538 .attach = pci224_attach,
1539 .detach = pci224_detach,
1540 .attach_pci = pci224_attach_pci,
1541 .board_name = &pci224_boards[0].name,
1542 .offset = sizeof(struct pci224_board),
1543 .num_names = ARRAY_SIZE(pci224_boards),
1546 static int __devinit amplc_pci224_pci_probe(struct pci_dev *dev,
1547 const struct pci_device_id
1550 return comedi_pci_auto_config(dev, &lc_pci224_driver);
1553 static void __devexit amplc_pci224_pci_remove(struct pci_dev *dev)
1555 comedi_pci_auto_unconfig(dev);
1558 static DEFINE_PCI_DEVICE_TABLE(amplc_pci224_pci_table) = {
1559 { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI224) },
1560 { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI234) },
1563 MODULE_DEVICE_TABLE(pci, amplc_pci224_pci_table);
1565 static struct pci_driver amplc_pci224_pci_driver = {
1566 .name = "amplc_pci224",
1567 .id_table = amplc_pci224_pci_table,
1568 .probe = amplc_pci224_pci_probe,
1569 .remove = __devexit_p(amplc_pci224_pci_remove),
1571 module_comedi_pci_driver(amplc_pci224_driver, amplc_pci224_pci_driver);
1573 MODULE_AUTHOR("Comedi http://www.comedi.org");
1574 MODULE_DESCRIPTION("Comedi low-level driver");
1575 MODULE_LICENSE("GPL");