2 comedi/drivers/cb_pcidas.c
4 Developed by Ivan Martinez and Frank Mori Hess, with valuable help from
5 David Schleef and the rest of the Comedi developers comunity.
7 Copyright (C) 2001-2003 Ivan Martinez <imr@oersted.dtu.dk>
8 Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net>
10 COMEDI - Linux Control and Measurement Device Interface
11 Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 ************************************************************************
31 Description: MeasurementComputing PCI-DAS series with the AMCC S5933 PCI controller
32 Author: Ivan Martinez <imr@oersted.dtu.dk>,
33 Frank Mori Hess <fmhess@users.sourceforge.net>
35 Devices: [Measurement Computing] PCI-DAS1602/16 (cb_pcidas),
36 PCI-DAS1602/16jr, PCI-DAS1602/12, PCI-DAS1200, PCI-DAS1200jr,
37 PCI-DAS1000, PCI-DAS1001, PCI_DAS1002
40 There are many reports of the driver being used with most of the
41 supported cards. Despite no detailed log is maintained, it can
42 be said that the driver is quite tested and stable.
44 The boards may be autocalibrated using the comedi_calibrate
47 Configuration options:
48 [0] - PCI bus of device (optional)
49 [1] - PCI slot of device (optional)
50 If bus/slot is not specified, the first supported
51 PCI device found will be used.
53 For commands, the scanned channels must be consecutive
54 (i.e. 4-5-6-7, 2-3-4,...), and must all have the same
61 analog triggering on 1602 series
64 #include "../comedidev.h"
65 #include <linux/delay.h>
66 #include <linux/interrupt.h>
70 #include "amcc_s5933.h"
71 #include "comedi_pci.h"
72 #include "comedi_fc.h"
74 #undef CB_PCIDAS_DEBUG /* disable debugging code */
75 /* #define CB_PCIDAS_DEBUG enable debugging code */
77 /* PCI vendor number of ComputerBoards/MeasurementComputing */
78 #define PCI_VENDOR_ID_CB 0x1307
79 #define TIMER_BASE 100 /* 10MHz master clock */
80 #define AI_BUFFER_SIZE 1024 /* maximum fifo size of any supported board */
81 #define AO_BUFFER_SIZE 1024 /* maximum fifo size of any supported board */
82 #define NUM_CHANNELS_8800 8
83 #define NUM_CHANNELS_7376 1
84 #define NUM_CHANNELS_8402 2
85 #define NUM_CHANNELS_DAC08 1
87 /* PCI-DAS base addresses */
89 /* indices of base address regions */
90 #define S5933_BADRINDEX 0
91 #define CONT_STAT_BADRINDEX 1
92 #define ADC_FIFO_BADRINDEX 2
93 #define PACER_BADRINDEX 3
94 #define AO_BADRINDEX 4
95 /* sizes of io regions */
96 #define CONT_STAT_SIZE 10
97 #define ADC_FIFO_SIZE 4
101 /* Control/Status registers */
102 #define INT_ADCFIFO 0 /* INTERRUPT / ADC FIFO register */
103 #define INT_EOS 0x1 /* interrupt end of scan */
104 #define INT_FHF 0x2 /* interrupt fifo half full */
105 #define INT_FNE 0x3 /* interrupt fifo not empty */
106 #define INT_MASK 0x3 /* mask of interrupt select bits */
107 #define INTE 0x4 /* interrupt enable */
108 #define DAHFIE 0x8 /* dac half full interrupt enable */
109 #define EOAIE 0x10 /* end of aquisition interrupt enable */
110 #define DAHFI 0x20 /* dac half full read status / write interrupt clear */
111 #define EOAI 0x40 /* read end of acq. interrupt status / write clear */
112 #define INT 0x80 /* read interrupt status / write clear */
113 #define EOBI 0x200 /* read end of burst interrupt status */
114 #define ADHFI 0x400 /* read half-full interrupt status */
115 #define ADNEI 0x800 /* read fifo not empty interrupt latch status */
116 #define ADNE 0x1000 /* read, fifo not empty (realtime, not latched) status */
117 #define DAEMIE 0x1000 /* write, dac empty interrupt enable */
118 #define LADFUL 0x2000 /* read fifo overflow / write clear */
119 #define DAEMI 0x4000 /* dac fifo empty interrupt status / write clear */
121 #define ADCMUX_CONT 2 /* ADC CHANNEL MUX AND CONTROL register */
122 #define BEGIN_SCAN(x) ((x) & 0xf)
123 #define END_SCAN(x) (((x) & 0xf) << 4)
124 #define GAIN_BITS(x) (((x) & 0x3) << 8)
125 #define UNIP 0x800 /* Analog front-end unipolar for range */
126 #define SE 0x400 /* Inputs in single-ended mode */
127 #define PACER_MASK 0x3000 /* pacer source bits */
128 #define PACER_INT 0x1000 /* internal pacer */
129 #define PACER_EXT_FALL 0x2000 /* external falling edge */
130 #define PACER_EXT_RISE 0x3000 /* external rising edge */
131 #define EOC 0x4000 /* adc not busy */
133 #define TRIG_CONTSTAT 4 /* TRIGGER CONTROL/STATUS register */
134 #define SW_TRIGGER 0x1 /* software start trigger */
135 #define EXT_TRIGGER 0x2 /* external start trigger */
136 #define ANALOG_TRIGGER 0x3 /* external analog trigger */
137 #define TRIGGER_MASK 0x3 /* mask of bits that determine start trigger */
138 #define TGEN 0x10 /* enable external start trigger */
139 #define BURSTE 0x20 /* burst mode enable */
140 #define XTRCL 0x80 /* clear external trigger */
142 #define CALIBRATION_REG 6 /* CALIBRATION register */
143 #define SELECT_8800_BIT 0x100 /* select 8800 caldac */
144 #define SELECT_TRIMPOT_BIT 0x200 /* select ad7376 trim pot */
145 #define SELECT_DAC08_BIT 0x400 /* select dac08 caldac */
146 #define CAL_SRC_BITS(x) (((x) & 0x7) << 11)
147 #define CAL_EN_BIT 0x4000 /* read calibration source instead of analog input channel 0 */
148 #define SERIAL_DATA_IN_BIT 0x8000 /* serial data stream going to 8800 and 7376 */
150 #define DAC_CSR 0x8 /* dac control and status register */
152 DACEN = 0x2, /* dac enable */
153 DAC_MODE_UPDATE_BOTH = 0x80, /* update both dacs when dac0 is written */
155 static inline unsigned int DAC_RANGE(unsigned int channel, unsigned int range)
157 return (range & 0x3) << (8 + 2 * (channel & 0x1));
160 static inline unsigned int DAC_RANGE_MASK(unsigned int channel)
162 return 0x3 << (8 + 2 * (channel & 0x1));
165 /* bits for 1602 series only */
166 enum dac_csr_bits_1602 {
167 DAC_EMPTY = 0x1, /* dac fifo empty, read, write clear */
168 DAC_START = 0x4, /* start/arm dac fifo operations */
169 DAC_PACER_MASK = 0x18, /* bits that set dac pacer source */
170 DAC_PACER_INT = 0x8, /* dac internal pacing */
171 DAC_PACER_EXT_FALL = 0x10, /* dac external pacing, falling edge */
172 DAC_PACER_EXT_RISE = 0x18, /* dac external pacing, rising edge */
174 static inline unsigned int DAC_CHAN_EN(unsigned int channel)
176 return 1 << (5 + (channel & 0x1)); /* enable channel 0 or 1 */
179 /* analog input fifo */
180 #define ADCDATA 0 /* ADC DATA register */
181 #define ADCFIFOCLR 2 /* ADC FIFO CLEAR */
183 /* pacer, counter, dio registers */
188 /* analog output registers for 100x, 1200 series */
189 static inline unsigned int DAC_DATA_REG(unsigned int channel)
191 return 2 * (channel & 0x1);
194 /* analog output registers for 1602 series*/
195 #define DACDATA 0 /* DAC DATA register */
196 #define DACFIFOCLR 2 /* DAC FIFO CLEAR */
198 /* bit in hexadecimal representation of range index that indicates unipolar input range */
199 #define IS_UNIPOLAR 0x4
200 /* analog input ranges for most boards */
201 static const struct comedi_lrange cb_pcidas_ranges = {
215 /* pci-das1001 input ranges */
216 static const struct comedi_lrange cb_pcidas_alt_ranges = {
230 /* analog output ranges */
231 static const struct comedi_lrange cb_pcidas_ao_ranges = {
246 struct cb_pcidas_board {
248 unsigned short device_id;
249 int ai_se_chans; /* Inputs in single-ended mode */
250 int ai_diff_chans; /* Inputs in differential mode */
251 int ai_bits; /* analog input resolution */
252 int ai_speed; /* fastest conversion period in ns */
253 int ao_nchan; /* number of analog out channels */
254 int has_ao_fifo; /* analog output has fifo */
255 int ao_scan_speed; /* analog output speed for 1602 series (for a scan, not conversion) */
256 int fifo_size; /* number of samples fifo can hold */
257 const struct comedi_lrange *ranges;
258 enum trimpot_model trimpot;
259 unsigned has_dac08:1;
262 static const struct cb_pcidas_board cb_pcidas_boards[] = {
264 .name = "pci-das1602/16",
272 .ao_scan_speed = 10000,
274 .ranges = &cb_pcidas_ranges,
279 .name = "pci-das1200",
288 .ranges = &cb_pcidas_ranges,
293 .name = "pci-das1602/12",
301 .ao_scan_speed = 4000,
303 .ranges = &cb_pcidas_ranges,
308 .name = "pci-das1200/jr",
317 .ranges = &cb_pcidas_ranges,
322 .name = "pci-das1602/16/jr",
331 .ranges = &cb_pcidas_ranges,
336 .name = "pci-das1000",
345 .ranges = &cb_pcidas_ranges,
350 .name = "pci-das1001",
359 .ranges = &cb_pcidas_alt_ranges,
364 .name = "pci-das1002",
373 .ranges = &cb_pcidas_ranges,
379 static DEFINE_PCI_DEVICE_TABLE(cb_pcidas_pci_table) = {
381 PCI_VENDOR_ID_CB, 0x0001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
382 PCI_VENDOR_ID_CB, 0x000f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
383 PCI_VENDOR_ID_CB, 0x0010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
384 PCI_VENDOR_ID_CB, 0x0019, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
385 PCI_VENDOR_ID_CB, 0x001c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
386 PCI_VENDOR_ID_CB, 0x004c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
387 PCI_VENDOR_ID_CB, 0x001a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
388 PCI_VENDOR_ID_CB, 0x001b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
392 MODULE_DEVICE_TABLE(pci, cb_pcidas_pci_table);
395 * Useful for shorthand access to the particular board structure
397 #define thisboard ((const struct cb_pcidas_board *)dev->board_ptr)
399 /* this structure is for data unique to this hardware driver. If
400 several hardware drivers keep similar information in this structure,
401 feel free to suggest moving the variable to the struct comedi_device struct. */
402 struct cb_pcidas_private {
403 /* would be useful for a PCI device */
404 struct pci_dev *pci_dev;
406 unsigned long s5933_config;
407 unsigned long control_status;
408 unsigned long adc_fifo;
409 unsigned long pacer_counter_dio;
410 unsigned long ao_registers;
411 /* divisors of master clock for analog input pacing */
412 unsigned int divisor1;
413 unsigned int divisor2;
414 volatile unsigned int count; /* number of analog input samples remaining */
415 volatile unsigned int adc_fifo_bits; /* bits to write to interupt/adcfifo register */
416 volatile unsigned int s5933_intcsr_bits; /* bits to write to amcc s5933 interrupt control/status register */
417 volatile unsigned int ao_control_bits; /* bits to write to ao control and status register */
418 short ai_buffer[AI_BUFFER_SIZE];
419 short ao_buffer[AO_BUFFER_SIZE];
420 /* divisors of master clock for analog output pacing */
421 unsigned int ao_divisor1;
422 unsigned int ao_divisor2;
423 volatile unsigned int ao_count; /* number of analog output samples remaining */
424 int ao_value[2]; /* remember what the analog outputs are set to, to allow readback */
425 unsigned int caldac_value[NUM_CHANNELS_8800]; /* for readback of caldac */
426 unsigned int trimpot_value[NUM_CHANNELS_8402]; /* for readback of trimpot */
427 unsigned int dac08_value;
428 unsigned int calibration_source;
432 * most drivers define the following macro to make it easy to
433 * access the private structure.
435 #define devpriv ((struct cb_pcidas_private *)dev->private)
438 * The struct comedi_driver structure tells the Comedi core module
439 * which functions to call to configure/deconfigure (attach/detach)
440 * the board, and also about the kernel module that contains
443 static int cb_pcidas_attach(struct comedi_device *dev,
444 struct comedi_devconfig *it);
445 static int cb_pcidas_detach(struct comedi_device *dev);
446 static struct comedi_driver driver_cb_pcidas = {
447 .driver_name = "cb_pcidas",
448 .module = THIS_MODULE,
449 .attach = cb_pcidas_attach,
450 .detach = cb_pcidas_detach,
453 static int cb_pcidas_ai_rinsn(struct comedi_device *dev,
454 struct comedi_subdevice *s,
455 struct comedi_insn *insn, unsigned int *data);
456 static int ai_config_insn(struct comedi_device *dev, struct comedi_subdevice *s,
457 struct comedi_insn *insn, unsigned int *data);
458 static int cb_pcidas_ao_nofifo_winsn(struct comedi_device *dev,
459 struct comedi_subdevice *s,
460 struct comedi_insn *insn,
462 static int cb_pcidas_ao_fifo_winsn(struct comedi_device *dev,
463 struct comedi_subdevice *s,
464 struct comedi_insn *insn,
466 static int cb_pcidas_ao_readback_insn(struct comedi_device *dev,
467 struct comedi_subdevice *s,
468 struct comedi_insn *insn,
470 static int cb_pcidas_ai_cmd(struct comedi_device *dev,
471 struct comedi_subdevice *s);
472 static int cb_pcidas_ai_cmdtest(struct comedi_device *dev,
473 struct comedi_subdevice *s,
474 struct comedi_cmd *cmd);
475 static int cb_pcidas_ao_cmd(struct comedi_device *dev,
476 struct comedi_subdevice *s);
477 static int cb_pcidas_ao_inttrig(struct comedi_device *dev,
478 struct comedi_subdevice *subdev,
479 unsigned int trig_num);
480 static int cb_pcidas_ao_cmdtest(struct comedi_device *dev,
481 struct comedi_subdevice *s,
482 struct comedi_cmd *cmd);
483 static irqreturn_t cb_pcidas_interrupt(int irq, void *d);
484 static void handle_ao_interrupt(struct comedi_device *dev, unsigned int status);
485 static int cb_pcidas_cancel(struct comedi_device *dev,
486 struct comedi_subdevice *s);
487 static int cb_pcidas_ao_cancel(struct comedi_device *dev,
488 struct comedi_subdevice *s);
489 static void cb_pcidas_load_counters(struct comedi_device *dev, unsigned int *ns,
491 static int eeprom_read_insn(struct comedi_device *dev,
492 struct comedi_subdevice *s,
493 struct comedi_insn *insn, unsigned int *data);
494 static int caldac_read_insn(struct comedi_device *dev,
495 struct comedi_subdevice *s,
496 struct comedi_insn *insn, unsigned int *data);
497 static int caldac_write_insn(struct comedi_device *dev,
498 struct comedi_subdevice *s,
499 struct comedi_insn *insn, unsigned int *data);
500 static int trimpot_read_insn(struct comedi_device *dev,
501 struct comedi_subdevice *s,
502 struct comedi_insn *insn, unsigned int *data);
503 static int cb_pcidas_trimpot_write(struct comedi_device *dev,
504 unsigned int channel, unsigned int value);
505 static int trimpot_write_insn(struct comedi_device *dev,
506 struct comedi_subdevice *s,
507 struct comedi_insn *insn, unsigned int *data);
508 static int dac08_read_insn(struct comedi_device *dev,
509 struct comedi_subdevice *s, struct comedi_insn *insn,
511 static int dac08_write(struct comedi_device *dev, unsigned int value);
512 static int dac08_write_insn(struct comedi_device *dev,
513 struct comedi_subdevice *s,
514 struct comedi_insn *insn, unsigned int *data);
515 static int caldac_8800_write(struct comedi_device *dev, unsigned int address,
517 static int trimpot_7376_write(struct comedi_device *dev, uint8_t value);
518 static int trimpot_8402_write(struct comedi_device *dev, unsigned int channel,
520 static int nvram_read(struct comedi_device *dev, unsigned int address,
523 static inline unsigned int cal_enable_bits(struct comedi_device *dev)
525 return CAL_EN_BIT | CAL_SRC_BITS(devpriv->calibration_source);
529 * Attach is called by the Comedi core to configure the driver
530 * for a particular board.
532 static int cb_pcidas_attach(struct comedi_device *dev,
533 struct comedi_devconfig *it)
535 struct comedi_subdevice *s;
536 struct pci_dev *pcidev = NULL;
540 printk("comedi%d: cb_pcidas: ", dev->minor);
543 * Allocate the private structure area.
545 if (alloc_private(dev, sizeof(struct cb_pcidas_private)) < 0)
549 * Probe the device to determine what device in the series it is.
553 for_each_pci_dev(pcidev) {
554 /* is it not a computer boards card? */
555 if (pcidev->vendor != PCI_VENDOR_ID_CB)
557 /* loop through cards supported by this driver */
558 for (index = 0; index < ARRAY_SIZE(cb_pcidas_boards); index++) {
559 if (cb_pcidas_boards[index].device_id != pcidev->device)
561 /* was a particular bus/slot requested? */
562 if (it->options[0] || it->options[1]) {
563 /* are we on the wrong bus/slot? */
564 if (pcidev->bus->number != it->options[0] ||
565 PCI_SLOT(pcidev->devfn) != it->options[1]) {
569 devpriv->pci_dev = pcidev;
570 dev->board_ptr = cb_pcidas_boards + index;
575 printk("No supported ComputerBoards/MeasurementComputing card found on "
576 "requested position\n");
581 printk("Found %s on bus %i, slot %i\n", cb_pcidas_boards[index].name,
582 pcidev->bus->number, PCI_SLOT(pcidev->devfn));
585 * Enable PCI device and reserve I/O ports.
587 if (comedi_pci_enable(pcidev, "cb_pcidas")) {
588 printk(" Failed to enable PCI device and request regions\n");
592 * Initialize devpriv->control_status and devpriv->adc_fifo to point to
593 * their base address.
595 devpriv->s5933_config =
596 pci_resource_start(devpriv->pci_dev, S5933_BADRINDEX);
597 devpriv->control_status =
598 pci_resource_start(devpriv->pci_dev, CONT_STAT_BADRINDEX);
600 pci_resource_start(devpriv->pci_dev, ADC_FIFO_BADRINDEX);
601 devpriv->pacer_counter_dio =
602 pci_resource_start(devpriv->pci_dev, PACER_BADRINDEX);
603 if (thisboard->ao_nchan) {
604 devpriv->ao_registers =
605 pci_resource_start(devpriv->pci_dev, AO_BADRINDEX);
607 /* disable and clear interrupts on amcc s5933 */
608 outl(INTCSR_INBOX_INTR_STATUS,
609 devpriv->s5933_config + AMCC_OP_REG_INTCSR);
612 if (request_irq(devpriv->pci_dev->irq, cb_pcidas_interrupt,
613 IRQF_SHARED, "cb_pcidas", dev)) {
614 printk(" unable to allocate irq %d\n", devpriv->pci_dev->irq);
617 dev->irq = devpriv->pci_dev->irq;
619 /* Initialize dev->board_name */
620 dev->board_name = thisboard->name;
623 * Allocate the subdevice structures.
625 if (alloc_subdevices(dev, 7) < 0)
628 s = dev->subdevices + 0;
629 /* analog input subdevice */
630 dev->read_subdev = s;
631 s->type = COMEDI_SUBD_AI;
632 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
633 /* WARNING: Number of inputs in differential mode is ignored */
634 s->n_chan = thisboard->ai_se_chans;
635 s->len_chanlist = thisboard->ai_se_chans;
636 s->maxdata = (1 << thisboard->ai_bits) - 1;
637 s->range_table = thisboard->ranges;
638 s->insn_read = cb_pcidas_ai_rinsn;
639 s->insn_config = ai_config_insn;
640 s->do_cmd = cb_pcidas_ai_cmd;
641 s->do_cmdtest = cb_pcidas_ai_cmdtest;
642 s->cancel = cb_pcidas_cancel;
644 /* analog output subdevice */
645 s = dev->subdevices + 1;
646 if (thisboard->ao_nchan) {
647 s->type = COMEDI_SUBD_AO;
648 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_GROUND;
649 s->n_chan = thisboard->ao_nchan;
650 /* analog out resolution is the same as analog input resolution, so use ai_bits */
651 s->maxdata = (1 << thisboard->ai_bits) - 1;
652 s->range_table = &cb_pcidas_ao_ranges;
653 s->insn_read = cb_pcidas_ao_readback_insn;
654 if (thisboard->has_ao_fifo) {
655 dev->write_subdev = s;
656 s->subdev_flags |= SDF_CMD_WRITE;
657 s->insn_write = cb_pcidas_ao_fifo_winsn;
658 s->do_cmdtest = cb_pcidas_ao_cmdtest;
659 s->do_cmd = cb_pcidas_ao_cmd;
660 s->cancel = cb_pcidas_ao_cancel;
662 s->insn_write = cb_pcidas_ao_nofifo_winsn;
665 s->type = COMEDI_SUBD_UNUSED;
669 s = dev->subdevices + 2;
670 subdev_8255_init(dev, s, NULL, devpriv->pacer_counter_dio + DIO_8255);
673 s = dev->subdevices + 3;
674 s->type = COMEDI_SUBD_MEMORY;
675 s->subdev_flags = SDF_READABLE | SDF_INTERNAL;
678 s->insn_read = eeprom_read_insn;
681 s = dev->subdevices + 4;
682 s->type = COMEDI_SUBD_CALIB;
683 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_INTERNAL;
684 s->n_chan = NUM_CHANNELS_8800;
686 s->insn_read = caldac_read_insn;
687 s->insn_write = caldac_write_insn;
688 for (i = 0; i < s->n_chan; i++)
689 caldac_8800_write(dev, i, s->maxdata / 2);
691 /* trim potentiometer */
692 s = dev->subdevices + 5;
693 s->type = COMEDI_SUBD_CALIB;
694 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_INTERNAL;
695 if (thisboard->trimpot == AD7376) {
696 s->n_chan = NUM_CHANNELS_7376;
699 s->n_chan = NUM_CHANNELS_8402;
702 s->insn_read = trimpot_read_insn;
703 s->insn_write = trimpot_write_insn;
704 for (i = 0; i < s->n_chan; i++)
705 cb_pcidas_trimpot_write(dev, i, s->maxdata / 2);
708 s = dev->subdevices + 6;
709 if (thisboard->has_dac08) {
710 s->type = COMEDI_SUBD_CALIB;
711 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_INTERNAL;
712 s->n_chan = NUM_CHANNELS_DAC08;
713 s->insn_read = dac08_read_insn;
714 s->insn_write = dac08_write_insn;
716 dac08_write(dev, s->maxdata / 2);
718 s->type = COMEDI_SUBD_UNUSED;
720 /* make sure mailbox 4 is empty */
721 inl(devpriv->s5933_config + AMCC_OP_REG_IMB4);
722 /* Set bits to enable incoming mailbox interrupts on amcc s5933. */
723 devpriv->s5933_intcsr_bits =
724 INTCSR_INBOX_BYTE(3) | INTCSR_INBOX_SELECT(3) |
725 INTCSR_INBOX_FULL_INT;
726 /* clear and enable interrupt on amcc s5933 */
727 outl(devpriv->s5933_intcsr_bits | INTCSR_INBOX_INTR_STATUS,
728 devpriv->s5933_config + AMCC_OP_REG_INTCSR);
734 * cb_pcidas_detach is called to deconfigure a device. It should deallocate
736 * This function is also called when _attach() fails, so it should be
737 * careful not to release resources that were not necessarily
738 * allocated by _attach(). dev->private and dev->subdevices are
739 * deallocated automatically by the core.
741 static int cb_pcidas_detach(struct comedi_device *dev)
743 printk("comedi%d: cb_pcidas: remove\n", dev->minor);
746 if (devpriv->s5933_config) {
747 /* disable and clear interrupts on amcc s5933 */
748 outl(INTCSR_INBOX_INTR_STATUS,
749 devpriv->s5933_config + AMCC_OP_REG_INTCSR);
750 #ifdef CB_PCIDAS_DEBUG
751 printk("detaching, incsr is 0x%x\n",
752 inl(devpriv->s5933_config + AMCC_OP_REG_INTCSR));
757 free_irq(dev->irq, dev);
759 subdev_8255_cleanup(dev, dev->subdevices + 2);
760 if (devpriv && devpriv->pci_dev) {
761 if (devpriv->s5933_config)
762 comedi_pci_disable(devpriv->pci_dev);
763 pci_dev_put(devpriv->pci_dev);
770 * "instructions" read/write data in "one-shot" or "software-triggered"
773 static int cb_pcidas_ai_rinsn(struct comedi_device *dev,
774 struct comedi_subdevice *s,
775 struct comedi_insn *insn, unsigned int *data)
779 static const int timeout = 10000;
781 /* enable calibration input if appropriate */
782 if (insn->chanspec & CR_ALT_SOURCE) {
783 outw(cal_enable_bits(dev),
784 devpriv->control_status + CALIBRATION_REG);
787 outw(0, devpriv->control_status + CALIBRATION_REG);
788 channel = CR_CHAN(insn->chanspec);
790 /* set mux limits and gain */
791 bits = BEGIN_SCAN(channel) |
792 END_SCAN(channel) | GAIN_BITS(CR_RANGE(insn->chanspec));
793 /* set unipolar/bipolar */
794 if (CR_RANGE(insn->chanspec) & IS_UNIPOLAR)
796 /* set singleended/differential */
797 if (CR_AREF(insn->chanspec) != AREF_DIFF)
799 outw(bits, devpriv->control_status + ADCMUX_CONT);
802 outw(0, devpriv->adc_fifo + ADCFIFOCLR);
804 /* convert n samples */
805 for (n = 0; n < insn->n; n++) {
806 /* trigger conversion */
807 outw(0, devpriv->adc_fifo + ADCDATA);
809 /* wait for conversion to end */
810 /* return -ETIMEDOUT if there is a timeout */
811 for (i = 0; i < timeout; i++) {
812 if (inw(devpriv->control_status + ADCMUX_CONT) & EOC)
819 data[n] = inw(devpriv->adc_fifo + ADCDATA);
822 /* return the number of samples read/written */
826 static int ai_config_calibration_source(struct comedi_device *dev,
829 static const int num_calibration_sources = 8;
830 unsigned int source = data[1];
832 if (source >= num_calibration_sources) {
833 printk("invalid calibration source: %i\n", source);
837 devpriv->calibration_source = source;
842 static int ai_config_insn(struct comedi_device *dev, struct comedi_subdevice *s,
843 struct comedi_insn *insn, unsigned int *data)
848 case INSN_CONFIG_ALT_SOURCE:
849 return ai_config_calibration_source(dev, data);
858 /* analog output insn for pcidas-1000 and 1200 series */
859 static int cb_pcidas_ao_nofifo_winsn(struct comedi_device *dev,
860 struct comedi_subdevice *s,
861 struct comedi_insn *insn,
867 /* set channel and range */
868 channel = CR_CHAN(insn->chanspec);
869 spin_lock_irqsave(&dev->spinlock, flags);
870 devpriv->ao_control_bits &=
871 ~DAC_MODE_UPDATE_BOTH & ~DAC_RANGE_MASK(channel);
872 devpriv->ao_control_bits |=
873 DACEN | DAC_RANGE(channel, CR_RANGE(insn->chanspec));
874 outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
875 spin_unlock_irqrestore(&dev->spinlock, flags);
877 /* remember value for readback */
878 devpriv->ao_value[channel] = data[0];
880 outw(data[0], devpriv->ao_registers + DAC_DATA_REG(channel));
885 /* analog output insn for pcidas-1602 series */
886 static int cb_pcidas_ao_fifo_winsn(struct comedi_device *dev,
887 struct comedi_subdevice *s,
888 struct comedi_insn *insn, unsigned int *data)
894 outw(0, devpriv->ao_registers + DACFIFOCLR);
896 /* set channel and range */
897 channel = CR_CHAN(insn->chanspec);
898 spin_lock_irqsave(&dev->spinlock, flags);
899 devpriv->ao_control_bits &=
900 ~DAC_CHAN_EN(0) & ~DAC_CHAN_EN(1) & ~DAC_RANGE_MASK(channel) &
902 devpriv->ao_control_bits |=
903 DACEN | DAC_RANGE(channel,
905 chanspec)) | DAC_CHAN_EN(channel) |
907 outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
908 spin_unlock_irqrestore(&dev->spinlock, flags);
910 /* remember value for readback */
911 devpriv->ao_value[channel] = data[0];
913 outw(data[0], devpriv->ao_registers + DACDATA);
918 /* analog output readback insn */
919 /* XXX loses track of analog output value back after an analog ouput command is executed */
920 static int cb_pcidas_ao_readback_insn(struct comedi_device *dev,
921 struct comedi_subdevice *s,
922 struct comedi_insn *insn,
925 data[0] = devpriv->ao_value[CR_CHAN(insn->chanspec)];
930 static int eeprom_read_insn(struct comedi_device *dev,
931 struct comedi_subdevice *s,
932 struct comedi_insn *insn, unsigned int *data)
937 retval = nvram_read(dev, CR_CHAN(insn->chanspec), &nvram_data);
941 data[0] = nvram_data;
946 static int caldac_write_insn(struct comedi_device *dev,
947 struct comedi_subdevice *s,
948 struct comedi_insn *insn, unsigned int *data)
950 const unsigned int channel = CR_CHAN(insn->chanspec);
952 return caldac_8800_write(dev, channel, data[0]);
955 static int caldac_read_insn(struct comedi_device *dev,
956 struct comedi_subdevice *s,
957 struct comedi_insn *insn, unsigned int *data)
959 data[0] = devpriv->caldac_value[CR_CHAN(insn->chanspec)];
964 /* 1602/16 pregain offset */
965 static int dac08_write(struct comedi_device *dev, unsigned int value)
967 if (devpriv->dac08_value == value)
970 devpriv->dac08_value = value;
972 outw(cal_enable_bits(dev) | (value & 0xff),
973 devpriv->control_status + CALIBRATION_REG);
975 outw(cal_enable_bits(dev) | SELECT_DAC08_BIT | (value & 0xff),
976 devpriv->control_status + CALIBRATION_REG);
978 outw(cal_enable_bits(dev) | (value & 0xff),
979 devpriv->control_status + CALIBRATION_REG);
985 static int dac08_write_insn(struct comedi_device *dev,
986 struct comedi_subdevice *s,
987 struct comedi_insn *insn, unsigned int *data)
989 return dac08_write(dev, data[0]);
992 static int dac08_read_insn(struct comedi_device *dev,
993 struct comedi_subdevice *s, struct comedi_insn *insn,
996 data[0] = devpriv->dac08_value;
1001 static int cb_pcidas_trimpot_write(struct comedi_device *dev,
1002 unsigned int channel, unsigned int value)
1004 if (devpriv->trimpot_value[channel] == value)
1007 devpriv->trimpot_value[channel] = value;
1008 switch (thisboard->trimpot) {
1010 trimpot_7376_write(dev, value);
1013 trimpot_8402_write(dev, channel, value);
1016 comedi_error(dev, "driver bug?");
1024 static int trimpot_write_insn(struct comedi_device *dev,
1025 struct comedi_subdevice *s,
1026 struct comedi_insn *insn, unsigned int *data)
1028 unsigned int channel = CR_CHAN(insn->chanspec);
1030 return cb_pcidas_trimpot_write(dev, channel, data[0]);
1033 static int trimpot_read_insn(struct comedi_device *dev,
1034 struct comedi_subdevice *s,
1035 struct comedi_insn *insn, unsigned int *data)
1037 unsigned int channel = CR_CHAN(insn->chanspec);
1039 data[0] = devpriv->trimpot_value[channel];
1044 static int cb_pcidas_ai_cmdtest(struct comedi_device *dev,
1045 struct comedi_subdevice *s,
1046 struct comedi_cmd *cmd)
1050 int i, gain, start_chan;
1052 /* cmdtest tests a particular command to see if it is valid.
1053 * Using the cmdtest ioctl, a user can create a valid cmd
1054 * and then have it executes by the cmd ioctl.
1056 * cmdtest returns 1,2,3,4 or 0, depending on which tests
1057 * the command passes. */
1059 /* step 1: make sure trigger sources are trivially valid */
1061 tmp = cmd->start_src;
1062 cmd->start_src &= TRIG_NOW | TRIG_EXT;
1063 if (!cmd->start_src || tmp != cmd->start_src)
1066 tmp = cmd->scan_begin_src;
1067 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT;
1068 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
1071 tmp = cmd->convert_src;
1072 cmd->convert_src &= TRIG_TIMER | TRIG_NOW | TRIG_EXT;
1073 if (!cmd->convert_src || tmp != cmd->convert_src)
1076 tmp = cmd->scan_end_src;
1077 cmd->scan_end_src &= TRIG_COUNT;
1078 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1081 tmp = cmd->stop_src;
1082 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1083 if (!cmd->stop_src || tmp != cmd->stop_src)
1089 /* step 2: make sure trigger sources are unique and mutually compatible */
1091 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT)
1093 if (cmd->scan_begin_src != TRIG_FOLLOW &&
1094 cmd->scan_begin_src != TRIG_TIMER &&
1095 cmd->scan_begin_src != TRIG_EXT)
1097 if (cmd->convert_src != TRIG_TIMER &&
1098 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
1100 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1103 /* make sure trigger sources are compatible with each other */
1104 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
1106 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
1108 if (cmd->start_src == TRIG_EXT &&
1109 (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT))
1115 /* step 3: make sure arguments are trivially compatible */
1117 if (cmd->start_arg != 0) {
1122 if (cmd->scan_begin_src == TRIG_TIMER) {
1123 if (cmd->scan_begin_arg <
1124 thisboard->ai_speed * cmd->chanlist_len) {
1125 cmd->scan_begin_arg =
1126 thisboard->ai_speed * cmd->chanlist_len;
1130 if (cmd->convert_src == TRIG_TIMER) {
1131 if (cmd->convert_arg < thisboard->ai_speed) {
1132 cmd->convert_arg = thisboard->ai_speed;
1137 if (cmd->scan_end_arg != cmd->chanlist_len) {
1138 cmd->scan_end_arg = cmd->chanlist_len;
1141 if (cmd->stop_src == TRIG_NONE) {
1143 if (cmd->stop_arg != 0) {
1152 /* step 4: fix up any arguments */
1154 if (cmd->scan_begin_src == TRIG_TIMER) {
1155 tmp = cmd->scan_begin_arg;
1156 i8253_cascade_ns_to_timer_2div(TIMER_BASE,
1157 &(devpriv->divisor1),
1158 &(devpriv->divisor2),
1159 &(cmd->scan_begin_arg),
1160 cmd->flags & TRIG_ROUND_MASK);
1161 if (tmp != cmd->scan_begin_arg)
1164 if (cmd->convert_src == TRIG_TIMER) {
1165 tmp = cmd->convert_arg;
1166 i8253_cascade_ns_to_timer_2div(TIMER_BASE,
1167 &(devpriv->divisor1),
1168 &(devpriv->divisor2),
1169 &(cmd->convert_arg),
1170 cmd->flags & TRIG_ROUND_MASK);
1171 if (tmp != cmd->convert_arg)
1178 /* check channel/gain list against card's limitations */
1179 if (cmd->chanlist) {
1180 gain = CR_RANGE(cmd->chanlist[0]);
1181 start_chan = CR_CHAN(cmd->chanlist[0]);
1182 for (i = 1; i < cmd->chanlist_len; i++) {
1183 if (CR_CHAN(cmd->chanlist[i]) !=
1184 (start_chan + i) % s->n_chan) {
1186 "entries in chanlist must be consecutive channels, counting upwards\n");
1189 if (CR_RANGE(cmd->chanlist[i]) != gain) {
1191 "entries in chanlist must all have the same gain\n");
1203 static int cb_pcidas_ai_cmd(struct comedi_device *dev,
1204 struct comedi_subdevice *s)
1206 struct comedi_async *async = s->async;
1207 struct comedi_cmd *cmd = &async->cmd;
1209 unsigned long flags;
1211 /* make sure CAL_EN_BIT is disabled */
1212 outw(0, devpriv->control_status + CALIBRATION_REG);
1213 /* initialize before settings pacer source and count values */
1214 outw(0, devpriv->control_status + TRIG_CONTSTAT);
1216 outw(0, devpriv->adc_fifo + ADCFIFOCLR);
1218 /* set mux limits, gain and pacer source */
1219 bits = BEGIN_SCAN(CR_CHAN(cmd->chanlist[0])) |
1220 END_SCAN(CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1])) |
1221 GAIN_BITS(CR_RANGE(cmd->chanlist[0]));
1222 /* set unipolar/bipolar */
1223 if (CR_RANGE(cmd->chanlist[0]) & IS_UNIPOLAR)
1225 /* set singleended/differential */
1226 if (CR_AREF(cmd->chanlist[0]) != AREF_DIFF)
1228 /* set pacer source */
1229 if (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT)
1230 bits |= PACER_EXT_RISE;
1233 outw(bits, devpriv->control_status + ADCMUX_CONT);
1235 #ifdef CB_PCIDAS_DEBUG
1236 printk("comedi: sent 0x%x to adcmux control\n", bits);
1240 if (cmd->convert_src == TRIG_TIMER)
1241 cb_pcidas_load_counters(dev, &cmd->convert_arg,
1242 cmd->flags & TRIG_ROUND_MASK);
1243 else if (cmd->scan_begin_src == TRIG_TIMER)
1244 cb_pcidas_load_counters(dev, &cmd->scan_begin_arg,
1245 cmd->flags & TRIG_ROUND_MASK);
1247 /* set number of conversions */
1248 if (cmd->stop_src == TRIG_COUNT)
1249 devpriv->count = cmd->chanlist_len * cmd->stop_arg;
1250 /* enable interrupts */
1251 spin_lock_irqsave(&dev->spinlock, flags);
1252 devpriv->adc_fifo_bits |= INTE;
1253 devpriv->adc_fifo_bits &= ~INT_MASK;
1254 if (cmd->flags & TRIG_WAKE_EOS) {
1255 if (cmd->convert_src == TRIG_NOW && cmd->chanlist_len > 1)
1256 devpriv->adc_fifo_bits |= INT_EOS; /* interrupt end of burst */
1258 devpriv->adc_fifo_bits |= INT_FNE; /* interrupt fifo not empty */
1260 devpriv->adc_fifo_bits |= INT_FHF; /* interrupt fifo half full */
1262 #ifdef CB_PCIDAS_DEBUG
1263 printk("comedi: adc_fifo_bits are 0x%x\n", devpriv->adc_fifo_bits);
1265 /* enable (and clear) interrupts */
1266 outw(devpriv->adc_fifo_bits | EOAI | INT | LADFUL,
1267 devpriv->control_status + INT_ADCFIFO);
1268 spin_unlock_irqrestore(&dev->spinlock, flags);
1270 /* set start trigger and burst mode */
1272 if (cmd->start_src == TRIG_NOW)
1274 else if (cmd->start_src == TRIG_EXT)
1275 bits |= EXT_TRIGGER | TGEN | XTRCL;
1277 comedi_error(dev, "bug!");
1280 if (cmd->convert_src == TRIG_NOW && cmd->chanlist_len > 1)
1282 outw(bits, devpriv->control_status + TRIG_CONTSTAT);
1283 #ifdef CB_PCIDAS_DEBUG
1284 printk("comedi: sent 0x%x to trig control\n", bits);
1290 static int cb_pcidas_ao_cmdtest(struct comedi_device *dev,
1291 struct comedi_subdevice *s,
1292 struct comedi_cmd *cmd)
1297 /* cmdtest tests a particular command to see if it is valid.
1298 * Using the cmdtest ioctl, a user can create a valid cmd
1299 * and then have it executes by the cmd ioctl.
1301 * cmdtest returns 1,2,3,4 or 0, depending on which tests
1302 * the command passes. */
1304 /* step 1: make sure trigger sources are trivially valid */
1306 tmp = cmd->start_src;
1307 cmd->start_src &= TRIG_INT;
1308 if (!cmd->start_src || tmp != cmd->start_src)
1311 tmp = cmd->scan_begin_src;
1312 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
1313 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
1316 tmp = cmd->convert_src;
1317 cmd->convert_src &= TRIG_NOW;
1318 if (!cmd->convert_src || tmp != cmd->convert_src)
1321 tmp = cmd->scan_end_src;
1322 cmd->scan_end_src &= TRIG_COUNT;
1323 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1326 tmp = cmd->stop_src;
1327 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1328 if (!cmd->stop_src || tmp != cmd->stop_src)
1334 /* step 2: make sure trigger sources are unique and mutually compatible */
1336 if (cmd->scan_begin_src != TRIG_TIMER &&
1337 cmd->scan_begin_src != TRIG_EXT)
1339 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1345 /* step 3: make sure arguments are trivially compatible */
1347 if (cmd->start_arg != 0) {
1352 if (cmd->scan_begin_src == TRIG_TIMER) {
1353 if (cmd->scan_begin_arg < thisboard->ao_scan_speed) {
1354 cmd->scan_begin_arg = thisboard->ao_scan_speed;
1359 if (cmd->scan_end_arg != cmd->chanlist_len) {
1360 cmd->scan_end_arg = cmd->chanlist_len;
1363 if (cmd->stop_src == TRIG_NONE) {
1365 if (cmd->stop_arg != 0) {
1374 /* step 4: fix up any arguments */
1376 if (cmd->scan_begin_src == TRIG_TIMER) {
1377 tmp = cmd->scan_begin_arg;
1378 i8253_cascade_ns_to_timer_2div(TIMER_BASE,
1379 &(devpriv->ao_divisor1),
1380 &(devpriv->ao_divisor2),
1381 &(cmd->scan_begin_arg),
1382 cmd->flags & TRIG_ROUND_MASK);
1383 if (tmp != cmd->scan_begin_arg)
1390 /* check channel/gain list against card's limitations */
1391 if (cmd->chanlist && cmd->chanlist_len > 1) {
1392 if (CR_CHAN(cmd->chanlist[0]) != 0 ||
1393 CR_CHAN(cmd->chanlist[1]) != 1) {
1395 "channels must be ordered channel 0, channel 1 in chanlist\n");
1406 static int cb_pcidas_ao_cmd(struct comedi_device *dev,
1407 struct comedi_subdevice *s)
1409 struct comedi_async *async = s->async;
1410 struct comedi_cmd *cmd = &async->cmd;
1412 unsigned long flags;
1414 /* set channel limits, gain */
1415 spin_lock_irqsave(&dev->spinlock, flags);
1416 for (i = 0; i < cmd->chanlist_len; i++) {
1417 /* enable channel */
1418 devpriv->ao_control_bits |=
1419 DAC_CHAN_EN(CR_CHAN(cmd->chanlist[i]));
1421 devpriv->ao_control_bits |= DAC_RANGE(CR_CHAN(cmd->chanlist[i]),
1426 /* disable analog out before settings pacer source and count values */
1427 outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
1428 spin_unlock_irqrestore(&dev->spinlock, flags);
1431 outw(0, devpriv->ao_registers + DACFIFOCLR);
1434 if (cmd->scan_begin_src == TRIG_TIMER) {
1435 i8253_cascade_ns_to_timer_2div(TIMER_BASE,
1436 &(devpriv->ao_divisor1),
1437 &(devpriv->ao_divisor2),
1438 &(cmd->scan_begin_arg),
1441 /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
1442 i8254_load(devpriv->pacer_counter_dio + DAC8254, 0, 1,
1443 devpriv->ao_divisor1, 2);
1444 i8254_load(devpriv->pacer_counter_dio + DAC8254, 0, 2,
1445 devpriv->ao_divisor2, 2);
1447 /* set number of conversions */
1448 if (cmd->stop_src == TRIG_COUNT)
1449 devpriv->ao_count = cmd->chanlist_len * cmd->stop_arg;
1450 /* set pacer source */
1451 spin_lock_irqsave(&dev->spinlock, flags);
1452 switch (cmd->scan_begin_src) {
1454 devpriv->ao_control_bits |= DAC_PACER_INT;
1457 devpriv->ao_control_bits |= DAC_PACER_EXT_RISE;
1460 spin_unlock_irqrestore(&dev->spinlock, flags);
1461 comedi_error(dev, "error setting dac pacer source");
1465 spin_unlock_irqrestore(&dev->spinlock, flags);
1467 async->inttrig = cb_pcidas_ao_inttrig;
1472 static int cb_pcidas_ao_inttrig(struct comedi_device *dev,
1473 struct comedi_subdevice *s,
1474 unsigned int trig_num)
1476 unsigned int num_bytes, num_points = thisboard->fifo_size;
1477 struct comedi_async *async = s->async;
1478 struct comedi_cmd *cmd = &s->async->cmd;
1479 unsigned long flags;
1485 if (cmd->stop_src == TRIG_COUNT && devpriv->ao_count < num_points)
1486 num_points = devpriv->ao_count;
1488 num_bytes = cfc_read_array_from_buffer(s, devpriv->ao_buffer,
1489 num_points * sizeof(short));
1490 num_points = num_bytes / sizeof(short);
1492 if (cmd->stop_src == TRIG_COUNT)
1493 devpriv->ao_count -= num_points;
1494 /* write data to board's fifo */
1495 outsw(devpriv->ao_registers + DACDATA, devpriv->ao_buffer, num_bytes);
1497 /* enable dac half-full and empty interrupts */
1498 spin_lock_irqsave(&dev->spinlock, flags);
1499 devpriv->adc_fifo_bits |= DAEMIE | DAHFIE;
1500 #ifdef CB_PCIDAS_DEBUG
1501 printk("comedi: adc_fifo_bits are 0x%x\n", devpriv->adc_fifo_bits);
1503 /* enable and clear interrupts */
1504 outw(devpriv->adc_fifo_bits | DAEMI | DAHFI,
1505 devpriv->control_status + INT_ADCFIFO);
1508 devpriv->ao_control_bits |= DAC_START | DACEN | DAC_EMPTY;
1509 outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
1510 #ifdef CB_PCIDAS_DEBUG
1511 printk("comedi: sent 0x%x to dac control\n", devpriv->ao_control_bits);
1513 spin_unlock_irqrestore(&dev->spinlock, flags);
1515 async->inttrig = NULL;
1520 static irqreturn_t cb_pcidas_interrupt(int irq, void *d)
1522 struct comedi_device *dev = (struct comedi_device *)d;
1523 struct comedi_subdevice *s = dev->read_subdev;
1524 struct comedi_async *async;
1525 int status, s5933_status;
1526 int half_fifo = thisboard->fifo_size / 2;
1527 unsigned int num_samples, i;
1528 static const int timeout = 10000;
1529 unsigned long flags;
1531 if (dev->attached == 0)
1537 s5933_status = inl(devpriv->s5933_config + AMCC_OP_REG_INTCSR);
1538 #ifdef CB_PCIDAS_DEBUG
1539 printk("intcsr 0x%x\n", s5933_status);
1540 printk("mbef 0x%x\n", inl(devpriv->s5933_config + AMCC_OP_REG_MBEF));
1543 if ((INTCSR_INTR_ASSERTED & s5933_status) == 0)
1546 /* make sure mailbox 4 is empty */
1547 inl_p(devpriv->s5933_config + AMCC_OP_REG_IMB4);
1548 /* clear interrupt on amcc s5933 */
1549 outl(devpriv->s5933_intcsr_bits | INTCSR_INBOX_INTR_STATUS,
1550 devpriv->s5933_config + AMCC_OP_REG_INTCSR);
1552 status = inw(devpriv->control_status + INT_ADCFIFO);
1553 #ifdef CB_PCIDAS_DEBUG
1554 if ((status & (INT | EOAI | LADFUL | DAHFI | DAEMI)) == 0)
1555 comedi_error(dev, "spurious interrupt");
1558 /* check for analog output interrupt */
1559 if (status & (DAHFI | DAEMI))
1560 handle_ao_interrupt(dev, status);
1561 /* check for analog input interrupts */
1562 /* if fifo half-full */
1563 if (status & ADHFI) {
1565 num_samples = half_fifo;
1566 if (async->cmd.stop_src == TRIG_COUNT &&
1567 num_samples > devpriv->count) {
1568 num_samples = devpriv->count;
1570 insw(devpriv->adc_fifo + ADCDATA, devpriv->ai_buffer,
1572 cfc_write_array_to_buffer(s, devpriv->ai_buffer,
1573 num_samples * sizeof(short));
1574 devpriv->count -= num_samples;
1575 if (async->cmd.stop_src == TRIG_COUNT && devpriv->count == 0) {
1576 async->events |= COMEDI_CB_EOA;
1577 cb_pcidas_cancel(dev, s);
1579 /* clear half-full interrupt latch */
1580 spin_lock_irqsave(&dev->spinlock, flags);
1581 outw(devpriv->adc_fifo_bits | INT,
1582 devpriv->control_status + INT_ADCFIFO);
1583 spin_unlock_irqrestore(&dev->spinlock, flags);
1584 /* else if fifo not empty */
1585 } else if (status & (ADNEI | EOBI)) {
1586 for (i = 0; i < timeout; i++) {
1587 /* break if fifo is empty */
1588 if ((ADNE & inw(devpriv->control_status +
1591 cfc_write_to_buffer(s, inw(devpriv->adc_fifo));
1592 if (async->cmd.stop_src == TRIG_COUNT && --devpriv->count == 0) { /* end of acquisition */
1593 cb_pcidas_cancel(dev, s);
1594 async->events |= COMEDI_CB_EOA;
1598 /* clear not-empty interrupt latch */
1599 spin_lock_irqsave(&dev->spinlock, flags);
1600 outw(devpriv->adc_fifo_bits | INT,
1601 devpriv->control_status + INT_ADCFIFO);
1602 spin_unlock_irqrestore(&dev->spinlock, flags);
1603 } else if (status & EOAI) {
1605 "bug! encountered end of aquisition interrupt?");
1606 /* clear EOA interrupt latch */
1607 spin_lock_irqsave(&dev->spinlock, flags);
1608 outw(devpriv->adc_fifo_bits | EOAI,
1609 devpriv->control_status + INT_ADCFIFO);
1610 spin_unlock_irqrestore(&dev->spinlock, flags);
1612 /* check for fifo overflow */
1613 if (status & LADFUL) {
1614 comedi_error(dev, "fifo overflow");
1615 /* clear overflow interrupt latch */
1616 spin_lock_irqsave(&dev->spinlock, flags);
1617 outw(devpriv->adc_fifo_bits | LADFUL,
1618 devpriv->control_status + INT_ADCFIFO);
1619 spin_unlock_irqrestore(&dev->spinlock, flags);
1620 cb_pcidas_cancel(dev, s);
1621 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
1624 comedi_event(dev, s);
1629 static void handle_ao_interrupt(struct comedi_device *dev, unsigned int status)
1631 struct comedi_subdevice *s = dev->write_subdev;
1632 struct comedi_async *async = s->async;
1633 struct comedi_cmd *cmd = &async->cmd;
1634 unsigned int half_fifo = thisboard->fifo_size / 2;
1635 unsigned int num_points;
1636 unsigned long flags;
1640 if (status & DAEMI) {
1641 /* clear dac empty interrupt latch */
1642 spin_lock_irqsave(&dev->spinlock, flags);
1643 outw(devpriv->adc_fifo_bits | DAEMI,
1644 devpriv->control_status + INT_ADCFIFO);
1645 spin_unlock_irqrestore(&dev->spinlock, flags);
1646 if (inw(devpriv->ao_registers + DAC_CSR) & DAC_EMPTY) {
1647 if (cmd->stop_src == TRIG_NONE ||
1648 (cmd->stop_src == TRIG_COUNT
1649 && devpriv->ao_count)) {
1650 comedi_error(dev, "dac fifo underflow");
1651 cb_pcidas_ao_cancel(dev, s);
1652 async->events |= COMEDI_CB_ERROR;
1654 async->events |= COMEDI_CB_EOA;
1656 } else if (status & DAHFI) {
1657 unsigned int num_bytes;
1659 /* figure out how many points we are writing to fifo */
1660 num_points = half_fifo;
1661 if (cmd->stop_src == TRIG_COUNT &&
1662 devpriv->ao_count < num_points)
1663 num_points = devpriv->ao_count;
1665 cfc_read_array_from_buffer(s, devpriv->ao_buffer,
1666 num_points * sizeof(short));
1667 num_points = num_bytes / sizeof(short);
1669 if (async->cmd.stop_src == TRIG_COUNT)
1670 devpriv->ao_count -= num_points;
1671 /* write data to board's fifo */
1672 outsw(devpriv->ao_registers + DACDATA, devpriv->ao_buffer,
1674 /* clear half-full interrupt latch */
1675 spin_lock_irqsave(&dev->spinlock, flags);
1676 outw(devpriv->adc_fifo_bits | DAHFI,
1677 devpriv->control_status + INT_ADCFIFO);
1678 spin_unlock_irqrestore(&dev->spinlock, flags);
1681 comedi_event(dev, s);
1684 /* cancel analog input command */
1685 static int cb_pcidas_cancel(struct comedi_device *dev,
1686 struct comedi_subdevice *s)
1688 unsigned long flags;
1690 spin_lock_irqsave(&dev->spinlock, flags);
1691 /* disable interrupts */
1692 devpriv->adc_fifo_bits &= ~INTE & ~EOAIE;
1693 outw(devpriv->adc_fifo_bits, devpriv->control_status + INT_ADCFIFO);
1694 spin_unlock_irqrestore(&dev->spinlock, flags);
1696 /* disable start trigger source and burst mode */
1697 outw(0, devpriv->control_status + TRIG_CONTSTAT);
1698 /* software pacer source */
1699 outw(0, devpriv->control_status + ADCMUX_CONT);
1704 /* cancel analog output command */
1705 static int cb_pcidas_ao_cancel(struct comedi_device *dev,
1706 struct comedi_subdevice *s)
1708 unsigned long flags;
1710 spin_lock_irqsave(&dev->spinlock, flags);
1711 /* disable interrupts */
1712 devpriv->adc_fifo_bits &= ~DAHFIE & ~DAEMIE;
1713 outw(devpriv->adc_fifo_bits, devpriv->control_status + INT_ADCFIFO);
1715 /* disable output */
1716 devpriv->ao_control_bits &= ~DACEN & ~DAC_PACER_MASK;
1717 outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
1718 spin_unlock_irqrestore(&dev->spinlock, flags);
1723 static void cb_pcidas_load_counters(struct comedi_device *dev, unsigned int *ns,
1726 i8253_cascade_ns_to_timer_2div(TIMER_BASE, &(devpriv->divisor1),
1727 &(devpriv->divisor2), ns,
1728 rounding_flags & TRIG_ROUND_MASK);
1730 /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
1731 i8254_load(devpriv->pacer_counter_dio + ADC8254, 0, 1,
1732 devpriv->divisor1, 2);
1733 i8254_load(devpriv->pacer_counter_dio + ADC8254, 0, 2,
1734 devpriv->divisor2, 2);
1737 static void write_calibration_bitstream(struct comedi_device *dev,
1738 unsigned int register_bits,
1739 unsigned int bitstream,
1740 unsigned int bitstream_length)
1742 static const int write_delay = 1;
1745 for (bit = 1 << (bitstream_length - 1); bit; bit >>= 1) {
1746 if (bitstream & bit)
1747 register_bits |= SERIAL_DATA_IN_BIT;
1749 register_bits &= ~SERIAL_DATA_IN_BIT;
1750 udelay(write_delay);
1751 outw(register_bits, devpriv->control_status + CALIBRATION_REG);
1755 static int caldac_8800_write(struct comedi_device *dev, unsigned int address,
1758 static const int num_caldac_channels = 8;
1759 static const int bitstream_length = 11;
1760 unsigned int bitstream = ((address & 0x7) << 8) | value;
1761 static const int caldac_8800_udelay = 1;
1763 if (address >= num_caldac_channels) {
1764 comedi_error(dev, "illegal caldac channel");
1768 if (value == devpriv->caldac_value[address])
1771 devpriv->caldac_value[address] = value;
1773 write_calibration_bitstream(dev, cal_enable_bits(dev), bitstream,
1776 udelay(caldac_8800_udelay);
1777 outw(cal_enable_bits(dev) | SELECT_8800_BIT,
1778 devpriv->control_status + CALIBRATION_REG);
1779 udelay(caldac_8800_udelay);
1780 outw(cal_enable_bits(dev), devpriv->control_status + CALIBRATION_REG);
1785 static int trimpot_7376_write(struct comedi_device *dev, uint8_t value)
1787 static const int bitstream_length = 7;
1788 unsigned int bitstream = value & 0x7f;
1789 unsigned int register_bits;
1790 static const int ad7376_udelay = 1;
1792 register_bits = cal_enable_bits(dev) | SELECT_TRIMPOT_BIT;
1793 udelay(ad7376_udelay);
1794 outw(register_bits, devpriv->control_status + CALIBRATION_REG);
1796 write_calibration_bitstream(dev, register_bits, bitstream,
1799 udelay(ad7376_udelay);
1800 outw(cal_enable_bits(dev), devpriv->control_status + CALIBRATION_REG);
1807 * ch 1 : adc postgain offset */
1808 static int trimpot_8402_write(struct comedi_device *dev, unsigned int channel,
1811 static const int bitstream_length = 10;
1812 unsigned int bitstream = ((channel & 0x3) << 8) | (value & 0xff);
1813 unsigned int register_bits;
1814 static const int ad8402_udelay = 1;
1816 register_bits = cal_enable_bits(dev) | SELECT_TRIMPOT_BIT;
1817 udelay(ad8402_udelay);
1818 outw(register_bits, devpriv->control_status + CALIBRATION_REG);
1820 write_calibration_bitstream(dev, register_bits, bitstream,
1823 udelay(ad8402_udelay);
1824 outw(cal_enable_bits(dev), devpriv->control_status + CALIBRATION_REG);
1829 static int wait_for_nvram_ready(unsigned long s5933_base_addr)
1831 static const int timeout = 1000;
1834 for (i = 0; i < timeout; i++) {
1835 if ((inb(s5933_base_addr +
1836 AMCC_OP_REG_MCSR_NVCMD) & MCSR_NV_BUSY)
1844 static int nvram_read(struct comedi_device *dev, unsigned int address,
1847 unsigned long iobase = devpriv->s5933_config;
1849 if (wait_for_nvram_ready(iobase) < 0)
1852 outb(MCSR_NV_ENABLE | MCSR_NV_LOAD_LOW_ADDR,
1853 iobase + AMCC_OP_REG_MCSR_NVCMD);
1854 outb(address & 0xff, iobase + AMCC_OP_REG_MCSR_NVDATA);
1855 outb(MCSR_NV_ENABLE | MCSR_NV_LOAD_HIGH_ADDR,
1856 iobase + AMCC_OP_REG_MCSR_NVCMD);
1857 outb((address >> 8) & 0xff, iobase + AMCC_OP_REG_MCSR_NVDATA);
1858 outb(MCSR_NV_ENABLE | MCSR_NV_READ, iobase + AMCC_OP_REG_MCSR_NVCMD);
1860 if (wait_for_nvram_ready(iobase) < 0)
1863 *data = inb(iobase + AMCC_OP_REG_MCSR_NVDATA);
1869 * A convenient macro that defines init_module() and cleanup_module(),
1872 static int __devinit driver_cb_pcidas_pci_probe(struct pci_dev *dev,
1873 const struct pci_device_id *ent)
1875 return comedi_pci_auto_config(dev, driver_cb_pcidas.driver_name);
1878 static void __devexit driver_cb_pcidas_pci_remove(struct pci_dev *dev)
1880 comedi_pci_auto_unconfig(dev);
1883 static struct pci_driver driver_cb_pcidas_pci_driver = {
1884 .id_table = cb_pcidas_pci_table,
1885 .probe = &driver_cb_pcidas_pci_probe,
1886 .remove = __devexit_p(&driver_cb_pcidas_pci_remove)
1889 static int __init driver_cb_pcidas_init_module(void)
1893 retval = comedi_driver_register(&driver_cb_pcidas);
1897 driver_cb_pcidas_pci_driver.name = (char *)driver_cb_pcidas.driver_name;
1898 return pci_register_driver(&driver_cb_pcidas_pci_driver);
1901 static void __exit driver_cb_pcidas_cleanup_module(void)
1903 pci_unregister_driver(&driver_cb_pcidas_pci_driver);
1904 comedi_driver_unregister(&driver_cb_pcidas);
1907 module_init(driver_cb_pcidas_init_module);
1908 module_exit(driver_cb_pcidas_cleanup_module);
1910 MODULE_AUTHOR("Comedi http://www.comedi.org");
1911 MODULE_DESCRIPTION("Comedi low-level driver");
1912 MODULE_LICENSE("GPL");